git.delta.rocks / unique-network / refs/commits / 12eee8195c76

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}