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}124125126impl<T: SolidityTypeName + 'static> SolidityTypeName for Option<T> {127 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {128 write!(writer, "{}", tc.collect_struct::<Self>())129 }130 fn is_simple() -> bool {131 false132 }133 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {134 write!(writer, "{}(", tc.collect_struct::<Self>())?;135 bool::solidity_default(writer, tc)?;136 write!(writer, ", ");137 T::solidity_default(writer, tc)?;138 write!(writer, ")")139 }140}141142impl<T: SolidityTypeName> super::SolidityStructTy for Option<T> {143 fn generate_solidity_interface(tc: &TypeCollector) -> String {144 let mut solidity_name = "Option_".to_string();145 T::solidity_name(&mut solidity_name, tc);146 let solidity_name_str = solidity_name.as_str();147 let interface = super::SolidityStruct {148 docs: &[" Optional value"],149 name: solidity_name_str,150 fields: (151 super::SolidityStructField::<bool> {152 docs: &[" Shows the status of accessibility of value"],153 name: "status",154 ty: ::core::marker::PhantomData,155 },156 super::SolidityStructField::<T> {157 docs: &[" Actual value if `status` is true"],158 name: "value",159 ty: ::core::marker::PhantomData,160 },161 ),162 };163164 let mut out = String::new();165 let _ = interface.format(&mut out, tc);166 tc.collect(out);167168 solidity_name.to_string()169 }170}