1use super::{TypeCollector, SolidityTypeName, SolidityType, StructCollect};2use crate::{sealed, types::*};3use core::fmt;45macro_rules! solidity_type_name {6 ($($ty:ty => $name:literal $simple:literal = $default:literal),* $(,)?) => {7 $(8 impl SolidityTypeName for $ty {9 fn solidity_name(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {10 write!(writer, $name)11 }12 fn is_simple() -> bool {13 $simple14 }15 fn solidity_default(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {16 write!(writer, $default)17 }18 }1920 impl StructCollect for $ty {21 fn name() -> String {22 $name.to_string()23 }2425 fn declaration() -> String {26 String::default()27 }28 }29 )*30 };31}3233solidity_type_name! {34 uint8 => "uint8" true = "0",35 uint32 => "uint32" true = "0",36 uint64 => "uint64" true = "0",37 uint128 => "uint128" true = "0",38 uint256 => "uint256" true = "0",39 bytes4 => "bytes4" true = "bytes4(0)",40 address => "address" true = "0x0000000000000000000000000000000000000000",41 string => "string" false = "\"\"",42 bytes => "bytes" false = "hex\"\"",43 bool => "bool" true = "false",44}4546impl SolidityTypeName for void {47 fn solidity_name(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {48 Ok(())49 }50 fn is_simple() -> bool {51 true52 }53 fn solidity_default(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {54 Ok(())55 }56 fn is_void() -> bool {57 true58 }59}6061impl<T: SolidityTypeName + sealed::CanBePlacedInVec> SolidityTypeName for Vec<T> {62 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {63 T::solidity_name(writer, tc)?;64 write!(writer, "[]")65 }66 fn is_simple() -> bool {67 false68 }69 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {70 write!(writer, "new ")?;71 T::solidity_name(writer, tc)?;72 write!(writer, "[](0)")73 }74}7576macro_rules! count {77 () => (0usize);78 ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));79}8081macro_rules! impl_tuples {82 ($($ident:ident)+) => {83 impl<$($ident: SolidityTypeName + 'static),+> SolidityType for ($($ident,)+) {84 fn names(tc: &TypeCollector) -> Vec<string> {85 let mut collected = Vec::with_capacity(Self::len());86 $({87 let mut out = string::new();88 $ident::solidity_name(&mut out, tc).expect("no fmt error");89 collected.push(out);90 })*;91 collected92 }9394 fn len() -> usize {95 count!($($ident)*)96 }97 }98 impl<$($ident: SolidityTypeName + 'static),+> SolidityTypeName for ($($ident,)+) {99 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {100 write!(writer, "{}", tc.collect_tuple::<Self>())101 }102 fn is_simple() -> bool {103 false104 }105 #[allow(unused_assignments)]106 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {107 write!(writer, "{}(", tc.collect_tuple::<Self>())?;108 let mut first = true;109 $(110 if !first {111 write!(writer, ",")?;112 } else {113 first = false;114 }115 <$ident>::solidity_default(writer, tc)?;116 )*117 write!(writer, ")")118 }119 }120 };121}122123impl_tuples! {A}124impl_tuples! {A B}125impl_tuples! {A B C}126impl_tuples! {A B C D}127impl_tuples! {A B C D E}128impl_tuples! {A B C D E F}129impl_tuples! {A B C D E F G}130impl_tuples! {A B C D E F G H}131impl_tuples! {A B C D E F G H I}132impl_tuples! {A B C D E F G H I J}133134impl sealed::CanBePlacedInVec for Property {}135impl StructCollect for Property {136 fn name() -> String {137 "Property".into()138 }139140 fn declaration() -> String {141 let mut str = String::new();142 writeln!(str, "/// @dev Property struct").unwrap();143 writeln!(str, "struct {} {{", Self::name()).unwrap();144 writeln!(str, "\tstring key;").unwrap();145 writeln!(str, "\tbytes value;").unwrap();146 writeln!(str, "}}").unwrap();147 str148 }149}150151impl SolidityTypeName for Property {152 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {153 write!(writer, "{}", tc.collect_struct::<Self>())154 }155156 fn is_simple() -> bool {157 false158 }159160 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {161 write!(writer, "{}(", tc.collect_struct::<Self>())?;162 address::solidity_default(writer, tc)?;163 write!(writer, ",")?;164 uint256::solidity_default(writer, tc)?;165 write!(writer, ")")166 }167}168169impl SolidityTupleType for Property {170 fn names(tc: &TypeCollector) -> Vec<string> {171 let mut collected = Vec::with_capacity(Self::len());172 {173 let mut out = string::new();174 string::solidity_name(&mut out, tc).expect("no fmt error");175 collected.push(out);176 }177 {178 let mut out = string::new();179 bytes::solidity_name(&mut out, tc).expect("no fmt error");180 collected.push(out);181 }182 collected183 }184185 fn len() -> usize {186 2187 }188}