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

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};2728use crate::{29	fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_path, parse_path_segment,30	parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,31	snake_ident_to_screaming,32};3334struct Is {35	name: Ident,36	pascal_call_name: Ident,37	snake_call_name: Ident,38}39impl Is {40	fn try_from(path: &Path) -> syn::Result<Self> {41		let name = parse_ident_from_path(path, false)?.clone();42		Ok(Self {43			pascal_call_name: pascal_ident_to_call(&name),44			snake_call_name: pascal_ident_to_snake_call(&name),45			name,46		})47	}4849	fn expand_call_def(&self, gen_ref: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {50		let name = &self.name;51		let pascal_call_name = &self.pascal_call_name;52		quote! {53			#name(#pascal_call_name #gen_ref)54		}55	}5657	fn expand_interface_id(&self) -> proc_macro2::TokenStream {58		let pascal_call_name = &self.pascal_call_name;59		quote! {60			interface_id ^= u32::from_be_bytes(#pascal_call_name::interface_id());61		}62	}6364	fn expand_supports_interface(65		&self,66		generics: &proc_macro2::TokenStream,67	) -> proc_macro2::TokenStream {68		let pascal_call_name = &self.pascal_call_name;69		quote! {70			<#pascal_call_name #generics>::supports_interface(interface_id)71		}72	}7374	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {75		let name = &self.name;76		quote! {77			Self::#name(call) => call.weight()78		}79	}8081	fn expand_variant_call(82		&self,83		call_name: &proc_macro2::Ident,84		generics: &proc_macro2::TokenStream,85	) -> proc_macro2::TokenStream {86		let name = &self.name;87		let pascal_call_name = &self.pascal_call_name;88		quote! {89			#call_name::#name(call) => return <Self as ::evm_coder::Callable<#pascal_call_name #generics>>::call(self, Msg {90				call,91				caller: c.caller,92				value: c.value,93			})94		}95	}9697	fn expand_parse(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {98		let name = &self.name;99		let pascal_call_name = &self.pascal_call_name;100		quote! {101			if let Some(parsed_call) = <#pascal_call_name #generics>::parse(method_id, reader)? {102				return Ok(Some(Self::#name(parsed_call)))103			}104		}105	}106107	fn expand_generator(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {108		let pascal_call_name = &self.pascal_call_name;109		quote! {110			<#pascal_call_name #generics>::generate_solidity_interface(tc, is_impl);111		}112	}113114	fn expand_event_generator(&self) -> proc_macro2::TokenStream {115		let name = &self.name;116		quote! {117			#name::generate_solidity_interface(tc, is_impl);118		}119	}120}121122#[derive(Default)]123struct IsList(Vec<Is>);124impl FromMeta for IsList {125	fn from_list(items: &[NestedMeta]) -> darling::Result<Self> {126		let mut out = Vec::new();127		for item in items {128			match item {129				NestedMeta::Meta(Meta::Path(path)) => out.push(Is::try_from(path)?),130				_ => return Err(syn::Error::new(item.span(), "expected path").into()),131			}132		}133		Ok(Self(out))134	}135}136137#[derive(FromMeta)]138pub struct InterfaceInfo {139	name: Ident,140	#[darling(default)]141	is: IsList,142	#[darling(default)]143	inline_is: IsList,144	#[darling(default)]145	events: IsList,146}147148#[derive(FromMeta)]149struct MethodInfo {150	#[darling(default)]151	rename_selector: Option<String>,152}153154enum AbiType {155	// type156	Plain(Ident),157	// (type1,type2)158	Tuple(Vec<AbiType>),159	// type[]160	Vec(Box<AbiType>),161	// type[20]162	Array(Box<AbiType>, usize),163}164impl AbiType {165	fn try_from(value: &Type) -> syn::Result<Self> {166		let value = Self::try_maybe_special_from(value)?;167		if value.is_special() {168			return Err(syn::Error::new(value.span(), "unexpected special type"));169		}170		Ok(value)171	}172	fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {173		match value {174			Type::Array(arr) => {175				let wrapped = AbiType::try_from(&arr.elem)?;176				match &arr.len {177					Expr::Lit(l) => match &l.lit {178						Lit::Int(i) => {179							let num = i.base10_parse::<usize>()?;180							Ok(AbiType::Array(Box::new(wrapped), num as usize))181						}182						_ => Err(syn::Error::new(arr.len.span(), "should be int literal")),183					},184					_ => Err(syn::Error::new(arr.len.span(), "should be literal")),185				}186			}187			Type::Path(_) => {188				let path = parse_path(value)?;189				let segment = parse_path_segment(path)?;190				if segment.ident == "Vec" {191					let args = match &segment.arguments {192						PathArguments::AngleBracketed(e) => e,193						_ => {194							return Err(syn::Error::new(195								segment.arguments.span(),196								"missing Vec generic",197							))198						}199					};200					let args = &args.args;201					if args.len() != 1 {202						return Err(syn::Error::new(203							args.span(),204							"expected only one generic for vec",205						));206					}207					let arg = args.first().unwrap();208209					let ty = match arg {210						GenericArgument::Type(ty) => ty,211						_ => {212							return Err(syn::Error::new(213								arg.span(),214								"expected first generic to be type",215							))216						}217					};218219					let wrapped = AbiType::try_from(ty)?;220					Ok(Self::Vec(Box::new(wrapped)))221				} else {222					if !segment.arguments.is_empty() {223						return Err(syn::Error::new(224							segment.arguments.span(),225							"unexpected generic arguments for non-vec type",226						));227					}228					Ok(Self::Plain(segment.ident.clone()))229				}230			}231			Type::Tuple(t) => {232				let mut out = Vec::with_capacity(t.elems.len());233				for el in t.elems.iter() {234					out.push(AbiType::try_from(el)?)235				}236				Ok(Self::Tuple(out))237			}238			_ => Err(syn::Error::new(239				value.span(),240				"unexpected type, only arrays, plain types and tuples are supported",241			)),242		}243	}244	fn is_value(&self) -> bool {245		matches!(self, Self::Plain(v) if v == "value")246	}247	fn is_caller(&self) -> bool {248		matches!(self, Self::Plain(v) if v == "caller")249	}250	fn is_special(&self) -> bool {251		self.is_caller() || self.is_value()252	}253	fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {254		match self {255			AbiType::Plain(t) => {256				write!(buf, "{}", t)257			}258			AbiType::Tuple(t) => {259				write!(buf, "(")?;260				for (i, t) in t.iter().enumerate() {261					if i != 0 {262						write!(buf, ",")?;263					}264					t.selector_ty_buf(buf)?;265				}266				write!(buf, ")")267			}268			AbiType::Vec(v) => {269				v.selector_ty_buf(buf)?;270				write!(buf, "[]")271			}272			AbiType::Array(v, len) => {273				v.selector_ty_buf(buf)?;274				write!(buf, "[{}]", len)275			}276		}277	}278	fn selector_ty(&self) -> String {279		let mut out = String::new();280		self.selector_ty_buf(&mut out).expect("no fmt error");281		out282	}283}284impl ToTokens for AbiType {285	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {286		match self {287			AbiType::Plain(t) => tokens.extend(quote! {#t}),288			AbiType::Tuple(t) => {289				tokens.extend(quote! {(290					#(#t),*291				)});292			}293			AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),294			AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),295		}296	}297}298299struct MethodArg {300	name: Ident,301	camel_name: String,302	ty: AbiType,303}304impl MethodArg {305	fn try_from(value: &PatType) -> syn::Result<Self> {306		let name = parse_ident_from_pat(&value.pat)?.clone();307		Ok(Self {308			camel_name: cases::camelcase::to_camel_case(&name.to_string()),309			name,310			ty: AbiType::try_maybe_special_from(&value.ty)?,311		})312	}313	fn is_value(&self) -> bool {314		self.ty.is_value()315	}316	fn is_caller(&self) -> bool {317		self.ty.is_caller()318	}319	fn is_special(&self) -> bool {320		self.ty.is_special()321	}322	fn selector_ty(&self) -> String {323		assert!(!self.is_special());324		self.ty.selector_ty()325	}326327	fn expand_call_def(&self) -> proc_macro2::TokenStream {328		assert!(!self.is_special());329		let name = &self.name;330		let ty = &self.ty;331332		quote! {333			#name: #ty334		}335	}336337	fn expand_parse(&self) -> proc_macro2::TokenStream {338		assert!(!self.is_special());339		let name = &self.name;340		quote! {341			#name: reader.abi_read()?342		}343	}344345	fn expand_call_arg(&self) -> proc_macro2::TokenStream {346		if self.is_value() {347			quote! {348				c.value.clone()349			}350		} else if self.is_caller() {351			quote! {352				c.caller.clone()353			}354		} else {355			let name = &self.name;356			quote! {357				#name358			}359		}360	}361362	fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {363		let camel_name = &self.camel_name.to_string();364		let ty = &self.ty;365		quote! {366			<NamedArgument<#ty>>::new(#camel_name)367		}368	}369}370371#[derive(PartialEq)]372enum Mutability {373	Mutable,374	View,375	Pure,376}377378pub struct WeightAttr(syn::Expr);379380mod keyword {381	syn::custom_keyword!(weight);382}383384impl syn::parse::Parse for WeightAttr {385	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {386		input.parse::<syn::Token![#]>()?;387		let content;388		syn::bracketed!(content in input);389		content.parse::<keyword::weight>()?;390391		let weight_content;392		syn::parenthesized!(weight_content in content);393		Ok(WeightAttr(weight_content.parse::<syn::Expr>()?))394	}395}396397struct Method {398	name: Ident,399	camel_name: String,400	pascal_name: Ident,401	screaming_name: Ident,402	selector_str: String,403	selector: u32,404	args: Vec<MethodArg>,405	has_normal_args: bool,406	mutability: Mutability,407	result: Type,408	weight: Option<Expr>,409	docs: Vec<String>,410}411impl Method {412	fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {413		let mut info = MethodInfo {414			rename_selector: None,415		};416		let mut docs = Vec::new();417		let mut weight = None;418		for attr in &value.attrs {419			let ident = parse_ident_from_path(&attr.path, false)?;420			if ident == "solidity" {421				let args = attr.parse_meta().unwrap();422				info = MethodInfo::from_meta(&args).unwrap();423			} else if ident == "doc" {424				let args = attr.parse_meta().unwrap();425				let value = match args {426					Meta::NameValue(MetaNameValue {427						lit: Lit::Str(str), ..428					}) => str.value(),429					_ => unreachable!(),430				};431				docs.push(value);432			} else if ident == "weight" {433				weight = Some(syn::parse2::<WeightAttr>(attr.to_token_stream())?.0);434			}435		}436		let ident = &value.sig.ident;437		let ident_str = ident.to_string();438		if !cases::snakecase::is_snake_case(&ident_str) {439			return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));440		}441442		let mut mutability = Mutability::Pure;443444		if let Some(FnArg::Receiver(receiver)) = value445			.sig446			.inputs447			.iter()448			.find(|arg| matches!(arg, FnArg::Receiver(_)))449		{450			if receiver.reference.is_none() {451				return Err(syn::Error::new(452					receiver.span(),453					"receiver should be by ref",454				));455			}456			if receiver.mutability.is_some() {457				mutability = Mutability::Mutable;458			} else {459				mutability = Mutability::View;460			}461		}462		let mut args = Vec::new();463		for typ in value464			.sig465			.inputs466			.iter()467			.filter(|arg| matches!(arg, FnArg::Typed(_)))468		{469			let typ = match typ {470				FnArg::Typed(typ) => typ,471				_ => unreachable!(),472			};473			args.push(MethodArg::try_from(typ)?);474		}475476		if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {477			return Err(syn::Error::new(478				args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),479				"payable function should be mutable",480			));481		}482483		let result = match &value.sig.output {484			ReturnType::Type(_, ty) => ty,485			_ => 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)")),486		};487		let result = parse_result_ok(result)?;488489		let camel_name = info490			.rename_selector491			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));492		let mut selector_str = camel_name.clone();493		selector_str.push('(');494		let mut has_normal_args = false;495		for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {496			if i != 0 {497				selector_str.push(',');498			}499			write!(selector_str, "{}", arg.selector_ty()).unwrap();500			has_normal_args = true;501		}502		selector_str.push(')');503		let selector = fn_selector_str(&selector_str);504505		Ok(Self {506			name: ident.clone(),507			camel_name,508			pascal_name: snake_ident_to_pascal(ident),509			screaming_name: snake_ident_to_screaming(ident),510			selector_str,511			selector,512			args,513			has_normal_args,514			mutability,515			result: result.clone(),516			weight,517			docs,518		})519	}520	fn expand_call_def(&self) -> proc_macro2::TokenStream {521		let defs = self522			.args523			.iter()524			.filter(|a| !a.is_special())525			.map(|a| a.expand_call_def());526		let pascal_name = &self.pascal_name;527528		if self.has_normal_args {529			quote! {530				#pascal_name {531					#(532						#defs,533					)*534				}535			}536		} else {537			quote! {#pascal_name}538		}539	}540541	fn expand_const(&self) -> proc_macro2::TokenStream {542		let screaming_name = &self.screaming_name;543		let selector = u32::to_be_bytes(self.selector);544		let selector_str = &self.selector_str;545		quote! {546			#[doc = #selector_str]547			const #screaming_name: ::evm_coder::types::bytes4 = [#(#selector,)*];548		}549	}550551	fn expand_interface_id(&self) -> proc_macro2::TokenStream {552		let screaming_name = &self.screaming_name;553		quote! {554			interface_id ^= u32::from_be_bytes(Self::#screaming_name);555		}556	}557558	fn expand_parse(&self) -> proc_macro2::TokenStream {559		let pascal_name = &self.pascal_name;560		let screaming_name = &self.screaming_name;561		if self.has_normal_args {562			let parsers = self563				.args564				.iter()565				.filter(|a| !a.is_special())566				.map(|a| a.expand_parse());567			quote! {568				Self::#screaming_name => return Ok(Some(Self::#pascal_name {569					#(570						#parsers,571					)*572				}))573			}574		} else {575			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }576		}577	}578579	fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {580		let pascal_name = &self.pascal_name;581		let name = &self.name;582583		let matcher = if self.has_normal_args {584			let names = self585				.args586				.iter()587				.filter(|a| !a.is_special())588				.map(|a| &a.name);589590			quote! {{591				#(592					#names,593				)*594			}}595		} else {596			quote! {}597		};598599		let receiver = match self.mutability {600			Mutability::Mutable | Mutability::View => quote! {self.},601			Mutability::Pure => quote! {Self::},602		};603		let args = self.args.iter().map(|a| a.expand_call_arg());604605		quote! {606			#call_name::#pascal_name #matcher => {607				let result = #receiver #name(608					#(609						#args,610					)*611				)?;612				(&result).to_result()613			}614		}615	}616617	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {618		let pascal_name = &self.pascal_name;619		if let Some(weight) = &self.weight {620			let matcher = if self.has_normal_args {621				let names = self622					.args623					.iter()624					.filter(|a| !a.is_special())625					.map(|a| &a.name);626627				quote! {{628					#(629						#names,630					)*631				}}632			} else {633				quote! {}634			};635			quote! {636				Self::#pascal_name #matcher => (#weight).into()637			}638		} else {639			let matcher = if self.has_normal_args {640				quote! {{..}}641			} else {642				quote! {}643			};644			quote! {645				Self::#pascal_name #matcher => ().into()646			}647		}648	}649650	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {651		let camel_name = &self.camel_name;652		let mutability = match self.mutability {653			Mutability::Mutable => quote! {SolidityMutability::Mutable},654			Mutability::View => quote! { SolidityMutability::View },655			Mutability::Pure => quote! {SolidityMutability::Pure},656		};657		let result = &self.result;658659		let args = self660			.args661			.iter()662			.filter(|a| !a.is_special())663			.map(MethodArg::expand_solidity_argument);664		let docs = self.docs.iter();665		let selector = format!("{} {:0>8x}", self.selector_str, self.selector);666667		quote! {668			SolidityFunction {669				docs: &[#(#docs),*],670				selector: #selector,671				name: #camel_name,672				mutability: #mutability,673				args: (674					#(675						#args,676					)*677				),678				result: <UnnamedArgument<#result>>::default(),679			}680		}681	}682}683684fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {685	if gen.params.is_empty() {686		return quote! {};687	}688	let params = gen.params.iter().map(|p| match p {689		syn::GenericParam::Type(id) => {690			let v = &id.ident;691			quote! {#v}692		}693		syn::GenericParam::Lifetime(lt) => {694			let v = &lt.lifetime;695			quote! {#v}696		}697		syn::GenericParam::Const(c) => {698			let i = &c.ident;699			quote! {#i}700		}701	});702	quote! { #(#params),* }703}704fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {705	if gen.params.is_empty() {706		return quote! {};707	}708	let list = generics_list(gen);709	quote! { <#list> }710}711fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {712	let list = generics_list(gen);713	if gen.params.len() == 1 {714		quote! {#list}715	} else {716		quote! { (#list) }717	}718}719720pub struct SolidityInterface {721	generics: Generics,722	name: Box<syn::Type>,723	info: InterfaceInfo,724	methods: Vec<Method>,725}726impl SolidityInterface {727	pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {728		let mut methods = Vec::new();729730		for item in &value.items {731			if let ImplItem::Method(method) = item {732				methods.push(Method::try_from(method)?)733			}734		}735		Ok(Self {736			generics: value.generics.clone(),737			name: value.self_ty.clone(),738			info,739			methods,740		})741	}742	pub fn expand(self) -> proc_macro2::TokenStream {743		let name = self.name;744745		let solidity_name = self.info.name.to_string();746		let call_name = pascal_ident_to_call(&self.info.name);747		let generics = self.generics;748		let gen_ref = generics_reference(&generics);749		let gen_data = generics_data(&generics);750751		let call_sub = self752			.info753			.inline_is754			.0755			.iter()756			.chain(self.info.is.0.iter())757			.map(|c| Is::expand_call_def(c, &gen_ref));758		let call_parse = self759			.info760			.inline_is761			.0762			.iter()763			.chain(self.info.is.0.iter())764			.map(|is| Is::expand_parse(is, &gen_ref));765		let call_variants = self766			.info767			.inline_is768			.0769			.iter()770			.chain(self.info.is.0.iter())771			.map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));772		let weight_variants = self773			.info774			.inline_is775			.0776			.iter()777			.chain(self.info.is.0.iter())778			.map(Is::expand_variant_weight);779780		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);781		let supports_interface = self782			.info783			.is784			.0785			.iter()786			.map(|is| Is::expand_supports_interface(is, &gen_ref));787788		let calls = self.methods.iter().map(Method::expand_call_def);789		let consts = self.methods.iter().map(Method::expand_const);790		let interface_id = self.methods.iter().map(Method::expand_interface_id);791		let parsers = self.methods.iter().map(Method::expand_parse);792		let call_variants_this = self793			.methods794			.iter()795			.map(|m| Method::expand_variant_call(m, &call_name));796		let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);797		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);798799		// TODO: Inline inline_is800		let solidity_is = self801			.info802			.is803			.0804			.iter()805			.chain(self.info.inline_is.0.iter())806			.map(|is| is.name.to_string());807		let solidity_events_is = self.info.events.0.iter().map(|is| is.name.to_string());808		let solidity_generators = self809			.info810			.is811			.0812			.iter()813			.chain(self.info.inline_is.0.iter())814			.map(|is| Is::expand_generator(is, &gen_ref));815		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);816817		// let methods = self.methods.iter().map(Method::solidity_def);818819		quote! {820			#[derive(Debug)]821			pub enum #call_name #gen_ref {822				ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),823				#(824					#calls,825				)*826				#(827					#call_sub,828				)*829			}830			impl #gen_ref #call_name #gen_ref {831				#(832					#consts833				)*834				pub fn interface_id() -> ::evm_coder::types::bytes4 {835					let mut interface_id = 0;836					#(#interface_id)*837					#(#inline_interface_id)*838					u32::to_be_bytes(interface_id)839				}840				pub fn supports_interface(interface_id: ::evm_coder::types::bytes4) -> bool {841					interface_id != u32::to_be_bytes(0xffffff) && (842						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||843						interface_id == Self::interface_id()844						#(845							|| #supports_interface846						)*847					)848				}849				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {850					use evm_coder::solidity::*;851					use core::fmt::Write;852					let interface = SolidityInterface {853						name: #solidity_name,854						selector: Self::interface_id(),855						is: &["Dummy", "ERC165", #(856							#solidity_is,857						)* #(858							#solidity_events_is,859						)* ],860						functions: (#(861							#solidity_functions,862						)*),863					};864					if is_impl {865						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());866					} else {867						tc.collect("// Common stubs holder\ninterface Dummy {\n}\ninterface ERC165 is Dummy {\n\tfunction supportsInterface(bytes4 interfaceID) external view returns (bool);\n}\n".into());868					}869					#(870						#solidity_generators871					)*872					#(873						#solidity_event_generators874					)*875876					let mut out = string::new();877					// In solidity interface usage (is) should be preceeded by interface definition878					// This comment helps to sort it in a set879					if #solidity_name.starts_with("Inline") {880						out.push_str("// Inline\n");881					}882					let _ = interface.format(is_impl, &mut out, tc);883					tc.collect(out);884				}885			}886			impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {887				fn parse(method_id: ::evm_coder::types::bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {888					use ::evm_coder::abi::AbiRead;889					match method_id {890						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(891							::evm_coder::ERC165Call::parse(method_id, reader)?892							.map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))893						),894						#(895							#parsers,896						)*897						_ => {},898					}899					#(900						#call_parse901					)else*902					return Ok(None);903				}904			}905			impl #generics ::evm_coder::Weighted for #call_name #gen_ref {906				#[allow(unused_variables)]907				fn weight(&self) -> ::evm_coder::execution::DispatchInfo {908					match self {909						#(910							#weight_variants,911						)*912						// TODO: It should be very cheap, but not free913						Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => 100u64.into(),914						#(915							#weight_variants_this,916						)*917					}918				}919			}920			impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name {921				#[allow(unreachable_code)] // In case of no inner calls922				fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {923					use ::evm_coder::abi::AbiWrite;924					match c.call {925						#(926							#call_variants,927						)*928						#call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {929							let mut writer = ::evm_coder::abi::AbiWriter::default();930							writer.bool(&<#call_name #gen_ref>::supports_interface(interface_id));931							return Ok(writer.into());932						}933						_ => {},934					}935					let mut writer = ::evm_coder::abi::AbiWriter::default();936					match c.call {937						#(938							#call_variants_this,939						)*940						_ => unreachable!()941					}942				}943			}944		}945	}946}