git.delta.rocks / unique-network / refs/commits / 99e7a932fe6e

1#![allow(dead_code)]23use quote::quote;4use darling::FromMeta;5use inflector::cases;6use std::fmt::Write;7use syn::{8	FnArg, Ident, ItemTrait, Meta, NestedMeta, PatType, Path, ReturnType, TraitItem,9	TraitItemMethod, Visibility, spanned::Spanned,10};1112use crate::{13	fn_selector_str, format_ty, parse_ident_from_pat, parse_ident_from_path, parse_ident_from_type,14	parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,15	snake_ident_to_screaming,16};1718struct Is {19	name: Ident,20	pascal_call_name: Ident,21	snake_call_name: Ident,22}23impl Is {24	fn try_from(path: &Path) -> syn::Result<Self> {25		let name = parse_ident_from_path(path)?.clone();26		Ok(Self {27			pascal_call_name: pascal_ident_to_call(&name),28			snake_call_name: pascal_ident_to_snake_call(&name),29			name,30		})31	}3233	fn expand_call_def(&self) -> proc_macro2::TokenStream {34		let name = &self.name;35		let pascal_call_name = &self.pascal_call_name;36		quote! {37			#name(#pascal_call_name)38		}39	}4041	fn expand_interface_id(&self) -> proc_macro2::TokenStream {42		let pascal_call_name = &self.pascal_call_name;43		quote! {44			interface_id ^= #pascal_call_name::interface_id();45		}46	}4748	fn expand_supports_interface(&self) -> proc_macro2::TokenStream {49		let pascal_call_name = &self.pascal_call_name;50		quote! {51			#pascal_call_name::supports_interface(interface_id)52		}53	}5455	fn expand_variant_call(&self) -> proc_macro2::TokenStream {56		let name = &self.name;57		let snake_call_name = &self.snake_call_name;58		quote! {59			InternalCall::#name(call) => return self.#snake_call_name(Msg {60				call,61				caller: c.caller,62				value: c.value,63			})64		}65	}6667	fn expand_call_inner(&self) -> proc_macro2::TokenStream {68		let snake_call_name = &self.snake_call_name;69		let pascal_call_name = &self.pascal_call_name;70		quote! {71			fn #snake_call_name(&mut self, c: Msg<#pascal_call_name>) -> ::core::result::Result<::evm_coder::abi::AbiWriter, Self::Error>;72		}73	}7475	fn expand_parse(&self) -> proc_macro2::TokenStream {76		let name = &self.name;77		let pascal_call_name = &self.pascal_call_name;78		quote! {79			if let Some(parsed_call) = #pascal_call_name::parse(method_id, reader)? {80				return Ok(Some(Self::#name(parsed_call)))81			}82		}83	}84}8586#[derive(Default)]87struct IsList(Vec<Is>);88impl FromMeta for IsList {89	fn from_list(items: &[NestedMeta]) -> darling::Result<Self> {90		let mut out = Vec::new();91		for item in items {92			match item {93				NestedMeta::Meta(Meta::Path(path)) => out.push(Is::try_from(path)?),94				_ => return Err(syn::Error::new(item.span(), "expected path").into()),95			}96		}97		Ok(Self(out))98	}99}100101#[derive(FromMeta)]102pub struct InterfaceInfo {103	#[darling(default)]104	is: IsList,105	#[darling(default)]106	inline_is: IsList,107	#[darling(default)]108	events: IsList,109}110111#[derive(FromMeta)]112struct MethodInfo {113	#[darling(default)]114	rename_selector: Option<String>,115}116117struct MethodArg {118	name: Ident,119	ty: Ident,120}121impl MethodArg {122	fn try_from(value: &PatType) -> syn::Result<Self> {123		Ok(Self {124			name: parse_ident_from_pat(&value.pat)?.clone(),125			ty: parse_ident_from_type(&value.ty)?.clone(),126		})127	}128	fn is_value(&self) -> bool {129		self.ty == "value"130	}131	fn is_caller(&self) -> bool {132		self.ty == "caller"133	}134	fn is_special(&self) -> bool {135		self.is_value() || self.is_caller()136	}137	fn selector_ty(&self) -> &Ident {138		assert!(!self.is_special());139		&self.ty140	}141142	fn expand_call_def(&self) -> proc_macro2::TokenStream {143		assert!(!self.is_special());144		let name = &self.name;145		let ty = &self.ty;146147		quote! {148			#name: #ty149		}150	}151152	fn expand_parse(&self) -> proc_macro2::TokenStream {153		assert!(!self.is_special());154		let name = &self.name;155		quote! {156			#name: reader.abi_read()?157		}158	}159160	fn expand_call_arg(&self) -> proc_macro2::TokenStream {161		if self.is_value() {162			quote! {163				c.value.clone()164			}165		} else if self.is_caller() {166			quote! {167				c.caller.clone()168			}169		} else {170			let name = &self.name;171			quote! {172				#name173			}174		}175	}176177	fn solidity_def(&self) -> String {178		assert!(!self.is_special());179		format!("{} {}", format_ty(&self.ty), self.name)180	}181}182183#[derive(PartialEq)]184enum Mutability {185	Mutable,186	View,187	Pure,188}189190struct Method {191	name: Ident,192	camel_name: String,193	pascal_name: Ident,194	screaming_name: Ident,195	selector_str: String,196	selector: u32,197	args: Vec<MethodArg>,198	has_normal_args: bool,199	mutability: Mutability,200	result: Ident,201}202impl Method {203	fn try_from(value: &TraitItemMethod) -> syn::Result<Self> {204		let mut info = MethodInfo {205			rename_selector: None,206		};207		for attr in &value.attrs {208			let ident = parse_ident_from_path(&attr.path)?;209			if ident == "solidity" {210				let args = attr.parse_meta().unwrap();211				info = MethodInfo::from_meta(&args).unwrap();212			} else if ident == "doc" {213				// TODO: Add docs to evm interfaces214			}215		}216		let ident = &value.sig.ident;217		let ident_str = ident.to_string();218		if !cases::snakecase::is_snake_case(&ident_str) {219			return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));220		}221222		let mut mutability = Mutability::Pure;223224		if let Some(FnArg::Receiver(receiver)) = value225			.sig226			.inputs227			.iter()228			.find(|arg| matches!(arg, FnArg::Receiver(_)))229		{230			if receiver.reference.is_none() {231				return Err(syn::Error::new(232					receiver.span(),233					"receiver should be by ref",234				));235			}236			if receiver.mutability.is_some() {237				mutability = Mutability::Mutable;238			} else {239				mutability = Mutability::View;240			}241		}242		let mut args = Vec::new();243		for typ in value244			.sig245			.inputs246			.iter()247			.filter(|arg| matches!(arg, FnArg::Typed(_)))248		{249			let typ = match typ {250				FnArg::Typed(typ) => typ,251				_ => unreachable!(),252			};253			args.push(MethodArg::try_from(typ)?);254		}255256		if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {257			return Err(syn::Error::new(258				args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),259				"payable function should be mutable",260			));261		}262263		let result = match &value.sig.output {264			ReturnType::Type(_, ty) => ty,265			_ => return Err(syn::Error::new(value.sig.output.span(), "interface method should return Result<value>\nif there is no value to return - specify void (which is alias to unit)")),266		};267		let result = parse_result_ok(result)?;268269		let camel_name = info270			.rename_selector271			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));272		let mut selector_str = camel_name.clone();273		selector_str.push('(');274		let mut has_normal_args = false;275		for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {276			if i != 0 {277				selector_str.push(',');278			}279			write!(selector_str, "{}", arg.selector_ty()).unwrap();280			has_normal_args = true;281		}282		selector_str.push(')');283		let selector = fn_selector_str(&selector_str);284285		Ok(Self {286			name: ident.clone(),287			camel_name,288			pascal_name: snake_ident_to_pascal(ident),289			screaming_name: snake_ident_to_screaming(ident),290			selector_str,291			selector,292			args,293			has_normal_args,294			mutability,295			result: result.clone(),296		})297	}298	fn expand_call_def(&self) -> proc_macro2::TokenStream {299		let defs = self300			.args301			.iter()302			.filter(|a| !a.is_special())303			.map(|a| a.expand_call_def());304		let pascal_name = &self.pascal_name;305306		if self.has_normal_args {307			quote! {308				#pascal_name {309					#(310						#defs,311					)*312				}313			}314		} else {315			quote! {#pascal_name}316		}317	}318319	fn expand_const(&self) -> proc_macro2::TokenStream {320		let screaming_name = &self.screaming_name;321		let selector = self.selector;322		let selector_str = &self.selector_str;323		quote! {324			#[doc = #selector_str]325			const #screaming_name: u32 = #selector;326		}327	}328329	fn expand_interface_id(&self) -> proc_macro2::TokenStream {330		let screaming_name = &self.screaming_name;331		quote! {332			interface_id ^= Self::#screaming_name;333		}334	}335336	fn expand_parse(&self) -> proc_macro2::TokenStream {337		let pascal_name = &self.pascal_name;338		let screaming_name = &self.screaming_name;339		if self.has_normal_args {340			let parsers = self341				.args342				.iter()343				.filter(|a| !a.is_special())344				.map(|a| a.expand_parse());345			quote! {346				Self::#screaming_name => return Ok(Some(Self::#pascal_name {347					#(348						#parsers,349					)*350				}))351			}352		} else {353			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }354		}355	}356357	fn expand_variant_call(&self) -> proc_macro2::TokenStream {358		let pascal_name = &self.pascal_name;359		let name = &self.name;360361		let matcher = if self.has_normal_args {362			let names = self363				.args364				.iter()365				.filter(|a| !a.is_special())366				.map(|a| &a.name);367368			quote! {{369				#(370					#names,371				)*372			}}373		} else {374			quote! {}375		};376377		let receiver = match self.mutability {378			Mutability::Mutable | Mutability::View => quote! {self.},379			Mutability::Pure => quote! {Self::},380		};381		let args = self.args.iter().map(|a| a.expand_call_arg());382383		quote! {384			InternalCall::#pascal_name #matcher => {385				let result = #receiver #name(386					#(387						#args,388					)*389				)?;390				(&result).abi_write(&mut writer);391			}392		}393	}394395	fn solidity_def(&self) -> String {396		let mut out = format!("function {}(", self.camel_name);397		for (i, arg) in self.args.iter().filter(|a| !a.is_special()).enumerate() {398			if i != 0 {399				out.push_str(", ");400			}401			out.push_str(&arg.solidity_def());402		}403		out.push(')');404		match self.mutability {405			Mutability::Mutable => {}406			Mutability::View => write!(out, " view").unwrap(),407			Mutability::Pure => write!(out, " pure").unwrap(),408		}409		if self.result != "void" {410			write!(out, " returns ({})", format_ty(&self.result)).unwrap();411		}412		out.push(';');413		out414	}415}416417pub struct SolidityInterface {418	vis: Visibility,419	name: Ident,420	info: InterfaceInfo,421	methods: Vec<Method>,422	items: Vec<TraitItem>,423}424impl SolidityInterface {425	pub fn try_from(info: InterfaceInfo, value: &ItemTrait) -> syn::Result<Self> {426		let mut found_error = false;427		let mut methods = Vec::new();428429		for item in &value.items {430			match item {431				TraitItem::Type(ty) => {432					if ty.ident == "Error" {433						found_error = true;434					}435				}436				TraitItem::Method(method) => methods.push(Method::try_from(method)?),437				_ => {}438			}439		}440		if !found_error {441			return Err(syn::Error::new(442				value.span(),443				"expected associated type called Error, which should implement From<&str>",444			));445		}446		Ok(Self {447			vis: value.vis.clone(),448			name: value.ident.clone(),449			info,450			methods,451			items: value.items.clone(),452		})453	}454	pub fn expand(self) -> proc_macro2::TokenStream {455		let vis = self.vis;456		let name = self.name;457		let items = self.items;458459		let call_name = pascal_ident_to_call(&name);460461		let call_sub = self462			.info463			.inline_is464			.0465			.iter()466			.chain(self.info.is.0.iter())467			.map(Is::expand_call_def);468		let call_inner = self469			.info470			.inline_is471			.0472			.iter()473			.chain(self.info.is.0.iter())474			.map(Is::expand_call_inner);475		let call_parse = self476			.info477			.inline_is478			.0479			.iter()480			.chain(self.info.is.0.iter())481			.map(Is::expand_parse);482		let call_variants = self483			.info484			.inline_is485			.0486			.iter()487			.chain(self.info.is.0.iter())488			.map(Is::expand_variant_call);489490		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);491		let supports_interface = self.info.is.0.iter().map(Is::expand_supports_interface);492493		let calls = self.methods.iter().map(Method::expand_call_def);494		let consts = self.methods.iter().map(Method::expand_const);495		let interface_id = self.methods.iter().map(Method::expand_interface_id);496		let parsers = self.methods.iter().map(Method::expand_parse);497		let call_variants_this = self.methods.iter().map(Method::expand_variant_call);498499		// let methods = self.methods.iter().map(Method::solidity_def);500501		quote! {502			#[derive(Debug)]503			#vis enum #call_name {504				#(505					#calls,506				)*507				#(508					#call_sub,509				)*510			}511			impl #call_name {512				#(513					#consts514				)*515				pub fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::abi::Result<Option<Self>> {516					use ::evm_coder::abi::AbiRead;517					match method_id {518						#(519							#parsers,520						)*521						_ => {},522					}523					#(524						#call_parse525					)else*526					return Ok(None);527				}528				pub const fn interface_id() -> u32 {529					let mut interface_id = 0;530					#(#interface_id)*531					#(#inline_interface_id)*532					interface_id533				}534				pub fn supports_interface(interface_id: u32) -> bool {535					interface_id != 0xffffff && (536						interface_id == Self::interface_id()537						#(538							|| #supports_interface539						)*540					)541				}542			}543			#vis trait #name {544				#(545					#items546				)*547				#(548					#call_inner549				)*550				#[allow(unreachable_code)] // In case of no inner calls551				fn call(&mut self, c: Msg<#call_name>) -> ::core::result::Result<::evm_coder::abi::AbiWriter, Self::Error> {552					use ::evm_coder::abi::AbiWrite;553					type InternalCall = #call_name;554					match c.call {555						#(556							#call_variants,557						)*558						_ => {},559					}560					let mut writer = ::evm_coder::abi::AbiWriter::default();561					match c.call {562						#(563							#call_variants_this,564						)*565						_ => unreachable!()566					}567					Ok(writer)568				}569			}570		}571	}572}