git.delta.rocks / unique-network / refs/commits / 4aadc003b1ed

1#[cfg(not(feature = "std"))]2use alloc::{3	string::String,4	vec::Vec,5	collections::{BTreeSet, BTreeMap},6	format,7};8#[cfg(feature = "std")]9use std::collections::{BTreeSet, BTreeMap};10use core::{11	fmt::{self, Write},12	marker::PhantomData,13	cell::{Cell, RefCell},14};15use impl_trait_for_tuples::impl_for_tuples;16use crate::types::*;1718#[derive(Default)]19pub struct TypeCollector {20	structs: RefCell<BTreeSet<string>>,21	anonymous: RefCell<BTreeMap<Vec<string>, usize>>,22	id: Cell<usize>,23}24impl TypeCollector {25	pub fn new() -> Self {26		Self::default()27	}28	pub fn collect(&self, item: string) {29		self.structs.borrow_mut().insert(item);30	}31	pub fn next_id(&self) -> usize {32		let v = self.id.get();33		self.id.set(v + 1);34		v35	}36	pub fn collect_tuple<T: SolidityTupleType>(&self) -> String {37		let names = T::names(self);38		if let Some(id) = self.anonymous.borrow().get(&names).cloned() {39			return format!("Tuple{}", id);40		}41		let id = self.next_id();42		let mut str = String::new();43		writeln!(str, "// Anonymous struct").unwrap();44		writeln!(str, "struct Tuple{} {{", id).unwrap();45		for (i, name) in names.iter().enumerate() {46			writeln!(str, "\t{} field_{};", name, i).unwrap();47		}48		writeln!(str, "}}").unwrap();49		self.collect(str);50		self.anonymous.borrow_mut().insert(names, id);51		format!("Tuple{}", id)52	}53	pub fn finish(self) -> BTreeSet<string> {54		self.structs.into_inner()55	}56}5758pub trait SolidityTypeName: 'static {59	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;60	fn is_simple() -> bool;61	fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;62	fn is_void() -> bool {63		false64	}65}66macro_rules! solidity_type_name {67    ($($ty:ty => $name:literal $simple:literal = $default:literal),* $(,)?) => {68        $(69            impl SolidityTypeName for $ty {70                fn solidity_name(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {71                    write!(writer, $name)72                }73				fn is_simple() -> bool {74					$simple75				}76				fn solidity_default(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {77					write!(writer, $default)78				}79            }80        )*81    };82}8384solidity_type_name! {85	uint8 => "uint8" true = "0",86	uint32 => "uint32" true = "0",87	uint128 => "uint128" true = "0",88	uint256 => "uint256" true = "0",89	address => "address" true = "0x0000000000000000000000000000000000000000",90	string => "string" false = "\"\"",91	bytes => "bytes" false = "hex\"\"",92	bool => "bool" true = "false",93}94impl SolidityTypeName for void {95	fn solidity_name(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {96		Ok(())97	}98	fn is_simple() -> bool {99		true100	}101	fn solidity_default(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {102		Ok(())103	}104	fn is_void() -> bool {105		true106	}107}108109mod sealed {110	pub trait CanBePlacedInVec {}111}112113impl sealed::CanBePlacedInVec for uint256 {}114impl sealed::CanBePlacedInVec for string {}115impl sealed::CanBePlacedInVec for address {}116117impl<T: SolidityTypeName + sealed::CanBePlacedInVec> SolidityTypeName for Vec<T> {118	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {119		T::solidity_name(writer, tc)?;120		write!(writer, "[]")121	}122	fn is_simple() -> bool {123		false124	}125	fn solidity_default(writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {126		write!(writer, "[]")127	}128}129130pub trait SolidityTupleType {131	fn names(tc: &TypeCollector) -> Vec<String>;132	fn len() -> usize;133}134135macro_rules! count {136    () => (0usize);137    ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));138}139140macro_rules! impl_tuples {141	($($ident:ident)+) => {142		impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}143		impl<$($ident: SolidityTypeName + 'static),+> SolidityTupleType for ($($ident,)+) {144			fn names(tc: &TypeCollector) -> Vec<string> {145				let mut collected = Vec::with_capacity(Self::len());146				$({147					let mut out = string::new();148					$ident::solidity_name(&mut out, tc).expect("no fmt error");149					collected.push(out);150				})*;151				collected152			}153154			fn len() -> usize {155				count!($($ident)*)156			}157		}158		impl<$($ident: SolidityTypeName + 'static),+> SolidityTypeName for ($($ident,)+) {159			fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {160				write!(writer, "{}", tc.collect_tuple::<Self>())161			}162			fn is_simple() -> bool {163				false164			}165			fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {166				write!(writer, "{}(", tc.collect_tuple::<Self>())?;167				$(168					<$ident>::solidity_default(writer, tc)?;169				)*170				write!(writer, ")")171			}172		}173	};174}175176impl_tuples! {A}177impl_tuples! {A B}178impl_tuples! {A B C}179impl_tuples! {A B C D}180impl_tuples! {A B C D E}181impl_tuples! {A B C D E F}182impl_tuples! {A B C D E F G}183impl_tuples! {A B C D E F G H}184impl_tuples! {A B C D E F G H I}185impl_tuples! {A B C D E F G H I J}186187pub trait SolidityArguments {188	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;189	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result;190	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;191	fn is_empty(&self) -> bool {192		self.len() == 0193	}194	fn len(&self) -> usize;195}196197#[derive(Default)]198pub struct UnnamedArgument<T>(PhantomData<*const T>);199200impl<T: SolidityTypeName> SolidityArguments for UnnamedArgument<T> {201	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {202		if !T::is_void() {203			T::solidity_name(writer, tc)?;204			if !T::is_simple() {205				write!(writer, " memory")?;206			}207			Ok(())208		} else {209			Ok(())210		}211	}212	fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {213		Ok(())214	}215	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {216		T::solidity_default(writer, tc)217	}218	fn len(&self) -> usize {219		if T::is_void() {220			0221		} else {222			1223		}224	}225}226227pub struct NamedArgument<T>(&'static str, PhantomData<*const T>);228229impl<T> NamedArgument<T> {230	pub fn new(name: &'static str) -> Self {231		Self(name, Default::default())232	}233}234235impl<T: SolidityTypeName> SolidityArguments for NamedArgument<T> {236	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {237		if !T::is_void() {238			T::solidity_name(writer, tc)?;239			if !T::is_simple() {240				write!(writer, " memory")?;241			}242			write!(writer, " {}", self.0)243		} else {244			Ok(())245		}246	}247	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {248		writeln!(writer, "\t\t{};", self.0)249	}250	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {251		T::solidity_default(writer, tc)252	}253	fn len(&self) -> usize {254		if T::is_void() {255			0256		} else {257			1258		}259	}260}261262pub struct SolidityEventArgument<T>(pub bool, &'static str, PhantomData<*const T>);263264impl<T> SolidityEventArgument<T> {265	pub fn new(indexed: bool, name: &'static str) -> Self {266		Self(indexed, name, Default::default())267	}268}269270impl<T: SolidityTypeName> SolidityArguments for SolidityEventArgument<T> {271	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {272		if !T::is_void() {273			T::solidity_name(writer, tc)?;274			if self.0 {275				write!(writer, " indexed")?;276			}277			write!(writer, " {}", self.1)278		} else {279			Ok(())280		}281	}282	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {283		writeln!(writer, "\t\t{};", self.1)284	}285	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {286		T::solidity_default(writer, tc)287	}288	fn len(&self) -> usize {289		if T::is_void() {290			0291		} else {292			1293		}294	}295}296297impl SolidityArguments for () {298	fn solidity_name(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {299		Ok(())300	}301	fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {302		Ok(())303	}304	fn solidity_default(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {305		Ok(())306	}307	fn len(&self) -> usize {308		0309	}310}311312#[impl_for_tuples(1, 5)]313impl SolidityArguments for Tuple {314	for_tuples!( where #( Tuple: SolidityArguments ),* );315316	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {317		let mut first = true;318		for_tuples!( #(319            if !Tuple.is_empty() {320                if !first {321                    write!(writer, ", ")?;322                }323                first = false;324                Tuple.solidity_name(writer, tc)?;325            }326        )* );327		Ok(())328	}329	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {330		for_tuples!( #(331            Tuple.solidity_get(writer)?;332        )* );333		Ok(())334	}335	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {336		if self.is_empty() {337			Ok(())338		} else if self.len() == 1 {339			for_tuples!( #(340				Tuple.solidity_default(writer, tc)?;341			)* );342			Ok(())343		} else {344			write!(writer, "(")?;345			let mut first = true;346			for_tuples!( #(347				if !Tuple.is_empty() {348					if !first {349						write!(writer, ", ")?;350					}351					first = false;352					Tuple.solidity_default(writer, tc)?;353				}354			)* );355			write!(writer, ")")?;356			Ok(())357		}358	}359	fn len(&self) -> usize {360		for_tuples!( #( Tuple.len() )+* )361	}362}363364pub trait SolidityFunctions {365	fn solidity_name(366		&self,367		is_impl: bool,368		writer: &mut impl fmt::Write,369		tc: &TypeCollector,370	) -> fmt::Result;371}372373pub enum SolidityMutability {374	Pure,375	View,376	Mutable,377}378pub struct SolidityFunction<A, R> {379	pub name: &'static str,380	pub args: A,381	pub result: R,382	pub mutability: SolidityMutability,383}384impl<A: SolidityArguments, R: SolidityArguments> SolidityFunctions for SolidityFunction<A, R> {385	fn solidity_name(386		&self,387		is_impl: bool,388		writer: &mut impl fmt::Write,389		tc: &TypeCollector,390	) -> fmt::Result {391		write!(writer, "\tfunction {}(", self.name)?;392		self.args.solidity_name(writer, tc)?;393		write!(writer, ")")?;394		if is_impl {395			write!(writer, " public")?;396		} else {397			write!(writer, " external")?;398		}399		match &self.mutability {400			SolidityMutability::Pure => write!(writer, " pure")?,401			SolidityMutability::View => write!(writer, " view")?,402			SolidityMutability::Mutable => {}403		}404		if !self.result.is_empty() {405			write!(writer, " returns (")?;406			self.result.solidity_name(writer, tc)?;407			write!(writer, ")")?;408		}409		if is_impl {410			writeln!(writer, " {{")?;411			writeln!(writer, "\t\trequire(false, stub_error);")?;412			self.args.solidity_get(writer)?;413			match &self.mutability {414				SolidityMutability::Pure => {}415				SolidityMutability::View => writeln!(writer, "\t\tdummy;")?,416				SolidityMutability::Mutable => writeln!(writer, "\t\tdummy = 0;")?,417			}418			if !self.result.is_empty() {419				write!(writer, "\t\treturn ")?;420				self.result.solidity_default(writer, tc)?;421				writeln!(writer, ";")?;422			}423			writeln!(writer, "\t}}")?;424		} else {425			writeln!(writer, ";")?;426		}427		Ok(())428	}429}430431#[impl_for_tuples(0, 12)]432impl SolidityFunctions for Tuple {433	for_tuples!( where #( Tuple: SolidityFunctions ),* );434435	fn solidity_name(436		&self,437		is_impl: bool,438		writer: &mut impl fmt::Write,439		tc: &TypeCollector,440	) -> fmt::Result {441		let mut first = false;442		for_tuples!( #(443            Tuple.solidity_name(is_impl, writer, tc)?;444        )* );445		Ok(())446	}447}448449pub struct SolidityInterface<F: SolidityFunctions> {450	pub name: &'static str,451	pub is: &'static [&'static str],452	pub functions: F,453}454455impl<F: SolidityFunctions> SolidityInterface<F> {456	pub fn format(457		&self,458		is_impl: bool,459		out: &mut impl fmt::Write,460		tc: &TypeCollector,461	) -> fmt::Result {462		if is_impl {463			write!(out, "contract ")?;464		} else {465			write!(out, "interface ")?;466		}467		write!(out, "{}", self.name)?;468		if !self.is.is_empty() {469			write!(out, " is")?;470			for (i, n) in self.is.iter().enumerate() {471				if i != 0 {472					write!(out, ",")?;473				}474				write!(out, " {}", n)?;475			}476		}477		writeln!(out, " {{")?;478		self.functions.solidity_name(is_impl, out, tc)?;479		writeln!(out, "}}")?;480		Ok(())481	}482}483484pub struct SolidityEvent<A> {485	pub name: &'static str,486	pub args: A,487}488489impl<A: SolidityArguments> SolidityFunctions for SolidityEvent<A> {490	fn solidity_name(491		&self,492		_is_impl: bool,493		writer: &mut impl fmt::Write,494		tc: &TypeCollector,495	) -> fmt::Result {496		write!(writer, "\tevent {}(", self.name)?;497		self.args.solidity_name(writer, tc)?;498		writeln!(writer, ");")499	}500}