1use super::{TypeCollector, SolidityTypeName, SolidityTupleTy};2use crate::{sealed, types::*};3use core::fmt;4use primitive_types::{U256, H160};56macro_rules! solidity_type_name {7 ($($ty:ty => $name:literal $simple:literal = $default:literal),* $(,)?) => {8 $(9 impl SolidityTypeName for $ty {10 fn solidity_name(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {11 write!(writer, $name)12 }13 fn is_simple() -> bool {14 $simple15 }16 fn solidity_default(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {17 write!(writer, $default)18 }19 }20 )*21 };22}2324solidity_type_name! {25 u8 => "uint8" true = "0",26 u32 => "uint32" true = "0",27 u64 => "uint64" true = "0",28 u128 => "uint128" true = "0",29 U256 => "uint256" true = "0",30 bytes4 => "bytes4" true = "bytes4(0)",31 H160 => "address" true = "0x0000000000000000000000000000000000000000",32 string => "string" false = "\"\"",33 bytes => "bytes" false = "hex\"\"",34 bool => "bool" true = "false",35}3637impl SolidityTypeName for void {38 fn solidity_name(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {39 Ok(())40 }41 fn is_simple() -> bool {42 true43 }44 fn solidity_default(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {45 Ok(())46 }47 fn is_void() -> bool {48 true49 }50}5152impl<T: SolidityTypeName + sealed::CanBePlacedInVec> SolidityTypeName for Vec<T> {53 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {54 T::solidity_name(writer, tc)?;55 write!(writer, "[]")56 }57 fn is_simple() -> bool {58 false59 }60 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {61 write!(writer, "new ")?;62 T::solidity_name(writer, tc)?;63 write!(writer, "[](0)")64 }65}6667macro_rules! count {68 () => (0usize);69 ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));70}7172macro_rules! impl_tuples {73 ($($ident:ident)+) => {74 impl<$($ident: SolidityTypeName + 'static),+> SolidityTupleTy for ($($ident,)+) {75 fn fields(tc: &TypeCollector) -> Vec<string> {76 let mut collected = Vec::with_capacity(Self::len());77 $({78 let mut out = string::new();79 $ident::solidity_name(&mut out, tc).expect("no fmt error");80 collected.push(out);81 })*;82 collected83 }8485 fn len() -> usize {86 count!($($ident)*)87 }88 }89 impl<$($ident: SolidityTypeName + 'static),+> SolidityTypeName for ($($ident,)+) {90 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {91 write!(writer, "{}", tc.collect_tuple::<Self>())92 }93 fn is_simple() -> bool {94 false95 }96 #[allow(unused_assignments)]97 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {98 write!(writer, "{}(", tc.collect_tuple::<Self>())?;99 let mut first = true;100 $(101 if !first {102 write!(writer, ",")?;103 } else {104 first = false;105 }106 <$ident>::solidity_default(writer, tc)?;107 )*108 write!(writer, ")")109 }110 }111 };112}113114impl_tuples! {A}115impl_tuples! {A B}116impl_tuples! {A B C}117impl_tuples! {A B C D}118impl_tuples! {A B C D E}119impl_tuples! {A B C D E F}120impl_tuples! {A B C D E F G}121impl_tuples! {A B C D E F G H}122impl_tuples! {A B C D E F G H I}123impl_tuples! {A B C D E F G H I J}