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

--- a/crates/evm-coder/CHANGELOG.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-
-<!-- bureaucrate goes here -->
-## [v0.1.6] - 2023-01-12
-
-### Added
-- Support Option<T> type.
-### Removed
-- Frontier dependency.
-
-## [v0.1.5] - 2022-11-30
-
-### Added
-- Derive macro to support structures and enums.
-
-## [v0.1.4] - 2022-11-02
-
-### Added
-
-- Named structures support.
-
-## [v0.1.3] - 2022-08-29
-
-### Fixed
-
-- Parsing simple values.
-
-## [v0.1.2] 2022-08-19
-
-### Added
-
-- Implementation `AbiWrite` for tuples.
-
-### Fixes
-
-- Tuple generation for solidity.
-
-## [v0.1.1] 2022-08-16
-
-### Other changes
-
-- build: Upgrade polkadot to v0.9.27 2c498572636f2b34d53b1c51b7283a761a7dc90a
-
-- build: Upgrade polkadot to v0.9.26 85515e54c4ca1b82a2630034e55dcc804c643bf8
-
-- build: Upgrade polkadot to v0.9.25 cdfb9bdc7b205ff1b5134f034ef9973d769e5e6b

--- a/crates/evm-coder/Cargo.toml
+++ /dev/null
@@ -1,32 +0,0 @@
-[package]
-edition = "2021"
-license = "GPLv3"
-name = "evm-coder"
-version = "0.1.6"
-
-[dependencies]
-sha3-const = { version = "0.1.1", default-features = false }
-# evm-coder reexports those proc-macro
-evm-coder-procedural = { path = "./procedural" }
-# Evm uses primitive-types for H160, H256 and others
-primitive-types = { workspace = true }
-# Evm doesn't have reexports for log and others
-ethereum = { workspace = true }
-frame-support = { workspace = true }
-# Error types for execution
-evm-core = { workspace = true }
-# We have tuple-heavy code in solidity.rs
-impl-trait-for-tuples = { workspace = true }
-
-[dev-dependencies]
-# We want to assert some large binary blobs equality in tests
-hex = "0.4.3"
-hex-literal = { workspace = true }
-similar-asserts = "1.4.2"
-trybuild = "1.0"
-
-[features]
-default = ["std"]
-std = ["ethereum/std", "evm-core/std", "frame-support/std", "primitive-types/std"]
-# Stub/interface generation
-stubgen = []

--- a/crates/evm-coder/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# evm-coder
-
-Library for seamless call translation between Rust and Solidity code
-
-By encoding solidity definitions in Rust, this library also provides generation of
-solidity interfaces for ethereum developers
-
-## Overview
-
-Most of this library functionality shouldn't be used directly, but via macros
-
-- [`solidity_interface`]
-- [`ToLog`]
-
-<!-- TODO: make links useable on github, by publishing crate to docs.rs, and linking it from here instead -->
\ No newline at end of file

--- a/crates/evm-coder/procedural/Cargo.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-[package]
-edition = "2021"
-license = "GPLv3"
-name = "evm-coder-procedural"
-version = "0.2.3"
-
-[lib]
-proc-macro = true
-
-[dependencies]
-# Ethereum uses keccak (=sha3) for selectors
-sha3 = "0.10.1"
-# Value formatting
-Inflector = "0.11.4"
-hex = "0.4.3"
-# General proc-macro utilities
-proc-macro2 = "1.0"
-quote = "1.0"
-syn = { version = "1.0", features = ["full"] }

--- a/crates/evm-coder/procedural/src/abi_derive/derive_enum.rs
+++ /dev/null
@@ -1,199 +0,0 @@
-use quote::quote;
-
-use super::extract_docs;
-
-pub fn impl_solidity_option<'a>(
-	docs: Vec<String>,
-	name: &proc_macro2::Ident,
-	enum_options: impl Iterator<Item = &'a syn::Variant> + Clone,
-) -> proc_macro2::TokenStream {
-	let variant_names = enum_options.clone().map(|opt| {
-		let opt = &opt.ident;
-		let s = name.to_string() + "." + opt.to_string().as_str();
-		let as_string = proc_macro2::Literal::string(s.as_str());
-		quote!(#name::#opt => #as_string,)
-	});
-	let solidity_name = name.to_string();
-
-	let solidity_fields = enum_options.map(|v| {
-		let docs = extract_docs(&v.attrs).expect("TODO: handle bad docs");
-		let name = v.ident.to_string();
-		quote! {
-			SolidityEnumVariant {
-				docs: &[#(#docs),*],
-				name: #name,
-			}
-		}
-	});
-
-	quote!(
-		#[cfg(feature = "stubgen")]
-		impl ::evm_coder::solidity::SolidityEnumTy for #name {
-			fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector) -> String {
-				use evm_coder::solidity::*;
-				use core::fmt::Write;
-				let interface = SolidityEnum {
-					docs: &[#(#docs),*],
-					name: #solidity_name,
-					fields: &[#(
-						#solidity_fields,
-					)*],
-				};
-				let mut out = String::new();
-				let _ = interface.format(&mut out, tc);
-				tc.collect(out);
-				#solidity_name.to_string()
-			}
-			fn solidity_option(&self) -> &str {
-				match self {
-					#(#variant_names)*
-				}
-			}
-		}
-	)
-}
-
-pub fn impl_enum_from_u8<'a>(
-	name: &proc_macro2::Ident,
-	enum_options: impl Iterator<Item = &'a syn::Variant>,
-) -> proc_macro2::TokenStream {
-	let error_str = format!("Value not convertible into enum \"{name}\"");
-	let error_str = proc_macro2::Literal::string(&error_str);
-	let enum_options = enum_options.enumerate().map(|(i, opt)| {
-		let opt = &opt.ident;
-		let n = proc_macro2::Literal::u8_suffixed(i as u8);
-		quote! {#n => Ok(#name::#opt),}
-	});
-
-	quote!(
-		impl TryFrom<u8> for #name {
-			type Error = &'static str;
-
-			fn try_from(value: u8) -> ::core::result::Result<Self, Self::Error> {
-				const err: &'static str = #error_str;
-				match value {
-					#(#enum_options)*
-					_ => Err(err)
-				}
-			}
-		}
-	)
-}
-
-pub fn impl_enum_abi_type(name: &syn::Ident) -> proc_macro2::TokenStream {
-	quote! {
-		impl ::evm_coder::abi::AbiType for #name {
-			const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <u8 as ::evm_coder::abi::AbiType>::SIGNATURE;
-
-			fn is_dynamic() -> bool {
-				<u8 as ::evm_coder::abi::AbiType>::is_dynamic()
-			}
-			fn size() -> usize {
-				<u8 as ::evm_coder::abi::AbiType>::size()
-			}
-		}
-	}
-}
-
-pub fn impl_enum_abi_read(name: &syn::Ident) -> proc_macro2::TokenStream {
-	quote!(
-		impl ::evm_coder::abi::AbiRead for #name {
-			fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {
-				Ok(
-					<u8 as ::evm_coder::abi::AbiRead>::abi_read(reader)?
-						.try_into()?
-				)
-			}
-		}
-	)
-}
-
-pub fn impl_enum_abi_write(name: &syn::Ident) -> proc_macro2::TokenStream {
-	quote!(
-		impl ::evm_coder::abi::AbiWrite for #name {
-			fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {
-				::evm_coder::abi::AbiWrite::abi_write(&(*self as u8), writer);
-			}
-		}
-	)
-}
-
-pub fn impl_enum_solidity_type_name(name: &syn::Ident) -> proc_macro2::TokenStream {
-	quote!(
-		#[cfg(feature = "stubgen")]
-		impl ::evm_coder::solidity::SolidityTypeName for #name {
-			fn solidity_name(
-				writer: &mut impl ::core::fmt::Write,
-				tc: &::evm_coder::solidity::TypeCollector,
-			) -> ::core::fmt::Result {
-				write!(writer, "{}", tc.collect_enum::<Self>())
-			}
-
-			fn is_simple() -> bool {
-				true
-			}
-
-			fn solidity_default(
-				writer: &mut impl ::core::fmt::Write,
-				tc: &::evm_coder::solidity::TypeCollector,
-			) -> ::core::fmt::Result {
-				write!(writer, "{}", <#name as ::evm_coder::solidity::SolidityEnumTy>::solidity_option(&<#name>::default()))
-			}
-		}
-	)
-}
-
-pub fn check_enum_fields(de: &syn::DataEnum) -> syn::Result<()> {
-	for v in de.variants.iter() {
-		if !v.fields.is_empty() {
-			return Err(syn::Error::new(
-				v.ident.span(),
-				"Enumeration parameters should not have fields",
-			));
-		} else if v.discriminant.is_some() {
-			return Err(syn::Error::new(
-				v.ident.span(),
-				"Enumeration options should not have an explicit specified value",
-			));
-		}
-	}
-
-	Ok(())
-}
-
-pub fn check_repr_u8(name: &syn::Ident, attrs: &[syn::Attribute]) -> syn::Result<()> {
-	let mut has_repr = false;
-	for attr in attrs.iter() {
-		if attr.path.is_ident("repr") {
-			has_repr = true;
-			let meta = attr.parse_meta()?;
-			check_meta_u8(&meta)?;
-		}
-	}
-
-	if !has_repr {
-		return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));
-	}
-
-	Ok(())
-}
-
-fn check_meta_u8(meta: &syn::Meta) -> Result<(), syn::Error> {
-	if let syn::Meta::List(p) = meta {
-		for nm in p.nested.iter() {
-			if let syn::NestedMeta::Meta(syn::Meta::Path(p)) = nm {
-				if !p.is_ident("u8") {
-					return Err(syn::Error::new(
-						p.segments
-							.first()
-							.expect("repr segments are empty")
-							.ident
-							.span(),
-						"Enum is not \"repr(u8)\"",
-					));
-				}
-			}
-		}
-	}
-	Ok(())
-}

--- a/crates/evm-coder/procedural/src/abi_derive/derive_struct.rs
+++ /dev/null
@@ -1,231 +0,0 @@
-use super::extract_docs;
-use quote::quote;
-use syn::Field;
-
-pub fn tuple_type<'a>(
-	field_types: impl Iterator<Item = &'a syn::Type> + Clone,
-) -> proc_macro2::TokenStream {
-	let field_types = field_types.map(|ty| quote!(#ty,));
-	quote! {(#(#field_types)*)}
-}
-
-pub fn tuple_ref_type<'a>(
-	field_types: impl Iterator<Item = &'a syn::Type> + Clone,
-) -> proc_macro2::TokenStream {
-	let field_types = field_types.map(|ty| quote!(&#ty,));
-	quote! {(#(#field_types)*)}
-}
-
-pub fn tuple_data_as_ref(
-	is_named_fields: bool,
-	field_names: impl Iterator<Item = syn::Ident> + Clone,
-) -> proc_macro2::TokenStream {
-	let field_names = field_names.enumerate().map(|(i, field)| {
-		if is_named_fields {
-			quote!(&self.#field,)
-		} else {
-			let field = proc_macro2::Literal::usize_unsuffixed(i);
-			quote!(&self.#field,)
-		}
-	});
-	quote! {(#(#field_names)*)}
-}
-
-pub fn tuple_names(
-	is_named_fields: bool,
-	field_names: impl Iterator<Item = syn::Ident> + Clone,
-) -> proc_macro2::TokenStream {
-	let field_names = field_names.enumerate().map(|(i, field)| {
-		if is_named_fields {
-			quote!(#field,)
-		} else {
-			let field = proc_macro2::Ident::new(
-				format!("field{}", i).as_str(),
-				proc_macro2::Span::call_site(),
-			);
-			quote!(#field,)
-		}
-	});
-	quote! {(#(#field_names)*)}
-}
-
-pub fn struct_from_tuple(
-	name: &syn::Ident,
-	is_named_fields: bool,
-	field_names: impl Iterator<Item = syn::Ident> + Clone,
-) -> proc_macro2::TokenStream {
-	let field_names = field_names.enumerate().map(|(i, field)| {
-		if is_named_fields {
-			quote!(#field,)
-		} else {
-			let field = proc_macro2::Ident::new(
-				format!("field{}", i).as_str(),
-				proc_macro2::Span::call_site(),
-			);
-			quote!(#field,)
-		}
-	});
-
-	if is_named_fields {
-		quote! {#name {#(#field_names)*}}
-	} else {
-		quote! {#name (#(#field_names)*)}
-	}
-}
-
-pub fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {
-	match field.1.ident.as_ref() {
-		Some(name) => name.clone(),
-		None => {
-			let mut name = "field".to_string();
-			name.push_str(field.0.to_string().as_str());
-			syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())
-		}
-	}
-}
-
-pub fn map_field_to_type(field: &syn::Field) -> &syn::Type {
-	&field.ty
-}
-
-pub fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {
-	quote! {
-		impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}
-	}
-}
-
-pub fn impl_struct_abi_type(
-	name: &syn::Ident,
-	tuple_type: proc_macro2::TokenStream,
-) -> proc_macro2::TokenStream {
-	quote! {
-		impl ::evm_coder::abi::AbiType for #name {
-			const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;
-			fn is_dynamic() -> bool {
-				<#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()
-			}
-			fn size() -> usize {
-				<#tuple_type as ::evm_coder::abi::AbiType>::size()
-			}
-		}
-	}
-}
-
-pub fn impl_struct_abi_read(
-	name: &syn::Ident,
-	tuple_type: proc_macro2::TokenStream,
-	tuple_names: proc_macro2::TokenStream,
-	struct_from_tuple: proc_macro2::TokenStream,
-) -> proc_macro2::TokenStream {
-	quote!(
-		impl ::evm_coder::abi::AbiRead for #name {
-			fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {
-				let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;
-				Ok(#struct_from_tuple)
-			}
-		}
-	)
-}
-
-pub fn impl_struct_abi_write(
-	name: &syn::Ident,
-	_is_named_fields: bool,
-	tuple_type: proc_macro2::TokenStream,
-	tuple_data: proc_macro2::TokenStream,
-) -> proc_macro2::TokenStream {
-	quote!(
-		impl ::evm_coder::abi::AbiWrite for #name {
-			fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {
-				<#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)
-			}
-		}
-	)
-}
-
-pub fn impl_struct_solidity_type<'a>(
-	name: &syn::Ident,
-	docs: Vec<String>,
-	fields: impl Iterator<Item = &'a Field> + Clone,
-) -> proc_macro2::TokenStream {
-	let solidity_name = name.to_string();
-	let solidity_fields = fields.enumerate().map(|(i, f)| {
-		let name = f
-			.ident
-			.as_ref()
-			.map(|i| i.to_string())
-			.unwrap_or_else(|| format!("field_{i}"));
-		let ty = &f.ty;
-		let docs = extract_docs(&f.attrs).expect("TODO: handle bad docs");
-		quote! {
-			SolidityStructField::<#ty> {
-				docs: &[#(#docs),*],
-				name: #name,
-				ty: ::core::marker::PhantomData,
-			}
-		}
-	});
-	quote! {
-		#[cfg(feature = "stubgen")]
-		impl ::evm_coder::solidity::SolidityStructTy for #name {
-			/// Generate solidity definitions for methods described in this struct
-			fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector) -> String {
-				use evm_coder::solidity::*;
-				use core::fmt::Write;
-				let interface = SolidityStruct {
-					docs: &[#(#docs),*],
-					name: #solidity_name,
-					fields: (#(
-						#solidity_fields,
-					)*),
-				};
-				let mut out = String::new();
-				let _ = interface.format(&mut out, tc);
-				tc.collect(out);
-				#solidity_name.to_string()
-			}
-		}
-	}
-}
-
-pub fn impl_struct_solidity_type_name<'a>(
-	name: &syn::Ident,
-	field_types: impl Iterator<Item = &'a syn::Type> + Clone,
-	params_count: usize,
-) -> proc_macro2::TokenStream {
-	let arg_dafaults = field_types.enumerate().map(|(i, ty)| {
-		let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName
-			>::solidity_default(writer, tc)?;);
-		let last_item = params_count - 1;
-		if i != last_item {
-			defult_value.extend(quote! {write!(writer, ",")?;})
-		}
-		defult_value
-	});
-
-	quote! {
-		#[cfg(feature = "stubgen")]
-		impl ::evm_coder::solidity::SolidityTypeName for #name {
-			fn solidity_name(
-				writer: &mut impl ::core::fmt::Write,
-				tc: &::evm_coder::solidity::TypeCollector,
-			) -> ::core::fmt::Result {
-				write!(writer, "{}", tc.collect_struct::<Self>())
-			}
-
-			fn is_simple() -> bool {
-				false
-			}
-
-			fn solidity_default(
-				writer: &mut impl ::core::fmt::Write,
-				tc: &::evm_coder::solidity::TypeCollector,
-			) -> ::core::fmt::Result {
-				write!(writer, "{}(", tc.collect_struct::<Self>())?;
-
-				#(#arg_dafaults)*
-
-				write!(writer, ")")
-			}
-		}
-	}
-}

--- a/crates/evm-coder/procedural/src/abi_derive/mod.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-mod derive_enum;
-mod derive_struct;
-
-use quote::quote;
-use derive_struct::*;
-use derive_enum::*;
-
-pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
-	let name = &ast.ident;
-	match &ast.data {
-		syn::Data::Struct(ds) => expand_struct(ds, ast),
-		syn::Data::Enum(de) => expand_enum(de, ast),
-		syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),
-	}
-}
-
-fn expand_struct(
-	ds: &syn::DataStruct,
-	ast: &syn::DeriveInput,
-) -> syn::Result<proc_macro2::TokenStream> {
-	let name = &ast.ident;
-	let docs = extract_docs(&ast.attrs)?;
-	let (is_named_fields, field_names, field_types, params_count) = match ds.fields {
-		syn::Fields::Named(ref fields) => Ok((
-			true,
-			fields.named.iter().enumerate().map(map_field_to_name),
-			fields.named.iter().map(map_field_to_type),
-			fields.named.len(),
-		)),
-		syn::Fields::Unnamed(ref fields) => Ok((
-			false,
-			fields.unnamed.iter().enumerate().map(map_field_to_name),
-			fields.unnamed.iter().map(map_field_to_type),
-			fields.unnamed.len(),
-		)),
-		syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),
-	}?;
-
-	if params_count == 0 {
-		return Err(syn::Error::new(name.span(), "Empty structs not supported"));
-	};
-
-	let tuple_type = tuple_type(field_types.clone());
-	let tuple_ref_type = tuple_ref_type(field_types.clone());
-	let tuple_data = tuple_data_as_ref(is_named_fields, field_names.clone());
-	let tuple_names = tuple_names(is_named_fields, field_names.clone());
-	let struct_from_tuple = struct_from_tuple(name, is_named_fields, field_names.clone());
-
-	let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);
-	let abi_type = impl_struct_abi_type(name, tuple_type.clone());
-	let abi_read = impl_struct_abi_read(name, tuple_type, tuple_names, struct_from_tuple);
-	let abi_write = impl_struct_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);
-	let solidity_type = impl_struct_solidity_type(name, docs, ds.fields.iter());
-	let solidity_type_name =
-		impl_struct_solidity_type_name(name, field_types.clone(), params_count);
-
-	Ok(quote! {
-		#can_be_plcaed_in_vec
-		#abi_type
-		#abi_read
-		#abi_write
-		#solidity_type
-		#solidity_type_name
-	})
-}
-
-fn expand_enum(
-	de: &syn::DataEnum,
-	ast: &syn::DeriveInput,
-) -> syn::Result<proc_macro2::TokenStream> {
-	let name = &ast.ident;
-	check_repr_u8(name, &ast.attrs)?;
-	check_enum_fields(de)?;
-	let docs = extract_docs(&ast.attrs)?;
-	let enum_options = de.variants.iter();
-
-	let from = impl_enum_from_u8(name, enum_options.clone());
-	let solidity_option = impl_solidity_option(docs, name, enum_options.clone());
-	let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);
-	let abi_type = impl_enum_abi_type(name);
-	let abi_read = impl_enum_abi_read(name);
-	let abi_write = impl_enum_abi_write(name);
-	let solidity_type_name = impl_enum_solidity_type_name(name);
-
-	Ok(quote! {
-		#from
-		#solidity_option
-		#can_be_plcaed_in_vec
-		#abi_type
-		#abi_read
-		#abi_write
-		#solidity_type_name
-	})
-}
-
-fn extract_docs(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {
-	attrs
-		.iter()
-		.filter_map(|attr| {
-			if let Some(ps) = attr.path.segments.first() {
-				if ps.ident == "doc" {
-					let meta = match attr.parse_meta() {
-						Ok(meta) => meta,
-						Err(e) => return Some(Err(e)),
-					};
-					match meta {
-						syn::Meta::NameValue(mnv) => match &mnv.lit {
-							syn::Lit::Str(ls) => return Some(Ok(ls.value())),
-							_ => unreachable!(),
-						},
-						_ => unreachable!(),
-					}
-				}
-			}
-			None
-		})
-		.collect()
-}

--- a/crates/evm-coder/procedural/src/lib.rs
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-#![allow(dead_code)]
-
-use inflector::cases;
-use proc_macro::TokenStream;
-use quote::quote;
-use sha3::{Digest, Keccak256};
-use syn::{
-	DeriveInput, GenericArgument, Ident, ItemImpl, Pat, Path, PathArguments, PathSegment, Type,
-	parse_macro_input, spanned::Spanned,
-};
-
-mod abi_derive;
-mod solidity_interface;
-mod to_log;
-
-fn fn_selector_str(input: &str) -> u32 {
-	let mut hasher = Keccak256::new();
-	hasher.update(input.as_bytes());
-	let result = hasher.finalize();
-
-	let mut selector_bytes = [0; 4];
-	selector_bytes.copy_from_slice(&result[0..4]);
-
-	u32::from_be_bytes(selector_bytes)
-}
-
-/// Returns solidity function selector (first 4 bytes of hash) by its
-/// textual representation
-///
-/// ```ignore
-/// use evm_coder_macros::fn_selector;
-///
-/// assert_eq!(fn_selector!(transfer(address, uint256)), 0xa9059cbb);
-/// ```
-#[proc_macro]
-pub fn fn_selector(input: TokenStream) -> TokenStream {
-	let input = input.to_string().replace(' ', "");
-	let selector = fn_selector_str(&input);
-
-	(quote! {
-		#selector
-	})
-	.into()
-}
-
-fn event_selector_str(input: &str) -> [u8; 32] {
-	let mut hasher = Keccak256::new();
-	hasher.update(input.as_bytes());
-	let result = hasher.finalize();
-
-	let mut selector_bytes = [0; 32];
-	selector_bytes.copy_from_slice(&result[0..32]);
-	selector_bytes
-}
-
-/// Returns solidity topic (hash) by its textual representation
-///
-/// ```ignore
-/// use evm_coder_macros::event_topic;
-///
-/// assert_eq!(
-///     format!("{:x}", event_topic!(Transfer(address, address, uint256))),
-///     "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
-/// );
-/// ```
-#[proc_macro]
-pub fn event_topic(stream: TokenStream) -> TokenStream {
-	let input = stream.to_string().replace(' ', "");
-	let selector_bytes = event_selector_str(&input);
-
-	(quote! {
-		::primitive_types::H256([#(
-			#selector_bytes,
-		)*])
-	})
-	.into()
-}
-
-fn parse_path(ty: &Type) -> syn::Result<&Path> {
-	match &ty {
-		syn::Type::Path(pat) => {
-			if let Some(qself) = &pat.qself {
-				return Err(syn::Error::new(qself.ty.span(), "no receiver expected"));
-			}
-			Ok(&pat.path)
-		}
-		_ => Err(syn::Error::new(ty.span(), "expected ty to be path")),
-	}
-}
-
-fn parse_path_segment(path: &Path) -> syn::Result<&PathSegment> {
-	if path.segments.len() != 1 {
-		return Err(syn::Error::new(
-			path.span(),
-			"expected path to have only one segment",
-		));
-	}
-	let last_segment = &path.segments.last().unwrap();
-	Ok(last_segment)
-}
-
-fn parse_ident_from_pat(pat: &Pat) -> syn::Result<&Ident> {
-	match pat {
-		Pat::Ident(i) => Ok(&i.ident),
-		_ => Err(syn::Error::new(pat.span(), "expected pat ident")),
-	}
-}
-
-fn parse_ident_from_segment(segment: &PathSegment, allow_generics: bool) -> syn::Result<&Ident> {
-	if segment.arguments != PathArguments::None && !allow_generics {
-		return Err(syn::Error::new(
-			segment.arguments.span(),
-			"unexpected generic type",
-		));
-	}
-	Ok(&segment.ident)
-}
-
-fn parse_ident_from_path(path: &Path, allow_generics: bool) -> syn::Result<&Ident> {
-	let segment = parse_path_segment(path)?;
-	parse_ident_from_segment(segment, allow_generics)
-}
-
-fn parse_ident_from_type(ty: &Type, allow_generics: bool) -> syn::Result<&Ident> {
-	let path = parse_path(ty)?;
-	parse_ident_from_path(path, allow_generics)
-}
-
-// Gets T out of Result<T>
-fn parse_result_ok(ty: &Type) -> syn::Result<&Type> {
-	let path = parse_path(ty)?;
-	let segment = parse_path_segment(path)?;
-
-	if segment.ident != "Result" {
-		return Err(syn::Error::new(
-			ty.span(),
-			"expected Result as return type (no renamed aliases allowed)",
-		));
-	}
-	let args = match &segment.arguments {
-		PathArguments::AngleBracketed(e) => e,
-		_ => {
-			return Err(syn::Error::new(
-				segment.arguments.span(),
-				"missing Result generics",
-			))
-		}
-	};
-
-	let args = &args.args;
-	let arg = args.first().unwrap();
-
-	let ty = match arg {
-		GenericArgument::Type(ty) => ty,
-		_ => {
-			return Err(syn::Error::new(
-				arg.span(),
-				"expected first generic to be type",
-			))
-		}
-	};
-
-	Ok(ty)
-}
-
-fn pascal_ident_to_call(ident: &Ident) -> Ident {
-	let name = format!("{}Call", ident);
-	Ident::new(&name, ident.span())
-}
-fn snake_ident_to_pascal(ident: &Ident) -> Ident {
-	let name = ident.to_string();
-	let name = cases::pascalcase::to_pascal_case(&name);
-	Ident::new(&name, ident.span())
-}
-fn snake_ident_to_screaming(ident: &Ident) -> Ident {
-	let name = ident.to_string();
-	let name = cases::screamingsnakecase::to_screaming_snake_case(&name);
-	Ident::new(&name, ident.span())
-}
-fn pascal_ident_to_snake_call(ident: &Ident) -> Ident {
-	let name = ident.to_string();
-	let name = cases::snakecase::to_snake_case(&name);
-	let name = format!("call_{}", name);
-	Ident::new(&name, ident.span())
-}
-
-/// See documentation for this proc-macro reexported in `evm-coder` crate
-#[proc_macro_attribute]
-pub fn solidity_interface(args: TokenStream, stream: TokenStream) -> TokenStream {
-	let args = parse_macro_input!(args as solidity_interface::InterfaceInfo);
-
-	let input: ItemImpl = match syn::parse(stream) {
-		Ok(t) => t,
-		Err(e) => return e.to_compile_error().into(),
-	};
-
-	let expanded = match solidity_interface::SolidityInterface::try_from(args, &input) {
-		Ok(v) => v.expand(),
-		Err(e) => e.to_compile_error(),
-	};
-
-	(quote! {
-		#input
-
-		#expanded
-	})
-	.into()
-}
-
-#[proc_macro_attribute]
-pub fn solidity(_args: TokenStream, stream: TokenStream) -> TokenStream {
-	stream
-}
-#[proc_macro_attribute]
-pub fn weight(_args: TokenStream, stream: TokenStream) -> TokenStream {
-	stream
-}
-
-/// See documentation for this proc-macro reexported in `evm-coder` crate
-#[proc_macro_derive(ToLog, attributes(indexed))]
-pub fn to_log(value: TokenStream) -> TokenStream {
-	let input = parse_macro_input!(value as DeriveInput);
-
-	match to_log::Events::try_from(&input) {
-		Ok(e) => e.expand(),
-		Err(e) => e.to_compile_error(),
-	}
-	.into()
-}
-
-#[proc_macro_derive(AbiCoder)]
-pub fn abi_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-	let ast = syn::parse(input).unwrap();
-	let ts = match abi_derive::impl_abi_macro(&ast) {
-		Ok(e) => e,
-		Err(e) => e.to_compile_error(),
-	};
-	ts.into()
-}

--- a/crates/evm-coder/procedural/src/solidity_interface.rs
+++ /dev/null
@@ -1,1099 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-#![allow(dead_code)]
-
-// NOTE: In order to understand this Rust macro better, first read this chapter
-// about Procedural Macros in Rust book:
-// https://doc.rust-lang.org/reference/procedural-macros.html
-
-use proc_macro2::TokenStream;
-use quote::{quote, format_ident};
-use inflector::cases;
-use syn::{
-	Expr, FnArg, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta, MetaNameValue,
-	PatType, ReturnType, Type,
-	spanned::Spanned,
-	parse::{Parse, ParseStream},
-	parenthesized, Token, LitInt, LitStr,
-};
-
-use crate::{
-	parse_ident_from_pat, parse_ident_from_path, parse_path, parse_path_segment, parse_result_ok,
-	pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,
-	snake_ident_to_screaming,
-};
-
-struct Is {
-	name: Ident,
-	pascal_call_name: Ident,
-	snake_call_name: Ident,
-	via: Option<(Type, Ident)>,
-	condition: Option<Expr>,
-}
-impl Is {
-	fn expand_call_def(&self, gen_ref: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
-		let name = &self.name;
-		let pascal_call_name = &self.pascal_call_name;
-		quote! {
-			#name(#pascal_call_name #gen_ref)
-		}
-	}
-
-	fn expand_interface_id(&self) -> proc_macro2::TokenStream {
-		let pascal_call_name = &self.pascal_call_name;
-		quote! {
-			interface_id ^= u32::from_be_bytes(#pascal_call_name::interface_id());
-		}
-	}
-
-	fn expand_supports_interface(
-		&self,
-		generics: &proc_macro2::TokenStream,
-	) -> proc_macro2::TokenStream {
-		let pascal_call_name = &self.pascal_call_name;
-		let condition = self.condition.as_ref().map(|condition| {
-			quote! {
-				(#condition) &&
-			}
-		});
-		quote! {
-			#condition <#pascal_call_name #generics>::supports_interface(this, interface_id)
-		}
-	}
-
-	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {
-		let name = &self.name;
-		quote! {
-			Self::#name(call) => call.weight()
-		}
-	}
-
-	fn expand_variant_call(
-		&self,
-		call_name: &proc_macro2::Ident,
-		generics: &proc_macro2::TokenStream,
-	) -> proc_macro2::TokenStream {
-		let name = &self.name;
-		let pascal_call_name = &self.pascal_call_name;
-		let via_typ = self
-			.via
-			.as_ref()
-			.map(|(t, _)| quote! {#t})
-			.unwrap_or_else(|| quote! {Self});
-		let via_map = self
-			.via
-			.as_ref()
-			.map(|(_, i)| quote! {.#i()})
-			.unwrap_or_default();
-		let condition = self.condition.as_ref().map(|condition| {
-			quote! {
-				if ({let this = &self; (#condition)})
-			}
-		});
-		quote! {
-			#call_name::#name(call) #condition => return <#via_typ as ::evm_coder::Callable<#pascal_call_name #generics>>::call(self #via_map, Msg {
-				call,
-				caller: c.caller,
-				value: c.value,
-			})
-		}
-	}
-
-	fn expand_parse(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
-		let name = &self.name;
-		let pascal_call_name = &self.pascal_call_name;
-		quote! {
-			if let Some(parsed_call) = <#pascal_call_name #generics>::parse(method_id, reader)? {
-				return Ok(Some(Self::#name(parsed_call)))
-			}
-		}
-	}
-
-	fn expand_generator(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
-		let pascal_call_name = &self.pascal_call_name;
-		quote! {
-			<#pascal_call_name #generics>::generate_solidity_interface(tc, is_impl);
-		}
-	}
-
-	fn expand_event_generator(&self) -> proc_macro2::TokenStream {
-		let name = &self.name;
-		quote! {
-			#name::generate_solidity_interface(tc, is_impl);
-		}
-	}
-}
-
-#[derive(Default)]
-struct IsList(Vec<Is>);
-impl Parse for IsList {
-	fn parse(input: ParseStream) -> syn::Result<Self> {
-		let mut out = vec![];
-		loop {
-			if input.is_empty() {
-				break;
-			}
-			let name = input.parse::<Ident>()?;
-			let lookahead = input.lookahead1();
-
-			let mut condition: Option<Expr> = None;
-			let mut via: Option<(Type, Ident)> = None;
-
-			if lookahead.peek(syn::token::Paren) {
-				let contents;
-				parenthesized!(contents in input);
-				let input = contents;
-
-				while !input.is_empty() {
-					let lookahead = input.lookahead1();
-					if lookahead.peek(Token![if]) {
-						input.parse::<Token![if]>()?;
-						let contents;
-						parenthesized!(contents in input);
-						let contents = contents.parse::<Expr>()?;
-
-						if condition.replace(contents).is_some() {
-							return Err(syn::Error::new(input.span(), "condition is already set"));
-						}
-					} else if lookahead.peek(kw::via) {
-						input.parse::<kw::via>()?;
-						let contents;
-						parenthesized!(contents in input);
-
-						let method = contents.parse::<Ident>()?;
-						contents.parse::<kw::returns>()?;
-						let ty = contents.parse::<Type>()?;
-
-						if via.replace((ty, method)).is_some() {
-							return Err(syn::Error::new(input.span(), "via is already set"));
-						}
-					} else {
-						return Err(lookahead.error());
-					}
-
-					if input.peek(Token![,]) {
-						input.parse::<Token![,]>()?;
-					} else if !input.is_empty() {
-						return Err(syn::Error::new(input.span(), "expected end"));
-					}
-				}
-			} else if lookahead.peek(Token![,]) || input.is_empty() {
-				// Pass
-			} else {
-				return Err(lookahead.error());
-			};
-			out.push(Is {
-				pascal_call_name: pascal_ident_to_call(&name),
-				snake_call_name: pascal_ident_to_snake_call(&name),
-				name,
-				via,
-				condition,
-			});
-			if input.peek(Token![,]) {
-				input.parse::<Token![,]>()?;
-				continue;
-			} else {
-				break;
-			}
-		}
-		Ok(Self(out))
-	}
-}
-
-pub struct InterfaceInfo {
-	name: Ident,
-	is: IsList,
-	inline_is: IsList,
-	events: IsList,
-	expect_selector: Option<u32>,
-}
-impl Parse for InterfaceInfo {
-	fn parse(input: ParseStream) -> syn::Result<Self> {
-		let mut name = None;
-		let mut is = None;
-		let mut inline_is = None;
-		let mut events = None;
-		let mut expect_selector = None;
-		// TODO: create proc-macro to optimize proc-macro boilerplate? :D
-		loop {
-			let lookahead = input.lookahead1();
-			if lookahead.peek(kw::name) {
-				let k = input.parse::<kw::name>()?;
-				input.parse::<Token![=]>()?;
-				if name.replace(input.parse::<Ident>()?).is_some() {
-					return Err(syn::Error::new(k.span(), "name is already set"));
-				}
-			} else if lookahead.peek(kw::is) {
-				let k = input.parse::<kw::is>()?;
-				let contents;
-				parenthesized!(contents in input);
-				if is.replace(contents.parse::<IsList>()?).is_some() {
-					return Err(syn::Error::new(k.span(), "is is already set"));
-				}
-			} else if lookahead.peek(kw::inline_is) {
-				let k = input.parse::<kw::inline_is>()?;
-				let contents;
-				parenthesized!(contents in input);
-				if inline_is.replace(contents.parse::<IsList>()?).is_some() {
-					return Err(syn::Error::new(k.span(), "inline_is is already set"));
-				}
-			} else if lookahead.peek(kw::events) {
-				let k = input.parse::<kw::events>()?;
-				let contents;
-				parenthesized!(contents in input);
-				if events.replace(contents.parse::<IsList>()?).is_some() {
-					return Err(syn::Error::new(k.span(), "events is already set"));
-				}
-			} else if lookahead.peek(kw::expect_selector) {
-				let k = input.parse::<kw::expect_selector>()?;
-				input.parse::<Token![=]>()?;
-				let value = input.parse::<LitInt>()?;
-				if expect_selector
-					.replace(value.base10_parse::<u32>()?)
-					.is_some()
-				{
-					return Err(syn::Error::new(k.span(), "expect_selector is already set"));
-				}
-			} else if input.is_empty() {
-				break;
-			} else {
-				return Err(lookahead.error());
-			}
-			if input.peek(Token![,]) {
-				input.parse::<Token![,]>()?;
-			} else {
-				break;
-			}
-		}
-		Ok(Self {
-			name: name.ok_or_else(|| syn::Error::new(input.span(), "missing name"))?,
-			is: is.unwrap_or_default(),
-			inline_is: inline_is.unwrap_or_default(),
-			events: events.unwrap_or_default(),
-			expect_selector,
-		})
-	}
-}
-
-struct MethodInfo {
-	rename_selector: Option<String>,
-	hide: bool,
-}
-impl Parse for MethodInfo {
-	fn parse(input: ParseStream) -> syn::Result<Self> {
-		let mut rename_selector = None;
-		let mut hide = false;
-		while !input.is_empty() {
-			let lookahead = input.lookahead1();
-			if lookahead.peek(kw::rename_selector) {
-				let k = input.parse::<kw::rename_selector>()?;
-				input.parse::<Token![=]>()?;
-				if rename_selector
-					.replace(input.parse::<LitStr>()?.value())
-					.is_some()
-				{
-					return Err(syn::Error::new(k.span(), "rename_selector is already set"));
-				}
-			} else if lookahead.peek(kw::hide) {
-				input.parse::<kw::hide>()?;
-				hide = true;
-			} else {
-				return Err(lookahead.error());
-			}
-
-			if input.peek(Token![,]) {
-				input.parse::<Token![,]>()?;
-			} else if !input.is_empty() {
-				return Err(syn::Error::new(input.span(), "expected end"));
-			}
-		}
-		Ok(Self {
-			rename_selector,
-			hide,
-		})
-	}
-}
-
-trait AbiTypeHelper {
-	fn plain(&self) -> syn::Result<&Ident>;
-	fn is_value(&self) -> bool;
-	fn is_caller(&self) -> bool;
-	fn is_special(&self) -> bool;
-}
-
-impl AbiTypeHelper for Type {
-	fn plain(&self) -> syn::Result<&Ident> {
-		let path = parse_path(self)?;
-		let segment = parse_path_segment(path)?;
-		if !segment.arguments.is_empty() {
-			return Err(syn::Error::new(self.span(), "Not plain type"));
-		}
-		Ok(&segment.ident)
-	}
-
-	fn is_value(&self) -> bool {
-		if let Ok(ident) = self.plain() {
-			return ident == "Value";
-		}
-		false
-	}
-
-	fn is_caller(&self) -> bool {
-		if let Ok(ident) = self.plain() {
-			return ident == "Caller";
-		}
-		false
-	}
-
-	fn is_special(&self) -> bool {
-		self.is_caller() || self.is_value()
-	}
-}
-
-#[derive(Debug)]
-struct MethodArg {
-	name: Ident,
-	camel_name: String,
-	ty: Type,
-}
-impl MethodArg {
-	fn try_from(value: &PatType) -> syn::Result<Self> {
-		let name = parse_ident_from_pat(&value.pat)?.clone();
-		Ok(Self {
-			camel_name: cases::camelcase::to_camel_case(&name.to_string()),
-			name,
-			ty: value.ty.as_ref().clone(),
-		})
-	}
-	fn is_value(&self) -> bool {
-		self.ty.is_value()
-	}
-	fn is_caller(&self) -> bool {
-		self.ty.is_caller()
-	}
-	fn is_special(&self) -> bool {
-		self.ty.is_special()
-	}
-
-	fn expand_call_def(&self) -> proc_macro2::TokenStream {
-		assert!(!self.is_special());
-		let name = &self.name;
-		let ty = &self.ty;
-
-		quote! {
-			#name: #ty
-		}
-	}
-
-	fn expand_parse(&self) -> proc_macro2::TokenStream {
-		assert!(!self.is_special());
-		let name = &self.name;
-		let ty = &self.ty;
-		quote! {
-			#name: {
-				let value = <#ty as ::evm_coder::abi::AbiRead>::abi_read(reader)?;
-				if !is_dynamic {reader.bytes_read(<#ty as ::evm_coder::abi::AbiType>::size())};
-				value
-			}
-		}
-	}
-
-	fn expand_call_arg(&self) -> proc_macro2::TokenStream {
-		if self.is_value() {
-			quote! {
-				c.value.clone()
-			}
-		} else if self.is_caller() {
-			quote! {
-				c.caller.clone()
-			}
-		} else {
-			let name = &self.name;
-			quote! {
-				#name
-			}
-		}
-	}
-
-	fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {
-		let camel_name = &self.camel_name.to_string();
-		let ty = &self.ty;
-		quote! {
-			<NamedArgument<#ty>>::new(#camel_name)
-		}
-	}
-}
-
-#[derive(PartialEq)]
-enum Mutability {
-	Mutable,
-	View,
-	Pure,
-}
-
-/// Group all keywords for this macro. Usage example:
-/// #[solidity_interface(name = "B", inline_is(A))]
-mod kw {
-	syn::custom_keyword!(weight);
-
-	syn::custom_keyword!(via);
-	syn::custom_keyword!(returns);
-	syn::custom_keyword!(name);
-	syn::custom_keyword!(is);
-	syn::custom_keyword!(inline_is);
-	syn::custom_keyword!(events);
-	syn::custom_keyword!(expect_selector);
-
-	syn::custom_keyword!(rename_selector);
-	syn::custom_keyword!(hide);
-}
-
-/// Rust methods are parsed into this structure when Solidity code is generated
-struct Method {
-	name: Ident,
-	camel_name: String,
-	pascal_name: Ident,
-	screaming_name: Ident,
-	hide: bool,
-	args: Vec<MethodArg>,
-	has_normal_args: bool,
-	has_value_args: bool,
-	mutability: Mutability,
-	result: Type,
-	weight: Option<Expr>,
-	docs: Vec<String>,
-}
-impl Method {
-	fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {
-		let mut info = MethodInfo {
-			rename_selector: None,
-			hide: false,
-		};
-		let mut docs = Vec::new();
-		let mut weight = None;
-		for attr in &value.attrs {
-			let ident = parse_ident_from_path(&attr.path, false)?;
-			if ident == "solidity" {
-				info = attr.parse_args::<MethodInfo>()?;
-			} else if ident == "doc" {
-				let args = attr.parse_meta().unwrap();
-				let value = match args {
-					Meta::NameValue(MetaNameValue {
-						lit: Lit::Str(str), ..
-					}) => str.value(),
-					_ => unreachable!(),
-				};
-				docs.push(value);
-			} else if ident == "weight" {
-				weight = Some(attr.parse_args::<Expr>()?);
-			}
-		}
-		let ident = &value.sig.ident;
-		let ident_str = ident.to_string();
-		if !cases::snakecase::is_snake_case(&ident_str) {
-			return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));
-		}
-
-		let mut mutability = Mutability::Pure;
-
-		if let Some(FnArg::Receiver(receiver)) = value
-			.sig
-			.inputs
-			.iter()
-			.find(|arg| matches!(arg, FnArg::Receiver(_)))
-		{
-			if receiver.reference.is_none() {
-				return Err(syn::Error::new(
-					receiver.span(),
-					"receiver should be by ref",
-				));
-			}
-			if receiver.mutability.is_some() {
-				mutability = Mutability::Mutable;
-			} else {
-				mutability = Mutability::View;
-			}
-		}
-		let mut args = Vec::new();
-		for typ in value
-			.sig
-			.inputs
-			.iter()
-			.filter(|arg| matches!(arg, FnArg::Typed(_)))
-		{
-			let typ = match typ {
-				FnArg::Typed(typ) => typ,
-				_ => unreachable!(),
-			};
-			args.push(MethodArg::try_from(typ)?);
-		}
-
-		if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {
-			return Err(syn::Error::new(
-				args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),
-				"payable function should be mutable",
-			));
-		}
-
-		let result = match &value.sig.output {
-			ReturnType::Type(_, ty) => ty,
-			_ => 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)")),
-		};
-		let result = parse_result_ok(result)?;
-
-		let camel_name = info
-			.rename_selector
-			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));
-		let has_normal_args = args.iter().filter(|arg| !arg.is_special()).count() != 0;
-		let has_value_args = args.iter().any(|a| a.is_value());
-
-		Ok(Self {
-			name: ident.clone(),
-			camel_name,
-			pascal_name: snake_ident_to_pascal(ident),
-			screaming_name: snake_ident_to_screaming(ident),
-			hide: info.hide,
-			args,
-			has_normal_args,
-			has_value_args,
-			mutability,
-			result: result.clone(),
-			weight,
-			docs,
-		})
-	}
-	fn expand_call_def(&self) -> proc_macro2::TokenStream {
-		let defs = self
-			.args
-			.iter()
-			.filter(|a| !a.is_special())
-			.map(|a| a.expand_call_def());
-		let pascal_name = &self.pascal_name;
-		let docs = &self.docs;
-
-		if self.has_normal_args {
-			quote! {
-				#(#[doc = #docs])*
-				#[allow(missing_docs)]
-				#pascal_name {
-					#(
-						#defs,
-					)*
-				}
-			}
-		} else {
-			quote! {
-				#(#[doc = #docs])*
-				#[allow(missing_docs)]
-				#pascal_name
-			}
-		}
-	}
-
-	fn expand_const(&self) -> proc_macro2::TokenStream {
-		let screaming_name = &self.screaming_name;
-		let screaming_name_signature = format_ident!("{}_SIGNATURE", &self.screaming_name);
-		let custom_signature = self.expand_custom_signature();
-		quote! {
-			const #screaming_name_signature: ::evm_coder::custom_signature::SignatureUnit = #custom_signature;
-			const #screaming_name: ::evm_coder::types::Bytes4 = {
-				let mut sum = ::evm_coder::sha3_const::Keccak256::new();
-				let mut pos = 0;
-				while pos < Self::#screaming_name_signature.len {
-					sum = sum.update(&[Self::#screaming_name_signature.data[pos]; 1]);
-					pos += 1;
-				}
-				let a = sum.finalize();
-				[a[0], a[1], a[2], a[3]]
-			};
-		}
-	}
-
-	fn expand_interface_id(&self) -> proc_macro2::TokenStream {
-		let screaming_name = &self.screaming_name;
-		quote! {
-			interface_id ^= u32::from_be_bytes(Self::#screaming_name);
-		}
-	}
-
-	fn expand_parse(&self) -> proc_macro2::TokenStream {
-		let pascal_name = &self.pascal_name;
-		let screaming_name = &self.screaming_name;
-		if self.has_normal_args {
-			let args_iter = self.args.iter().filter(|a| !a.is_special());
-			let arg_type = args_iter.clone().map(|a| &a.ty);
-			let parsers = args_iter.map(|a| a.expand_parse());
-			quote! {
-				Self::#screaming_name => {
-					let is_dynamic = false #(|| <#arg_type as ::evm_coder::abi::AbiType>::is_dynamic())*;
-					return Ok(Some(Self::#pascal_name {
-						#(
-							#parsers,
-						)*
-					}))
-				}
-			}
-		} else {
-			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }
-		}
-	}
-
-	fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {
-		let pascal_name = &self.pascal_name;
-		let name = &self.name;
-
-		let matcher = if self.has_normal_args {
-			let names = self
-				.args
-				.iter()
-				.filter(|a| !a.is_special())
-				.map(|a| &a.name);
-
-			quote! {{
-				#(
-					#names,
-				)*
-			}}
-		} else {
-			quote! {}
-		};
-
-		let receiver = match self.mutability {
-			Mutability::Mutable | Mutability::View => quote! {self.},
-			Mutability::Pure => quote! {Self::},
-		};
-		let args = self.args.iter().map(|a| a.expand_call_arg());
-
-		quote! {
-			#call_name::#pascal_name #matcher => {
-				#[allow(deprecated)]
-				let result = #receiver #name(
-					#(
-						#args,
-					)*
-				)?;
-				(&result).to_result()
-			}
-		}
-	}
-
-	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {
-		let pascal_name = &self.pascal_name;
-		if let Some(weight) = &self.weight {
-			let matcher = if self.has_normal_args {
-				let names = self
-					.args
-					.iter()
-					.filter(|a| !a.is_special())
-					.map(|a| &a.name);
-
-				quote! {{
-					#(
-						#names,
-					)*
-				}}
-			} else {
-				quote! {}
-			};
-			quote! {
-				Self::#pascal_name #matcher => (#weight).into()
-			}
-		} else {
-			let matcher = if self.has_normal_args {
-				quote! {{..}}
-			} else {
-				quote! {}
-			};
-			quote! {
-				Self::#pascal_name #matcher => ().into()
-			}
-		}
-	}
-
-	fn expand_custom_signature(&self) -> proc_macro2::TokenStream {
-		let mut args = TokenStream::new();
-
-		let mut has_params = false;
-		for arg in self.args.iter().filter(|a| !a.is_special()) {
-			has_params = true;
-			let ty = &arg.ty;
-			args.extend(quote! {nameof(<#ty>::SIGNATURE)});
-			args.extend(quote! {fixed(",")})
-		}
-
-		// Remove trailing comma
-		if has_params {
-			args.extend(quote! {shift_left(1)})
-		}
-
-		let func_name = self.camel_name.clone();
-		quote! { ::evm_coder::make_signature!(new fixed(#func_name) fixed("(") #args fixed(")")) }
-	}
-
-	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {
-		let camel_name = &self.camel_name;
-		let mutability = match self.mutability {
-			Mutability::Mutable => quote! {SolidityMutability::Mutable},
-			Mutability::View => quote! { SolidityMutability::View },
-			Mutability::Pure => quote! {SolidityMutability::Pure},
-		};
-		let result = &self.result;
-
-		let args = self
-			.args
-			.iter()
-			.filter(|a| !a.is_special())
-			.map(MethodArg::expand_solidity_argument);
-		let docs = &self.docs;
-		let screaming_name = &self.screaming_name;
-		let hide = self.hide;
-		let custom_signature = self.expand_custom_signature();
-		let is_payable = self.has_value_args;
-
-		quote! {
-			SolidityFunction {
-				docs: &[#(#docs),*],
-				hide: #hide,
-				selector: u32::from_be_bytes(Self::#screaming_name),
-				custom_signature: #custom_signature,
-				name: #camel_name,
-				mutability: #mutability,
-				is_payable: #is_payable,
-				args: (
-					#(
-						#args,
-					)*
-				),
-				result: <UnnamedArgument<#result>>::default(),
-			}
-		}
-	}
-}
-
-fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {
-	if gen.params.is_empty() {
-		return quote! {};
-	}
-	let params = gen.params.iter().map(|p| match p {
-		syn::GenericParam::Type(id) => {
-			let v = &id.ident;
-			quote! {#v}
-		}
-		syn::GenericParam::Lifetime(lt) => {
-			let v = &lt.lifetime;
-			quote! {#v}
-		}
-		syn::GenericParam::Const(c) => {
-			let i = &c.ident;
-			quote! {#i}
-		}
-	});
-	quote! { #(#params),* }
-}
-fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {
-	if gen.params.is_empty() {
-		return quote! {};
-	}
-	let list = generics_list(gen);
-	quote! { <#list> }
-}
-fn generics_stub(gen: &Generics) -> proc_macro2::TokenStream {
-	if gen.params.is_empty() {
-		return quote! {};
-	}
-	let params = (0..gen.params.len()).map(|_| quote! {()});
-	quote! {<#(#params,)*>}
-}
-fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {
-	let list = generics_list(gen);
-	if gen.params.len() == 1 {
-		quote! {#list}
-	} else {
-		quote! { (#list) }
-	}
-}
-
-pub struct SolidityInterface {
-	generics: Generics,
-	name: Box<syn::Type>,
-	info: InterfaceInfo,
-	methods: Vec<Method>,
-	docs: Vec<String>,
-}
-impl SolidityInterface {
-	pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {
-		let mut methods = Vec::new();
-
-		for item in &value.items {
-			if let ImplItem::Method(method) = item {
-				methods.push(Method::try_from(method)?)
-			}
-		}
-		let mut docs = vec![];
-		for attr in &value.attrs {
-			let ident = parse_ident_from_path(&attr.path, false)?;
-			if ident == "doc" {
-				let args = attr.parse_meta().unwrap();
-				let value = match args {
-					Meta::NameValue(MetaNameValue {
-						lit: Lit::Str(str), ..
-					}) => str.value(),
-					_ => unreachable!(),
-				};
-				docs.push(value);
-			}
-		}
-		Ok(Self {
-			generics: value.generics.clone(),
-			name: value.self_ty.clone(),
-			info,
-			methods,
-			docs,
-		})
-	}
-	pub fn expand(self) -> proc_macro2::TokenStream {
-		let name = self.name;
-
-		let solidity_name = self.info.name.to_string();
-		let call_name = pascal_ident_to_call(&self.info.name);
-		let generics = self.generics;
-		let gen_ref = generics_reference(&generics);
-		let gen_data = generics_data(&generics);
-		let gen_stub = generics_stub(&generics);
-		let gen_where = &generics.where_clause;
-
-		let call_sub = self
-			.info
-			.inline_is
-			.0
-			.iter()
-			.chain(self.info.is.0.iter())
-			.map(|c| Is::expand_call_def(c, &gen_ref));
-		let call_parse = self
-			.info
-			.inline_is
-			.0
-			.iter()
-			.chain(self.info.is.0.iter())
-			.map(|is| Is::expand_parse(is, &gen_ref));
-		let call_variants = self
-			.info
-			.inline_is
-			.0
-			.iter()
-			.chain(self.info.is.0.iter())
-			.map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));
-		let weight_variants = self
-			.info
-			.inline_is
-			.0
-			.iter()
-			.chain(self.info.is.0.iter())
-			.map(Is::expand_variant_weight);
-
-		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);
-		let supports_interface = self
-			.info
-			.is
-			.0
-			.iter()
-			.map(|is| Is::expand_supports_interface(is, &gen_ref));
-
-		let calls = self.methods.iter().map(Method::expand_call_def);
-		let consts = self.methods.iter().map(Method::expand_const);
-		let interface_id = self.methods.iter().map(Method::expand_interface_id);
-		let parsers = self.methods.iter().map(Method::expand_parse);
-		let call_variants_this = self
-			.methods
-			.iter()
-			.map(|m| Method::expand_variant_call(m, &call_name));
-		let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);
-		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);
-
-		// TODO: Inline inline_is
-		let solidity_is = self
-			.info
-			.is
-			.0
-			.iter()
-			.chain(self.info.inline_is.0.iter())
-			.map(|is| is.name.to_string());
-		let solidity_events_is = self.info.events.0.iter().map(|is| is.name.to_string());
-		let solidity_generators = self
-			.info
-			.is
-			.0
-			.iter()
-			.chain(self.info.inline_is.0.iter())
-			.map(|is| Is::expand_generator(is, &gen_ref));
-		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);
-		let solidity_events_idents = self.info.events.0.iter().map(|is| is.name.clone());
-		let docs = &self.docs;
-
-		let expect_selector = self.info.expect_selector.map(|s| {
-            quote! {
-                const _: () = assert!(#s == u32::from_be_bytes(<#call_name #gen_stub>::interface_id()), "selector mismatch, review contained function selectors");
-            }
-        });
-
-		quote! {
-			#(
-				const _: ::core::marker::PhantomData<#solidity_events_idents> = ::core::marker::PhantomData;
-			)*
-			#[derive(Debug)]
-			#(#[doc = #docs])*
-			pub enum #call_name #gen_ref {
-				/// Inherited method
-				ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),
-				#(
-					#calls,
-				)*
-				#(
-					#call_sub,
-				)*
-			}
-
-			#expect_selector
-
-			impl #gen_ref #call_name #gen_ref {
-				#(
-					#consts
-				)*
-				/// Return this call ERC165 selector
-				pub const fn interface_id() -> ::evm_coder::types::Bytes4 {
-					let mut interface_id = 0;
-					#(#interface_id)*
-					#(#inline_interface_id)*
-					u32::to_be_bytes(interface_id)
-				}
-				/// Generate solidity definitions for methods described in this interface
-				#[cfg(feature = "stubgen")]
-				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {
-					use evm_coder::solidity::*;
-					use core::fmt::Write;
-					let interface = SolidityInterface {
-						docs: &[#(#docs),*],
-						name: #solidity_name,
-						selector: Self::interface_id(),
-						is: &["Dummy", "ERC165", #(
-							#solidity_is,
-						)* #(
-							#solidity_events_is,
-						)* ],
-						functions: (#(
-							#solidity_functions,
-						)*),
-					};
-
-					let mut out = ::evm_coder::types::String::new();
-					if #solidity_name.starts_with("Inline") {
-						out.push_str("/// @dev inlined interface\n");
-					}
-					let _ = interface.format(is_impl, &mut out, tc);
-					tc.collect(out);
-					#(
-						#solidity_event_generators
-					)*
-					#(
-						#solidity_generators
-					)*
-					if is_impl {
-						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());
-					} else {
-						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());
-					}
-				}
-			}
-			impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {
-				fn parse(method_id: ::evm_coder::types::Bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {
-					use ::evm_coder::abi::AbiRead;
-					match method_id {
-						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(
-							::evm_coder::ERC165Call::parse(method_id, reader)?
-							.map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))
-						),
-						#(
-							#parsers,
-						)*
-						_ => {},
-					}
-					#(
-						#call_parse
-					)else*
-					return Ok(None);
-				}
-			}
-			impl #generics #call_name #gen_ref
-			#gen_where
-			{
-				/// Is this contract implements specified ERC165 selector
-				pub fn supports_interface(this: &#name, interface_id: ::evm_coder::types::Bytes4) -> bool {
-					interface_id != u32::to_be_bytes(0xffffff) && (
-						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||
-						interface_id == Self::interface_id()
-						#(
-							|| #supports_interface
-						)*
-					)
-				}
-			}
-			impl #generics ::evm_coder::Weighted for #call_name #gen_ref
-			#gen_where
-			{
-				#[allow(unused_variables)]
-				fn weight(&self) -> ::evm_coder::execution::DispatchInfo {
-					match self {
-						#(
-							#weight_variants,
-						)*
-						// TODO: It should be very cheap, but not free
-						Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => ::frame_support::weights::Weight::from_ref_time(100).into(),
-						#(
-							#weight_variants_this,
-						)*
-					}
-				}
-			}
-			impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name
-			#gen_where
-			{
-				#[allow(unreachable_code)] // In case of no inner calls
-				fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {
-					use ::evm_coder::abi::AbiWrite;
-					match c.call {
-						#(
-							#call_variants,
-						)*
-						#call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {
-							let mut writer = ::evm_coder::abi::AbiWriter::default();
-							writer.bool(&<#call_name #gen_ref>::supports_interface(self, interface_id));
-							return Ok(writer.into());
-						}
-						_ => {},
-					}
-					let mut writer = ::evm_coder::abi::AbiWriter::default();
-					match c.call {
-						#(
-							#call_variants_this,
-						)*
-						_ => Err(::evm_coder::execution::Error::from("method is not available").into()),
-					}
-				}
-			}
-		}
-	}
-}

--- a/crates/evm-coder/procedural/src/to_log.rs
+++ /dev/null
@@ -1,253 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-use inflector::cases;
-use syn::{Data, DeriveInput, Field, Fields, Ident, Variant, spanned::Spanned};
-use quote::quote;
-
-use crate::{parse_ident_from_path, parse_ident_from_type, snake_ident_to_screaming};
-
-struct EventField {
-	name: Ident,
-	camel_name: String,
-	ty: Ident,
-	indexed: bool,
-}
-
-impl EventField {
-	fn try_from(field: &Field) -> syn::Result<Self> {
-		let name = field.ident.as_ref().unwrap();
-		let ty = parse_ident_from_type(&field.ty, false)?;
-		let mut indexed = false;
-		for attr in &field.attrs {
-			if let Ok(ident) = parse_ident_from_path(&attr.path, false) {
-				if ident == "indexed" {
-					indexed = true;
-				}
-			}
-		}
-		Ok(Self {
-			name: name.to_owned(),
-			camel_name: cases::camelcase::to_camel_case(&name.to_string()),
-			ty: ty.to_owned(),
-			indexed,
-		})
-	}
-	fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {
-		let camel_name = &self.camel_name;
-		let ty = &self.ty;
-		let indexed = self.indexed;
-		quote! {
-			<SolidityEventArgument<#ty>>::new(#indexed, #camel_name)
-		}
-	}
-}
-
-struct Event {
-	name: Ident,
-	name_screaming: Ident,
-	fields: Vec<EventField>,
-	selector: proc_macro2::TokenStream,
-}
-
-impl Event {
-	fn try_from(variant: &Variant) -> syn::Result<Self> {
-		let name = &variant.ident;
-		let name_lit = proc_macro2::Literal::string(name.to_string().as_str());
-		let name_screaming = snake_ident_to_screaming(name);
-
-		let named = match &variant.fields {
-			Fields::Named(named) => named,
-			_ => {
-				return Err(syn::Error::new(
-					variant.fields.span(),
-					"expected named fields",
-				))
-			}
-		};
-		let mut fields = Vec::new();
-		for field in &named.named {
-			fields.push(EventField::try_from(field)?);
-		}
-		if fields.iter().filter(|f| f.indexed).count() > 3 {
-			return Err(syn::Error::new(
-				variant.fields.span(),
-				"events can have at most 4 indexed fields (1 indexed field is reserved for event signature)"
-			));
-		}
-
-		let args = fields.iter().map(|f| {
-			let ty = &f.ty;
-			quote! {nameof(<#ty as ::evm_coder::abi::AbiType>::SIGNATURE) fixed(",")}
-		});
-		// Remove trailing comma
-		let shift = (!fields.is_empty()).then(|| quote! {shift_left(1)});
-
-		let signature = quote! { ::evm_coder::make_signature!(new fixed(#name_lit) fixed("(") #(#args)* #shift fixed(")")) };
-		let selector = quote! {
-			{
-				let signature = #signature;
-				let mut sum = ::evm_coder::sha3_const::Keccak256::new();
-				let mut pos = 0;
-				while pos < signature.len {
-					sum = sum.update(&[signature.data[pos]; 1]);
-					pos += 1;
-				}
-				let a = sum.finalize();
-				let mut selector_bytes = [0; 32];
-				let mut i = 0;
-				while i != 32 {
-					selector_bytes[i] = a[i];
-					i += 1;
-				}
-				selector_bytes
-			}
-		};
-
-		Ok(Self {
-			name: name.to_owned(),
-			name_screaming,
-			fields,
-			selector,
-		})
-	}
-
-	fn expand_serializers(&self) -> proc_macro2::TokenStream {
-		let name = &self.name;
-		let name_screaming = &self.name_screaming;
-		let fields = self.fields.iter().map(|f| &f.name);
-
-		let indexed = self.fields.iter().filter(|f| f.indexed).map(|f| &f.name);
-		let plain = self.fields.iter().filter(|f| !f.indexed).map(|f| &f.name);
-
-		quote! {
-			Self::#name {#(
-				#fields,
-			)*} => {
-				topics.push(::evm_coder::types::Topic::from(Self::#name_screaming));
-				#(
-					topics.push(#indexed.to_topic());
-				)*
-				#(
-					#plain.abi_write(&mut writer);
-				)*
-			}
-		}
-	}
-
-	fn expand_consts(&self) -> proc_macro2::TokenStream {
-		let name_screaming = &self.name_screaming;
-		let selector = &self.selector;
-
-		quote! {
-			const #name_screaming: [u8; 32] = #selector;
-		}
-	}
-
-	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {
-		let name = self.name.to_string();
-		let args = self.fields.iter().map(EventField::expand_solidity_argument);
-		quote! {
-			SolidityEvent {
-				name: #name,
-				args: (
-					#(
-						#args,
-					)*
-				),
-			}
-		}
-	}
-}
-
-pub struct Events {
-	name: Ident,
-	events: Vec<Event>,
-}
-
-impl Events {
-	pub fn try_from(data: &DeriveInput) -> syn::Result<Self> {
-		let name = &data.ident;
-		let en = match &data.data {
-			Data::Enum(en) => en,
-			_ => return Err(syn::Error::new(data.span(), "expected enum")),
-		};
-		let mut events = Vec::new();
-		for variant in &en.variants {
-			events.push(Event::try_from(variant)?);
-		}
-		Ok(Self {
-			name: name.to_owned(),
-			events,
-		})
-	}
-	pub fn expand(&self) -> proc_macro2::TokenStream {
-		let name = &self.name;
-
-		let consts = self.events.iter().map(Event::expand_consts);
-		let serializers = self.events.iter().map(Event::expand_serializers);
-		let solidity_name = self.name.to_string();
-		let solidity_functions = self.events.iter().map(Event::expand_solidity_function);
-
-		quote! {
-			impl #name {
-				#(
-					#consts
-				)*
-
-				/// Generate solidity definitions for methods described in this interface
-				#[cfg(feature = "stubgen")]
-				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {
-					use evm_coder::solidity::*;
-					use core::fmt::Write;
-					let interface = SolidityInterface {
-						docs: &[],
-						selector: [0; 4],
-						name: #solidity_name,
-						is: &[],
-						functions: (#(
-							#solidity_functions,
-						)*),
-					};
-					let mut out = ::evm_coder::types::String::new();
-					out.push_str("/// @dev inlined interface\n");
-					let _ = interface.format(is_impl, &mut out, tc);
-					tc.collect(out);
-				}
-			}
-
-			#[automatically_derived]
-			impl ::evm_coder::events::ToLog for #name {
-				fn to_log(&self, contract: Address) -> ::evm_coder::ethereum::Log {
-					use ::evm_coder::events::ToTopic;
-					use ::evm_coder::abi::AbiWrite;
-					let mut writer = ::evm_coder::abi::AbiWriter::new();
-					let mut topics = Vec::new();
-					match self {
-						#(
-							#serializers,
-						)*
-					}
-					::evm_coder::ethereum::Log {
-						address: contract,
-						topics,
-						data: writer.finish(),
-					}
-				}
-			}
-		}
-	}
-}

--- a/crates/evm-coder/src/abi/impls.rs
+++ /dev/null
@@ -1,296 +0,0 @@
-use crate::{
-	custom_signature::SignatureUnit,
-	execution::{Result, ResultWithPostInfo, WithPostDispatchInfo},
-	make_signature, sealed,
-	types::*,
-};
-use super::{traits::*, ABI_ALIGNMENT, AbiReader, AbiWriter};
-use primitive_types::{U256, H160};
-
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
-
-macro_rules! impl_abi_type {
-	($ty:ty, $name:ident, $dynamic:literal) => {
-		impl sealed::CanBePlacedInVec for $ty {}
-
-		impl AbiType for $ty {
-			const SIGNATURE: SignatureUnit = make_signature!(new fixed(stringify!($name)));
-
-			fn is_dynamic() -> bool {
-				$dynamic
-			}
-
-			fn size() -> usize {
-				ABI_ALIGNMENT
-			}
-		}
-	};
-}
-
-macro_rules! impl_abi_readable {
-	($ty:ty, $method:ident) => {
-		impl AbiRead for $ty {
-			fn abi_read(reader: &mut AbiReader) -> Result<$ty> {
-				reader.$method()
-			}
-		}
-	};
-}
-
-macro_rules! impl_abi_writeable {
-	($ty:ty, $method:ident) => {
-		impl AbiWrite for $ty {
-			fn abi_write(&self, writer: &mut AbiWriter) {
-				writer.$method(&self)
-			}
-		}
-	};
-}
-
-macro_rules! impl_abi {
-	($ty:ty, $method:ident, $dynamic:literal) => {
-		impl_abi_type!($ty, $method, $dynamic);
-		impl_abi_readable!($ty, $method);
-		impl_abi_writeable!($ty, $method);
-	};
-}
-
-impl_abi!(bool, bool, false);
-impl_abi!(u8, uint8, false);
-impl_abi!(u32, uint32, false);
-impl_abi!(u64, uint64, false);
-impl_abi!(u128, uint128, false);
-impl_abi!(U256, uint256, false);
-impl_abi!(H160, address, false);
-impl_abi!(String, string, true);
-
-impl_abi_writeable!(&str, string);
-
-impl_abi_type!(Bytes, bytes, true);
-
-impl AbiRead for Bytes {
-	fn abi_read(reader: &mut AbiReader) -> Result<Bytes> {
-		Ok(Bytes(reader.bytes()?))
-	}
-}
-
-impl AbiWrite for Bytes {
-	fn abi_write(&self, writer: &mut AbiWriter) {
-		writer.bytes(self.0.as_slice())
-	}
-}
-
-impl_abi_type!(Bytes4, bytes4, false);
-impl AbiRead for Bytes4 {
-	fn abi_read(reader: &mut AbiReader) -> Result<Bytes4> {
-		reader.bytes4()
-	}
-}
-
-impl<T: AbiWrite> AbiWrite for &T {
-	fn abi_write(&self, writer: &mut AbiWriter) {
-		T::abi_write(self, writer);
-	}
-}
-
-impl<T: AbiType> AbiType for &T {
-	const SIGNATURE: SignatureUnit = T::SIGNATURE;
-
-	fn is_dynamic() -> bool {
-		T::is_dynamic()
-	}
-
-	fn size() -> usize {
-		T::size()
-	}
-}
-
-impl<T: AbiType + AbiRead + sealed::CanBePlacedInVec> AbiRead for Vec<T> {
-	fn abi_read(reader: &mut AbiReader) -> Result<Vec<T>> {
-		let mut sub = reader.subresult(None)?;
-		let size = sub.uint32()? as usize;
-		sub.subresult_offset = sub.offset;
-		let is_dynamic = <T as AbiType>::is_dynamic();
-		let mut out = Vec::with_capacity(size);
-		for _ in 0..size {
-			out.push(<T as AbiRead>::abi_read(&mut sub)?);
-			if !is_dynamic {
-				sub.bytes_read(<T as AbiType>::size());
-			};
-		}
-		Ok(out)
-	}
-}
-
-impl<T: AbiType> AbiType for Vec<T> {
-	const SIGNATURE: SignatureUnit = make_signature!(new nameof(T::SIGNATURE) fixed("[]"));
-
-	fn is_dynamic() -> bool {
-		true
-	}
-
-	fn size() -> usize {
-		ABI_ALIGNMENT
-	}
-}
-
-impl<T: AbiWrite + AbiType> AbiWrite for Vec<T> {
-	fn abi_write(&self, writer: &mut AbiWriter) {
-		let is_dynamic = T::is_dynamic();
-		let mut sub = if is_dynamic {
-			AbiWriter::new_dynamic(is_dynamic)
-		} else {
-			AbiWriter::new()
-		};
-
-		// Write items count
-		(self.len() as u32).abi_write(&mut sub);
-
-		for item in self {
-			item.abi_write(&mut sub);
-		}
-		writer.write_subresult(sub);
-	}
-}
-
-impl AbiWrite for () {
-	fn abi_write(&self, _writer: &mut AbiWriter) {}
-}
-
-/// This particular AbiWrite implementation should be split to another trait,
-/// which only implements `to_result`, but due to lack of specialization feature
-/// in stable Rust, we can't have blanket impl of this trait `for T where T: AbiWrite`,
-/// so here we abusing default trait methods for it
-impl<T: AbiWrite> AbiWrite for ResultWithPostInfo<T> {
-	fn abi_write(&self, _writer: &mut AbiWriter) {
-		debug_assert!(false, "shouldn't be called, see comment")
-	}
-	fn to_result(&self) -> ResultWithPostInfo<AbiWriter> {
-		match self {
-			Ok(v) => Ok(WithPostDispatchInfo {
-				post_info: v.post_info.clone(),
-				data: {
-					let mut out = AbiWriter::new();
-					v.data.abi_write(&mut out);
-					out
-				},
-			}),
-			Err(e) => Err(e.clone()),
-		}
-	}
-}
-
-macro_rules! impl_tuples {
-	($($ident:ident)+) => {
-		impl<$($ident: AbiType,)+> AbiType for ($($ident,)+)
-		where
-        $(
-            $ident: AbiType,
-        )+
-		{
-            const SIGNATURE: SignatureUnit = make_signature!(
-                new fixed("(")
-                $(nameof(<$ident>::SIGNATURE) fixed(","))+
-                shift_left(1)
-                fixed(")")
-            );
-
-			fn is_dynamic() -> bool {
-				false
-				$(
-					|| <$ident>::is_dynamic()
-				)*
-			}
-
-			fn size() -> usize {
-				0 $(+ <$ident>::size())+
-			}
-		}
-
-		impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}
-
-		impl<$($ident),+> AbiRead for ($($ident,)+)
-		where
-			Self: AbiType,
-			$($ident: AbiRead + AbiType,)+
-		{
-			fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {
-				let is_dynamic = <Self>::is_dynamic();
-				let size = if !is_dynamic { Some(<Self>::size()) } else { None };
-				let mut subresult = reader.subresult(size)?;
-				Ok((
-					$({
-						let value = <$ident>::abi_read(&mut subresult)?;
-						if !is_dynamic {subresult.bytes_read(<$ident as AbiType>::size())};
-						value
-					},)+
-				))
-			}
-		}
-
-		#[allow(non_snake_case)]
-		impl<$($ident),+> AbiWrite for ($($ident,)+)
-		where
-			$($ident: AbiWrite + AbiType,)+
-		{
-			fn abi_write(&self, writer: &mut AbiWriter) {
-				let ($($ident,)+) = self;
-				if <Self as AbiType>::is_dynamic() {
-					let mut sub = AbiWriter::new();
-					$($ident.abi_write(&mut sub);)+
-					writer.write_subresult(sub);
-				} else {
-					$($ident.abi_write(writer);)+
-				}
-			}
-		}
-	};
-}
-
-impl_tuples! {A}
-impl_tuples! {A B}
-impl_tuples! {A B C}
-impl_tuples! {A B C D}
-impl_tuples! {A B C D E}
-impl_tuples! {A B C D E F}
-impl_tuples! {A B C D E F G}
-impl_tuples! {A B C D E F G H}
-impl_tuples! {A B C D E F G H I}
-impl_tuples! {A B C D E F G H I J}
-
-//----- impls for Option -----
-impl<T: AbiType> AbiType for Option<T> {
-	const SIGNATURE: SignatureUnit = <(bool, T)>::SIGNATURE;
-
-	fn is_dynamic() -> bool {
-		<(bool, T)>::is_dynamic()
-	}
-
-	fn size() -> usize {
-		<(bool, T)>::size()
-	}
-}
-
-impl<T: AbiWrite + AbiType + Default> AbiWrite for Option<T> {
-	fn abi_write(&self, writer: &mut AbiWriter) {
-		match self {
-			Some(value) => (true, value).abi_write(writer),
-			None => (false, T::default()).abi_write(writer),
-		}
-	}
-}
-
-impl<T> AbiRead for Option<T>
-where
-	Self: AbiType,
-	T: AbiRead + AbiType,
-{
-	fn abi_read(reader: &mut AbiReader) -> Result<Self>
-	where
-		Self: Sized,
-	{
-		let (status, value) = <(bool, T)>::abi_read(reader)?;
-		Ok(if status { Some(value) } else { None })
-	}
-}

--- a/crates/evm-coder/src/abi/mod.rs
+++ /dev/null
@@ -1,348 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-//! Implementation of EVM RLP reader/writer
-
-#![allow(dead_code)]
-
-mod traits;
-pub use traits::*;
-mod impls;
-
-#[cfg(test)]
-mod test;
-
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
-use evm_core::ExitError;
-use primitive_types::{H160, U256};
-
-use crate::{
-	execution::{Result, Error},
-	types::*,
-};
-
-const ABI_ALIGNMENT: usize = 32;
-
-/// View into RLP data, which provides method to read typed items from it
-#[derive(Clone)]
-pub struct AbiReader<'i> {
-	buf: &'i [u8],
-	subresult_offset: usize,
-	offset: usize,
-}
-impl<'i> AbiReader<'i> {
-	/// Start reading RLP buffer, assuming there is no padding bytes
-	pub fn new(buf: &'i [u8]) -> Self {
-		Self {
-			buf,
-			subresult_offset: 0,
-			offset: 0,
-		}
-	}
-	/// Start reading RLP buffer, parsing first 4 bytes as selector
-	pub fn new_call(buf: &'i [u8]) -> Result<(Bytes4, Self)> {
-		if buf.len() < 4 {
-			return Err(Error::Error(ExitError::OutOfOffset));
-		}
-		let mut method_id = [0; 4];
-		method_id.copy_from_slice(&buf[0..4]);
-
-		Ok((
-			method_id,
-			Self {
-				buf,
-				subresult_offset: 4,
-				offset: 4,
-			},
-		))
-	}
-
-	fn read_pad<const S: usize>(
-		buf: &[u8],
-		offset: usize,
-		pad_start: usize,
-		pad_end: usize,
-		block_start: usize,
-		block_end: usize,
-	) -> Result<[u8; S]> {
-		if buf.len() - offset < ABI_ALIGNMENT {
-			return Err(Error::Error(ExitError::OutOfOffset));
-		}
-		let mut block = [0; S];
-		let is_pad_zeroed = buf[pad_start..pad_end].iter().all(|&v| v == 0);
-		if !is_pad_zeroed {
-			return Err(Error::Error(ExitError::InvalidRange));
-		}
-		block.copy_from_slice(&buf[block_start..block_end]);
-		Ok(block)
-	}
-
-	fn read_padleft<const S: usize>(&mut self) -> Result<[u8; S]> {
-		let offset = self.offset;
-		self.offset += ABI_ALIGNMENT;
-		Self::read_pad(
-			self.buf,
-			offset,
-			offset,
-			offset + ABI_ALIGNMENT - S,
-			offset + ABI_ALIGNMENT - S,
-			offset + ABI_ALIGNMENT,
-		)
-	}
-
-	fn read_padright<const S: usize>(&mut self) -> Result<[u8; S]> {
-		let offset = self.offset;
-		self.offset += ABI_ALIGNMENT;
-		Self::read_pad(
-			self.buf,
-			offset,
-			offset + S,
-			offset + ABI_ALIGNMENT,
-			offset,
-			offset + S,
-		)
-	}
-
-	/// Read [`H160`] at current position, then advance
-	pub fn address(&mut self) -> Result<H160> {
-		Ok(H160(self.read_padleft()?))
-	}
-
-	/// Read [`bool`] at current position, then advance
-	pub fn bool(&mut self) -> Result<bool> {
-		let data: [u8; 1] = self.read_padleft()?;
-		match data[0] {
-			0 => Ok(false),
-			1 => Ok(true),
-			_ => Err(Error::Error(ExitError::InvalidRange)),
-		}
-	}
-
-	/// Read [`[u8; 4]`] at current position, then advance
-	pub fn bytes4(&mut self) -> Result<[u8; 4]> {
-		self.read_padright()
-	}
-
-	/// Read [`Vec<u8>`] at current position, then advance
-	pub fn bytes(&mut self) -> Result<Vec<u8>> {
-		let mut subresult = self.subresult(None)?;
-		let length = subresult.uint32()? as usize;
-		if subresult.buf.len() < subresult.offset + length {
-			return Err(Error::Error(ExitError::OutOfOffset));
-		}
-		Ok(subresult.buf[subresult.offset..subresult.offset + length].into())
-	}
-
-	/// Read [`string`] at current position, then advance
-	pub fn string(&mut self) -> Result<String> {
-		String::from_utf8(self.bytes()?).map_err(|_| Error::Error(ExitError::InvalidRange))
-	}
-
-	/// Read [`u8`] at current position, then advance
-	pub fn uint8(&mut self) -> Result<u8> {
-		Ok(self.read_padleft::<1>()?[0])
-	}
-
-	/// Read [`u32`] at current position, then advance
-	pub fn uint32(&mut self) -> Result<u32> {
-		Ok(u32::from_be_bytes(self.read_padleft()?))
-	}
-
-	/// Read [`u128`] at current position, then advance
-	pub fn uint128(&mut self) -> Result<u128> {
-		Ok(u128::from_be_bytes(self.read_padleft()?))
-	}
-
-	/// Read [`U256`] at current position, then advance
-	pub fn uint256(&mut self) -> Result<U256> {
-		let buf: [u8; 32] = self.read_padleft()?;
-		Ok(U256::from_big_endian(&buf))
-	}
-
-	/// Read [`u64`] at current position, then advance
-	pub fn uint64(&mut self) -> Result<u64> {
-		Ok(u64::from_be_bytes(self.read_padleft()?))
-	}
-
-	/// Read [`usize`] at current position, then advance
-	#[deprecated = "dangerous, as usize may have different width in wasm and native execution"]
-	pub fn read_usize(&mut self) -> Result<usize> {
-		Ok(usize::from_be_bytes(self.read_padleft()?))
-	}
-
-	/// Slice recursive buffer, advance one word for buffer offset
-	/// If `size` is [`None`] then [`Self::offset`] and [`Self::subresult_offset`] evals from [`Self::buf`].
-	pub fn subresult(&mut self, size: Option<usize>) -> Result<AbiReader<'i>> {
-		let subresult_offset = self.subresult_offset;
-		let offset = if let Some(size) = size {
-			self.offset += size;
-			0
-		} else {
-			self.uint32()? as usize
-		};
-
-		if offset + self.subresult_offset > self.buf.len() {
-			return Err(Error::Error(ExitError::InvalidRange));
-		}
-
-		let new_offset = offset + subresult_offset;
-		Ok(AbiReader {
-			buf: self.buf,
-			subresult_offset: new_offset,
-			offset: new_offset,
-		})
-	}
-
-	/// Notify about readed data portion.
-	pub fn bytes_read(&mut self, size: usize) {
-		self.subresult_offset += size;
-	}
-
-	/// Is this parser reached end of buffer?
-	pub fn is_finished(&self) -> bool {
-		self.buf.len() == self.offset
-	}
-}
-
-/// Writer for RLP encoded data
-#[derive(Default)]
-pub struct AbiWriter {
-	static_part: Vec<u8>,
-	dynamic_part: Vec<(usize, AbiWriter)>,
-	had_call: bool,
-	is_dynamic: bool,
-}
-impl AbiWriter {
-	/// Initialize internal buffers for output data, assuming no padding required
-	pub fn new() -> Self {
-		Self::default()
-	}
-
-	/// Initialize internal buffers with data size
-	pub fn new_dynamic(is_dynamic: bool) -> Self {
-		Self {
-			is_dynamic,
-			..Default::default()
-		}
-	}
-	/// Initialize internal buffers, inserting method selector at beginning
-	pub fn new_call(method_id: u32) -> Self {
-		let mut val = Self::new();
-		val.static_part.extend(&method_id.to_be_bytes());
-		val.had_call = true;
-		val
-	}
-
-	fn write_padleft(&mut self, block: &[u8]) {
-		assert!(block.len() <= ABI_ALIGNMENT);
-		self.static_part
-			.extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - block.len()]);
-		self.static_part.extend(block);
-	}
-
-	fn write_padright(&mut self, block: &[u8]) {
-		assert!(block.len() <= ABI_ALIGNMENT);
-		self.static_part.extend(block);
-		self.static_part
-			.extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - block.len()]);
-	}
-
-	/// Write [`H160`] to end of buffer
-	pub fn address(&mut self, address: &H160) {
-		self.write_padleft(&address.0)
-	}
-
-	/// Write [`bool`] to end of buffer
-	pub fn bool(&mut self, value: &bool) {
-		self.write_padleft(&[if *value { 1 } else { 0 }])
-	}
-
-	/// Write [`u8`] to end of buffer
-	pub fn uint8(&mut self, value: &u8) {
-		self.write_padleft(&[*value])
-	}
-
-	/// Write [`u32`] to end of buffer
-	pub fn uint32(&mut self, value: &u32) {
-		self.write_padleft(&u32::to_be_bytes(*value))
-	}
-
-	/// Write [`u64`] to end of buffer
-	pub fn uint64(&mut self, value: &u64) {
-		self.write_padleft(&u64::to_be_bytes(*value))
-	}
-
-	/// Write [`u128`] to end of buffer
-	pub fn uint128(&mut self, value: &u128) {
-		self.write_padleft(&u128::to_be_bytes(*value))
-	}
-
-	/// Write [`U256`] to end of buffer
-	pub fn uint256(&mut self, value: &U256) {
-		let mut out = [0; 32];
-		value.to_big_endian(&mut out);
-		self.write_padleft(&out)
-	}
-
-	/// Write [`usize`] to end of buffer
-	#[deprecated = "dangerous, as usize may have different width in wasm and native execution"]
-	pub fn write_usize(&mut self, value: &usize) {
-		self.write_padleft(&usize::to_be_bytes(*value))
-	}
-
-	/// Append recursive data, writing pending offset at end of buffer
-	pub fn write_subresult(&mut self, result: Self) {
-		self.dynamic_part.push((self.static_part.len(), result));
-		// Empty block, to be filled later
-		self.write_padleft(&[]);
-	}
-
-	fn memory(&mut self, value: &[u8]) {
-		let mut sub = Self::new();
-		sub.uint32(&(value.len() as u32));
-		for chunk in value.chunks(ABI_ALIGNMENT) {
-			sub.write_padright(chunk);
-		}
-		self.write_subresult(sub);
-	}
-
-	/// Append recursive [`str`] at end of buffer
-	pub fn string(&mut self, value: &str) {
-		self.memory(value.as_bytes())
-	}
-
-	/// Append recursive [`[u8]`] at end of buffer
-	pub fn bytes(&mut self, value: &[u8]) {
-		self.memory(value)
-	}
-
-	/// Finish writer, concatenating all internal buffers
-	pub fn finish(mut self) -> Vec<u8> {
-		for (static_offset, part) in self.dynamic_part {
-			let part_offset = self.static_part.len()
-				- if self.had_call { 4 } else { 0 }
-				- if self.is_dynamic { ABI_ALIGNMENT } else { 0 };
-
-			let encoded_dynamic_offset = usize::to_be_bytes(part_offset);
-			let start = static_offset + ABI_ALIGNMENT - encoded_dynamic_offset.len();
-			let stop = static_offset + ABI_ALIGNMENT;
-			self.static_part[start..stop].copy_from_slice(&encoded_dynamic_offset);
-			self.static_part.extend(part.finish())
-		}
-		self.static_part
-	}
-}

--- a/crates/evm-coder/src/abi/test.rs
+++ /dev/null
@@ -1,605 +0,0 @@
-use crate::{
-	abi::{AbiRead, AbiWrite},
-	types::*,
-};
-
-use super::{AbiReader, AbiWriter};
-use hex_literal::hex;
-use primitive_types::{H160, U256};
-
-fn test_impl<T>(function_identifier: u32, decoded_data: T, encoded_data: &[u8])
-where
-	T: AbiWrite + AbiRead + std::cmp::PartialEq + std::fmt::Debug,
-{
-	let (call, mut decoder) = AbiReader::new_call(encoded_data).unwrap();
-	assert_eq!(call, u32::to_be_bytes(function_identifier));
-	let data = <T>::abi_read(&mut decoder).unwrap();
-	assert_eq!(data, decoded_data);
-
-	let mut writer = AbiWriter::new_call(function_identifier);
-	decoded_data.abi_write(&mut writer);
-	let ed = writer.finish();
-	similar_asserts::assert_eq!(encoded_data, ed.as_slice());
-}
-
-macro_rules! test_impl_uint {
-	($type:ident) => {
-		test_impl::<$type>(
-			0xdeadbeef,
-			255 as $type,
-			&hex!(
-				"
-                    deadbeef
-                    00000000000000000000000000000000000000000000000000000000000000ff
-                "
-			),
-		);
-	};
-}
-
-#[test]
-fn encode_decode_uint8() {
-	test_impl_uint!(u8);
-}
-
-#[test]
-fn encode_decode_uint32() {
-	test_impl_uint!(u32);
-}
-
-#[test]
-fn encode_decode_uint128() {
-	test_impl_uint!(u128);
-}
-
-#[test]
-fn encode_decode_uint256() {
-	test_impl::<U256>(
-		0xdeadbeef,
-		U256([255, 0, 0, 0]),
-		&hex!(
-			"
-                deadbeef
-                00000000000000000000000000000000000000000000000000000000000000ff
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_string() {
-	test_impl::<String>(
-		0xdeadbeef,
-		"some string".to_string(),
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000020
-                000000000000000000000000000000000000000000000000000000000000000b
-                736f6d6520737472696e67000000000000000000000000000000000000000000
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_tuple_string() {
-	test_impl::<(String,)>(
-		0xdeadbeef,
-		("some string".to_string(),),
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000020
-                0000000000000000000000000000000000000000000000000000000000000020
-                000000000000000000000000000000000000000000000000000000000000000b
-                736f6d6520737472696e67000000000000000000000000000000000000000000
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_vec_tuple_address_uint256() {
-	test_impl::<Vec<(Address, U256)>>(
-        0x1ACF2D55,
-        vec![
-            (
-                H160(hex!("2D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC")),
-                U256([10, 0, 0, 0]),
-            ),
-            (
-                H160(hex!("AB8E3D9134955566483B11E6825C9223B6737B10")),
-                U256([20, 0, 0, 0]),
-            ),
-            (
-                H160(hex!("8C582BDF2953046705FC56F189385255EFC1BE18")),
-                U256([30, 0, 0, 0]),
-            ),
-        ],
-        &hex!(
-            "
-                1ACF2D55
-                0000000000000000000000000000000000000000000000000000000000000020 // offset of (address, uint256)[]
-                0000000000000000000000000000000000000000000000000000000000000003 // length of (address, uint256)[]
-
-                0000000000000000000000002D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC // address
-                000000000000000000000000000000000000000000000000000000000000000A // uint256
-
-                000000000000000000000000AB8E3D9134955566483B11E6825C9223B6737B10 // address
-                0000000000000000000000000000000000000000000000000000000000000014 // uint256
-
-                0000000000000000000000008C582BDF2953046705FC56F189385255EFC1BE18 // address
-                000000000000000000000000000000000000000000000000000000000000001E // uint256
-            "
-        )
-    );
-}
-
-#[test]
-fn encode_decode_vec_tuple_uint256_string() {
-	test_impl::<Vec<(U256, String)>>(
-        0xdeadbeef,
-        vec![
-            (1.into(), "Test URI 0".to_string()),
-            (11.into(), "Test URI 1".to_string()),
-            (12.into(), "Test URI 2".to_string()),
-        ],
-        &hex!(
-            "
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000020 // offset of (uint256, string)[]
-                0000000000000000000000000000000000000000000000000000000000000003 // length of (uint256, string)[]
-
-                0000000000000000000000000000000000000000000000000000000000000060 // offset of first elem
-                00000000000000000000000000000000000000000000000000000000000000e0 // offset of second elem
-                0000000000000000000000000000000000000000000000000000000000000160 // offset of third elem
-
-                0000000000000000000000000000000000000000000000000000000000000001 // first token id?   					#60
-                0000000000000000000000000000000000000000000000000000000000000040 // offset of string
-                000000000000000000000000000000000000000000000000000000000000000a // size of string
-                5465737420555249203000000000000000000000000000000000000000000000 // string
-
-                000000000000000000000000000000000000000000000000000000000000000b // second token id? Why ==11?			#e0
-                0000000000000000000000000000000000000000000000000000000000000040 // offset of string
-                000000000000000000000000000000000000000000000000000000000000000a // size of string
-                5465737420555249203100000000000000000000000000000000000000000000 // string
-
-                000000000000000000000000000000000000000000000000000000000000000c // third token id?  Why ==12?			#160
-                0000000000000000000000000000000000000000000000000000000000000040 // offset of string
-                000000000000000000000000000000000000000000000000000000000000000a // size of string
-                5465737420555249203200000000000000000000000000000000000000000000 // string
-            "
-        )
-    );
-}
-
-#[test]
-fn dynamic_after_static() {
-	let mut encoder = AbiWriter::new();
-	encoder.bool(&true);
-	encoder.string("test");
-	let encoded = encoder.finish();
-
-	let mut encoder = AbiWriter::new();
-	encoder.bool(&true);
-	// Offset to subresult
-	encoder.uint32(&(32 * 2));
-	// Len of "test"
-	encoder.uint32(&4);
-	encoder.write_padright(&[b't', b'e', b's', b't']);
-	let alternative_encoded = encoder.finish();
-
-	assert_eq!(encoded, alternative_encoded);
-
-	let mut decoder = AbiReader::new(&encoded);
-	assert!(decoder.bool().unwrap());
-	assert_eq!(decoder.string().unwrap(), "test");
-}
-
-#[test]
-fn mint_sample() {
-	let (call, mut decoder) = AbiReader::new_call(&hex!(
-		"
-            50bb4e7f
-            000000000000000000000000ad2c0954693c2b5404b7e50967d3481bea432374
-            0000000000000000000000000000000000000000000000000000000000000001
-            0000000000000000000000000000000000000000000000000000000000000060
-            0000000000000000000000000000000000000000000000000000000000000008
-            5465737420555249000000000000000000000000000000000000000000000000
-        "
-	))
-	.unwrap();
-	assert_eq!(call, u32::to_be_bytes(0x50bb4e7f));
-	assert_eq!(
-		format!("{:?}", decoder.address().unwrap()),
-		"0xad2c0954693c2b5404b7e50967d3481bea432374"
-	);
-	assert_eq!(decoder.uint32().unwrap(), 1);
-	assert_eq!(decoder.string().unwrap(), "Test URI");
-}
-
-#[test]
-fn parse_vec_with_dynamic_type() {
-	let decoded_data = (
-		0x36543006,
-		vec![
-			(1.into(), "Test URI 0".to_string()),
-			(11.into(), "Test URI 1".to_string()),
-			(12.into(), "Test URI 2".to_string()),
-		],
-	);
-
-	let encoded_data = &hex!(
-        "
-            36543006
-            00000000000000000000000053744e6da587ba10b32a2554d2efdcd985bc27a3 // address
-            0000000000000000000000000000000000000000000000000000000000000040 // offset of (uint256, string)[]
-            0000000000000000000000000000000000000000000000000000000000000003 // length of (uint256, string)[]
-
-            0000000000000000000000000000000000000000000000000000000000000060 // offset of first elem
-            00000000000000000000000000000000000000000000000000000000000000e0 // offset of second elem
-            0000000000000000000000000000000000000000000000000000000000000160 // offset of third elem
-
-            0000000000000000000000000000000000000000000000000000000000000001 // first token id?   					#60
-            0000000000000000000000000000000000000000000000000000000000000040 // offset of string
-            000000000000000000000000000000000000000000000000000000000000000a // size of string
-            5465737420555249203000000000000000000000000000000000000000000000 // string
-
-            000000000000000000000000000000000000000000000000000000000000000b // second token id? Why ==11?			#e0
-            0000000000000000000000000000000000000000000000000000000000000040 // offset of string
-            000000000000000000000000000000000000000000000000000000000000000a // size of string
-            5465737420555249203100000000000000000000000000000000000000000000 // string
-
-            000000000000000000000000000000000000000000000000000000000000000c // third token id?  Why ==12?			#160
-            0000000000000000000000000000000000000000000000000000000000000040 // offset of string
-            000000000000000000000000000000000000000000000000000000000000000a // size of string
-            5465737420555249203200000000000000000000000000000000000000000000 // string
-        "
-    );
-
-	let (call, mut decoder) = AbiReader::new_call(encoded_data).unwrap();
-	assert_eq!(call, u32::to_be_bytes(decoded_data.0));
-	let address = decoder.address().unwrap();
-	let data = <Vec<(U256, String)>>::abi_read(&mut decoder).unwrap();
-	assert_eq!(data, decoded_data.1);
-
-	let mut writer = AbiWriter::new_call(decoded_data.0);
-	address.abi_write(&mut writer);
-	decoded_data.1.abi_write(&mut writer);
-	let ed = writer.finish();
-	similar_asserts::assert_eq!(encoded_data, ed.as_slice());
-}
-
-#[test]
-fn encode_decode_vec_tuple_string_bytes() {
-	test_impl::<Vec<(String, Bytes)>>(
-		0xdeadbeef,
-		vec![
-			(
-				"Test URI 0".to_string(),
-				Bytes(vec![
-					0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-					0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-					0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-					0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-				]),
-			),
-			(
-				"Test URI 1".to_string(),
-				Bytes(vec![
-					0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-					0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-					0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-					0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-				]),
-			),
-			("Test URI 2".to_string(), Bytes(vec![0x33, 0x33])),
-		],
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000020
-                0000000000000000000000000000000000000000000000000000000000000003
-
-                0000000000000000000000000000000000000000000000000000000000000060
-                0000000000000000000000000000000000000000000000000000000000000140
-                0000000000000000000000000000000000000000000000000000000000000220
-
-                0000000000000000000000000000000000000000000000000000000000000040
-                0000000000000000000000000000000000000000000000000000000000000080
-                000000000000000000000000000000000000000000000000000000000000000a
-                5465737420555249203000000000000000000000000000000000000000000000
-                0000000000000000000000000000000000000000000000000000000000000030
-                1111111111111111111111111111111111111111111111111111111111111111
-                1111111111111111111111111111111100000000000000000000000000000000
-
-                0000000000000000000000000000000000000000000000000000000000000040
-                0000000000000000000000000000000000000000000000000000000000000080
-                000000000000000000000000000000000000000000000000000000000000000a
-                5465737420555249203100000000000000000000000000000000000000000000
-                000000000000000000000000000000000000000000000000000000000000002f
-                2222222222222222222222222222222222222222222222222222222222222222
-                2222222222222222222222222222220000000000000000000000000000000000
-
-                0000000000000000000000000000000000000000000000000000000000000040
-                0000000000000000000000000000000000000000000000000000000000000080
-                000000000000000000000000000000000000000000000000000000000000000a
-                5465737420555249203200000000000000000000000000000000000000000000
-                0000000000000000000000000000000000000000000000000000000000000002
-                3333000000000000000000000000000000000000000000000000000000000000
-            "
-		),
-	);
-}
-
-#[test]
-// #[ignore = "reason"]
-fn encode_decode_tuple0_tuple1_uint8_tuple1_string_bytes_tuple1_uint8_bytes() {
-	let int = 0xff;
-	let by = Bytes(vec![0x11, 0x22, 0x33]);
-	let string = "some string".to_string();
-
-	test_impl::<((u8,), (String, Bytes), (u8, Bytes))>(
-		0xdeadbeef,
-		((int,), (string.clone(), by.clone()), (int, by)),
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000020
-                00000000000000000000000000000000000000000000000000000000000000ff
-                0000000000000000000000000000000000000000000000000000000000000060
-                0000000000000000000000000000000000000000000000000000000000000120
-                0000000000000000000000000000000000000000000000000000000000000040
-                0000000000000000000000000000000000000000000000000000000000000080
-                000000000000000000000000000000000000000000000000000000000000000b
-                736f6d6520737472696e67000000000000000000000000000000000000000000
-                0000000000000000000000000000000000000000000000000000000000000003
-                1122330000000000000000000000000000000000000000000000000000000000
-                00000000000000000000000000000000000000000000000000000000000000ff
-                0000000000000000000000000000000000000000000000000000000000000040
-                0000000000000000000000000000000000000000000000000000000000000003
-                1122330000000000000000000000000000000000000000000000000000000000
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_tuple0_tuple1_uint8_tuple1_uint8_uint8_tuple1_uint8_uint8() {
-	test_impl::<((u8,), (u8, u8), (u8, u8))>(
-		0xdeadbeef,
-		((43,), (44, 45), (46, 47)),
-		&hex!(
-			"
-                deadbeef
-                000000000000000000000000000000000000000000000000000000000000002b
-                000000000000000000000000000000000000000000000000000000000000002c
-                000000000000000000000000000000000000000000000000000000000000002d
-                000000000000000000000000000000000000000000000000000000000000002e
-                000000000000000000000000000000000000000000000000000000000000002f
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_tuple0_tuple1_uint8_tuple1_uint8() {
-	test_impl::<((u8,), (u8,))>(
-		0xdeadbeef,
-		((43,), (44,)),
-		&hex!(
-			"
-                deadbeef
-                000000000000000000000000000000000000000000000000000000000000002b
-                000000000000000000000000000000000000000000000000000000000000002c
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_tuple0_tuple1_uint8_uint8() {
-	test_impl::<((u8, u8),)>(
-		0xdeadbeef,
-		((43, 44),),
-		&hex!(
-			"
-                deadbeef
-                000000000000000000000000000000000000000000000000000000000000002b
-                000000000000000000000000000000000000000000000000000000000000002c
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_tuple_uint8_uint8() {
-	test_impl::<(u8, u8)>(
-		0xdeadbeef,
-		(43, 44),
-		&hex!(
-			"
-                deadbeef
-                000000000000000000000000000000000000000000000000000000000000002b
-                000000000000000000000000000000000000000000000000000000000000002c
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_tuple0_tuple1_uint8_uint8_tuple1_uint8_uint8_and_uint8() {
-	test_impl::<((u8, u8), (u8, u8), u8)>(
-		0xdeadbeef,
-		((10, 11), (12, 13), 14),
-		&hex!(
-			"
-                deadbeef
-                000000000000000000000000000000000000000000000000000000000000000a
-                000000000000000000000000000000000000000000000000000000000000000b
-                000000000000000000000000000000000000000000000000000000000000000c
-                000000000000000000000000000000000000000000000000000000000000000d
-                000000000000000000000000000000000000000000000000000000000000000e
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_tuple0_tuple1_string() {
-	test_impl::<((String,),)>(
-		0xdeadbeef,
-		(("some string".to_string(),),),
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000020
-                0000000000000000000000000000000000000000000000000000000000000020
-                0000000000000000000000000000000000000000000000000000000000000020
-                000000000000000000000000000000000000000000000000000000000000000b
-                736f6d6520737472696e67000000000000000000000000000000000000000000
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_tuple0_tuple1_uint8_string() {
-	test_impl::<((u8, String),)>(
-		0xdeadbeef,
-		((0xff, "some string".to_string()),),
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000020
-                0000000000000000000000000000000000000000000000000000000000000020
-                00000000000000000000000000000000000000000000000000000000000000ff
-                0000000000000000000000000000000000000000000000000000000000000040
-                000000000000000000000000000000000000000000000000000000000000000b
-                736f6d6520737472696e67000000000000000000000000000000000000000000
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_tuple0_tuple1_string_bytes() {
-	test_impl::<((String, Bytes),)>(
-		0xdeadbeef,
-		(("some string".to_string(), Bytes(vec![1, 2, 3])),),
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000020
-                0000000000000000000000000000000000000000000000000000000000000020
-                0000000000000000000000000000000000000000000000000000000000000040
-                0000000000000000000000000000000000000000000000000000000000000080
-                000000000000000000000000000000000000000000000000000000000000000b
-                736f6d6520737472696e67000000000000000000000000000000000000000000
-                0000000000000000000000000000000000000000000000000000000000000003
-                0102030000000000000000000000000000000000000000000000000000000000
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_tuple0_tuple1_uint8_tuple1_string() {
-	test_impl::<((u8,), (String,))>(
-		0xdeadbeef,
-		((0xff,), ("some string".to_string(),)),
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000020
-                00000000000000000000000000000000000000000000000000000000000000ff
-                0000000000000000000000000000000000000000000000000000000000000040
-                0000000000000000000000000000000000000000000000000000000000000020
-                000000000000000000000000000000000000000000000000000000000000000b
-                736f6d6520737472696e67000000000000000000000000000000000000000000
-            "
-		),
-	);
-}
-
-#[test]
-fn parse_multiple_params() {
-	let encoded_data = hex!(
-		"
-            deadbeef
-            000000000000000000000000000000000000000000000000000000000000000a
-            000000000000000000000000000000000000000000000000000000000000000b
-        "
-	);
-	let (_, mut decoder) = AbiReader::new_call(&encoded_data).unwrap();
-	let p1 = <u8>::abi_read(&mut decoder).unwrap();
-	let p2 = <u8>::abi_read(&mut decoder).unwrap();
-	assert_eq!(p1, 0x0a);
-	assert_eq!(p2, 0x0b);
-}
-
-#[test]
-fn encode_decode_option_uint8_some() {
-	test_impl::<Option<u8>>(
-		0xdeadbeef,
-		Some(44),
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000001
-                000000000000000000000000000000000000000000000000000000000000002c
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_option_uint8_none() {
-	test_impl::<Option<u8>>(
-		0xdeadbeef,
-		None,
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000000
-                0000000000000000000000000000000000000000000000000000000000000000
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_option_string_some() {
-	test_impl::<Option<String>>(
-		0xdeadbeef,
-		Some("some string".to_string()),
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000020
-                0000000000000000000000000000000000000000000000000000000000000001
-                0000000000000000000000000000000000000000000000000000000000000040
-                000000000000000000000000000000000000000000000000000000000000000b
-                736f6d6520737472696e67000000000000000000000000000000000000000000
-            "
-		),
-	);
-}
-
-#[test]
-fn encode_decode_option_string_none() {
-	test_impl::<Option<String>>(
-		0xdeadbeef,
-		None,
-		&hex!(
-			"
-                deadbeef
-                0000000000000000000000000000000000000000000000000000000000000020
-                0000000000000000000000000000000000000000000000000000000000000000
-                0000000000000000000000000000000000000000000000000000000000000040
-                0000000000000000000000000000000000000000000000000000000000000000
-            "
-		),
-	);
-}

--- a/crates/evm-coder/src/abi/traits.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use super::{AbiReader, AbiWriter};
-use crate::{
-	custom_signature::*,
-	execution::{Result, ResultWithPostInfo},
-};
-use core::str::from_utf8;
-
-/// Helper for type.
-pub trait AbiType {
-	/// Signature for Etherium ABI.
-	const SIGNATURE: SignatureUnit;
-
-	/// Signature as str.
-	fn as_str() -> &'static str {
-		from_utf8(&Self::SIGNATURE.data[..Self::SIGNATURE.len]).expect("bad utf-8")
-	}
-
-	/// Is type dynamic sized.
-	fn is_dynamic() -> bool;
-
-	/// Size for type aligned to [`ABI_ALIGNMENT`].
-	fn size() -> usize;
-}
-
-/// [`AbiReader`] implements reading of many types.
-pub trait AbiRead {
-	/// Read item from current position, advanding decoder
-	fn abi_read(reader: &mut AbiReader) -> Result<Self>
-	where
-		Self: Sized;
-}
-
-/// For questions about inability to provide custom implementations,
-/// see [`AbiRead`]
-pub trait AbiWrite {
-	/// Write value to end of specified encoder
-	fn abi_write(&self, writer: &mut AbiWriter);
-	/// Specialization for [`crate::solidity_interface`] implementation,
-	/// see comment in `impl AbiWrite for ResultWithPostInfo`
-	fn to_result(&self) -> ResultWithPostInfo<AbiWriter> {
-		let mut writer = AbiWriter::new();
-		self.abi_write(&mut writer);
-		Ok(writer.into())
-	}
-}

--- a/crates/evm-coder/src/custom_signature.rs
+++ /dev/null
@@ -1,326 +0,0 @@
-//! # A module for custom signature support.
-//!
-//! ## Overview
-//! This module allows you to create arbitrary signatures for types and functions in compile time.
-//!
-//! ### Type signatures
-//! To create the desired type signature, you need to create your own trait with the `SIGNATURE` constant.
-//! Then in the implementation, for the required type, use the macro [`make_signature`]
-//! #### Example
-//! ```
-//! use std::str::from_utf8;
-//! use evm_coder::{custom_signature::SignatureUnit, make_signature};
-//!
-//! // Create trait for our signature
-//! trait SoliditySignature {
-//!     const SIGNATURE: SignatureUnit;
-//!
-//!     fn name() -> &'static str {
-//!         from_utf8(&Self::SIGNATURE.data[..Self::SIGNATURE.len]).expect("bad utf-8")
-//!     }
-//! }
-//!
-//! // Make signatures for some types
-//! impl SoliditySignature for u8 {
-//!     const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint8"));
-//! }
-//! impl SoliditySignature for u32 {
-//!     const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint32"));
-//! }
-//! impl<T: SoliditySignature> SoliditySignature for Vec<T> {
-//!     const SIGNATURE: SignatureUnit = make_signature!(new nameof(T::SIGNATURE) fixed("[]"));
-//! }
-//! impl<A: SoliditySignature, B: SoliditySignature> SoliditySignature for (A, B) {
-//!     const SIGNATURE: SignatureUnit = make_signature!(new fixed("(") nameof(A::SIGNATURE) fixed(",") nameof(B::SIGNATURE) fixed(")"));
-//! }
-//! impl<A: SoliditySignature> SoliditySignature for (A,) {
-//!     const SIGNATURE: SignatureUnit = make_signature!(new fixed("(") nameof(A::SIGNATURE) fixed(",") shift_left(1) fixed(")"));
-//! }
-//!
-//! assert_eq!(u8::name(), "uint8");
-//! assert_eq!(<Vec<u8>>::name(), "uint8[]");
-//! assert_eq!(<(u32, u8)>::name(), "(uint32,uint8)");
-//! ```
-//!
-//! ### Function signatures
-//! To create a function signature, the macro [`make_signature`] is also used, which accepts
-//! settings for the function format [`SignaturePreferences`] and function parameters [`SignatureUnit`]
-//! #### Example
-//! ```
-//! use core::str::from_utf8;
-//! use evm_coder::{custom_signature::SignatureUnit, make_signature};
-//! // Trait for our signature
-//! trait SoliditySignature {
-//!     const SIGNATURE: SignatureUnit;
-//!
-//!     fn name() -> &'static str {
-//!         from_utf8(&Self::SIGNATURE.data[..Self::SIGNATURE.len]).expect("bad utf-8")
-//!     }
-//! }
-//!
-//! // Make signatures for some types
-//! impl SoliditySignature for u8 {
-//!     const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint8"));
-//! }
-//! impl<T: SoliditySignature> SoliditySignature for Vec<T> {
-//!     const SIGNATURE: SignatureUnit = make_signature!(new nameof(T::SIGNATURE) fixed("[]"));
-//! }
-//! ```
-
-/// The maximum length of the signature.
-pub const SIGNATURE_SIZE_LIMIT: usize = 256;
-
-/// Storage for the signature or its elements.
-#[derive(Debug)]
-pub struct SignatureUnit {
-	/// Signature data.
-	pub data: [u8; SIGNATURE_SIZE_LIMIT],
-	/// The actual size of the data.
-	pub len: usize,
-}
-
-impl SignatureUnit {
-	/// Create a signature from `&str'.
-	pub const fn new(name: &'static str) -> SignatureUnit {
-		let mut signature = [0_u8; SIGNATURE_SIZE_LIMIT];
-		let name = name.as_bytes();
-		let name_len = name.len();
-		let mut dst_offset = 0;
-		crate::make_signature!(@copy(name, signature, name_len, dst_offset));
-		SignatureUnit {
-			data: signature,
-			len: name_len,
-		}
-	}
-	/// String conversion
-	pub fn as_str(&self) -> Option<&str> {
-		core::str::from_utf8(&self.data[0..self.len]).ok()
-	}
-}
-
-/// ### Macro to create signatures of types and functions.
-///
-/// Format for creating a type of signature:
-/// ```ignore
-/// make_signature!(new fixed("uint8")); // Simple type
-/// make_signature!(new fixed("(") nameof(u8) fixed(",") nameof(u8) fixed(")")); // Composite type
-/// ```
-#[macro_export]
-macro_rules! make_signature {
-	(new $($tt:tt)*) => {
-		($crate::custom_signature::SignatureUnit {
-			data: {
-				let mut out = [0u8; $crate::custom_signature::SIGNATURE_SIZE_LIMIT];
-				let mut dst_offset = 0;
-				$crate::make_signature!(@data(out, dst_offset); $($tt)*);
-				out
-			},
-			len: {0 + $crate::make_signature!(@size; $($tt)*)},
-		})
-	};
-
-	(@size;) => {
-		0
-	};
-	(@size; fixed($expr:expr) $($tt:tt)*) => {
-		$expr.len() + $crate::make_signature!(@size; $($tt)*)
-	};
-	(@size; nameof($expr:expr) $($tt:tt)*) => {
-		$expr.len + $crate::make_signature!(@size; $($tt)*)
-	};
-	(@size; numof($expr:expr) $($tt:tt)*) => {
-		{
-			let mut out = 0;
-			let mut v = $expr;
-			if v == 0 {
-				out = 1;
-			} else {
-				while v > 0 {
-					out += 1;
-					v /= 10;
-				}
-			}
-			out
-		} + $crate::make_signature!(@size; $($tt)*)
-	};
-	(@size; shift_left($expr:expr) $($tt:tt)*) => {
-		$crate::make_signature!(@size; $($tt)*) - $expr
-	};
-
-	(@data($dst:ident, $dst_offset:ident);) => {};
-	(@data($dst:ident, $dst_offset:ident); fixed($expr:expr) $($tt:tt)*) => {
-		{
-			let data = $expr.as_bytes();
-			let data_len = data.len();
-			$crate::make_signature!(@copy(data, $dst, data_len, $dst_offset));
-		}
-		$crate::make_signature!(@data($dst, $dst_offset); $($tt)*)
-	};
-	(@data($dst:ident, $dst_offset:ident); nameof($expr:expr) $($tt:tt)*) => {
-		{
-			$crate::make_signature!(@copy(&$expr.data, $dst, $expr.len, $dst_offset));
-		}
-		$crate::make_signature!(@data($dst, $dst_offset); $($tt)*)
-	};
-	(@data($dst:ident, $dst_offset:ident); numof($expr:expr) $($tt:tt)*) => {
-		{
-			let mut v = $expr;
-			let mut need_to_swap = 0;
-			if v == 0 {
-				$dst[$dst_offset] = b'0';
-				$dst_offset += 1;
-			} else {
-				while v > 0 {
-					let n = (v % 10) as u8;
-					$dst[$dst_offset] = b'0' + n;
-					v /= 10;
-					need_to_swap += 1;
-					$dst_offset += 1;
-				}
-			}
-			let mut i = 0;
-			#[allow(clippy::manual_swap)]
-			while i < need_to_swap / 2 {
-				let a = $dst_offset - i - 1;
-				let b = $dst_offset - need_to_swap + i;
-				let v = $dst[a];
-				$dst[a] = $dst[b];
-				$dst[b] = v;
-				i += 1;
-			}
-		}
-		$crate::make_signature!(@data($dst, $dst_offset); $($tt)*)
-	};
-	(@data($dst:ident, $dst_offset:ident); shift_left($expr:expr) $($tt:tt)*) => {
-		$dst_offset -= $expr;
-		$crate::make_signature!(@data($dst, $dst_offset); $($tt)*)
-	};
-
-	(@copy($src:expr, $dst:expr, $src_len:expr, $dst_offset:ident)) => {
-		{
-			let mut src_offset = 0;
-			let src_len: usize = $src_len;
-			while src_offset < src_len {
-				$dst[$dst_offset] = $src[src_offset];
-				$dst_offset += 1;
-				src_offset += 1;
-			}
-		}
-	}
-}
-
-#[cfg(test)]
-mod test {
-	use core::str::from_utf8;
-
-	use super::{SIGNATURE_SIZE_LIMIT, SignatureUnit};
-
-	trait Name {
-		const NAME: SignatureUnit;
-
-		fn name() -> &'static str {
-			from_utf8(&Self::NAME.data[..Self::NAME.len]).expect("bad utf-8")
-		}
-	}
-
-	impl Name for u8 {
-		const NAME: SignatureUnit = make_signature!(new fixed("uint8"));
-	}
-	impl Name for u32 {
-		const NAME: SignatureUnit = make_signature!(new fixed("uint32"));
-	}
-	impl<T: Name> Name for Vec<T> {
-		const NAME: SignatureUnit = make_signature!(new nameof(T::NAME) fixed("[]"));
-	}
-	impl<A: Name, B: Name> Name for (A, B) {
-		const NAME: SignatureUnit =
-			make_signature!(new fixed("(") nameof(A::NAME) fixed(",") nameof(B::NAME) fixed(")"));
-	}
-	impl<A: Name> Name for (A,) {
-		const NAME: SignatureUnit =
-			make_signature!(new fixed("(") nameof(A::NAME) fixed(",") shift_left(1) fixed(")"));
-	}
-	impl<A: Name, const SIZE: usize> Name for [A; SIZE] {
-		const NAME: SignatureUnit =
-			make_signature!(new nameof(A::NAME) fixed("[") numof(SIZE) fixed("]"));
-	}
-
-	struct MaxSize();
-	impl Name for MaxSize {
-		const NAME: SignatureUnit = SignatureUnit {
-			data: [b'!'; SIGNATURE_SIZE_LIMIT],
-			len: SIGNATURE_SIZE_LIMIT,
-		};
-	}
-
-	#[test]
-	fn simple() {
-		assert_eq!(u8::name(), "uint8");
-		assert_eq!(u32::name(), "uint32");
-	}
-
-	#[test]
-	fn vector_of_simple() {
-		assert_eq!(<Vec<u8>>::name(), "uint8[]");
-		assert_eq!(<Vec<u32>>::name(), "uint32[]");
-	}
-
-	#[test]
-	fn vector_of_vector() {
-		assert_eq!(<Vec<Vec<u8>>>::name(), "uint8[][]");
-	}
-
-	#[test]
-	fn tuple_of_simple() {
-		assert_eq!(<(u32, u8)>::name(), "(uint32,uint8)");
-	}
-
-	#[test]
-	fn tuple_of_tuple() {
-		assert_eq!(
-			<((u32, u8), (u8, u32))>::name(),
-			"((uint32,uint8),(uint8,uint32))"
-		);
-	}
-
-	#[test]
-	fn vector_of_tuple() {
-		assert_eq!(<Vec<(u32, u8)>>::name(), "(uint32,uint8)[]");
-	}
-
-	#[test]
-	fn tuple_of_vector() {
-		assert_eq!(<(Vec<u32>, u8)>::name(), "(uint32[],uint8)");
-	}
-
-	#[test]
-	fn complex() {
-		assert_eq!(
-			<(Vec<u32>, (u32, Vec<u8>))>::name(),
-			"(uint32[],(uint32,uint8[]))"
-		);
-	}
-
-	#[test]
-	fn max_size() {
-		assert_eq!(<MaxSize>::name(), "!".repeat(SIGNATURE_SIZE_LIMIT));
-	}
-
-	#[test]
-	fn shift() {
-		assert_eq!(<(u32,)>::name(), "(uint32)");
-	}
-
-	#[test]
-	fn num() {
-		assert_eq!(<[u8; 0]>::name(), "uint8[0]");
-		assert_eq!(<[u8; 1234]>::name(), "uint8[1234]");
-		assert_eq!(<[u8; 12345]>::name(), "uint8[12345]");
-	}
-
-	#[test]
-	fn over_max_size() {
-		let t = trybuild::TestCases::new();
-		t.compile_fail("tests/build_failed/custom_signature_over_max_size.rs");
-	}
-}

--- a/crates/evm-coder/src/events.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-use ethereum::Log;
-use primitive_types::{H160, H256, U256};
-
-use crate::types::*;
-
-/// Implementation of this trait should not be written manually,
-/// instead use [`crate::ToLog`] proc macros.
-///
-/// See also [`evm_coder_procedural::ToLog`], [solidity docs on events](https://docs.soliditylang.org/en/develop/contracts.html#events)
-pub trait ToLog {
-	/// Convert event to [`ethereum::Log`].
-	/// Because event by itself doesn't contains current contract
-	/// address, it should be specified manually.
-	fn to_log(&self, contract: H160) -> Log;
-}
-
-/// Only items implementing `ToTopic` may be used as `#[indexed]` field
-/// in [`crate::ToLog`] macro usage.
-///
-/// See also (solidity docs on events)[<https://docs.soliditylang.org/en/develop/contracts.html#events>]
-pub trait ToTopic {
-	/// Convert value to topic to be used in [`ethereum::Log`]
-	fn to_topic(&self) -> H256;
-}
-
-impl ToTopic for H256 {
-	fn to_topic(&self) -> H256 {
-		*self
-	}
-}
-
-impl ToTopic for U256 {
-	fn to_topic(&self) -> H256 {
-		let mut out = [0u8; 32];
-		self.to_big_endian(&mut out);
-		H256(out)
-	}
-}
-
-impl ToTopic for Address {
-	fn to_topic(&self) -> H256 {
-		let mut out = [0u8; 32];
-		out[12..32].copy_from_slice(&self.0);
-		H256(out)
-	}
-}
-
-impl ToTopic for u32 {
-	fn to_topic(&self) -> H256 {
-		let mut out = [0u8; 32];
-		out[28..32].copy_from_slice(&self.to_be_bytes());
-		H256(out)
-	}
-}

no changes

--- a/crates/evm-coder/src/lib.rs
+++ /dev/null
@@ -1,298 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-#![doc = include_str!("../README.md")]
-#![deny(missing_docs)]
-#![macro_use]
-#![cfg_attr(not(feature = "std"), no_std)]
-#[cfg(not(feature = "std"))]
-extern crate alloc;
-
-use abi::{AbiRead, AbiReader, AbiWriter};
-pub use evm_coder_procedural::{event_topic, fn_selector};
-pub mod abi;
-pub use events::{ToLog, ToTopic};
-use execution::DispatchInfo;
-pub mod execution;
-#[macro_use]
-pub mod custom_signature;
-
-/// Derives call enum implementing [`crate::Callable`], [`crate::Weighted`]
-/// and [`crate::Call`] from impl block.
-///
-/// ## Macro syntax
-///
-/// `#[solidity_interface(name, is, inline_is, events)]`
-/// - *name* - used in generated code, and for Call enum name
-/// - *is* - used to provide inheritance in Solidity
-/// - *inline_is* - same as `is`, but ERC165::SupportsInterface will work differently: For `is` SupportsInterface(A) will return true
-///   if A is one of the interfaces the contract is inherited from (e.g. B is created as `is(A)`). If B is created as `inline_is(A)`
-///   SupportsInterface(A) will internally create a new interface that combines all methods of A and B, so SupportsInterface(A) will return
-///   false.
-///
-/// `#[weight(value)]`
-/// Can be added to every method of impl block, used for deriving [`crate::Weighted`], which
-/// is used by substrate bridge.
-/// - *value*: expression, which evaluates to weight required to call this method.
-/// This expression can use call arguments to calculate non-constant execution time.
-/// This expression should evaluate faster than actual execution does, and may provide worse case
-/// than one is called.
-///
-/// `#[solidity_interface(rename_selector)]`
-/// - *rename_selector* - by default, selector name will be generated by transforming method name
-/// from snake_case to camelCase. Use this option, if other naming convention is required.
-/// I.e: method `token_uri` will be automatically renamed to `tokenUri` in selector, but name
-/// required by ERC721 standard is `tokenURI`, thus we need to specify `rename_selector = "tokenURI"`
-/// explicitly.
-///
-/// Both contract and contract methods may have doccomments, which will end up in a generated
-/// solidity interface file, thus you should use [solidity syntax](https://docs.soliditylang.org/en/latest/natspec-format.html) for writing documentation in this macro
-///
-/// ## Example
-///
-/// ```ignore
-/// struct SuperContract;
-/// struct InlineContract;
-/// struct Contract;
-///
-/// #[derive(ToLog)]
-/// enum ContractEvents {
-///     Event(#[indexed] uint32),
-/// }
-///
-/// /// @dev This contract provides function to multiply two numbers
-/// #[solidity_interface(name = MyContract, is(SuperContract), inline_is(InlineContract))]
-/// impl Contract {
-///     /// Multiply two numbers
-///     /// @param a First number
-///     /// @param b Second number
-///     /// @return uint32 Product of two passed numbers
-///     /// @dev This function returns error in case of overflow
-///     #[weight(200 + a + b)]
-///     #[solidity_interface(rename_selector = "mul")]
-///     fn mul(&mut self, a: uint32, b: uint32) -> Result<uint32> {
-///         Ok(a.checked_mul(b).ok_or("overflow")?)
-///     }
-/// }
-/// ```
-pub use evm_coder_procedural::solidity_interface;
-/// See [`solidity_interface`]
-pub use evm_coder_procedural::solidity;
-/// See [`solidity_interface`]
-pub use evm_coder_procedural::weight;
-pub use evm_coder_procedural::AbiCoder;
-pub use sha3_const;
-
-/// macro reexports
-pub use ethereum;
-
-/// Derives [`ToLog`] for enum
-///
-/// Selectors will be derived from variant names, there is currently no way to have custom naming
-/// for them
-///
-/// `#[indexed]`
-/// Marks this field as indexed, so it will appear in [`ethereum::Log`] topics instead of data
-pub use evm_coder_procedural::ToLog;
-
-// Api of those modules shouldn't be consumed directly, it is only exported for usage in proc macros
-#[doc(hidden)]
-pub mod events;
-#[doc(hidden)]
-#[cfg(feature = "stubgen")]
-pub mod solidity;
-
-/// Sealed traits.
-pub mod sealed {
-	/// Not every type should be directly placed in vec.
-	/// Vec encoding is not memory efficient, as every item will be padded
-	/// to 32 bytes.
-	/// Instead you should use specialized types (`bytes` in case of `Vec<u8>`)
-	pub trait CanBePlacedInVec {}
-}
-
-/// Solidity type definitions (aliases from solidity name to rust type)
-/// To be used in [`solidity_interface`] definitions, to make sure there is no
-/// type conflict between Rust code and generated definitions
-pub mod types {
-	#![allow(non_camel_case_types, missing_docs)]
-
-	#[cfg(not(feature = "std"))]
-	use alloc::{vec::Vec};
-	use primitive_types::{U256, H160, H256};
-
-	pub type Address = H160;
-	pub type Bytes4 = [u8; 4];
-	pub type Topic = H256;
-
-	#[cfg(not(feature = "std"))]
-	pub type String = ::alloc::string::String;
-	#[cfg(feature = "std")]
-	pub type String = ::std::string::String;
-
-	#[derive(Default, Debug, PartialEq, Eq, Clone)]
-	pub struct Bytes(pub Vec<u8>);
-
-	//#region Special types
-	/// Makes function payable
-	pub type Value = U256;
-	/// Makes function caller-sensitive
-	pub type Caller = Address;
-	//#endregion
-
-	/// Ethereum typed call message, similar to solidity
-	/// `msg` object.
-	pub struct Msg<C> {
-		pub call: C,
-		/// Address of user, which called this contract.
-		pub caller: H160,
-		/// Payment amount to contract.
-		/// Contract should reject payment, if target call is not payable,
-		/// and there is no `receiver()` function defined.
-		pub value: U256,
-	}
-
-	impl From<Vec<u8>> for Bytes {
-		fn from(src: Vec<u8>) -> Self {
-			Self(src)
-		}
-	}
-
-	#[allow(clippy::from_over_into)]
-	impl Into<Vec<u8>> for Bytes {
-		fn into(self) -> Vec<u8> {
-			self.0
-		}
-	}
-
-	impl Bytes {
-		#[must_use]
-		pub fn len(&self) -> usize {
-			self.0.len()
-		}
-
-		#[must_use]
-		pub fn is_empty(&self) -> bool {
-			self.len() == 0
-		}
-	}
-}
-
-/// Parseable EVM call, this trait should be implemented with [`solidity_interface`] macro
-pub trait Call: Sized {
-	/// Parse call buffer into typed call enum
-	fn parse(selector: types::Bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>>;
-}
-
-/// Intended to be used as `#[weight]` output type
-/// Should be same between evm-coder and substrate to avoid confusion
-///
-/// Isn't same thing as gas, some mapping is required between those types
-pub type Weight = frame_support::pallet_prelude::Weight;
-
-/// In substrate, we have benchmarking, which allows
-/// us to not rely on gas metering, but instead predict amount of gas to execute call
-pub trait Weighted: Call {
-	/// Predict weight of this call
-	fn weight(&self) -> DispatchInfo;
-}
-
-/// Type callable with ethereum message, may be implemented by [`solidity_interface`] macro
-/// on interface implementation, or for externally-owned real EVM contract
-pub trait Callable<C: Call> {
-	/// Call contract using specified call data
-	fn call(&mut self, call: types::Msg<C>) -> execution::ResultWithPostInfo<AbiWriter>;
-}
-
-/// Implementation of ERC165 is implicitly generated for all interfaces in [`solidity_interface`],
-/// this structure holds parsed data for ERC165Call subvariant
-///
-/// Note: no [`Callable`] implementation is provided, call implementation is inlined into every
-/// implementing contract
-///
-/// See <https://eips.ethereum.org/EIPS/eip-165>
-#[derive(Debug)]
-pub enum ERC165Call {
-	/// ERC165 provides single method, which returns true, if contract
-	/// implements specified interface
-	SupportsInterface {
-		/// Requested interface
-		interface_id: types::Bytes4,
-	},
-}
-
-impl ERC165Call {
-	/// ERC165 selector is provided by standard
-	pub const INTERFACE_ID: types::Bytes4 = u32::to_be_bytes(0x01ffc9a7);
-}
-
-impl Call for ERC165Call {
-	fn parse(selector: types::Bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>> {
-		if selector != Self::INTERFACE_ID {
-			return Ok(None);
-		}
-		Ok(Some(Self::SupportsInterface {
-			interface_id: types::Bytes4::abi_read(input)?,
-		}))
-	}
-}
-
-/// Generate "tests", which will generate solidity code on execution and print it to stdout
-/// Script at .maintain/scripts/generate_api.sh can split this output from test runtime
-///
-/// This macro receives type usage as second argument, but you can use anything as generics,
-/// because no bounds are implied
-#[macro_export]
-macro_rules! generate_stubgen {
-	($name:ident, $decl:ty, $is_impl:literal) => {
-		#[cfg(feature = "stubgen")]
-		#[test]
-		#[ignore]
-		fn $name() {
-			use evm_coder::solidity::TypeCollector;
-			let mut out = TypeCollector::new();
-			<$decl>::generate_solidity_interface(&mut out, $is_impl);
-			println!("=== SNIP START ===");
-			println!("// SPDX-License-Identifier: OTHER");
-			println!("// This code is automatically generated");
-			println!();
-			println!("pragma solidity >=0.8.0 <0.9.0;");
-			println!();
-			for b in out.finish() {
-				println!("{}", b);
-			}
-			println!("=== SNIP END ===");
-		}
-	};
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-
-	#[test]
-	fn function_selector_generation() {
-		assert_eq!(fn_selector!(transfer(address, uint256)), 0xa9059cbb);
-	}
-
-	#[test]
-	fn event_topic_generation() {
-		assert_eq!(
-			hex::encode(&event_topic!(Transfer(address, address, uint256))[..]),
-			"ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
-		);
-	}
-}

--- a/crates/evm-coder/src/solidity/impls.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-use super::{TypeCollector, SolidityTypeName, SolidityTupleTy};
-use crate::{sealed, types::*};
-use core::fmt;
-use primitive_types::{U256, H160};
-
-macro_rules! solidity_type_name {
-    ($($ty:ty => $name:literal $simple:literal = $default:literal),* $(,)?) => {
-        $(
-            impl SolidityTypeName for $ty {
-                fn solidity_name(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {
-                    write!(writer, $name)
-                }
-				fn is_simple() -> bool {
-					$simple
-				}
-				fn solidity_default(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {
-					write!(writer, $default)
-				}
-            }
-        )*
-    };
-}
-
-solidity_type_name! {
-	u8 => "uint8" true = "0",
-	u32 => "uint32" true = "0",
-	u64 => "uint64" true = "0",
-	u128 => "uint128" true = "0",
-	U256 => "uint256" true = "0",
-	Bytes4 => "bytes4" true = "bytes4(0)",
-	H160 => "address" true = "0x0000000000000000000000000000000000000000",
-	String => "string" false = "\"\"",
-	Bytes => "bytes" false = "hex\"\"",
-	bool => "bool" true = "false",
-}
-
-impl SolidityTypeName for () {
-	fn solidity_name(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
-		Ok(())
-	}
-	fn is_simple() -> bool {
-		true
-	}
-	fn solidity_default(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
-		Ok(())
-	}
-	fn is_void() -> bool {
-		true
-	}
-}
-
-impl<T: SolidityTypeName + sealed::CanBePlacedInVec> SolidityTypeName for Vec<T> {
-	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		T::solidity_name(writer, tc)?;
-		write!(writer, "[]")
-	}
-	fn is_simple() -> bool {
-		false
-	}
-	fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		write!(writer, "new ")?;
-		T::solidity_name(writer, tc)?;
-		write!(writer, "[](0)")
-	}
-}
-
-macro_rules! count {
-    () => (0usize);
-    ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));
-}
-
-macro_rules! impl_tuples {
-	($($ident:ident)+) => {
-		impl<$($ident: SolidityTypeName + 'static),+> SolidityTupleTy for ($($ident,)+) {
-			fn fields(tc: &TypeCollector) -> Vec<String> {
-				let mut collected = Vec::with_capacity(Self::len());
-				$({
-					let mut out = String::new();
-					$ident::solidity_name(&mut out, tc).expect("no fmt error");
-					collected.push(out);
-				})*;
-				collected
-			}
-
-			fn len() -> usize {
-				count!($($ident)*)
-			}
-		}
-		impl<$($ident: SolidityTypeName + 'static),+> SolidityTypeName for ($($ident,)+) {
-			fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-				write!(writer, "{}", tc.collect_tuple::<Self>())
-			}
-			fn is_simple() -> bool {
-				false
-			}
-			#[allow(unused_assignments)]
-			fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-				write!(writer, "{}(", tc.collect_tuple::<Self>())?;
-				let mut first = true;
-				$(
-					if !first {
-						write!(writer, ",")?;
-					} else {
-						first = false;
-					}
-					<$ident>::solidity_default(writer, tc)?;
-				)*
-				write!(writer, ")")
-			}
-		}
-	};
-}
-
-impl_tuples! {A}
-impl_tuples! {A B}
-impl_tuples! {A B C}
-impl_tuples! {A B C D}
-impl_tuples! {A B C D E}
-impl_tuples! {A B C D E F}
-impl_tuples! {A B C D E F G}
-impl_tuples! {A B C D E F G H}
-impl_tuples! {A B C D E F G H I}
-impl_tuples! {A B C D E F G H I J}
-
-//----- impls for Option -----
-impl<T: SolidityTypeName + 'static> SolidityTypeName for Option<T> {
-	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		write!(writer, "{}", tc.collect_struct::<Self>())
-	}
-	fn is_simple() -> bool {
-		false
-	}
-	fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		write!(writer, "{}(", tc.collect_struct::<Self>())?;
-		bool::solidity_default(writer, tc)?;
-		write!(writer, ", ");
-		T::solidity_default(writer, tc)?;
-		write!(writer, ")")
-	}
-}
-
-impl<T: SolidityTypeName> super::SolidityStructTy for Option<T> {
-	fn generate_solidity_interface(tc: &TypeCollector) -> String {
-		let mut solidity_name = "Option".to_string();
-		let mut generic_name = String::new();
-		T::solidity_name(&mut generic_name, tc);
-		solidity_name.push(
-			generic_name
-				.chars()
-				.next()
-				.expect("Generic name is empty")
-				.to_ascii_uppercase(),
-		);
-		solidity_name.push_str(&generic_name[1..]);
-
-		let interface = super::SolidityStruct {
-			docs: &[" Optional value"],
-			name: solidity_name.as_str(),
-			fields: (
-				super::SolidityStructField::<bool> {
-					docs: &[" Shows the status of accessibility of value"],
-					name: "status",
-					ty: ::core::marker::PhantomData,
-				},
-				super::SolidityStructField::<T> {
-					docs: &[" Actual value if `status` is true"],
-					name: "value",
-					ty: ::core::marker::PhantomData,
-				},
-			),
-		};
-
-		let mut out = String::new();
-		let _ = interface.format(&mut out, tc);
-		tc.collect(out);
-
-		solidity_name.to_string()
-	}
-}

--- a/crates/evm-coder/src/solidity/mod.rs
+++ /dev/null
@@ -1,515 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-//! Implementation detail of [`crate::solidity_interface`] macro code-generation.
-//! You should not rely on any public item from this module, as it is only intended to be used
-//! by procedural macro, API and output format may be changed at any time.
-//!
-//! Purpose of this module is to receive solidity contract definition in module-specified
-//! format, and then output string, representing interface of this contract in solidity language
-
-mod traits;
-pub use traits::*;
-mod impls;
-
-#[cfg(not(feature = "std"))]
-use alloc::{vec::Vec, collections::BTreeMap, format};
-#[cfg(feature = "std")]
-use std::collections::BTreeMap;
-use core::{
-	fmt::{self, Write},
-	marker::PhantomData,
-	cell::{Cell, RefCell},
-	cmp::Reverse,
-};
-use impl_trait_for_tuples::impl_for_tuples;
-use crate::{types::*, custom_signature::SignatureUnit};
-
-#[derive(Default)]
-pub struct TypeCollector {
-	/// Code => id
-	/// id ordering is required to perform topo-sort on the resulting data
-	structs: RefCell<BTreeMap<String, usize>>,
-	anonymous: RefCell<BTreeMap<Vec<String>, usize>>,
-	// generic: RefCell<BTreeMap<String, usize>>,
-	id: Cell<usize>,
-}
-impl TypeCollector {
-	pub fn new() -> Self {
-		Self::default()
-	}
-	pub fn collect(&self, item: String) {
-		let id = self.next_id();
-		self.structs.borrow_mut().insert(item, id);
-	}
-	pub fn next_id(&self) -> usize {
-		let v = self.id.get();
-		self.id.set(v + 1);
-		v
-	}
-	/// Collect typle, deduplicating it by type, and returning generated name
-	pub fn collect_tuple<T: SolidityTupleTy>(&self) -> String {
-		let names = T::fields(self);
-		if let Some(id) = self.anonymous.borrow().get(&names).cloned() {
-			return format!("Tuple{}", id);
-		}
-		let id = self.next_id();
-		let mut str = String::new();
-		writeln!(str, "/// @dev anonymous struct").unwrap();
-		writeln!(str, "struct Tuple{} {{", id).unwrap();
-		for (i, name) in names.iter().enumerate() {
-			writeln!(str, "\t{} field_{};", name, i).unwrap();
-		}
-		writeln!(str, "}}").unwrap();
-		self.collect(str);
-		self.anonymous.borrow_mut().insert(names, id);
-		format!("Tuple{}", id)
-	}
-	pub fn collect_struct<T: SolidityStructTy>(&self) -> String {
-		T::generate_solidity_interface(self)
-	}
-	pub fn collect_enum<T: SolidityEnumTy>(&self) -> String {
-		T::generate_solidity_interface(self)
-	}
-	pub fn finish(self) -> Vec<String> {
-		let mut data = self.structs.into_inner().into_iter().collect::<Vec<_>>();
-		data.sort_by_key(|(_, id)| Reverse(*id));
-		data.into_iter().map(|(code, _)| code).collect()
-	}
-}
-#[derive(Default)]
-pub struct UnnamedArgument<T>(PhantomData<*const T>);
-
-impl<T: SolidityTypeName> SolidityArguments for UnnamedArgument<T> {
-	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		if !T::is_void() {
-			T::solidity_name(writer, tc)?;
-			if !T::is_simple() {
-				write!(writer, " memory")?;
-			}
-			Ok(())
-		} else {
-			Ok(())
-		}
-	}
-	fn solidity_get(&self, _prefix: &str, _writer: &mut impl fmt::Write) -> fmt::Result {
-		Ok(())
-	}
-	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		T::solidity_default(writer, tc)
-	}
-	fn len(&self) -> usize {
-		if T::is_void() {
-			0
-		} else {
-			1
-		}
-	}
-}
-
-pub struct NamedArgument<T>(&'static str, PhantomData<*const T>);
-
-impl<T> NamedArgument<T> {
-	pub fn new(name: &'static str) -> Self {
-		Self(name, Default::default())
-	}
-}
-
-impl<T: SolidityTypeName> SolidityArguments for NamedArgument<T> {
-	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		if !T::is_void() {
-			T::solidity_name(writer, tc)?;
-			if !T::is_simple() {
-				write!(writer, " memory")?;
-			}
-			write!(writer, " {}", self.0)
-		} else {
-			Ok(())
-		}
-	}
-	fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
-		writeln!(writer, "\t{prefix}\t{};", self.0)
-	}
-	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		T::solidity_default(writer, tc)
-	}
-	fn len(&self) -> usize {
-		if T::is_void() {
-			0
-		} else {
-			1
-		}
-	}
-}
-
-pub struct SolidityEventArgument<T>(pub bool, &'static str, PhantomData<*const T>);
-
-impl<T> SolidityEventArgument<T> {
-	pub fn new(indexed: bool, name: &'static str) -> Self {
-		Self(indexed, name, Default::default())
-	}
-}
-
-impl<T: SolidityTypeName> SolidityArguments for SolidityEventArgument<T> {
-	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		if !T::is_void() {
-			T::solidity_name(writer, tc)?;
-			if self.0 {
-				write!(writer, " indexed")?;
-			}
-			write!(writer, " {}", self.1)
-		} else {
-			Ok(())
-		}
-	}
-	fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
-		writeln!(writer, "\t{prefix}\t{};", self.1)
-	}
-	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		T::solidity_default(writer, tc)
-	}
-	fn len(&self) -> usize {
-		if T::is_void() {
-			0
-		} else {
-			1
-		}
-	}
-}
-
-impl SolidityArguments for () {
-	fn solidity_name(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
-		Ok(())
-	}
-	fn solidity_get(&self, _prefix: &str, _writer: &mut impl fmt::Write) -> fmt::Result {
-		Ok(())
-	}
-	fn solidity_default(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
-		Ok(())
-	}
-	fn len(&self) -> usize {
-		0
-	}
-}
-
-#[impl_for_tuples(1, 12)]
-impl SolidityArguments for Tuple {
-	for_tuples!( where #( Tuple: SolidityArguments ),* );
-
-	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		let mut first = true;
-		for_tuples!( #(
-            if !Tuple.is_empty() {
-                if !first {
-                    write!(writer, ", ")?;
-                }
-                first = false;
-                Tuple.solidity_name(writer, tc)?;
-            }
-        )* );
-		Ok(())
-	}
-	fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
-		for_tuples!( #(
-            Tuple.solidity_get(prefix, writer)?;
-        )* );
-		Ok(())
-	}
-	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		if self.is_empty() {
-			Ok(())
-		} else if self.len() == 1 {
-			for_tuples!( #(
-				Tuple.solidity_default(writer, tc)?;
-			)* );
-			Ok(())
-		} else {
-			write!(writer, "(")?;
-			let mut first = true;
-			for_tuples!( #(
-				if !Tuple.is_empty() {
-					if !first {
-						write!(writer, ", ")?;
-					}
-					first = false;
-					Tuple.solidity_default(writer, tc)?;
-				}
-			)* );
-			write!(writer, ")")?;
-			Ok(())
-		}
-	}
-	fn len(&self) -> usize {
-		for_tuples!( #( Tuple.len() )+* )
-	}
-}
-
-pub enum SolidityMutability {
-	Pure,
-	View,
-	Mutable,
-}
-pub struct SolidityFunction<A, R> {
-	pub docs: &'static [&'static str],
-	pub selector: u32,
-	pub hide: bool,
-	pub custom_signature: SignatureUnit,
-	pub name: &'static str,
-	pub args: A,
-	pub result: R,
-	pub mutability: SolidityMutability,
-	pub is_payable: bool,
-}
-impl<A: SolidityArguments, R: SolidityArguments> SolidityFunctions for SolidityFunction<A, R> {
-	fn solidity_name(
-		&self,
-		is_impl: bool,
-		writer: &mut impl fmt::Write,
-		tc: &TypeCollector,
-	) -> fmt::Result {
-		let hide_comment = self.hide.then_some("// ").unwrap_or("");
-		for doc in self.docs {
-			writeln!(writer, "\t{hide_comment}///{}", doc)?;
-		}
-		writeln!(
-			writer,
-			"\t{hide_comment}/// @dev EVM selector for this function is: 0x{:0>8x},",
-			self.selector
-		)?;
-		writeln!(
-			writer,
-			"\t{hide_comment}///  or in textual repr: {}",
-			self.custom_signature.as_str().expect("bad utf-8")
-		)?;
-		write!(writer, "\t{hide_comment}function {}(", self.name)?;
-		self.args.solidity_name(writer, tc)?;
-		write!(writer, ")")?;
-		if is_impl {
-			write!(writer, " public")?;
-		} else {
-			write!(writer, " external")?;
-		}
-		match &self.mutability {
-			SolidityMutability::Pure => write!(writer, " pure")?,
-			SolidityMutability::View => write!(writer, " view")?,
-			SolidityMutability::Mutable => {}
-		}
-		if self.is_payable {
-			write!(writer, " payable")?;
-		}
-		if !self.result.is_empty() {
-			write!(writer, " returns (")?;
-			self.result.solidity_name(writer, tc)?;
-			write!(writer, ")")?;
-		}
-		if is_impl {
-			writeln!(writer, " {{")?;
-			writeln!(writer, "\t{hide_comment}\trequire(false, stub_error);")?;
-			self.args.solidity_get(hide_comment, writer)?;
-			match &self.mutability {
-				SolidityMutability::Pure => {}
-				SolidityMutability::View => writeln!(writer, "\t{hide_comment}\tdummy;")?,
-				SolidityMutability::Mutable => writeln!(writer, "\t{hide_comment}\tdummy = 0;")?,
-			}
-			if !self.result.is_empty() {
-				write!(writer, "\t{hide_comment}\treturn ")?;
-				self.result.solidity_default(writer, tc)?;
-				writeln!(writer, ";")?;
-			}
-			writeln!(writer, "\t{hide_comment}}}")?;
-		} else {
-			writeln!(writer, ";")?;
-		}
-		if self.hide {
-			writeln!(writer, "// FORMATTING: FORCE NEWLINE")?;
-		}
-		Ok(())
-	}
-}
-
-#[impl_for_tuples(0, 48)]
-impl SolidityFunctions for Tuple {
-	for_tuples!( where #( Tuple: SolidityFunctions ),* );
-
-	fn solidity_name(
-		&self,
-		is_impl: bool,
-		writer: &mut impl fmt::Write,
-		tc: &TypeCollector,
-	) -> fmt::Result {
-		let mut first = false;
-		for_tuples!( #(
-            Tuple.solidity_name(is_impl, writer, tc)?;
-        )* );
-		Ok(())
-	}
-}
-
-pub struct SolidityInterface<F: SolidityFunctions> {
-	pub docs: &'static [&'static str],
-	pub selector: Bytes4,
-	pub name: &'static str,
-	pub is: &'static [&'static str],
-	pub functions: F,
-}
-
-impl<F: SolidityFunctions> SolidityInterface<F> {
-	pub fn format(
-		&self,
-		is_impl: bool,
-		out: &mut impl fmt::Write,
-		tc: &TypeCollector,
-	) -> fmt::Result {
-		const ZERO_BYTES: [u8; 4] = [0; 4];
-		for doc in self.docs {
-			writeln!(out, "///{}", doc)?;
-		}
-		if self.selector != ZERO_BYTES {
-			writeln!(
-				out,
-				"/// @dev the ERC-165 identifier for this interface is 0x{:0>8x}",
-				u32::from_be_bytes(self.selector)
-			)?;
-		}
-		if is_impl {
-			write!(out, "contract ")?;
-		} else {
-			write!(out, "interface ")?;
-		}
-		write!(out, "{}", self.name)?;
-		if !self.is.is_empty() {
-			write!(out, " is")?;
-			for (i, n) in self.is.iter().enumerate() {
-				if i != 0 {
-					write!(out, ",")?;
-				}
-				write!(out, " {}", n)?;
-			}
-		}
-		writeln!(out, " {{")?;
-		self.functions.solidity_name(is_impl, out, tc)?;
-		writeln!(out, "}}")?;
-		Ok(())
-	}
-}
-
-pub struct SolidityEvent<A> {
-	pub name: &'static str,
-	pub args: A,
-}
-
-impl<A: SolidityArguments> SolidityFunctions for SolidityEvent<A> {
-	fn solidity_name(
-		&self,
-		_is_impl: bool,
-		writer: &mut impl fmt::Write,
-		tc: &TypeCollector,
-	) -> fmt::Result {
-		write!(writer, "\tevent {}(", self.name)?;
-		self.args.solidity_name(writer, tc)?;
-		writeln!(writer, ");")
-	}
-}
-
-#[impl_for_tuples(0, 48)]
-impl SolidityItems for Tuple {
-	for_tuples!( where #( Tuple: SolidityItems ),* );
-
-	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		for_tuples!( #(
-            Tuple.solidity_name(writer, tc)?;
-        )* );
-		Ok(())
-	}
-}
-
-pub struct SolidityStructField<T> {
-	pub docs: &'static [&'static str],
-	pub name: &'static str,
-	pub ty: PhantomData<*const T>,
-}
-
-impl<T> SolidityItems for SolidityStructField<T>
-where
-	T: SolidityTypeName,
-{
-	fn solidity_name(&self, out: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		for doc in self.docs {
-			writeln!(out, "///{}", doc)?;
-		}
-		write!(out, "\t")?;
-		T::solidity_name(out, tc)?;
-		writeln!(out, " {};", self.name)?;
-		Ok(())
-	}
-}
-pub struct SolidityStruct<'a, F> {
-	pub docs: &'a [&'a str],
-	// pub generics:
-	pub name: &'a str,
-	pub fields: F,
-}
-impl<F> SolidityStruct<'_, F>
-where
-	F: SolidityItems,
-{
-	pub fn format(&self, out: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		for doc in self.docs {
-			writeln!(out, "///{}", doc)?;
-		}
-		writeln!(out, "struct {} {{", self.name)?;
-		self.fields.solidity_name(out, tc)?;
-		writeln!(out, "}}")?;
-		Ok(())
-	}
-}
-
-pub struct SolidityEnumVariant {
-	pub docs: &'static [&'static str],
-	pub name: &'static str,
-}
-impl SolidityItems for SolidityEnumVariant {
-	fn solidity_name(&self, out: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
-		for doc in self.docs {
-			writeln!(out, "///{}", doc)?;
-		}
-		write!(out, "\t{}", self.name)?;
-		Ok(())
-	}
-}
-pub struct SolidityEnum {
-	pub docs: &'static [&'static str],
-	pub name: &'static str,
-	pub fields: &'static [SolidityEnumVariant],
-}
-impl SolidityEnum {
-	pub fn format(&self, out: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
-		for doc in self.docs {
-			writeln!(out, "///{}", doc)?;
-		}
-		write!(out, "enum {} {{", self.name)?;
-		for (i, field) in self.fields.iter().enumerate() {
-			if i != 0 {
-				write!(out, ",")?;
-			}
-			writeln!(out)?;
-			field.solidity_name(out, tc)?;
-		}
-		writeln!(out)?;
-		writeln!(out, "}}")?;
-		Ok(())
-	}
-}

--- a/crates/evm-coder/src/solidity/traits.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use super::TypeCollector;
-use core::fmt;
-
-pub trait SolidityTypeName: 'static {
-	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
-	/// "simple" types are stored inline, no `memory` modifier should be used in solidity
-	fn is_simple() -> bool;
-	fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
-	/// Specialization
-	fn is_void() -> bool {
-		false
-	}
-}
-
-pub trait SolidityTupleTy: 'static {
-	fn fields(tc: &TypeCollector) -> Vec<String>;
-	fn len() -> usize;
-}
-pub trait SolidityStructTy: 'static {
-	fn generate_solidity_interface(tc: &TypeCollector) -> String;
-}
-pub trait SolidityEnumTy: 'static {
-	fn generate_solidity_interface(tc: &TypeCollector) -> String;
-	fn solidity_option(&self) -> &str;
-}
-
-pub trait SolidityArguments {
-	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
-	fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result;
-	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
-	fn is_empty(&self) -> bool {
-		self.len() == 0
-	}
-	fn len(&self) -> usize;
-}
-
-pub trait SolidityFunctions {
-	fn solidity_name(
-		&self,
-		is_impl: bool,
-		writer: &mut impl fmt::Write,
-		tc: &TypeCollector,
-	) -> fmt::Result;
-}
-
-pub trait SolidityItems {
-	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
-	// For PhantomData fields
-	// fn is_void()
-}

--- a/crates/evm-coder/tests/abi_derive_generation.rs
+++ /dev/null
@@ -1,765 +0,0 @@
-mod test_struct {
-	use evm_coder_procedural::AbiCoder;
-	use evm_coder::types::Bytes;
-
-	#[test]
-	fn empty_struct() {
-		let t = trybuild::TestCases::new();
-		t.compile_fail("tests/build_failed/abi_derive_struct_generation.rs");
-	}
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TypeStruct1SimpleParam {
-		_a: u8,
-	}
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TypeStruct1DynamicParam {
-		_a: String,
-	}
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TypeStruct2SimpleParam {
-		_a: u8,
-		_b: u32,
-	}
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TypeStruct2DynamicParam {
-		_a: String,
-		_b: Bytes,
-	}
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TypeStruct2MixedParam {
-		_a: u8,
-		_b: Bytes,
-	}
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TypeStruct1DerivedSimpleParam {
-		_a: TypeStruct1SimpleParam,
-	}
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TypeStruct2DerivedSimpleParam {
-		_a: TypeStruct1SimpleParam,
-		_b: TypeStruct2SimpleParam,
-	}
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TypeStruct1DerivedDynamicParam {
-		_a: TypeStruct1DynamicParam,
-	}
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TypeStruct2DerivedDynamicParam {
-		_a: TypeStruct1DynamicParam,
-		_b: TypeStruct2DynamicParam,
-	}
-
-	/// Some docs
-	/// At multi
-	/// line
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TypeStruct3DerivedMixedParam {
-		/// Docs for A
-		/// multi
-		/// line
-		_a: TypeStruct1SimpleParam,
-		/// Docs for B
-		_b: TypeStruct2DynamicParam,
-		/// Docs for C
-		_c: TypeStruct2MixedParam,
-	}
-
-	#[test]
-	fn impl_abi_type_signature() {
-		assert_eq!(
-			<TypeStruct1SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			"(uint8)"
-		);
-		assert_eq!(
-			<TypeStruct1DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			"(string)"
-		);
-		assert_eq!(
-			<TypeStruct2SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			"(uint8,uint32)"
-		);
-		assert_eq!(
-			<TypeStruct2DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			"(string,bytes)"
-		);
-		assert_eq!(
-			<TypeStruct2MixedParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			"(uint8,bytes)"
-		);
-		assert_eq!(
-			<TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			"((uint8))"
-		);
-		assert_eq!(
-			<TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			"((uint8),(uint8,uint32))"
-		);
-		assert_eq!(
-			<TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			"((string))"
-		);
-		assert_eq!(
-			<TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			"((string),(string,bytes))"
-		);
-		assert_eq!(
-			<TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			"((uint8),(string,bytes),(uint8,bytes))"
-		);
-	}
-
-	#[test]
-	fn impl_abi_type_is_dynamic() {
-		assert_eq!(
-			<TypeStruct1SimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
-			false
-		);
-		assert_eq!(
-			<TypeStruct1DynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
-			true
-		);
-		assert_eq!(
-			<TypeStruct2SimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
-			false
-		);
-		assert_eq!(
-			<TypeStruct2DynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
-			true
-		);
-		assert_eq!(
-			<TypeStruct2MixedParam as evm_coder::abi::AbiType>::is_dynamic(),
-			true
-		);
-		assert_eq!(
-			<TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
-			false
-		);
-		assert_eq!(
-			<TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
-			false
-		);
-		assert_eq!(
-			<TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
-			true
-		);
-		assert_eq!(
-			<TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
-			true
-		);
-		assert_eq!(
-			<TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::is_dynamic(),
-			true
-		);
-	}
-
-	#[test]
-	fn impl_abi_type_size() {
-		const ABI_ALIGNMENT: usize = 32;
-		assert_eq!(
-			<TypeStruct1SimpleParam as evm_coder::abi::AbiType>::size(),
-			ABI_ALIGNMENT
-		);
-		assert_eq!(
-			<TypeStruct1DynamicParam as evm_coder::abi::AbiType>::size(),
-			ABI_ALIGNMENT
-		);
-		assert_eq!(
-			<TypeStruct2SimpleParam as evm_coder::abi::AbiType>::size(),
-			ABI_ALIGNMENT * 2
-		);
-		assert_eq!(
-			<TypeStruct2DynamicParam as evm_coder::abi::AbiType>::size(),
-			ABI_ALIGNMENT * 2
-		);
-		assert_eq!(
-			<TypeStruct2MixedParam as evm_coder::abi::AbiType>::size(),
-			ABI_ALIGNMENT * 2
-		);
-		assert_eq!(
-			<TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::size(),
-			ABI_ALIGNMENT
-		);
-		assert_eq!(
-			<TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::size(),
-			ABI_ALIGNMENT * 3
-		);
-		assert_eq!(
-			<TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::size(),
-			ABI_ALIGNMENT
-		);
-		assert_eq!(
-			<TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::size(),
-			ABI_ALIGNMENT * 3
-		);
-		assert_eq!(
-			<TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::size(),
-			ABI_ALIGNMENT * 5
-		);
-	}
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TupleStruct1SimpleParam(u8);
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TupleStruct1DynamicParam(String);
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TupleStruct2SimpleParam(u8, u32);
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TupleStruct2DynamicParam(String, Bytes);
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TupleStruct2MixedParam(u8, Bytes);
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TupleStruct1DerivedSimpleParam(TupleStruct1SimpleParam);
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TupleStruct2DerivedSimpleParam(TupleStruct1SimpleParam, TupleStruct2SimpleParam);
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TupleStruct1DerivedDynamicParam(TupleStruct1DynamicParam);
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TupleStruct2DerivedDynamicParam(TupleStruct1DynamicParam, TupleStruct2DynamicParam);
-
-	/// Some docs
-	/// At multi
-	/// line
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TupleStruct3DerivedMixedParam(
-		/// Docs for A
-		/// multi
-		/// line
-		TupleStruct1SimpleParam,
-		TupleStruct2DynamicParam,
-		/// Docs for C
-		TupleStruct2MixedParam,
-	);
-
-	#[test]
-	fn impl_abi_type_signature_same_for_structs() {
-		assert_eq!(
-			<TypeStruct1SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			<TupleStruct1SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap()
-		);
-		assert_eq!(
-			<TypeStruct1DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			<TupleStruct1DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap()
-		);
-		assert_eq!(
-			<TypeStruct2SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			<TupleStruct2SimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap()
-		);
-		assert_eq!(
-			<TypeStruct2DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			<TupleStruct2DynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap()
-		);
-		assert_eq!(
-			<TypeStruct2MixedParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			<TupleStruct2MixedParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-		);
-		assert_eq!(
-			<TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			<TupleStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-		);
-		assert_eq!(
-			<TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			<TupleStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-		);
-		assert_eq!(
-			<TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			<TupleStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-		);
-		assert_eq!(
-			<TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			<TupleStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-		);
-		assert_eq!(
-			<TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			<TupleStruct3DerivedMixedParam as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-		);
-	}
-
-	#[test]
-	fn impl_abi_type_is_dynamic_same_for_structs() {
-		assert_eq!(
-			<TypeStruct1SimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
-			<TupleStruct1SimpleParam as evm_coder::abi::AbiType>::is_dynamic()
-		);
-		assert_eq!(
-			<TypeStruct1DynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
-			<TupleStruct1DynamicParam as evm_coder::abi::AbiType>::is_dynamic()
-		);
-		assert_eq!(
-			<TypeStruct2SimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
-			<TupleStruct2SimpleParam as evm_coder::abi::AbiType>::is_dynamic()
-		);
-		assert_eq!(
-			<TypeStruct2DynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
-			<TupleStruct2DynamicParam as evm_coder::abi::AbiType>::is_dynamic()
-		);
-		assert_eq!(
-			<TypeStruct2MixedParam as evm_coder::abi::AbiType>::is_dynamic(),
-			<TupleStruct2MixedParam as evm_coder::abi::AbiType>::is_dynamic()
-		);
-		assert_eq!(
-			<TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
-			<TupleStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic()
-		);
-		assert_eq!(
-			<TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic(),
-			<TupleStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::is_dynamic()
-		);
-		assert_eq!(
-			<TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
-			<TupleStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic()
-		);
-		assert_eq!(
-			<TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic(),
-			<TupleStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::is_dynamic()
-		);
-		assert_eq!(
-			<TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::is_dynamic(),
-			<TupleStruct3DerivedMixedParam as evm_coder::abi::AbiType>::is_dynamic()
-		);
-	}
-
-	#[test]
-	fn impl_abi_type_size_same_for_structs() {
-		assert_eq!(
-			<TypeStruct1SimpleParam as evm_coder::abi::AbiType>::size(),
-			<TupleStruct1SimpleParam as evm_coder::abi::AbiType>::size()
-		);
-		assert_eq!(
-			<TypeStruct1DynamicParam as evm_coder::abi::AbiType>::size(),
-			<TupleStruct1DynamicParam as evm_coder::abi::AbiType>::size()
-		);
-		assert_eq!(
-			<TypeStruct2SimpleParam as evm_coder::abi::AbiType>::size(),
-			<TupleStruct2SimpleParam as evm_coder::abi::AbiType>::size()
-		);
-		assert_eq!(
-			<TypeStruct2DynamicParam as evm_coder::abi::AbiType>::size(),
-			<TupleStruct2DynamicParam as evm_coder::abi::AbiType>::size()
-		);
-		assert_eq!(
-			<TypeStruct2MixedParam as evm_coder::abi::AbiType>::size(),
-			<TupleStruct2MixedParam as evm_coder::abi::AbiType>::size()
-		);
-		assert_eq!(
-			<TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::size(),
-			<TupleStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::size()
-		);
-		assert_eq!(
-			<TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::size(),
-			<TupleStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::size()
-		);
-		assert_eq!(
-			<TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::size(),
-			<TupleStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::size()
-		);
-		assert_eq!(
-			<TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::size(),
-			<TupleStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::size()
-		);
-		assert_eq!(
-			<TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::size(),
-			<TupleStruct3DerivedMixedParam as evm_coder::abi::AbiType>::size()
-		);
-	}
-
-	const FUNCTION_IDENTIFIER: u32 = 0xdeadbeef;
-
-	fn test_impl<Tuple, TupleStruct, TypeStruct>(
-		tuple_data: Tuple,
-		tuple_struct_data: TupleStruct,
-		type_struct_data: TypeStruct,
-	) where
-		TypeStruct: evm_coder::abi::AbiWrite
-			+ evm_coder::abi::AbiRead
-			+ std::cmp::PartialEq
-			+ std::fmt::Debug,
-		TupleStruct: evm_coder::abi::AbiWrite
-			+ evm_coder::abi::AbiRead
-			+ std::cmp::PartialEq
-			+ std::fmt::Debug,
-		Tuple: evm_coder::abi::AbiWrite
-			+ evm_coder::abi::AbiRead
-			+ std::cmp::PartialEq
-			+ std::fmt::Debug,
-	{
-		let encoded_type_struct = test_abi_write_impl(&type_struct_data);
-		let encoded_tuple_struct = test_abi_write_impl(&tuple_struct_data);
-		let encoded_tuple = test_abi_write_impl(&tuple_data);
-
-		similar_asserts::assert_eq!(encoded_tuple, encoded_type_struct);
-		similar_asserts::assert_eq!(encoded_tuple, encoded_tuple_struct);
-
-		{
-			let (_, mut decoder) = evm_coder::abi::AbiReader::new_call(&encoded_tuple).unwrap();
-			let restored_struct_data = <TypeStruct>::abi_read(&mut decoder).unwrap();
-			assert_eq!(restored_struct_data, type_struct_data);
-		}
-		{
-			let (_, mut decoder) = evm_coder::abi::AbiReader::new_call(&encoded_tuple).unwrap();
-			let restored_struct_data = <TupleStruct>::abi_read(&mut decoder).unwrap();
-			assert_eq!(restored_struct_data, tuple_struct_data);
-		}
-
-		{
-			let (_, mut decoder) =
-				evm_coder::abi::AbiReader::new_call(&encoded_type_struct).unwrap();
-			let restored_tuple_data = <Tuple>::abi_read(&mut decoder).unwrap();
-			assert_eq!(restored_tuple_data, tuple_data);
-		}
-		{
-			let (_, mut decoder) =
-				evm_coder::abi::AbiReader::new_call(&encoded_tuple_struct).unwrap();
-			let restored_tuple_data = <Tuple>::abi_read(&mut decoder).unwrap();
-			assert_eq!(restored_tuple_data, tuple_data);
-		}
-	}
-
-	fn test_abi_write_impl<A>(data: &A) -> Vec<u8>
-	where
-		A: evm_coder::abi::AbiWrite
-			+ evm_coder::abi::AbiRead
-			+ std::cmp::PartialEq
-			+ std::fmt::Debug,
-	{
-		let mut writer = evm_coder::abi::AbiWriter::new_call(FUNCTION_IDENTIFIER);
-		data.abi_write(&mut writer);
-		let encoded_tuple = writer.finish();
-		encoded_tuple
-	}
-
-	#[test]
-	fn codec_struct_1_simple() {
-		let _a = 0xff;
-		test_impl::<(u8,), TupleStruct1SimpleParam, TypeStruct1SimpleParam>(
-			(_a,),
-			TupleStruct1SimpleParam(_a),
-			TypeStruct1SimpleParam { _a },
-		);
-	}
-
-	#[test]
-	fn codec_struct_1_dynamic() {
-		let _a: String = "some string".into();
-		test_impl::<(String,), TupleStruct1DynamicParam, TypeStruct1DynamicParam>(
-			(_a.clone(),),
-			TupleStruct1DynamicParam(_a.clone()),
-			TypeStruct1DynamicParam { _a },
-		);
-	}
-
-	#[test]
-	fn codec_struct_1_derived_simple() {
-		let _a: u8 = 0xff;
-		test_impl::<((u8,),), TupleStruct1DerivedSimpleParam, TypeStruct1DerivedSimpleParam>(
-			((_a,),),
-			TupleStruct1DerivedSimpleParam(TupleStruct1SimpleParam(_a)),
-			TypeStruct1DerivedSimpleParam {
-				_a: TypeStruct1SimpleParam { _a },
-			},
-		);
-	}
-
-	#[test]
-	fn codec_struct_1_derived_dynamic() {
-		let _a: String = "some string".into();
-		test_impl::<((String,),), TupleStruct1DerivedDynamicParam, TypeStruct1DerivedDynamicParam>(
-			((_a.clone(),),),
-			TupleStruct1DerivedDynamicParam(TupleStruct1DynamicParam(_a.clone())),
-			TypeStruct1DerivedDynamicParam {
-				_a: TypeStruct1DynamicParam { _a },
-			},
-		);
-	}
-
-	#[test]
-	fn codec_struct_2_simple() {
-		let _a = 0xff;
-		let _b = 0xbeefbaba;
-		test_impl::<(u8, u32), TupleStruct2SimpleParam, TypeStruct2SimpleParam>(
-			(_a, _b),
-			TupleStruct2SimpleParam(_a, _b),
-			TypeStruct2SimpleParam { _a, _b },
-		);
-	}
-
-	#[test]
-	fn codec_struct_2_dynamic() {
-		let _a: String = "some string".into();
-		let _b: Bytes = Bytes(vec![0x11, 0x22, 0x33]);
-		test_impl::<(String, Bytes), TupleStruct2DynamicParam, TypeStruct2DynamicParam>(
-			(_a.clone(), _b.clone()),
-			TupleStruct2DynamicParam(_a.clone(), _b.clone()),
-			TypeStruct2DynamicParam { _a, _b },
-		);
-	}
-
-	#[test]
-	fn codec_struct_2_mixed() {
-		let _a: u8 = 0xff;
-		let _b: Bytes = Bytes(vec![0x11, 0x22, 0x33]);
-		test_impl::<(u8, Bytes), TupleStruct2MixedParam, TypeStruct2MixedParam>(
-			(_a.clone(), _b.clone()),
-			TupleStruct2MixedParam(_a.clone(), _b.clone()),
-			TypeStruct2MixedParam { _a, _b },
-		);
-	}
-
-	#[test]
-	fn codec_struct_2_derived_simple() {
-		let _a = 0xff;
-		let _b = 0xbeefbaba;
-		test_impl::<
-			((u8,), (u8, u32)),
-			TupleStruct2DerivedSimpleParam,
-			TypeStruct2DerivedSimpleParam,
-		>(
-			((_a,), (_a, _b)),
-			TupleStruct2DerivedSimpleParam(
-				TupleStruct1SimpleParam(_a),
-				TupleStruct2SimpleParam(_a, _b),
-			),
-			TypeStruct2DerivedSimpleParam {
-				_a: TypeStruct1SimpleParam { _a },
-				_b: TypeStruct2SimpleParam { _a, _b },
-			},
-		);
-	}
-
-	#[test]
-	fn codec_struct_2_derived_dynamic() {
-		let _a = "some string".to_string();
-		let _b = Bytes(vec![0x11, 0x22, 0x33]);
-		test_impl::<
-			((String,), (String, Bytes)),
-			TupleStruct2DerivedDynamicParam,
-			TypeStruct2DerivedDynamicParam,
-		>(
-			((_a.clone(),), (_a.clone(), _b.clone())),
-			TupleStruct2DerivedDynamicParam(
-				TupleStruct1DynamicParam(_a.clone()),
-				TupleStruct2DynamicParam(_a.clone(), _b.clone()),
-			),
-			TypeStruct2DerivedDynamicParam {
-				_a: TypeStruct1DynamicParam { _a: _a.clone() },
-				_b: TypeStruct2DynamicParam { _a, _b },
-			},
-		);
-	}
-
-	#[test]
-	fn codec_struct_3_derived_mixed() {
-		let int = 0xff;
-		let by = Bytes(vec![0x11, 0x22, 0x33]);
-		let string = "some string".to_string();
-		test_impl::<
-			((u8,), (String, Bytes), (u8, Bytes)),
-			TupleStruct3DerivedMixedParam,
-			TypeStruct3DerivedMixedParam,
-		>(
-			((int,), (string.clone(), by.clone()), (int, by.clone())),
-			TupleStruct3DerivedMixedParam(
-				TupleStruct1SimpleParam(int),
-				TupleStruct2DynamicParam(string.clone(), by.clone()),
-				TupleStruct2MixedParam(int, by.clone()),
-			),
-			TypeStruct3DerivedMixedParam {
-				_a: TypeStruct1SimpleParam { _a: int },
-				_b: TypeStruct2DynamicParam {
-					_a: string.clone(),
-					_b: by.clone(),
-				},
-				_c: TypeStruct2MixedParam { _a: int, _b: by },
-			},
-		);
-	}
-
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TypeStruct2SimpleStruct1Simple {
-		_a: TypeStruct2SimpleParam,
-		_b: TypeStruct2SimpleParam,
-		_c: u8,
-	}
-	#[derive(AbiCoder, PartialEq, Debug)]
-	struct TupleStruct2SimpleStruct1Simple(TupleStruct2SimpleParam, TupleStruct2SimpleParam, u8);
-
-	#[test]
-	fn codec_struct_2_struct_simple_1_simple() {
-		let _a = 0xff;
-		let _b = 0xbeefbaba;
-		test_impl::<
-			((u8, u32), (u8, u32), u8),
-			TupleStruct2SimpleStruct1Simple,
-			TypeStruct2SimpleStruct1Simple,
-		>(
-			((_a, _b), (_a, _b), _a),
-			TupleStruct2SimpleStruct1Simple(
-				TupleStruct2SimpleParam(_a, _b),
-				TupleStruct2SimpleParam(_a, _b),
-				_a,
-			),
-			TypeStruct2SimpleStruct1Simple {
-				_a: TypeStruct2SimpleParam { _a, _b },
-				_b: TypeStruct2SimpleParam { _a, _b },
-				_c: _a,
-			},
-		);
-	}
-}
-
-mod test_enum {
-	use evm_coder::AbiCoder;
-
-	/// Some docs
-	/// At multi
-	/// line
-	#[derive(AbiCoder, Debug, PartialEq, Default, Clone, Copy)]
-	#[repr(u8)]
-	enum Color {
-		/// Docs for Red
-		/// multi
-		/// line
-		Red,
-		Green,
-		/// Docs for Blue
-		#[default]
-		Blue,
-	}
-
-	#[test]
-	fn empty() {}
-
-	#[test]
-	fn bad_enums() {
-		let t = trybuild::TestCases::new();
-		t.compile_fail("tests/build_failed/abi_derive_enum_generation.rs");
-	}
-
-	#[test]
-	fn impl_abi_type_signature_same_for_structs() {
-		assert_eq!(
-			<Color as evm_coder::abi::AbiType>::SIGNATURE
-				.as_str()
-				.unwrap(),
-			<u8 as evm_coder::abi::AbiType>::SIGNATURE.as_str().unwrap()
-		);
-	}
-
-	#[test]
-	fn impl_abi_type_is_dynamic_same_for_structs() {
-		assert_eq!(
-			<Color as evm_coder::abi::AbiType>::is_dynamic(),
-			<u8 as evm_coder::abi::AbiType>::is_dynamic()
-		);
-	}
-
-	#[test]
-	fn impl_abi_type_size_same_for_structs() {
-		assert_eq!(
-			<Color as evm_coder::abi::AbiType>::size(),
-			<u8 as evm_coder::abi::AbiType>::size()
-		);
-	}
-
-	#[test]
-	fn test_coder() {
-		const FUNCTION_IDENTIFIER: u32 = 0xdeadbeef;
-
-		let encoded_enum = {
-			let mut writer = evm_coder::abi::AbiWriter::new_call(FUNCTION_IDENTIFIER);
-			<Color as evm_coder::abi::AbiWrite>::abi_write(&Color::Green, &mut writer);
-			writer.finish()
-		};
-
-		let encoded_u8 = {
-			let mut writer = evm_coder::abi::AbiWriter::new_call(FUNCTION_IDENTIFIER);
-			<u8 as evm_coder::abi::AbiWrite>::abi_write(&(Color::Green as u8), &mut writer);
-			writer.finish()
-		};
-
-		similar_asserts::assert_eq!(encoded_enum, encoded_u8);
-
-		{
-			let (_, mut decoder) = evm_coder::abi::AbiReader::new_call(&encoded_enum).unwrap();
-			let restored_enum_data =
-				<Color as evm_coder::abi::AbiRead>::abi_read(&mut decoder).unwrap();
-			assert_eq!(restored_enum_data, Color::Green);
-		}
-	}
-}

--- a/crates/evm-coder/tests/build_failed/abi_derive_enum_generation.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use evm_coder_procedural::AbiCoder;
-
-#[derive(AbiCoder)]
-enum NonRepr {
-	A,
-	B,
-	C,
-}
-
-#[derive(AbiCoder)]
-#[repr(u32)]
-enum NonReprU8 {
-	A,
-	B,
-	C,
-}
-
-#[derive(AbiCoder)]
-#[repr(u8)]
-enum RustEnum {
-	A(u128),
-	B,
-	C,
-}
-
-#[derive(AbiCoder)]
-#[repr(u8)]
-enum WithExplicit {
-	A = 128,
-	B,
-	C,
-}
-
-fn main() {
-	assert!(false);
-}

--- a/crates/evm-coder/tests/build_failed/abi_derive_enum_generation.stderr
+++ /dev/null
@@ -1,23 +0,0 @@
-error: Enum is not "repr(u8)"
- --> tests/build_failed/abi_derive_enum_generation.rs:4:6
-  |
-4 | enum NonRepr {
-  |      ^^^^^^^
-
-error: Enum is not "repr(u8)"
-  --> tests/build_failed/abi_derive_enum_generation.rs:11:8
-   |
-11 | #[repr(u32)]
-   |        ^^^
-
-error: Enumeration parameters should not have fields
-  --> tests/build_failed/abi_derive_enum_generation.rs:21:2
-   |
-21 |     A(u128),
-   |     ^
-
-error: Enumeration options should not have an explicit specified value
-  --> tests/build_failed/abi_derive_enum_generation.rs:29:2
-   |
-29 |     A = 128,
-   |     ^

--- a/crates/evm-coder/tests/build_failed/abi_derive_struct_generation.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use evm_coder_procedural::AbiCoder;
-
-#[derive(AbiCoder, PartialEq, Debug)]
-struct EmptyStruct {}
-
-#[derive(AbiCoder, PartialEq, Debug)]
-struct EmptyTupleStruct();
-
-fn main() {
-	assert!(false);
-}

--- a/crates/evm-coder/tests/build_failed/abi_derive_struct_generation.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: Empty structs not supported
- --> tests/build_failed/abi_derive_struct_generation.rs:4:8
-  |
-4 | struct EmptyStruct {}
-  |        ^^^^^^^^^^^
-
-error: Empty structs not supported
- --> tests/build_failed/abi_derive_struct_generation.rs:7:8
-  |
-7 | struct EmptyTupleStruct();
-  |        ^^^^^^^^^^^^^^^^

--- a/crates/evm-coder/tests/build_failed/custom_signature_over_max_size.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-#![allow(dead_code)]
-use std::str::from_utf8;
-
-use evm_coder::{
-	make_signature,
-	custom_signature::{SignatureUnit, SIGNATURE_SIZE_LIMIT},
-};
-
-trait Name {
-	const SIGNATURE: SignatureUnit;
-
-	fn name() -> &'static str {
-		from_utf8(&Self::SIGNATURE.data[..Self::SIGNATURE.len]).expect("bad utf-8")
-	}
-}
-
-impl<T: Name> Name for Vec<T> {
-	const SIGNATURE: SignatureUnit =
-		evm_coder::make_signature!(new nameof(T::SIGNATURE) fixed("[]"));
-}
-
-struct MaxSize();
-impl Name for MaxSize {
-	const SIGNATURE: SignatureUnit = SignatureUnit {
-		data: [b'!'; SIGNATURE_SIZE_LIMIT],
-		len: SIGNATURE_SIZE_LIMIT,
-	};
-}
-
-const NAME: SignatureUnit = <Vec<MaxSize>>::SIGNATURE;
-
-fn main() {
-	assert!(false);
-}

--- a/crates/evm-coder/tests/build_failed/custom_signature_over_max_size.stderr
+++ /dev/null
@@ -1,21 +0,0 @@
-warning: unused import: `make_signature`
- --> tests/build_failed/custom_signature_over_max_size.rs:5:2
-  |
-5 |     make_signature,
-  |     ^^^^^^^^^^^^^^
-  |
-  = note: `#[warn(unused_imports)]` on by default
-
-error[E0080]: evaluation of `<std::vec::Vec<MaxSize> as Name>::SIGNATURE` failed
-  --> tests/build_failed/custom_signature_over_max_size.rs:19:3
-   |
-19 |         evm_coder::make_signature!(new nameof(T::SIGNATURE) fixed("[]"));
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ index out of bounds: the length is 256 but the index is 256
-   |
-   = note: this error originates in the macro `$crate::make_signature` which comes from the expansion of the macro `evm_coder::make_signature` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0080]: evaluation of constant value failed
-  --> tests/build_failed/custom_signature_over_max_size.rs:30:29
-   |
-30 | const NAME: SignatureUnit = <Vec<MaxSize>>::SIGNATURE;
-   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors

--- a/crates/evm-coder/tests/conditional_is.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use evm_coder::{types::*, solidity_interface, execution::Result};
-
-pub struct Contract(bool);
-
-#[solidity_interface(name = A)]
-impl Contract {
-	fn method_a() -> Result<()> {
-		Ok(())
-	}
-}
-
-#[solidity_interface(name = B)]
-impl Contract {
-	fn method_b() -> Result<()> {
-		Ok(())
-	}
-}
-
-#[solidity_interface(name = Contract, is(
-	A(if(this.0)),
-	B(if(!this.0)),
-))]
-impl Contract {}
-
-#[test]
-fn conditional_erc165() {
-	assert!(ContractCall::supports_interface(
-		&Contract(true),
-		ACall::METHOD_A
-	));
-	assert!(!ContractCall::supports_interface(
-		&Contract(false),
-		ACall::METHOD_A
-	));
-
-	assert!(ContractCall::supports_interface(
-		&Contract(false),
-		BCall::METHOD_B
-	));
-	assert!(!ContractCall::supports_interface(
-		&Contract(true),
-		BCall::METHOD_B
-	));
-}

--- a/crates/evm-coder/tests/generics.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-use std::marker::PhantomData;
-use evm_coder::{execution::Result, generate_stubgen, solidity_interface, types::*};
-use primitive_types::U256;
-
-pub struct Generic<T>(PhantomData<T>);
-
-#[solidity_interface(name = GenericIs)]
-impl<T> Generic<T> {
-	fn test_1(&self) -> Result<U256> {
-		unreachable!()
-	}
-}
-
-#[solidity_interface(name = Generic, is(GenericIs))]
-impl<T: Into<u32>> Generic<T> {
-	fn test_2(&self) -> Result<U256> {
-		unreachable!()
-	}
-}
-
-generate_stubgen!(gen_iface, GenericCall<()>, false);
-
-#[solidity_interface(name = GenericWhere)]
-impl<T> Generic<T>
-where
-	T: core::fmt::Debug,
-{
-	fn test_3(&self) -> Result<U256> {
-		unreachable!()
-	}
-}
-
-generate_stubgen!(gen_where_iface, GenericWhereCall<()>, false);

--- a/crates/evm-coder/tests/log.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-#![allow(dead_code)]
-
-use evm_coder::{ToLog, types::*};
-use primitive_types::U256;
-
-#[derive(ToLog)]
-enum ERC721Log {
-	Transfer {
-		#[indexed]
-		from: Address,
-		#[indexed]
-		to: Address,
-		value: U256,
-	},
-	Eee {
-		#[indexed]
-		aaa: Address,
-		bbb: U256,
-	},
-}

--- a/crates/evm-coder/tests/random.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-#![allow(dead_code)] // This test only checks that macros is not panicking
-
-use evm_coder::{
-	abi::AbiType, ToLog, execution::Result, solidity_interface, types::*, solidity, weight,
-};
-use primitive_types::U256;
-
-pub struct Impls;
-
-#[solidity_interface(name = OurInterface)]
-impl Impls {
-	fn fn_a(&self, _input: U256) -> Result<bool> {
-		unreachable!()
-	}
-}
-
-#[solidity_interface(name = OurInterface1)]
-impl Impls {
-	fn fn_b(&self, _input: u128) -> Result<u32> {
-		unreachable!()
-	}
-}
-
-#[derive(ToLog)]
-enum OurEvents {
-	Event1 {
-		field1: u32,
-	},
-	Event2 {
-		field1: u32,
-		#[indexed]
-		field2: u32,
-	},
-}
-
-#[solidity_interface(
-	name = OurInterface2,
-	is(OurInterface),
-	inline_is(OurInterface1),
-	events(OurEvents)
-)]
-impl Impls {
-	#[solidity(rename_selector = "fnK")]
-	fn fn_c(&self, _input: u32) -> Result<u8> {
-		unreachable!()
-	}
-	fn fn_d(&self, _value: u32) -> Result<u32> {
-		unreachable!()
-	}
-
-	fn caller_sensitive(&self, _caller: Caller) -> Result<u8> {
-		unreachable!()
-	}
-	fn payable(&mut self, _value: Value) -> Result<u8> {
-		unreachable!()
-	}
-
-	#[weight(*_weight)]
-	fn with_weight(&self, _weight: u64) -> Result<()> {
-		unreachable!()
-	}
-
-	/// Doccoment example
-	fn with_doc(&self) -> Result<()> {
-		unreachable!()
-	}
-}
-
-#[solidity_interface(
-	name = ValidSelector,
-	expect_selector = 0x00000000,
-)]
-impl Impls {}

--- a/crates/evm-coder/tests/solidity_generation.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-use evm_coder::{abi::AbiType, execution::Result, generate_stubgen, solidity_interface, types::*};
-use primitive_types::U256;
-
-pub struct ERC20;
-
-#[solidity_interface(name = ERC20)]
-impl ERC20 {
-	fn decimals(&self) -> Result<u8> {
-		unreachable!()
-	}
-	/// Get balance of specified owner
-	fn balance_of(&self, _owner: Address) -> Result<U256> {
-		unreachable!()
-	}
-	fn transfer(&mut self, _caller: Caller, _to: Address, _value: U256) -> Result<bool> {
-		unreachable!()
-	}
-	fn transfer_from(
-		&mut self,
-		_caller: Caller,
-		_from: Address,
-		_to: Address,
-		_value: U256,
-	) -> Result<bool> {
-		unreachable!()
-	}
-	fn approve(&mut self, _caller: Caller, _spender: Address, _value: U256) -> Result<bool> {
-		unreachable!()
-	}
-	fn allowance(&self, _owner: Address, _spender: Address) -> Result<U256> {
-		unreachable!()
-	}
-}
-
-generate_stubgen!(gen_impl, ERC20Call, true);
-generate_stubgen!(gen_iface, ERC20Call, false);