git.delta.rocks / unique-network / refs/commits / f3ac592dce90

1#![allow(dead_code)]23use quote::quote;4use darling::FromMeta;5use inflector::cases;6use std::fmt::Write;7use syn::{FnArg, Ident, ItemTrait, Meta, NestedMeta, PatType, Path, ReturnType, TraitItem, TraitItemMethod, Type, Visibility, spanned::Spanned};89use crate::{10	fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_ident_from_type,11	parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,12	snake_ident_to_screaming,13};1415struct Is {16	name: Ident,17	pascal_call_name: Ident,18	snake_call_name: Ident,19}20impl Is {21	fn try_from(path: &Path) -> syn::Result<Self> {22		let name = parse_ident_from_path(path)?.clone();23		Ok(Self {24			pascal_call_name: pascal_ident_to_call(&name),25			snake_call_name: pascal_ident_to_snake_call(&name),26			name,27		})28	}2930	fn expand_call_def(&self) -> proc_macro2::TokenStream {31		let name = &self.name;32		let pascal_call_name = &self.pascal_call_name;33		quote! {34			#name(#pascal_call_name)35		}36	}3738	fn expand_interface_id(&self) -> proc_macro2::TokenStream {39		let pascal_call_name = &self.pascal_call_name;40		quote! {41			interface_id ^= #pascal_call_name::interface_id();42		}43	}4445	fn expand_supports_interface(&self) -> proc_macro2::TokenStream {46		let pascal_call_name = &self.pascal_call_name;47		quote! {48			#pascal_call_name::supports_interface(interface_id)49		}50	}5152	fn expand_variant_call(&self) -> proc_macro2::TokenStream {53		let name = &self.name;54		let snake_call_name = &self.snake_call_name;55		quote! {56			InternalCall::#name(call) => return self.#snake_call_name(Msg {57				call,58				caller: c.caller,59				value: c.value,60			})61		}62	}6364	fn expand_call_inner(&self) -> proc_macro2::TokenStream {65		let snake_call_name = &self.snake_call_name;66		let pascal_call_name = &self.pascal_call_name;67		quote! {68			fn #snake_call_name(&mut self, c: Msg<#pascal_call_name>) -> Result<::evm_coder::abi::AbiWriter>;69		}70	}7172	fn expand_parse(&self) -> proc_macro2::TokenStream {73		let name = &self.name;74		let pascal_call_name = &self.pascal_call_name;75		quote! {76			if let Some(parsed_call) = #pascal_call_name::parse(method_id, reader)? {77				return Ok(Some(Self::#name(parsed_call)))78			}79		}80	}81}8283#[derive(Default)]84struct IsList(Vec<Is>);85impl FromMeta for IsList {86	fn from_list(items: &[NestedMeta]) -> darling::Result<Self> {87		let mut out = Vec::new();88		for item in items {89			match item {90				NestedMeta::Meta(Meta::Path(path)) => out.push(Is::try_from(path)?),91				_ => return Err(syn::Error::new(item.span(), "expected path").into()),92			}93		}94		Ok(Self(out))95	}96}9798#[derive(FromMeta)]99pub struct InterfaceInfo {100	#[darling(default)]101	is: IsList,102	#[darling(default)]103	inline_is: IsList,104	#[darling(default)]105	events: IsList,106}107108#[derive(FromMeta)]109struct MethodInfo {110	#[darling(default)]111	rename_selector: Option<String>,112}113114struct MethodArg {115	name: Ident,116	ty: Ident,117}118impl MethodArg {119	fn try_from(value: &PatType) -> syn::Result<Self> {120		Ok(Self {121			name: parse_ident_from_pat(&value.pat)?.clone(),122			ty: parse_ident_from_type(&value.ty)?.clone(),123		})124	}125	fn is_value(&self) -> bool {126		self.ty == "value"127	}128	fn is_caller(&self) -> bool {129		self.ty == "caller"130	}131	fn is_special(&self) -> bool {132		self.is_value() || self.is_caller()133	}134	fn selector_ty(&self) -> &Ident {135		assert!(!self.is_special());136		&self.ty137	}138139	fn expand_call_def(&self) -> proc_macro2::TokenStream {140		assert!(!self.is_special());141		let name = &self.name;142		let ty = &self.ty;143144		quote! {145			#name: #ty146		}147	}148149	fn expand_parse(&self) -> proc_macro2::TokenStream {150		assert!(!self.is_special());151		let name = &self.name;152		quote! {153			#name: reader.abi_read()?154		}155	}156157	fn expand_call_arg(&self) -> proc_macro2::TokenStream {158		if self.is_value() {159			quote! {160				c.value.clone()161			}162		} else if self.is_caller() {163			quote! {164				c.caller.clone()165			}166		} else {167			let name = &self.name;168			quote! {169				#name170			}171		}172	}173}174175#[derive(PartialEq)]176enum Mutability {177	Mutable,178	View,179	Pure,180}181182struct Method {183	name: Ident,184	camel_name: String,185	pascal_name: Ident,186	screaming_name: Ident,187	selector_str: String,188	selector: u32,189	args: Vec<MethodArg>,190	has_normal_args: bool,191	mutability: Mutability,192	result: Type,193}194impl Method {195	fn try_from(value: &TraitItemMethod) -> syn::Result<Self> {196		let mut info = MethodInfo {197			rename_selector: None,198		};199		for attr in &value.attrs {200			let ident = parse_ident_from_path(&attr.path)?;201			if ident == "solidity" {202				let args = attr.parse_meta().unwrap();203				info = MethodInfo::from_meta(&args).unwrap();204			} else if ident == "doc" {205				// TODO: Add docs to evm interfaces206			}207		}208		let ident = &value.sig.ident;209		let ident_str = ident.to_string();210		if !cases::snakecase::is_snake_case(&ident_str) {211			return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));212		}213214		let mut mutability = Mutability::Pure;215216		if let Some(FnArg::Receiver(receiver)) = value217			.sig218			.inputs219			.iter()220			.find(|arg| matches!(arg, FnArg::Receiver(_)))221		{222			if receiver.reference.is_none() {223				return Err(syn::Error::new(224					receiver.span(),225					"receiver should be by ref",226				));227			}228			if receiver.mutability.is_some() {229				mutability = Mutability::Mutable;230			} else {231				mutability = Mutability::View;232			}233		}234		let mut args = Vec::new();235		for typ in value236			.sig237			.inputs238			.iter()239			.filter(|arg| matches!(arg, FnArg::Typed(_)))240		{241			let typ = match typ {242				FnArg::Typed(typ) => typ,243				_ => unreachable!(),244			};245			args.push(MethodArg::try_from(typ)?);246		}247248		if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {249			return Err(syn::Error::new(250				args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),251				"payable function should be mutable",252			));253		}254255		let result = match &value.sig.output {256			ReturnType::Type(_, ty) => ty,257			_ => 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)")),258		};259		let result = parse_result_ok(result)?;260261		let camel_name = info262			.rename_selector263			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));264		let mut selector_str = camel_name.clone();265		selector_str.push('(');266		let mut has_normal_args = false;267		for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {268			if i != 0 {269				selector_str.push(',');270			}271			write!(selector_str, "{}", arg.selector_ty()).unwrap();272			has_normal_args = true;273		}274		selector_str.push(')');275		let selector = fn_selector_str(&selector_str);276277		Ok(Self {278			name: ident.clone(),279			camel_name,280			pascal_name: snake_ident_to_pascal(ident),281			screaming_name: snake_ident_to_screaming(ident),282			selector_str,283			selector,284			args,285			has_normal_args,286			mutability,287			result: result.clone(),288		})289	}290	fn expand_call_def(&self) -> proc_macro2::TokenStream {291		let defs = self292			.args293			.iter()294			.filter(|a| !a.is_special())295			.map(|a| a.expand_call_def());296		let pascal_name = &self.pascal_name;297298		if self.has_normal_args {299			quote! {300				#pascal_name {301					#(302						#defs,303					)*304				}305			}306		} else {307			quote! {#pascal_name}308		}309	}310311	fn expand_const(&self) -> proc_macro2::TokenStream {312		let screaming_name = &self.screaming_name;313		let selector = self.selector;314		let selector_str = &self.selector_str;315		quote! {316			#[doc = #selector_str]317			const #screaming_name: u32 = #selector;318		}319	}320321	fn expand_interface_id(&self) -> proc_macro2::TokenStream {322		let screaming_name = &self.screaming_name;323		quote! {324			interface_id ^= Self::#screaming_name;325		}326	}327328	fn expand_parse(&self) -> proc_macro2::TokenStream {329		let pascal_name = &self.pascal_name;330		let screaming_name = &self.screaming_name;331		if self.has_normal_args {332			let parsers = self333				.args334				.iter()335				.filter(|a| !a.is_special())336				.map(|a| a.expand_parse());337			quote! {338				Self::#screaming_name => return Ok(Some(Self::#pascal_name {339					#(340						#parsers,341					)*342				}))343			}344		} else {345			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }346		}347	}348349	fn expand_variant_call(&self) -> proc_macro2::TokenStream {350		let pascal_name = &self.pascal_name;351		let name = &self.name;352353		let matcher = if self.has_normal_args {354			let names = self355				.args356				.iter()357				.filter(|a| !a.is_special())358				.map(|a| &a.name);359360			quote! {{361				#(362					#names,363				)*364			}}365		} else {366			quote! {}367		};368369		let receiver = match self.mutability {370			Mutability::Mutable | Mutability::View => quote! {self.},371			Mutability::Pure => quote! {Self::},372		};373		let args = self.args.iter().map(|a| a.expand_call_arg());374375		quote! {376			InternalCall::#pascal_name #matcher => {377				let result = #receiver #name(378					#(379						#args,380					)*381				)?;382				(&result).abi_write(&mut writer);383			}384		}385	}386}387388pub struct SolidityInterface {389	vis: Visibility,390	name: Ident,391	info: InterfaceInfo,392	methods: Vec<Method>,393	items: Vec<TraitItem>,394}395impl SolidityInterface {396	pub fn try_from(info: InterfaceInfo, value: &ItemTrait) -> syn::Result<Self> {397		let mut methods = Vec::new();398399		for item in &value.items {400			match item {401				TraitItem::Method(method) => methods.push(Method::try_from(method)?),402				_ => {}403			}404		}405		Ok(Self {406			vis: value.vis.clone(),407			name: value.ident.clone(),408			info,409			methods,410			items: value.items.clone(),411		})412	}413	pub fn expand(self) -> proc_macro2::TokenStream {414		let vis = self.vis;415		let name = self.name;416		let items = self.items;417418		let call_name = pascal_ident_to_call(&name);419420		let call_sub = self421			.info422			.inline_is423			.0424			.iter()425			.chain(self.info.is.0.iter())426			.map(Is::expand_call_def);427		let call_inner = self428			.info429			.inline_is430			.0431			.iter()432			.chain(self.info.is.0.iter())433			.map(Is::expand_call_inner);434		let call_parse = self435			.info436			.inline_is437			.0438			.iter()439			.chain(self.info.is.0.iter())440			.map(Is::expand_parse);441		let call_variants = self442			.info443			.inline_is444			.0445			.iter()446			.chain(self.info.is.0.iter())447			.map(Is::expand_variant_call);448449		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);450		let supports_interface = self.info.is.0.iter().map(Is::expand_supports_interface);451452		let calls = self.methods.iter().map(Method::expand_call_def);453		let consts = self.methods.iter().map(Method::expand_const);454		let interface_id = self.methods.iter().map(Method::expand_interface_id);455		let parsers = self.methods.iter().map(Method::expand_parse);456		let call_variants_this = self.methods.iter().map(Method::expand_variant_call);457458		// let methods = self.methods.iter().map(Method::solidity_def);459460		quote! {461			#[derive(Debug)]462			#vis enum #call_name {463				#(464					#calls,465				)*466				#(467					#call_sub,468				)*469			}470			impl #call_name {471				#(472					#consts473				)*474				pub const fn interface_id() -> u32 {475					let mut interface_id = 0;476					#(#interface_id)*477					#(#inline_interface_id)*478					interface_id479				}480				pub fn supports_interface(interface_id: u32) -> bool {481					interface_id != 0xffffff && (482						interface_id == Self::interface_id()483						#(484							|| #supports_interface485						)*486					)487				}488			}489            impl ::evm_coder::Call for #call_name {490				fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {491					use ::evm_coder::abi::AbiRead;492					match method_id {493						#(494							#parsers,495						)*496						_ => {},497					}498					#(499						#call_parse500					)else*501					return Ok(None);502				}503            }504			#vis trait #name {505				#(506					#items507				)*508				#(509					#call_inner510				)*511			}512            impl<T> ::evm_coder::Callable for T where T: #name {513                type Call = #call_name;514				#[allow(unreachable_code)] // In case of no inner calls515				fn call(&mut self, c: Msg<#call_name>) -> Result<::evm_coder::abi::AbiWriter> {516					use ::evm_coder::abi::AbiWrite;517					type InternalCall = #call_name;518					match c.call {519						#(520							#call_variants,521						)*522						_ => {},523					}524					let mut writer = ::evm_coder::abi::AbiWriter::default();525					match c.call {526						#(527							#call_variants_this,528						)*529						_ => unreachable!()530					}531					Ok(writer)532				}533            }534		}535	}536}