git.delta.rocks / unique-network / refs/commits / 258c7f483482

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)]1819use quote::quote;20use darling::{FromMeta, ToTokens};21use inflector::cases;22use std::fmt::Write;23use syn::{24	Expr, FnArg, GenericArgument, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta,25	MetaNameValue, NestedMeta, PatType, Path, PathArguments, ReturnType, Type, spanned::Spanned,26	parse_str,27};2829use crate::{30	fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_path, parse_path_segment,31	parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,32	snake_ident_to_screaming,33};3435struct Is {36	name: Ident,37	pascal_call_name: Ident,38	snake_call_name: Ident,39	via: Option<(Type, Ident)>,40}41impl Is {42	fn new_via(path: &Path, via: Option<(Type, Ident)>) -> syn::Result<Self> {43		let name = parse_ident_from_path(path, false)?.clone();44		Ok(Self {45			pascal_call_name: pascal_ident_to_call(&name),46			snake_call_name: pascal_ident_to_snake_call(&name),47			name,48			via,49		})50	}51	fn new(path: &Path) -> syn::Result<Self> {52		Self::new_via(path, None)53	}5455	fn expand_call_def(&self, gen_ref: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {56		let name = &self.name;57		let pascal_call_name = &self.pascal_call_name;58		quote! {59			#name(#pascal_call_name #gen_ref)60		}61	}6263	fn expand_interface_id(&self) -> proc_macro2::TokenStream {64		let pascal_call_name = &self.pascal_call_name;65		quote! {66			interface_id ^= u32::from_be_bytes(#pascal_call_name::interface_id());67		}68	}6970	fn expand_supports_interface(71		&self,72		generics: &proc_macro2::TokenStream,73	) -> proc_macro2::TokenStream {74		let pascal_call_name = &self.pascal_call_name;75		quote! {76			<#pascal_call_name #generics>::supports_interface(interface_id)77		}78	}7980	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {81		let name = &self.name;82		quote! {83			Self::#name(call) => call.weight()84		}85	}8687	fn expand_variant_call(88		&self,89		call_name: &proc_macro2::Ident,90		generics: &proc_macro2::TokenStream,91	) -> proc_macro2::TokenStream {92		let name = &self.name;93		let pascal_call_name = &self.pascal_call_name;94		let via_typ = self95			.via96			.as_ref()97			.map(|(t, _)| quote! {#t})98			.unwrap_or_else(|| quote! {Self});99		let via_map = self100			.via101			.as_ref()102			.map(|(_, i)| quote! {.#i()})103			.unwrap_or_default();104		quote! {105			#call_name::#name(call) => return <#via_typ as ::evm_coder::Callable<#pascal_call_name #generics>>::call(self #via_map, Msg {106				call,107				caller: c.caller,108				value: c.value,109			})110		}111	}112113	fn expand_parse(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {114		let name = &self.name;115		let pascal_call_name = &self.pascal_call_name;116		quote! {117			if let Some(parsed_call) = <#pascal_call_name #generics>::parse(method_id, reader)? {118				return Ok(Some(Self::#name(parsed_call)))119			}120		}121	}122123	fn expand_generator(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {124		let pascal_call_name = &self.pascal_call_name;125		quote! {126			<#pascal_call_name #generics>::generate_solidity_interface(tc, is_impl);127		}128	}129130	fn expand_event_generator(&self) -> proc_macro2::TokenStream {131		let name = &self.name;132		quote! {133			#name::generate_solidity_interface(tc, is_impl);134		}135	}136}137138#[derive(Default)]139struct IsList(Vec<Is>);140impl FromMeta for IsList {141	fn from_list(items: &[NestedMeta]) -> darling::Result<Self> {142		let mut out = Vec::new();143		for item in items {144			match item {145				NestedMeta::Meta(Meta::Path(path)) => out.push(Is::new(path)?),146				// TODO: replace meta parsing with manual147				NestedMeta::Meta(Meta::List(list))148					if list.path.is_ident("via") && list.nested.len() == 3 =>149				{150					let mut data = list.nested.iter();151					let typ = match data.next().expect("len == 3") {152						NestedMeta::Lit(Lit::Str(s)) => {153							let v = s.value();154							let typ: Type = parse_str(&v)?;155							typ156						}157						_ => {158							return Err(syn::Error::new(159								item.span(),160								"via typ should be type in string",161							)162							.into())163						}164					};165					let via = match data.next().expect("len == 3") {166						NestedMeta::Meta(Meta::Path(path)) => path167							.get_ident()168							.ok_or_else(|| syn::Error::new(item.span(), "via should be ident"))?,169						_ => return Err(syn::Error::new(item.span(), "via should be ident").into()),170					};171					let path = match data.next().expect("len == 3") {172						NestedMeta::Meta(Meta::Path(path)) => path,173						_ => return Err(syn::Error::new(item.span(), "path should be path").into()),174					};175176					out.push(Is::new_via(path, Some((typ, via.clone())))?)177				}178				_ => {179					return Err(syn::Error::new(180						item.span(),181						"expected either Name or via(\"Type\", getter, Name)",182					)183					.into())184				}185			}186		}187		Ok(Self(out))188	}189}190191#[derive(FromMeta)]192pub struct InterfaceInfo {193	name: Ident,194	#[darling(default)]195	is: IsList,196	#[darling(default)]197	inline_is: IsList,198	#[darling(default)]199	events: IsList,200}201202#[derive(FromMeta)]203struct MethodInfo {204	#[darling(default)]205	rename_selector: Option<String>,206}207208enum AbiType {209	// type210	Plain(Ident),211	// (type1,type2)212	Tuple(Vec<AbiType>),213	// type[]214	Vec(Box<AbiType>),215	// type[20]216	Array(Box<AbiType>, usize),217}218impl AbiType {219	fn try_from(value: &Type) -> syn::Result<Self> {220		let value = Self::try_maybe_special_from(value)?;221		if value.is_special() {222			return Err(syn::Error::new(value.span(), "unexpected special type"));223		}224		Ok(value)225	}226	fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {227		match value {228			Type::Array(arr) => {229				let wrapped = AbiType::try_from(&arr.elem)?;230				match &arr.len {231					Expr::Lit(l) => match &l.lit {232						Lit::Int(i) => {233							let num = i.base10_parse::<usize>()?;234							Ok(AbiType::Array(Box::new(wrapped), num as usize))235						}236						_ => Err(syn::Error::new(arr.len.span(), "should be int literal")),237					},238					_ => Err(syn::Error::new(arr.len.span(), "should be literal")),239				}240			}241			Type::Path(_) => {242				let path = parse_path(value)?;243				let segment = parse_path_segment(path)?;244				if segment.ident == "Vec" {245					let args = match &segment.arguments {246						PathArguments::AngleBracketed(e) => e,247						_ => {248							return Err(syn::Error::new(249								segment.arguments.span(),250								"missing Vec generic",251							))252						}253					};254					let args = &args.args;255					if args.len() != 1 {256						return Err(syn::Error::new(257							args.span(),258							"expected only one generic for vec",259						));260					}261					let arg = args.first().unwrap();262263					let ty = match arg {264						GenericArgument::Type(ty) => ty,265						_ => {266							return Err(syn::Error::new(267								arg.span(),268								"expected first generic to be type",269							))270						}271					};272273					let wrapped = AbiType::try_from(ty)?;274					Ok(Self::Vec(Box::new(wrapped)))275				} else {276					if !segment.arguments.is_empty() {277						return Err(syn::Error::new(278							segment.arguments.span(),279							"unexpected generic arguments for non-vec type",280						));281					}282					Ok(Self::Plain(segment.ident.clone()))283				}284			}285			Type::Tuple(t) => {286				let mut out = Vec::with_capacity(t.elems.len());287				for el in t.elems.iter() {288					out.push(AbiType::try_from(el)?)289				}290				Ok(Self::Tuple(out))291			}292			_ => Err(syn::Error::new(293				value.span(),294				"unexpected type, only arrays, plain types and tuples are supported",295			)),296		}297	}298	fn is_value(&self) -> bool {299		matches!(self, Self::Plain(v) if v == "value")300	}301	fn is_caller(&self) -> bool {302		matches!(self, Self::Plain(v) if v == "caller")303	}304	fn is_special(&self) -> bool {305		self.is_caller() || self.is_value()306	}307	fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {308		match self {309			AbiType::Plain(t) => {310				write!(buf, "{}", t)311			}312			AbiType::Tuple(t) => {313				write!(buf, "(")?;314				for (i, t) in t.iter().enumerate() {315					if i != 0 {316						write!(buf, ",")?;317					}318					t.selector_ty_buf(buf)?;319				}320				write!(buf, ")")321			}322			AbiType::Vec(v) => {323				v.selector_ty_buf(buf)?;324				write!(buf, "[]")325			}326			AbiType::Array(v, len) => {327				v.selector_ty_buf(buf)?;328				write!(buf, "[{}]", len)329			}330		}331	}332	fn selector_ty(&self) -> String {333		let mut out = String::new();334		self.selector_ty_buf(&mut out).expect("no fmt error");335		out336	}337}338impl ToTokens for AbiType {339	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {340		match self {341			AbiType::Plain(t) => tokens.extend(quote! {#t}),342			AbiType::Tuple(t) => {343				tokens.extend(quote! {(344					#(#t),*345				)});346			}347			AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),348			AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),349		}350	}351}352353struct MethodArg {354	name: Ident,355	camel_name: String,356	ty: AbiType,357}358impl MethodArg {359	fn try_from(value: &PatType) -> syn::Result<Self> {360		let name = parse_ident_from_pat(&value.pat)?.clone();361		Ok(Self {362			camel_name: cases::camelcase::to_camel_case(&name.to_string()),363			name,364			ty: AbiType::try_maybe_special_from(&value.ty)?,365		})366	}367	fn is_value(&self) -> bool {368		self.ty.is_value()369	}370	fn is_caller(&self) -> bool {371		self.ty.is_caller()372	}373	fn is_special(&self) -> bool {374		self.ty.is_special()375	}376	fn selector_ty(&self) -> String {377		assert!(!self.is_special());378		self.ty.selector_ty()379	}380381	fn expand_call_def(&self) -> proc_macro2::TokenStream {382		assert!(!self.is_special());383		let name = &self.name;384		let ty = &self.ty;385386		quote! {387			#name: #ty388		}389	}390391	fn expand_parse(&self) -> proc_macro2::TokenStream {392		assert!(!self.is_special());393		let name = &self.name;394		quote! {395			#name: reader.abi_read()?396		}397	}398399	fn expand_call_arg(&self) -> proc_macro2::TokenStream {400		if self.is_value() {401			quote! {402				c.value.clone()403			}404		} else if self.is_caller() {405			quote! {406				c.caller.clone()407			}408		} else {409			let name = &self.name;410			quote! {411				#name412			}413		}414	}415416	fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {417		let camel_name = &self.camel_name.to_string();418		let ty = &self.ty;419		quote! {420			<NamedArgument<#ty>>::new(#camel_name)421		}422	}423}424425#[derive(PartialEq)]426enum Mutability {427	Mutable,428	View,429	Pure,430}431432pub struct WeightAttr(syn::Expr);433434mod keyword {435	syn::custom_keyword!(weight);436}437438impl syn::parse::Parse for WeightAttr {439	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {440		input.parse::<syn::Token![#]>()?;441		let content;442		syn::bracketed!(content in input);443		content.parse::<keyword::weight>()?;444445		let weight_content;446		syn::parenthesized!(weight_content in content);447		Ok(WeightAttr(weight_content.parse::<syn::Expr>()?))448	}449}450451struct Method {452	name: Ident,453	camel_name: String,454	pascal_name: Ident,455	screaming_name: Ident,456	selector_str: String,457	selector: u32,458	args: Vec<MethodArg>,459	has_normal_args: bool,460	mutability: Mutability,461	result: Type,462	weight: Option<Expr>,463	docs: Vec<String>,464}465impl Method {466	fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {467		let mut info = MethodInfo {468			rename_selector: None,469		};470		let mut docs = Vec::new();471		let mut weight = None;472		for attr in &value.attrs {473			let ident = parse_ident_from_path(&attr.path, false)?;474			if ident == "solidity" {475				let args = attr.parse_meta().unwrap();476				info = MethodInfo::from_meta(&args).unwrap();477			} else if ident == "doc" {478				let args = attr.parse_meta().unwrap();479				let value = match args {480					Meta::NameValue(MetaNameValue {481						lit: Lit::Str(str), ..482					}) => str.value(),483					_ => unreachable!(),484				};485				docs.push(value);486			} else if ident == "weight" {487				weight = Some(syn::parse2::<WeightAttr>(attr.to_token_stream())?.0);488			}489		}490		let ident = &value.sig.ident;491		let ident_str = ident.to_string();492		if !cases::snakecase::is_snake_case(&ident_str) {493			return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));494		}495496		let mut mutability = Mutability::Pure;497498		if let Some(FnArg::Receiver(receiver)) = value499			.sig500			.inputs501			.iter()502			.find(|arg| matches!(arg, FnArg::Receiver(_)))503		{504			if receiver.reference.is_none() {505				return Err(syn::Error::new(506					receiver.span(),507					"receiver should be by ref",508				));509			}510			if receiver.mutability.is_some() {511				mutability = Mutability::Mutable;512			} else {513				mutability = Mutability::View;514			}515		}516		let mut args = Vec::new();517		for typ in value518			.sig519			.inputs520			.iter()521			.filter(|arg| matches!(arg, FnArg::Typed(_)))522		{523			let typ = match typ {524				FnArg::Typed(typ) => typ,525				_ => unreachable!(),526			};527			args.push(MethodArg::try_from(typ)?);528		}529530		if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {531			return Err(syn::Error::new(532				args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),533				"payable function should be mutable",534			));535		}536537		let result = match &value.sig.output {538			ReturnType::Type(_, ty) => ty,539			_ => 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)")),540		};541		let result = parse_result_ok(result)?;542543		let camel_name = info544			.rename_selector545			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));546		let mut selector_str = camel_name.clone();547		selector_str.push('(');548		let mut has_normal_args = false;549		for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {550			if i != 0 {551				selector_str.push(',');552			}553			write!(selector_str, "{}", arg.selector_ty()).unwrap();554			has_normal_args = true;555		}556		selector_str.push(')');557		let selector = fn_selector_str(&selector_str);558559		Ok(Self {560			name: ident.clone(),561			camel_name,562			pascal_name: snake_ident_to_pascal(ident),563			screaming_name: snake_ident_to_screaming(ident),564			selector_str,565			selector,566			args,567			has_normal_args,568			mutability,569			result: result.clone(),570			weight,571			docs,572		})573	}574	fn expand_call_def(&self) -> proc_macro2::TokenStream {575		let defs = self576			.args577			.iter()578			.filter(|a| !a.is_special())579			.map(|a| a.expand_call_def());580		let pascal_name = &self.pascal_name;581582		if self.has_normal_args {583			quote! {584				#pascal_name {585					#(586						#defs,587					)*588				}589			}590		} else {591			quote! {#pascal_name}592		}593	}594595	fn expand_const(&self) -> proc_macro2::TokenStream {596		let screaming_name = &self.screaming_name;597		let selector = u32::to_be_bytes(self.selector);598		let selector_str = &self.selector_str;599		quote! {600			#[doc = #selector_str]601			const #screaming_name: ::evm_coder::types::bytes4 = [#(#selector,)*];602		}603	}604605	fn expand_interface_id(&self) -> proc_macro2::TokenStream {606		let screaming_name = &self.screaming_name;607		quote! {608			interface_id ^= u32::from_be_bytes(Self::#screaming_name);609		}610	}611612	fn expand_parse(&self) -> proc_macro2::TokenStream {613		let pascal_name = &self.pascal_name;614		let screaming_name = &self.screaming_name;615		if self.has_normal_args {616			let parsers = self617				.args618				.iter()619				.filter(|a| !a.is_special())620				.map(|a| a.expand_parse());621			quote! {622				Self::#screaming_name => return Ok(Some(Self::#pascal_name {623					#(624						#parsers,625					)*626				}))627			}628		} else {629			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }630		}631	}632633	fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {634		let pascal_name = &self.pascal_name;635		let name = &self.name;636637		let matcher = if self.has_normal_args {638			let names = self639				.args640				.iter()641				.filter(|a| !a.is_special())642				.map(|a| &a.name);643644			quote! {{645				#(646					#names,647				)*648			}}649		} else {650			quote! {}651		};652653		let receiver = match self.mutability {654			Mutability::Mutable | Mutability::View => quote! {self.},655			Mutability::Pure => quote! {Self::},656		};657		let args = self.args.iter().map(|a| a.expand_call_arg());658659		quote! {660			#call_name::#pascal_name #matcher => {661				let result = #receiver #name(662					#(663						#args,664					)*665				)?;666				(&result).to_result()667			}668		}669	}670671	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {672		let pascal_name = &self.pascal_name;673		if let Some(weight) = &self.weight {674			let matcher = if self.has_normal_args {675				let names = self676					.args677					.iter()678					.filter(|a| !a.is_special())679					.map(|a| &a.name);680681				quote! {{682					#(683						#names,684					)*685				}}686			} else {687				quote! {}688			};689			quote! {690				Self::#pascal_name #matcher => (#weight).into()691			}692		} else {693			let matcher = if self.has_normal_args {694				quote! {{..}}695			} else {696				quote! {}697			};698			quote! {699				Self::#pascal_name #matcher => ().into()700			}701		}702	}703704	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {705		let camel_name = &self.camel_name;706		let mutability = match self.mutability {707			Mutability::Mutable => quote! {SolidityMutability::Mutable},708			Mutability::View => quote! { SolidityMutability::View },709			Mutability::Pure => quote! {SolidityMutability::Pure},710		};711		let result = &self.result;712713		let args = self714			.args715			.iter()716			.filter(|a| !a.is_special())717			.map(MethodArg::expand_solidity_argument);718		let docs = self.docs.iter();719		let selector = format!("{} {:0>8x}", self.selector_str, self.selector);720721		quote! {722			SolidityFunction {723				docs: &[#(#docs),*],724				selector: #selector,725				name: #camel_name,726				mutability: #mutability,727				args: (728					#(729						#args,730					)*731				),732				result: <UnnamedArgument<#result>>::default(),733			}734		}735	}736}737738fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {739	if gen.params.is_empty() {740		return quote! {};741	}742	let params = gen.params.iter().map(|p| match p {743		syn::GenericParam::Type(id) => {744			let v = &id.ident;745			quote! {#v}746		}747		syn::GenericParam::Lifetime(lt) => {748			let v = &lt.lifetime;749			quote! {#v}750		}751		syn::GenericParam::Const(c) => {752			let i = &c.ident;753			quote! {#i}754		}755	});756	quote! { #(#params),* }757}758fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {759	if gen.params.is_empty() {760		return quote! {};761	}762	let list = generics_list(gen);763	quote! { <#list> }764}765fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {766	let list = generics_list(gen);767	if gen.params.len() == 1 {768		quote! {#list}769	} else {770		quote! { (#list) }771	}772}773774pub struct SolidityInterface {775	generics: Generics,776	name: Box<syn::Type>,777	info: InterfaceInfo,778	methods: Vec<Method>,779}780impl SolidityInterface {781	pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {782		let mut methods = Vec::new();783784		for item in &value.items {785			if let ImplItem::Method(method) = item {786				methods.push(Method::try_from(method)?)787			}788		}789		Ok(Self {790			generics: value.generics.clone(),791			name: value.self_ty.clone(),792			info,793			methods,794		})795	}796	pub fn expand(self) -> proc_macro2::TokenStream {797		let name = self.name;798799		let solidity_name = self.info.name.to_string();800		let call_name = pascal_ident_to_call(&self.info.name);801		let generics = self.generics;802		let gen_ref = generics_reference(&generics);803		let gen_data = generics_data(&generics);804		let gen_where = &generics.where_clause;805806		let call_sub = self807			.info808			.inline_is809			.0810			.iter()811			.chain(self.info.is.0.iter())812			.map(|c| Is::expand_call_def(c, &gen_ref));813		let call_parse = self814			.info815			.inline_is816			.0817			.iter()818			.chain(self.info.is.0.iter())819			.map(|is| Is::expand_parse(is, &gen_ref));820		let call_variants = self821			.info822			.inline_is823			.0824			.iter()825			.chain(self.info.is.0.iter())826			.map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));827		let weight_variants = self828			.info829			.inline_is830			.0831			.iter()832			.chain(self.info.is.0.iter())833			.map(Is::expand_variant_weight);834835		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);836		let supports_interface = self837			.info838			.is839			.0840			.iter()841			.map(|is| Is::expand_supports_interface(is, &gen_ref));842843		let calls = self.methods.iter().map(Method::expand_call_def);844		let consts = self.methods.iter().map(Method::expand_const);845		let interface_id = self.methods.iter().map(Method::expand_interface_id);846		let parsers = self.methods.iter().map(Method::expand_parse);847		let call_variants_this = self848			.methods849			.iter()850			.map(|m| Method::expand_variant_call(m, &call_name));851		let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);852		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);853854		// TODO: Inline inline_is855		let solidity_is = self856			.info857			.is858			.0859			.iter()860			.chain(self.info.inline_is.0.iter())861			.map(|is| is.name.to_string());862		let solidity_events_is = self.info.events.0.iter().map(|is| is.name.to_string());863		let solidity_generators = self864			.info865			.is866			.0867			.iter()868			.chain(self.info.inline_is.0.iter())869			.map(|is| Is::expand_generator(is, &gen_ref));870		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);871872		// let methods = self.methods.iter().map(Method::solidity_def);873874		quote! {875			#[derive(Debug)]876			pub enum #call_name #gen_ref {877				ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),878				#(879					#calls,880				)*881				#(882					#call_sub,883				)*884			}885			impl #gen_ref #call_name #gen_ref {886				#(887					#consts888				)*889				pub fn interface_id() -> ::evm_coder::types::bytes4 {890					let mut interface_id = 0;891					#(#interface_id)*892					#(#inline_interface_id)*893					u32::to_be_bytes(interface_id)894				}895				pub fn supports_interface(interface_id: ::evm_coder::types::bytes4) -> bool {896					interface_id != u32::to_be_bytes(0xffffff) && (897						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||898						interface_id == Self::interface_id()899						#(900							|| #supports_interface901						)*902					)903				}904				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {905					use evm_coder::solidity::*;906					use core::fmt::Write;907					let interface = SolidityInterface {908						name: #solidity_name,909						selector: Self::interface_id(),910						is: &["Dummy", "ERC165", #(911							#solidity_is,912						)* #(913							#solidity_events_is,914						)* ],915						functions: (#(916							#solidity_functions,917						)*),918					};919					if is_impl {920						tc.collect("// 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());921					} else {922						tc.collect("// Common stubs holder\ninterface Dummy {\n}\ninterface ERC165 is Dummy {\n\tfunction supportsInterface(bytes4 interfaceID) external view returns (bool);\n}\n".into());923					}924					#(925						#solidity_generators926					)*927					#(928						#solidity_event_generators929					)*930931					let mut out = string::new();932					// In solidity interface usage (is) should be preceeded by interface definition933					// This comment helps to sort it in a set934					if #solidity_name.starts_with("Inline") {935						out.push_str("// Inline\n");936					}937					let _ = interface.format(is_impl, &mut out, tc);938					tc.collect(out);939				}940			}941			impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {942				fn parse(method_id: ::evm_coder::types::bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {943					use ::evm_coder::abi::AbiRead;944					match method_id {945						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(946							::evm_coder::ERC165Call::parse(method_id, reader)?947							.map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))948						),949						#(950							#parsers,951						)*952						_ => {},953					}954					#(955						#call_parse956					)else*957					return Ok(None);958				}959			}960			impl #generics ::evm_coder::Weighted for #call_name #gen_ref961			#gen_where962			{963				#[allow(unused_variables)]964				fn weight(&self) -> ::evm_coder::execution::DispatchInfo {965					match self {966						#(967							#weight_variants,968						)*969						// TODO: It should be very cheap, but not free970						Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => 100u64.into(),971						#(972							#weight_variants_this,973						)*974					}975				}976			}977			impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name978			#gen_where979			{980				#[allow(unreachable_code)] // In case of no inner calls981				fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {982					use ::evm_coder::abi::AbiWrite;983					match c.call {984						#(985							#call_variants,986						)*987						#call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {988							let mut writer = ::evm_coder::abi::AbiWriter::default();989							writer.bool(&<#call_name #gen_ref>::supports_interface(interface_id));990							return Ok(writer.into());991						}992						_ => {},993					}994					let mut writer = ::evm_coder::abi::AbiWriter::default();995					match c.call {996						#(997							#call_variants_this,998						)*999						_ => unreachable!()1000					}1001				}1002			}1003		}1004	}1005}