1use super::{TypeCollector, SolidityTypeName, SolidityType, StructCollect};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 }2021 impl StructCollect for $ty {22 fn name() -> String {23 $name.to_string()24 }2526 fn declaration() -> String {27 String::default()28 }29 }30 )*31 };32}3334solidity_type_name! {35 u8 => "uint8" true = "0",36 u32 => "uint32" true = "0",37 u64 => "uint64" true = "0",38 u128 => "uint128" true = "0",39 U256 => "uint256" true = "0",40 bytes4 => "bytes4" true = "bytes4(0)",41 H160 => "address" true = "0x0000000000000000000000000000000000000000",42 string => "string" false = "\"\"",43 bytes => "bytes" false = "hex\"\"",44 bool => "bool" true = "false",45}4647impl SolidityTypeName for void {48 fn solidity_name(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {49 Ok(())50 }51 fn is_simple() -> bool {52 true53 }54 fn solidity_default(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {55 Ok(())56 }57 fn is_void() -> bool {58 true59 }60}6162impl<T: SolidityTypeName + sealed::CanBePlacedInVec> SolidityTypeName for Vec<T> {63 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {64 T::solidity_name(writer, tc)?;65 write!(writer, "[]")66 }67 fn is_simple() -> bool {68 false69 }70 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {71 write!(writer, "new ")?;72 T::solidity_name(writer, tc)?;73 write!(writer, "[](0)")74 }75}7677macro_rules! count {78 () => (0usize);79 ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));80}8182macro_rules! impl_tuples {83 ($($ident:ident)+) => {84 impl<$($ident: SolidityTypeName + 'static),+> SolidityType for ($($ident,)+) {85 fn names(tc: &TypeCollector) -> Vec<string> {86 let mut collected = Vec::with_capacity(Self::len());87 $({88 let mut out = string::new();89 $ident::solidity_name(&mut out, tc).expect("no fmt error");90 collected.push(out);91 })*;92 collected93 }9495 fn len() -> usize {96 count!($($ident)*)97 }98 }99 impl<$($ident: SolidityTypeName + 'static),+> SolidityTypeName for ($($ident,)+) {100 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {101 write!(writer, "{}", tc.collect_tuple::<Self>())102 }103 fn is_simple() -> bool {104 false105 }106 #[allow(unused_assignments)]107 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {108 write!(writer, "{}(", tc.collect_tuple::<Self>())?;109 let mut first = true;110 $(111 if !first {112 write!(writer, ",")?;113 } else {114 first = false;115 }116 <$ident>::solidity_default(writer, tc)?;117 )*118 write!(writer, ")")119 }120 }121 };122}123124impl_tuples! {A}125impl_tuples! {A B}126impl_tuples! {A B C}127impl_tuples! {A B C D}128impl_tuples! {A B C D E}129impl_tuples! {A B C D E F}130impl_tuples! {A B C D E F G}131impl_tuples! {A B C D E F G H}132impl_tuples! {A B C D E F G H I}133impl_tuples! {A B C D E F G H I J}134135impl StructCollect for Property {136 fn name() -> String {137 "Property".into()138 }139140 fn declaration() -> String {141 use std::fmt::Write;142143 let mut str = String::new();144 writeln!(str, "/// @dev Property struct").unwrap();145 writeln!(str, "struct {} {{", Self::name()).unwrap();146 writeln!(str, "\tstring key;").unwrap();147 writeln!(str, "\tbytes value;").unwrap();148 writeln!(str, "}}").unwrap();149 str150 }151}152153impl SolidityTypeName for Property {154 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {155 write!(writer, "{}", tc.collect_struct::<Self>())156 }157158 fn is_simple() -> bool {159 false160 }161162 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {163 write!(writer, "{}(", tc.collect_struct::<Self>())?;164 address::solidity_default(writer, tc)?;165 write!(writer, ",")?;166 uint256::solidity_default(writer, tc)?;167 write!(writer, ")")168 }169}170171impl SolidityType for Property {172 fn names(tc: &TypeCollector) -> Vec<string> {173 let mut collected = Vec::with_capacity(Self::len());174 {175 let mut out = string::new();176 string::solidity_name(&mut out, tc).expect("no fmt error");177 collected.push(out);178 }179 {180 let mut out = string::new();181 bytes::solidity_name(&mut out, tc).expect("no fmt error");182 collected.push(out);183 }184 collected185 }186187 fn len() -> usize {188 2189 }190}