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

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617#![allow(dead_code)]1819// NOTE: In order to understand this Rust macro better, first read this chapter20// about Procedural Macros in Rust book:21// https://doc.rust-lang.org/reference/procedural-macros.html2223use proc_macro2::TokenStream;24use quote::{quote, format_ident};25use inflector::cases;26use syn::{27	Expr, FnArg, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta, MetaNameValue,28	PatType, ReturnType, Type,29	spanned::Spanned,30	parse::{Parse, ParseStream},31	parenthesized, Token, LitInt, LitStr,32};3334use crate::{35	parse_ident_from_pat, parse_ident_from_path, parse_path, parse_path_segment, parse_result_ok,36	pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,37	snake_ident_to_screaming,38};3940struct Is {41	name: Ident,42	pascal_call_name: Ident,43	snake_call_name: Ident,44	via: Option<(Type, Ident)>,45	condition: Option<Expr>,46}47impl Is {48	fn expand_call_def(&self, gen_ref: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {49		let name = &self.name;50		let pascal_call_name = &self.pascal_call_name;51		quote! {52			#name(#pascal_call_name #gen_ref)53		}54	}5556	fn expand_interface_id(&self) -> proc_macro2::TokenStream {57		let pascal_call_name = &self.pascal_call_name;58		quote! {59			interface_id ^= u32::from_be_bytes(#pascal_call_name::interface_id());60		}61	}6263	fn expand_supports_interface(64		&self,65		generics: &proc_macro2::TokenStream,66	) -> proc_macro2::TokenStream {67		let pascal_call_name = &self.pascal_call_name;68		let condition = self.condition.as_ref().map(|condition| {69			quote! {70				(#condition) &&71			}72		});73		quote! {74			#condition <#pascal_call_name #generics>::supports_interface(this, interface_id)75		}76	}7778	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {79		let name = &self.name;80		quote! {81			Self::#name(call) => call.weight()82		}83	}8485	fn expand_variant_call(86		&self,87		call_name: &proc_macro2::Ident,88		generics: &proc_macro2::TokenStream,89	) -> proc_macro2::TokenStream {90		let name = &self.name;91		let pascal_call_name = &self.pascal_call_name;92		let via_typ = self93			.via94			.as_ref()95			.map(|(t, _)| quote! {#t})96			.unwrap_or_else(|| quote! {Self});97		let via_map = self98			.via99			.as_ref()100			.map(|(_, i)| quote! {.#i()})101			.unwrap_or_default();102		let condition = self.condition.as_ref().map(|condition| {103			quote! {104				if ({let this = &self; (#condition)})105			}106		});107		quote! {108			#call_name::#name(call) #condition => return <#via_typ as ::evm_coder::Callable<#pascal_call_name #generics>>::call(self #via_map, Msg {109				call,110				caller: c.caller,111				value: c.value,112			})113		}114	}115116	fn expand_parse(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {117		let name = &self.name;118		let pascal_call_name = &self.pascal_call_name;119		quote! {120			if let Some(parsed_call) = <#pascal_call_name #generics>::parse(method_id, reader)? {121				return Ok(Some(Self::#name(parsed_call)))122			}123		}124	}125126	fn expand_generator(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {127		let pascal_call_name = &self.pascal_call_name;128		quote! {129			<#pascal_call_name #generics>::generate_solidity_interface(tc, is_impl);130		}131	}132133	fn expand_event_generator(&self) -> proc_macro2::TokenStream {134		let name = &self.name;135		quote! {136			#name::generate_solidity_interface(tc, is_impl);137		}138	}139}140141#[derive(Default)]142struct IsList(Vec<Is>);143impl Parse for IsList {144	fn parse(input: ParseStream) -> syn::Result<Self> {145		let mut out = vec![];146		loop {147			if input.is_empty() {148				break;149			}150			let name = input.parse::<Ident>()?;151			let lookahead = input.lookahead1();152153			let mut condition: Option<Expr> = None;154			let mut via: Option<(Type, Ident)> = None;155156			if lookahead.peek(syn::token::Paren) {157				let contents;158				parenthesized!(contents in input);159				let input = contents;160161				while !input.is_empty() {162					let lookahead = input.lookahead1();163					if lookahead.peek(Token![if]) {164						input.parse::<Token![if]>()?;165						let contents;166						parenthesized!(contents in input);167						let contents = contents.parse::<Expr>()?;168169						if condition.replace(contents).is_some() {170							return Err(syn::Error::new(input.span(), "condition is already set"));171						}172					} else if lookahead.peek(kw::via) {173						input.parse::<kw::via>()?;174						let contents;175						parenthesized!(contents in input);176177						let method = contents.parse::<Ident>()?;178						contents.parse::<kw::returns>()?;179						let ty = contents.parse::<Type>()?;180181						if via.replace((ty, method)).is_some() {182							return Err(syn::Error::new(input.span(), "via is already set"));183						}184					} else {185						return Err(lookahead.error());186					}187188					if input.peek(Token![,]) {189						input.parse::<Token![,]>()?;190					} else if !input.is_empty() {191						return Err(syn::Error::new(input.span(), "expected end"));192					}193				}194			} else if lookahead.peek(Token![,]) || input.is_empty() {195				// Pass196			} else {197				return Err(lookahead.error());198			};199			out.push(Is {200				pascal_call_name: pascal_ident_to_call(&name),201				snake_call_name: pascal_ident_to_snake_call(&name),202				name,203				via,204				condition,205			});206			if input.peek(Token![,]) {207				input.parse::<Token![,]>()?;208				continue;209			} else {210				break;211			}212		}213		Ok(Self(out))214	}215}216217pub struct InterfaceInfo {218	name: Ident,219	is: IsList,220	inline_is: IsList,221	events: IsList,222	expect_selector: Option<u32>,223}224impl Parse for InterfaceInfo {225	fn parse(input: ParseStream) -> syn::Result<Self> {226		let mut name = None;227		let mut is = None;228		let mut inline_is = None;229		let mut events = None;230		let mut expect_selector = None;231		// TODO: create proc-macro to optimize proc-macro boilerplate? :D232		loop {233			let lookahead = input.lookahead1();234			if lookahead.peek(kw::name) {235				let k = input.parse::<kw::name>()?;236				input.parse::<Token![=]>()?;237				if name.replace(input.parse::<Ident>()?).is_some() {238					return Err(syn::Error::new(k.span(), "name is already set"));239				}240			} else if lookahead.peek(kw::is) {241				let k = input.parse::<kw::is>()?;242				let contents;243				parenthesized!(contents in input);244				if is.replace(contents.parse::<IsList>()?).is_some() {245					return Err(syn::Error::new(k.span(), "is is already set"));246				}247			} else if lookahead.peek(kw::inline_is) {248				let k = input.parse::<kw::inline_is>()?;249				let contents;250				parenthesized!(contents in input);251				if inline_is.replace(contents.parse::<IsList>()?).is_some() {252					return Err(syn::Error::new(k.span(), "inline_is is already set"));253				}254			} else if lookahead.peek(kw::events) {255				let k = input.parse::<kw::events>()?;256				let contents;257				parenthesized!(contents in input);258				if events.replace(contents.parse::<IsList>()?).is_some() {259					return Err(syn::Error::new(k.span(), "events is already set"));260				}261			} else if lookahead.peek(kw::expect_selector) {262				let k = input.parse::<kw::expect_selector>()?;263				input.parse::<Token![=]>()?;264				let value = input.parse::<LitInt>()?;265				if expect_selector266					.replace(value.base10_parse::<u32>()?)267					.is_some()268				{269					return Err(syn::Error::new(k.span(), "expect_selector is already set"));270				}271			} else if input.is_empty() {272				break;273			} else {274				return Err(lookahead.error());275			}276			if input.peek(Token![,]) {277				input.parse::<Token![,]>()?;278			} else {279				break;280			}281		}282		Ok(Self {283			name: name.ok_or_else(|| syn::Error::new(input.span(), "missing name"))?,284			is: is.unwrap_or_default(),285			inline_is: inline_is.unwrap_or_default(),286			events: events.unwrap_or_default(),287			expect_selector,288		})289	}290}291292struct MethodInfo {293	rename_selector: Option<String>,294	hide: bool,295}296impl Parse for MethodInfo {297	fn parse(input: ParseStream) -> syn::Result<Self> {298		let mut rename_selector = None;299		let mut hide = false;300		while !input.is_empty() {301			let lookahead = input.lookahead1();302			if lookahead.peek(kw::rename_selector) {303				let k = input.parse::<kw::rename_selector>()?;304				input.parse::<Token![=]>()?;305				if rename_selector306					.replace(input.parse::<LitStr>()?.value())307					.is_some()308				{309					return Err(syn::Error::new(k.span(), "rename_selector is already set"));310				}311			} else if lookahead.peek(kw::hide) {312				input.parse::<kw::hide>()?;313				hide = true;314			} else {315				return Err(lookahead.error());316			}317318			if input.peek(Token![,]) {319				input.parse::<Token![,]>()?;320			} else if !input.is_empty() {321				return Err(syn::Error::new(input.span(), "expected end"));322			}323		}324		Ok(Self {325			rename_selector,326			hide,327		})328	}329}330331trait AbiTypeHelper {332	fn plain(&self) -> syn::Result<&Ident>;333	fn is_value(&self) -> bool;334	fn is_caller(&self) -> bool;335	fn is_special(&self) -> bool;336}337338impl AbiTypeHelper for Type {339	fn plain(&self) -> syn::Result<&Ident> {340		let path = parse_path(self)?;341		let segment = parse_path_segment(path)?;342		if !segment.arguments.is_empty() {343			return Err(syn::Error::new(self.span(), "Not plain type"));344		}345		Ok(&segment.ident)346	}347348	fn is_value(&self) -> bool {349		if let Ok(ident) = self.plain() {350			return ident == "value";351		}352		false353	}354355	fn is_caller(&self) -> bool {356		if let Ok(ident) = self.plain() {357			return ident == "caller";358		}359		false360	}361362	fn is_special(&self) -> bool {363		self.is_caller() || self.is_value()364	}365}366367#[derive(Debug)]368struct MethodArg {369	name: Ident,370	camel_name: String,371	ty: Type,372}373impl MethodArg {374	fn try_from(value: &PatType) -> syn::Result<Self> {375		let name = parse_ident_from_pat(&value.pat)?.clone();376		Ok(Self {377			camel_name: cases::camelcase::to_camel_case(&name.to_string()),378			name,379			ty: value.ty.as_ref().clone(),380		})381	}382	fn is_value(&self) -> bool {383		self.ty.is_value()384	}385	fn is_caller(&self) -> bool {386		self.ty.is_caller()387	}388	fn is_special(&self) -> bool {389		self.ty.is_special()390	}391392	fn expand_call_def(&self) -> proc_macro2::TokenStream {393		assert!(!self.is_special());394		let name = &self.name;395		let ty = &self.ty;396397		quote! {398			#name: #ty399		}400	}401402	fn expand_parse(&self) -> proc_macro2::TokenStream {403		assert!(!self.is_special());404		let name = &self.name;405		let ty = &self.ty;406		quote! {407			#name: {408				let value = <#ty as ::evm_coder::abi::AbiRead>::abi_read(reader)?;409				if !is_dynamic {reader.bytes_read(<#ty as ::evm_coder::abi::AbiType>::size())};410				value411			}412		}413	}414415	fn expand_call_arg(&self) -> proc_macro2::TokenStream {416		if self.is_value() {417			quote! {418				c.value.clone()419			}420		} else if self.is_caller() {421			quote! {422				c.caller.clone()423			}424		} else {425			let name = &self.name;426			quote! {427				#name428			}429		}430	}431432	fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {433		let camel_name = &self.camel_name.to_string();434		let ty = &self.ty;435		quote! {436			<NamedArgument<#ty>>::new(#camel_name)437		}438	}439}440441#[derive(PartialEq)]442enum Mutability {443	Mutable,444	View,445	Pure,446}447448/// Group all keywords for this macro. Usage example:449/// #[solidity_interface(name = "B", inline_is(A))]450mod kw {451	syn::custom_keyword!(weight);452453	syn::custom_keyword!(via);454	syn::custom_keyword!(returns);455	syn::custom_keyword!(name);456	syn::custom_keyword!(is);457	syn::custom_keyword!(inline_is);458	syn::custom_keyword!(events);459	syn::custom_keyword!(expect_selector);460461	syn::custom_keyword!(rename_selector);462	syn::custom_keyword!(hide);463}464465/// Rust methods are parsed into this structure when Solidity code is generated466struct Method {467	name: Ident,468	camel_name: String,469	pascal_name: Ident,470	screaming_name: Ident,471	hide: bool,472	args: Vec<MethodArg>,473	has_normal_args: bool,474	has_value_args: bool,475	mutability: Mutability,476	result: Type,477	weight: Option<Expr>,478	docs: Vec<String>,479}480impl Method {481	fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {482		let mut info = MethodInfo {483			rename_selector: None,484			hide: false,485		};486		let mut docs = Vec::new();487		let mut weight = None;488		for attr in &value.attrs {489			let ident = parse_ident_from_path(&attr.path, false)?;490			if ident == "solidity" {491				info = attr.parse_args::<MethodInfo>()?;492			} else if ident == "doc" {493				let args = attr.parse_meta().unwrap();494				let value = match args {495					Meta::NameValue(MetaNameValue {496						lit: Lit::Str(str), ..497					}) => str.value(),498					_ => unreachable!(),499				};500				docs.push(value);501			} else if ident == "weight" {502				weight = Some(attr.parse_args::<Expr>()?);503			}504		}505		let ident = &value.sig.ident;506		let ident_str = ident.to_string();507		if !cases::snakecase::is_snake_case(&ident_str) {508			return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));509		}510511		let mut mutability = Mutability::Pure;512513		if let Some(FnArg::Receiver(receiver)) = value514			.sig515			.inputs516			.iter()517			.find(|arg| matches!(arg, FnArg::Receiver(_)))518		{519			if receiver.reference.is_none() {520				return Err(syn::Error::new(521					receiver.span(),522					"receiver should be by ref",523				));524			}525			if receiver.mutability.is_some() {526				mutability = Mutability::Mutable;527			} else {528				mutability = Mutability::View;529			}530		}531		let mut args = Vec::new();532		for typ in value533			.sig534			.inputs535			.iter()536			.filter(|arg| matches!(arg, FnArg::Typed(_)))537		{538			let typ = match typ {539				FnArg::Typed(typ) => typ,540				_ => unreachable!(),541			};542			args.push(MethodArg::try_from(typ)?);543		}544545		if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {546			return Err(syn::Error::new(547				args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),548				"payable function should be mutable",549			));550		}551552		let result = match &value.sig.output {553			ReturnType::Type(_, ty) => ty,554			_ => 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)")),555		};556		let result = parse_result_ok(result)?;557558		let camel_name = info559			.rename_selector560			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));561		let has_normal_args = args.iter().filter(|arg| !arg.is_special()).count() != 0;562		let has_value_args = args.iter().any(|a| a.is_value());563564		Ok(Self {565			name: ident.clone(),566			camel_name,567			pascal_name: snake_ident_to_pascal(ident),568			screaming_name: snake_ident_to_screaming(ident),569			hide: info.hide,570			args,571			has_normal_args,572			has_value_args,573			mutability,574			result: result.clone(),575			weight,576			docs,577		})578	}579	fn expand_call_def(&self) -> proc_macro2::TokenStream {580		let defs = self581			.args582			.iter()583			.filter(|a| !a.is_special())584			.map(|a| a.expand_call_def());585		let pascal_name = &self.pascal_name;586		let docs = &self.docs;587588		if self.has_normal_args {589			quote! {590				#(#[doc = #docs])*591				#[allow(missing_docs)]592				#pascal_name {593					#(594						#defs,595					)*596				}597			}598		} else {599			quote! {600				#(#[doc = #docs])*601				#[allow(missing_docs)]602				#pascal_name603			}604		}605	}606607	fn expand_const(&self) -> proc_macro2::TokenStream {608		let screaming_name = &self.screaming_name;609		let screaming_name_signature = format_ident!("{}_SIGNATURE", &self.screaming_name);610		let custom_signature = self.expand_custom_signature();611		quote! {612			const #screaming_name_signature: ::evm_coder::custom_signature::SignatureUnit = #custom_signature;613			const #screaming_name: ::evm_coder::types::Bytes4 = {614				let mut sum = ::evm_coder::sha3_const::Keccak256::new();615				let mut pos = 0;616				while pos < Self::#screaming_name_signature.len {617					sum = sum.update(&[Self::#screaming_name_signature.data[pos]; 1]);618					pos += 1;619				}620				let a = sum.finalize();621				[a[0], a[1], a[2], a[3]]622			};623		}624	}625626	fn expand_interface_id(&self) -> proc_macro2::TokenStream {627		let screaming_name = &self.screaming_name;628		quote! {629			interface_id ^= u32::from_be_bytes(Self::#screaming_name);630		}631	}632633	fn expand_parse(&self) -> proc_macro2::TokenStream {634		let pascal_name = &self.pascal_name;635		let screaming_name = &self.screaming_name;636		if self.has_normal_args {637			let args_iter = self.args.iter().filter(|a| !a.is_special());638			let arg_type = args_iter.clone().map(|a| &a.ty);639			let parsers = args_iter.map(|a| a.expand_parse());640			quote! {641				Self::#screaming_name => {642					let is_dynamic = false #(|| <#arg_type as ::evm_coder::abi::AbiType>::is_dynamic())*;643					return Ok(Some(Self::#pascal_name {644						#(645							#parsers,646						)*647					}))648				}649			}650		} else {651			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }652		}653	}654655	fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {656		let pascal_name = &self.pascal_name;657		let name = &self.name;658659		let matcher = if self.has_normal_args {660			let names = self661				.args662				.iter()663				.filter(|a| !a.is_special())664				.map(|a| &a.name);665666			quote! {{667				#(668					#names,669				)*670			}}671		} else {672			quote! {}673		};674675		let receiver = match self.mutability {676			Mutability::Mutable | Mutability::View => quote! {self.},677			Mutability::Pure => quote! {Self::},678		};679		let args = self.args.iter().map(|a| a.expand_call_arg());680681		quote! {682			#call_name::#pascal_name #matcher => {683				#[allow(deprecated)]684				let result = #receiver #name(685					#(686						#args,687					)*688				)?;689				(&result).to_result()690			}691		}692	}693694	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {695		let pascal_name = &self.pascal_name;696		if let Some(weight) = &self.weight {697			let matcher = if self.has_normal_args {698				let names = self699					.args700					.iter()701					.filter(|a| !a.is_special())702					.map(|a| &a.name);703704				quote! {{705					#(706						#names,707					)*708				}}709			} else {710				quote! {}711			};712			quote! {713				Self::#pascal_name #matcher => (#weight).into()714			}715		} else {716			let matcher = if self.has_normal_args {717				quote! {{..}}718			} else {719				quote! {}720			};721			quote! {722				Self::#pascal_name #matcher => ().into()723			}724		}725	}726727	fn expand_custom_signature(&self) -> proc_macro2::TokenStream {728		let mut args = TokenStream::new();729730		let mut has_params = false;731		for arg in self.args.iter().filter(|a| !a.is_special()) {732			has_params = true;733			let ty = &arg.ty;734			args.extend(quote! {nameof(<#ty>::SIGNATURE)});735			args.extend(quote! {fixed(",")})736		}737738		// Remove trailing comma739		if has_params {740			args.extend(quote! {shift_left(1)})741		}742743		let func_name = self.camel_name.clone();744		quote! { ::evm_coder::make_signature!(new fixed(#func_name) fixed("(") #args fixed(")")) }745	}746747	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {748		let camel_name = &self.camel_name;749		let mutability = match self.mutability {750			Mutability::Mutable => quote! {SolidityMutability::Mutable},751			Mutability::View => quote! { SolidityMutability::View },752			Mutability::Pure => quote! {SolidityMutability::Pure},753		};754		let result = &self.result;755756		let args = self757			.args758			.iter()759			.filter(|a| !a.is_special())760			.map(MethodArg::expand_solidity_argument);761		let docs = &self.docs;762		let screaming_name = &self.screaming_name;763		let hide = self.hide;764		let custom_signature = self.expand_custom_signature();765		let is_payable = self.has_value_args;766767		quote! {768			SolidityFunction {769				docs: &[#(#docs),*],770				hide: #hide,771				selector: u32::from_be_bytes(Self::#screaming_name),772				custom_signature: #custom_signature,773				name: #camel_name,774				mutability: #mutability,775				is_payable: #is_payable,776				args: (777					#(778						#args,779					)*780				),781				result: <UnnamedArgument<#result>>::default(),782			}783		}784	}785}786787fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {788	if gen.params.is_empty() {789		return quote! {};790	}791	let params = gen.params.iter().map(|p| match p {792		syn::GenericParam::Type(id) => {793			let v = &id.ident;794			quote! {#v}795		}796		syn::GenericParam::Lifetime(lt) => {797			let v = &lt.lifetime;798			quote! {#v}799		}800		syn::GenericParam::Const(c) => {801			let i = &c.ident;802			quote! {#i}803		}804	});805	quote! { #(#params),* }806}807fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {808	if gen.params.is_empty() {809		return quote! {};810	}811	let list = generics_list(gen);812	quote! { <#list> }813}814fn generics_stub(gen: &Generics) -> proc_macro2::TokenStream {815	if gen.params.is_empty() {816		return quote! {};817	}818	let params = (0..gen.params.len()).map(|_| quote! {()});819	quote! {<#(#params,)*>}820}821fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {822	let list = generics_list(gen);823	if gen.params.len() == 1 {824		quote! {#list}825	} else {826		quote! { (#list) }827	}828}829830pub struct SolidityInterface {831	generics: Generics,832	name: Box<syn::Type>,833	info: InterfaceInfo,834	methods: Vec<Method>,835	docs: Vec<String>,836}837impl SolidityInterface {838	pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {839		let mut methods = Vec::new();840841		for item in &value.items {842			if let ImplItem::Method(method) = item {843				methods.push(Method::try_from(method)?)844			}845		}846		let mut docs = vec![];847		for attr in &value.attrs {848			let ident = parse_ident_from_path(&attr.path, false)?;849			if ident == "doc" {850				let args = attr.parse_meta().unwrap();851				let value = match args {852					Meta::NameValue(MetaNameValue {853						lit: Lit::Str(str), ..854					}) => str.value(),855					_ => unreachable!(),856				};857				docs.push(value);858			}859		}860		Ok(Self {861			generics: value.generics.clone(),862			name: value.self_ty.clone(),863			info,864			methods,865			docs,866		})867	}868	pub fn expand(self) -> proc_macro2::TokenStream {869		let name = self.name;870871		let solidity_name = self.info.name.to_string();872		let call_name = pascal_ident_to_call(&self.info.name);873		let generics = self.generics;874		let gen_ref = generics_reference(&generics);875		let gen_data = generics_data(&generics);876		let gen_stub = generics_stub(&generics);877		let gen_where = &generics.where_clause;878879		let call_sub = self880			.info881			.inline_is882			.0883			.iter()884			.chain(self.info.is.0.iter())885			.map(|c| Is::expand_call_def(c, &gen_ref));886		let call_parse = self887			.info888			.inline_is889			.0890			.iter()891			.chain(self.info.is.0.iter())892			.map(|is| Is::expand_parse(is, &gen_ref));893		let call_variants = self894			.info895			.inline_is896			.0897			.iter()898			.chain(self.info.is.0.iter())899			.map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));900		let weight_variants = self901			.info902			.inline_is903			.0904			.iter()905			.chain(self.info.is.0.iter())906			.map(Is::expand_variant_weight);907908		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);909		let supports_interface = self910			.info911			.is912			.0913			.iter()914			.map(|is| Is::expand_supports_interface(is, &gen_ref));915916		let calls = self.methods.iter().map(Method::expand_call_def);917		let consts = self.methods.iter().map(Method::expand_const);918		let interface_id = self.methods.iter().map(Method::expand_interface_id);919		let parsers = self.methods.iter().map(Method::expand_parse);920		let call_variants_this = self921			.methods922			.iter()923			.map(|m| Method::expand_variant_call(m, &call_name));924		let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);925		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);926927		// TODO: Inline inline_is928		let solidity_is = self929			.info930			.is931			.0932			.iter()933			.chain(self.info.inline_is.0.iter())934			.map(|is| is.name.to_string());935		let solidity_events_is = self.info.events.0.iter().map(|is| is.name.to_string());936		let solidity_generators = self937			.info938			.is939			.0940			.iter()941			.chain(self.info.inline_is.0.iter())942			.map(|is| Is::expand_generator(is, &gen_ref));943		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);944		let solidity_events_idents = self.info.events.0.iter().map(|is| is.name.clone());945		let docs = &self.docs;946947		let expect_selector = self.info.expect_selector.map(|s| {948            quote! {949                const _: () = assert!(#s == u32::from_be_bytes(<#call_name #gen_stub>::interface_id()), "selector mismatch, review contained function selectors");950            }951        });952953		quote! {954			#(955				const _: ::core::marker::PhantomData<#solidity_events_idents> = ::core::marker::PhantomData;956			)*957			#[derive(Debug)]958			#(#[doc = #docs])*959			pub enum #call_name #gen_ref {960				/// Inherited method961				ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),962				#(963					#calls,964				)*965				#(966					#call_sub,967				)*968			}969970			#expect_selector971972			impl #gen_ref #call_name #gen_ref {973				#(974					#consts975				)*976				/// Return this call ERC165 selector977				pub const fn interface_id() -> ::evm_coder::types::Bytes4 {978					let mut interface_id = 0;979					#(#interface_id)*980					#(#inline_interface_id)*981					u32::to_be_bytes(interface_id)982				}983				/// Generate solidity definitions for methods described in this interface984				#[cfg(feature = "stubgen")]985				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {986					use evm_coder::solidity::*;987					use core::fmt::Write;988					let interface = SolidityInterface {989						docs: &[#(#docs),*],990						name: #solidity_name,991						selector: Self::interface_id(),992						is: &["Dummy", "ERC165", #(993							#solidity_is,994						)* #(995							#solidity_events_is,996						)* ],997						functions: (#(998							#solidity_functions,999						)*),1000					};10011002					let mut out = ::evm_coder::types::string::new();1003					if #solidity_name.starts_with("Inline") {1004						out.push_str("/// @dev inlined interface\n");1005					}1006					let _ = interface.format(is_impl, &mut out, tc);1007					tc.collect(out);1008					#(1009						#solidity_event_generators1010					)*1011					#(1012						#solidity_generators1013					)*1014					if is_impl {1015						tc.collect("/// @dev common stubs holder\ncontract Dummy {\n\tuint8 dummy;\n\tstring stub_error = \"this contract is implemented in native\";\n}\ncontract ERC165 is Dummy {\n\tfunction supportsInterface(bytes4 interfaceID) external view returns (bool) {\n\t\trequire(false, stub_error);\n\t\tinterfaceID;\n\t\treturn true;\n\t}\n}\n".into());1016					} else {1017						tc.collect("/// @dev common stubs holder\ninterface Dummy {\n}\ninterface ERC165 is Dummy {\n\tfunction supportsInterface(bytes4 interfaceID) external view returns (bool);\n}\n".into());1018					}1019				}1020			}1021			impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {1022				fn parse(method_id: ::evm_coder::types::Bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {1023					use ::evm_coder::abi::AbiRead;1024					match method_id {1025						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(1026							::evm_coder::ERC165Call::parse(method_id, reader)?1027							.map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))1028						),1029						#(1030							#parsers,1031						)*1032						_ => {},1033					}1034					#(1035						#call_parse1036					)else*1037					return Ok(None);1038				}1039			}1040			impl #generics #call_name #gen_ref1041			#gen_where1042			{1043				/// Is this contract implements specified ERC165 selector1044				pub fn supports_interface(this: &#name, interface_id: ::evm_coder::types::Bytes4) -> bool {1045					interface_id != u32::to_be_bytes(0xffffff) && (1046						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||1047						interface_id == Self::interface_id()1048						#(1049							|| #supports_interface1050						)*1051					)1052				}1053			}1054			impl #generics ::evm_coder::Weighted for #call_name #gen_ref1055			#gen_where1056			{1057				#[allow(unused_variables)]1058				fn weight(&self) -> ::evm_coder::execution::DispatchInfo {1059					match self {1060						#(1061							#weight_variants,1062						)*1063						// TODO: It should be very cheap, but not free1064						Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => ::frame_support::weights::Weight::from_ref_time(100).into(),1065						#(1066							#weight_variants_this,1067						)*1068					}1069				}1070			}1071			impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name1072			#gen_where1073			{1074				#[allow(unreachable_code)] // In case of no inner calls1075				fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {1076					use ::evm_coder::abi::AbiWrite;1077					match c.call {1078						#(1079							#call_variants,1080						)*1081						#call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {1082							let mut writer = ::evm_coder::abi::AbiWriter::default();1083							writer.bool(&<#call_name #gen_ref>::supports_interface(self, interface_id));1084							return Ok(writer.into());1085						}1086						_ => {},1087					}1088					let mut writer = ::evm_coder::abi::AbiWriter::default();1089					match c.call {1090						#(1091							#call_variants_this,1092						)*1093						_ => Err(::evm_coder::execution::Error::from("method is not available").into()),1094					}1095				}1096			}1097		}1098	}1099}