git.delta.rocks / unique-network / refs/commits / 7ab1f7d9bcf7

--- a/.maintain/scripts/compile_stub.sh
+++ b/.maintain/scripts/compile_stub.sh
@@ -6,6 +6,7 @@
 tmp=$(mktemp -d)
 cd $tmp
 cp $dir/$INPUT input.sol
+echo "Tmp file: $tmp/input.sol"
 solcjs --optimize --bin input.sol -o $PWD
 
 mv input_sol_$(basename $OUTPUT .raw).bin out.bin

--- a/.maintain/scripts/generate_sol.sh
+++ b/.maintain/scripts/generate_sol.sh
@@ -4,7 +4,7 @@
 PRETTIER_CONFIG="$(pwd)""/.prettierrc"
 
 tmp=$(mktemp)
-cargo test --package $PACKAGE -- $NAME --exact --nocapture --ignored | tee $tmp
+cargo test --package=$PACKAGE --features=stubgen -- $NAME --exact --nocapture --ignored | tee $tmp
 raw=$(mktemp --suffix .sol)
 sed -n '/=== SNIP START ===/, /=== SNIP END ===/{ /=== SNIP START ===/! { /=== SNIP END ===/! p } }' $tmp > $raw
 

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -252,11 +252,12 @@
 
 [[package]]
 name = "async-lock"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e97a171d191782fba31bb902b14ad94e24a68145032b7eedf871ab0bc0d077b6"
+checksum = "c8101efe8695a6c17e02911402145357e718ac92d3ff88ae8419e84b1707b685"
 dependencies = [
  "event-listener",
+ "futures-lite",
 ]
 
 [[package]]
@@ -977,9 +978,9 @@
 
 [[package]]
 name = "clap"
-version = "3.2.22"
+version = "3.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86447ad904c7fb335a790c9d7fe3d0d971dc523b8ccd1561a520de9a85302750"
+checksum = "71655c45cb9845d3270c9d6df84ebe72b4dad3c2ba3f7023ad47c144e4e473a5"
 dependencies = [
  "atty",
  "bitflags",
@@ -1871,9 +1872,9 @@
 
 [[package]]
 name = "cxx"
-version = "1.0.78"
+version = "1.0.80"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19f39818dcfc97d45b03953c1292efc4e80954e1583c4aa770bac1383e2310a4"
+checksum = "6b7d4e43b25d3c994662706a1d4fcfc32aaa6afd287502c111b237093bb23f3a"
 dependencies = [
  "cc",
  "cxxbridge-flags",
@@ -1883,9 +1884,9 @@
 
 [[package]]
 name = "cxx-build"
-version = "1.0.78"
+version = "1.0.80"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e580d70777c116df50c390d1211993f62d40302881e54d4b79727acb83d0199"
+checksum = "84f8829ddc213e2c1368e51a2564c552b65a8cb6a28f31e576270ac81d5e5827"
 dependencies = [
  "cc",
  "codespan-reporting",
@@ -1898,15 +1899,15 @@
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.78"
+version = "1.0.80"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56a46460b88d1cec95112c8c363f0e2c39afdb237f60583b0b36343bf627ea9c"
+checksum = "e72537424b474af1460806647c41d4b6d35d09ef7fe031c5c2fa5766047cc56a"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.78"
+version = "1.0.80"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "747b608fecf06b0d72d440f27acc99288207324b793be2c17991839f3d4995ea"
+checksum = "309e4fb93eed90e1e14bea0da16b209f81813ba9fc7830c20ed151dd7bc0a4d7"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2128,15 +2129,15 @@
 
 [[package]]
 name = "ed25519-zebra"
-version = "3.0.0"
+version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "403ef3e961ab98f0ba902771d29f842058578bb1ce7e3c59dad5a6a93e784c69"
+checksum = "7c24f403d068ad0b359e577a77f92392118be3f3c927538f2bb544a5ecd828c6"
 dependencies = [
  "curve25519-dalek 3.2.0",
+ "hashbrown",
  "hex",
  "rand_core 0.6.4",
  "sha2 0.9.9",
- "thiserror",
  "zeroize",
 ]
 
@@ -2331,7 +2332,7 @@
 
 [[package]]
 name = "evm-coder"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "concat-idents",
  "ethereum",
@@ -2341,14 +2342,17 @@
  "hex",
  "hex-literal",
  "impl-trait-for-tuples",
+ "pallet-evm",
  "primitive-types",
+ "sha3-const",
  "similar-asserts",
  "sp-std",
+ "trybuild",
 ]
 
 [[package]]
 name = "evm-coder-procedural"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "Inflector",
  "hex",
@@ -3336,9 +3340,9 @@
 
 [[package]]
 name = "h2"
-version = "0.3.14"
+version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca32592cf21ac7ccab1825cd87f6c9b3d9022c44d086172ed0966bec8af30be"
+checksum = "5f9f29bc9dda355256b2916cf526ab02ce0aeaaaf2bad60d65ef3f12f11dd0f4"
 dependencies = [
  "bytes",
  "fnv",
@@ -3561,9 +3565,9 @@
 
 [[package]]
 name = "iana-time-zone-haiku"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fde6edd6cef363e9359ed3c98ba64590ba9eecba2293eb5a723ab32aee8926aa"
+checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
 dependencies = [
  "cxx",
  "cxx-build",
@@ -3702,9 +3706,9 @@
 
 [[package]]
 name = "io-lifetimes"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ea37f355c05dde75b84bba2d767906ad522e97cd9e2eef2be7a4ab7fb442c06"
+checksum = "e6e481ccbe3dea62107216d0d1138bb8ad8e5e5c43009a098bd1990272c497b0"
 
 [[package]]
 name = "ip_network"
@@ -4093,9 +4097,9 @@
 
 [[package]]
 name = "libc"
-version = "0.2.135"
+version = "0.2.137"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68783febc7782c6c5cb401fbda4de5a9898be1762314da0bb2c10ced61f18b0c"
+checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"
 
 [[package]]
 name = "libloading"
@@ -4967,14 +4971,14 @@
 
 [[package]]
 name = "mio"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57ee1c23c7c63b0c9250c339ffdc69255f110b298b901b9f6c82547b7b87caaf"
+checksum = "e5d732bc30207a6423068df043e3d02e0735b155ad7ce1a6f76fe2baa5b158de"
 dependencies = [
  "libc",
  "log",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.36.1",
+ "windows-sys 0.42.0",
 ]
 
 [[package]]
@@ -5826,7 +5830,7 @@
 
 [[package]]
 name = "pallet-common"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "ethereum",
  "evm-coder",
@@ -6116,7 +6120,7 @@
 
 [[package]]
 name = "pallet-fungible"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "ethereum",
  "evm-coder",
@@ -6359,7 +6363,7 @@
 
 [[package]]
 name = "pallet-nonfungible"
-version = "0.1.6"
+version = "0.1.7"
 dependencies = [
  "ethereum",
  "evm-coder",
@@ -6481,7 +6485,7 @@
 
 [[package]]
 name = "pallet-refungible"
-version = "0.2.5"
+version = "0.2.6"
 dependencies = [
  "derivative",
  "ethereum",
@@ -7248,9 +7252,9 @@
 
 [[package]]
 name = "pkg-config"
-version = "0.3.25"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1df8c4ec4b0627e53bdf214615ad287367e482558cf84b109250b37464dc03ae"
+checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
 
 [[package]]
 name = "platforms"
@@ -8501,9 +8505,9 @@
 
 [[package]]
 name = "polling"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "899b00b9c8ab553c743b3e11e87c5c7d423b2a2de229ba95b24a756344748011"
+checksum = "ab4609a838d88b73d8238967b60dd115cc08d38e2bbaf51ee1e4b695f89122e2"
 dependencies = [
  "autocfg",
  "cfg-if 1.0.0",
@@ -9408,9 +9412,9 @@
 
 [[package]]
 name = "rustix"
-version = "0.35.11"
+version = "0.35.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbb2fda4666def1433b1b05431ab402e42a1084285477222b72d6c564c417cef"
+checksum = "985947f9b6423159c4726323f373be0a21bdb514c5af06a849cb3d2dce2d01e8"
 dependencies = [
  "bitflags",
  "errno",
@@ -10683,9 +10687,9 @@
 
 [[package]]
 name = "secp256k1"
-version = "0.24.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7649a0b3ffb32636e60c7ce0d70511eda9c52c658cd0634e194d5a19943aeff"
+checksum = "ff55dc09d460954e9ef2fa8a7ced735a964be9981fd50e870b2b3b0705e14964"
 dependencies = [
  "secp256k1-sys",
 ]
@@ -10766,18 +10770,18 @@
 
 [[package]]
 name = "serde"
-version = "1.0.146"
+version = "1.0.147"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6df50b7a60a0ad48e1b42eb38373eac8ff785d619fb14db917b4e63d5439361f"
+checksum = "d193d69bae983fc11a79df82342761dfbf28a99fc8d203dca4c3c1b590948965"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.146"
+version = "1.0.147"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a714fd32ba1d66047ce7d53dabd809e9922d538f9047de13cc4cffca47b36205"
+checksum = "4f1d362ca8fc9c3e3a7484440752472d68a6caa98f1ab81d99b5dfe517cec852"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -10786,9 +10790,9 @@
 
 [[package]]
 name = "serde_json"
-version = "1.0.86"
+version = "1.0.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41feea4228a6f1cd09ec7a3593a682276702cd67b5273544757dae23c096f074"
+checksum = "6ce777b7b150d76b9cf60d28b55f5847135a003f7d7350c6be7a773508ce7d45"
 dependencies = [
  "itoa",
  "ryu",
@@ -10875,6 +10879,12 @@
 ]
 
 [[package]]
+name = "sha3-const"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b04774de876479a8f712e787f8271b14712971329a4be66c6dff144db7cfc343"
+
+[[package]]
 name = "sharded-slab"
 version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12067,9 +12077,9 @@
 
 [[package]]
 name = "syn"
-version = "1.0.102"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fcd952facd492f9be3ef0d0b7032a6e442ee9b361d4acc2b1d0c4aaa5f613a1"
+checksum = "a864042229133ada95abf3b54fdc62ef5ccabe9515b64717bcb9a1919e59445d"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -12198,9 +12208,9 @@
 
 [[package]]
 name = "textwrap"
-version = "0.15.1"
+version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "949517c0cf1bf4ee812e2e07e08ab448e3ae0d23472aee8a06c985f0c8815b16"
+checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
 
 [[package]]
 name = "thiserror"
@@ -12643,6 +12653,21 @@
 ]
 
 [[package]]
+name = "trybuild"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea496675d71016e9bc76aa42d87f16aefd95447cc5818e671e12b2d7e269075d"
+dependencies = [
+ "glob",
+ "once_cell",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "termcolor",
+ "toml",
+]
+
+[[package]]
 name = "tt-call"
 version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"

--- a/crates/evm-coder/CHANGELOG.md
+++ b/crates/evm-coder/CHANGELOG.md
@@ -2,13 +2,17 @@
 
 All notable changes to this project will be documented in this file.
 
-## [0.1.3] - 2022-08-29
+<!-- bureaucrate goes here -->
+## [v0.1.4] - 2022-11-02
+### Added
+ - Named structures support.
+
+## [v0.1.3] - 2022-08-29
 
 ### Fixed
 
  - Parsing simple values.
 
-<!-- bureaucrate goes here -->
 ## [v0.1.2] 2022-08-19
 
 ### Added

--- a/crates/evm-coder/Cargo.toml
+++ b/crates/evm-coder/Cargo.toml
@@ -1,10 +1,11 @@
 [package]
 name = "evm-coder"
-version = "0.1.3"
+version = "0.1.4"
 license = "GPLv3"
 edition = "2021"
 
 [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
@@ -18,12 +19,15 @@
 # We have tuple-heavy code in solidity.rs
 impl-trait-for-tuples = "0.2.2"
 
+pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.30" }
+
 [dev-dependencies]
 # We want to assert some large binary blobs equality in tests
 hex = "0.4.3"
 hex-literal = "0.3.4"
 similar-asserts = "1.4.2"
 concat-idents = "1.1.3"
+trybuild = "1.0"
 
 [features]
 default = ["std"]
@@ -33,3 +37,5 @@
     "evm-core/std",
     "frame-support/std",
 ]
+# Stub/interface generation
+stubgen = []

--- a/crates/evm-coder/procedural/Cargo.toml
+++ b/crates/evm-coder/procedural/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "evm-coder-procedural"
-version = "0.2.0"
+version = "0.2.1"
 license = "GPLv3"
 edition = "2021"
 

--- a/crates/evm-coder/procedural/src/lib.rs
+++ b/crates/evm-coder/procedural/src/lib.rs
@@ -107,7 +107,7 @@
 	if path.segments.len() != 1 {
 		return Err(syn::Error::new(
 			path.span(),
-			"expected path to have only segment",
+			"expected path to have only one segment",
 		));
 	}
 	let last_segment = &path.segments.last().unwrap();

--- a/crates/evm-coder/procedural/src/solidity_interface.rs
+++ b/crates/evm-coder/procedural/src/solidity_interface.rs
@@ -20,20 +20,20 @@
 // about Procedural Macros in Rust book:
 // https://doc.rust-lang.org/reference/procedural-macros.html
 
-use quote::{quote, ToTokens};
+use proc_macro2::TokenStream;
+use quote::{quote, format_ident};
 use inflector::cases;
-use std::fmt::Write;
 use syn::{
-	Expr, FnArg, GenericArgument, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta,
-	MetaNameValue, PatType, PathArguments, ReturnType, Type,
+	Expr, FnArg, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta, MetaNameValue,
+	PatType, ReturnType, Type,
 	spanned::Spanned,
 	parse::{Parse, ParseStream},
 	parenthesized, Token, LitInt, LitStr,
 };
 
 use crate::{
-	fn_selector_str, 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,
+	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,
 };
 
@@ -328,155 +328,47 @@
 	}
 }
 
-enum AbiType {
-	// type
-	Plain(Ident),
-	// (type1,type2)
-	Tuple(Vec<AbiType>),
-	// type[]
-	Vec(Box<AbiType>),
-	// type[20]
-	Array(Box<AbiType>, usize),
+trait AbiType {
+	fn plain(&self) -> syn::Result<&Ident>;
+	fn is_value(&self) -> bool;
+	fn is_caller(&self) -> bool;
+	fn is_special(&self) -> bool;
 }
-impl AbiType {
-	fn try_from(value: &Type) -> syn::Result<Self> {
-		let value = Self::try_maybe_special_from(value)?;
-		if value.is_special() {
-			return Err(syn::Error::new(value.span(), "unexpected special type"));
-		}
-		Ok(value)
-	}
-	fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {
-		match value {
-			Type::Array(arr) => {
-				let wrapped = AbiType::try_from(&arr.elem)?;
-				match &arr.len {
-					Expr::Lit(l) => match &l.lit {
-						Lit::Int(i) => {
-							let num = i.base10_parse::<usize>()?;
-							Ok(AbiType::Array(Box::new(wrapped), num as usize))
-						}
-						_ => Err(syn::Error::new(arr.len.span(), "should be int literal")),
-					},
-					_ => Err(syn::Error::new(arr.len.span(), "should be literal")),
-				}
-			}
-			Type::Path(_) => {
-				let path = parse_path(value)?;
-				let segment = parse_path_segment(path)?;
-				if segment.ident == "Vec" {
-					let args = match &segment.arguments {
-						PathArguments::AngleBracketed(e) => e,
-						_ => {
-							return Err(syn::Error::new(
-								segment.arguments.span(),
-								"missing Vec generic",
-							))
-						}
-					};
-					let args = &args.args;
-					if args.len() != 1 {
-						return Err(syn::Error::new(
-							args.span(),
-							"expected only one generic for vec",
-						));
-					}
-					let arg = args.first().expect("first arg");
 
-					let ty = match arg {
-						GenericArgument::Type(ty) => ty,
-						_ => {
-							return Err(syn::Error::new(
-								arg.span(),
-								"expected first generic to be type",
-							))
-						}
-					};
-
-					let wrapped = AbiType::try_from(ty)?;
-					Ok(Self::Vec(Box::new(wrapped)))
-				} else {
-					if !segment.arguments.is_empty() {
-						return Err(syn::Error::new(
-							segment.arguments.span(),
-							"unexpected generic arguments for non-vec type",
-						));
-					}
-					Ok(Self::Plain(segment.ident.clone()))
-				}
-			}
-			Type::Tuple(t) => {
-				let mut out = Vec::with_capacity(t.elems.len());
-				for el in t.elems.iter() {
-					out.push(AbiType::try_from(el)?)
-				}
-				Ok(Self::Tuple(out))
-			}
-			_ => Err(syn::Error::new(
-				value.span(),
-				"unexpected type, only arrays, plain types and tuples are supported",
-			)),
+impl AbiType 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 {
-		matches!(self, Self::Plain(v) if v == "value")
+		if let Ok(ident) = self.plain() {
+			return ident == "value";
+		}
+		false
 	}
+
 	fn is_caller(&self) -> bool {
-		matches!(self, Self::Plain(v) if v == "caller")
+		if let Ok(ident) = self.plain() {
+			return ident == "caller";
+		}
+		false
 	}
+
 	fn is_special(&self) -> bool {
 		self.is_caller() || self.is_value()
-	}
-	fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {
-		match self {
-			AbiType::Plain(t) => {
-				write!(buf, "{}", t)
-			}
-			AbiType::Tuple(t) => {
-				write!(buf, "(")?;
-				for (i, t) in t.iter().enumerate() {
-					if i != 0 {
-						write!(buf, ",")?;
-					}
-					t.selector_ty_buf(buf)?;
-				}
-				write!(buf, ")")
-			}
-			AbiType::Vec(v) => {
-				v.selector_ty_buf(buf)?;
-				write!(buf, "[]")
-			}
-			AbiType::Array(v, len) => {
-				v.selector_ty_buf(buf)?;
-				write!(buf, "[{}]", len)
-			}
-		}
 	}
-	fn selector_ty(&self) -> String {
-		let mut out = String::new();
-		self.selector_ty_buf(&mut out).expect("no fmt error");
-		out
-	}
 }
-impl ToTokens for AbiType {
-	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-		match self {
-			AbiType::Plain(t) => tokens.extend(quote! {#t}),
-			AbiType::Tuple(t) => {
-				tokens.extend(quote! {(
-					#(#t),*
-				)});
-			}
-			AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),
-			AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),
-		}
-	}
-}
 
+#[derive(Debug)]
 struct MethodArg {
 	name: Ident,
 	camel_name: String,
-	ty: AbiType,
+	ty: Type,
 }
 impl MethodArg {
 	fn try_from(value: &PatType) -> syn::Result<Self> {
@@ -484,7 +376,7 @@
 		Ok(Self {
 			camel_name: cases::camelcase::to_camel_case(&name.to_string()),
 			name,
-			ty: AbiType::try_maybe_special_from(&value.ty)?,
+			ty: value.ty.as_ref().clone(),
 		})
 	}
 	fn is_value(&self) -> bool {
@@ -496,10 +388,6 @@
 	fn is_special(&self) -> bool {
 		self.ty.is_special()
 	}
-	fn selector_ty(&self) -> String {
-		assert!(!self.is_special());
-		self.ty.selector_ty()
-	}
 
 	fn expand_call_def(&self) -> proc_macro2::TokenStream {
 		assert!(!self.is_special());
@@ -514,8 +402,9 @@
 	fn expand_parse(&self) -> proc_macro2::TokenStream {
 		assert!(!self.is_special());
 		let name = &self.name;
+		let ty = &self.ty;
 		quote! {
-			#name: reader.abi_read()?
+			#name: <#ty>::abi_read(reader)?
 		}
 	}
 
@@ -575,8 +464,6 @@
 	camel_name: String,
 	pascal_name: Ident,
 	screaming_name: Ident,
-	selector_str: String,
-	selector: u32,
 	hide: bool,
 	args: Vec<MethodArg>,
 	has_normal_args: bool,
@@ -667,27 +554,14 @@
 		let camel_name = info
 			.rename_selector
 			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));
-		let mut selector_str = camel_name.clone();
-		selector_str.push('(');
-		let mut has_normal_args = false;
-		for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {
-			if i != 0 {
-				selector_str.push(',');
-			}
-			write!(selector_str, "{}", arg.selector_ty()).unwrap();
-			has_normal_args = true;
-		}
+		let has_normal_args = args.iter().filter(|arg| !arg.is_special()).count() != 0;
 		let has_value_args = args.iter().any(|a| a.is_value());
-		selector_str.push(')');
-		let selector = fn_selector_str(&selector_str);
 
 		Ok(Self {
 			name: ident.clone(),
 			camel_name,
 			pascal_name: snake_ident_to_pascal(ident),
 			screaming_name: snake_ident_to_screaming(ident),
-			selector_str,
-			selector,
 			hide: info.hide,
 			args,
 			has_normal_args,
@@ -718,17 +592,30 @@
 				}
 			}
 		} else {
-			quote! {#pascal_name}
+			quote! {
+				#(#[doc = #docs])*
+				#[allow(missing_docs)]
+				#pascal_name
+			}
 		}
 	}
 
 	fn expand_const(&self) -> proc_macro2::TokenStream {
 		let screaming_name = &self.screaming_name;
-		let selector = u32::to_be_bytes(self.selector);
-		let selector_str = &self.selector_str;
+		let screaming_name_signature = format_ident!("{}_SIGNATURE", &self.screaming_name);
+		let custom_signature = self.expand_custom_signature();
 		quote! {
-			#[doc = #selector_str]
-			const #screaming_name: ::evm_coder::types::bytes4 = [#(#selector,)*];
+			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]]
+			};
 		}
 	}
 
@@ -788,6 +675,7 @@
 
 		quote! {
 			#call_name::#pascal_name #matcher => {
+				#[allow(deprecated)]
 				let result = #receiver #name(
 					#(
 						#args,
@@ -831,6 +719,26 @@
 		}
 	}
 
+	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 {
@@ -846,16 +754,17 @@
 			.filter(|a| !a.is_special())
 			.map(MethodArg::expand_solidity_argument);
 		let docs = &self.docs;
-		let selector_str = &self.selector_str;
-		let selector = self.selector;
+		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),*],
-				selector_str: #selector_str,
-				selector: #selector,
 				hide: #hide,
+				selector: u32::from_be_bytes(Self::#screaming_name),
+				custom_signature: #custom_signature,
 				name: #camel_name,
 				mutability: #mutability,
 				is_payable: #is_payable,
@@ -1021,31 +930,7 @@
 		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);
 
 		let docs = &self.docs;
-
-		if let Some(expect_selector) = &self.info.expect_selector {
-			if !self.info.inline_is.0.is_empty() {
-				return syn::Error::new(
-					name.span(),
-					"expect_selector is not compatible with inline_is",
-				)
-				.to_compile_error();
-			}
-			let selector = self
-				.methods
-				.iter()
-				.map(|m| m.selector)
-				.fold(0, |a, b| a ^ b);
 
-			if *expect_selector != selector {
-				let mut methods = String::new();
-				for meth in self.methods.iter() {
-					write!(methods, "\n- {}", meth.selector_str).expect("write to string");
-				}
-				return syn::Error::new(name.span(), format!("expected selector mismatch, expected {expect_selector:0>8x}, but implementation has {selector:0>8x}{methods}")).to_compile_error();
-			}
-		}
-		// let methods = self.methods.iter().map(Method::solidity_def);
-
 		quote! {
 			#[derive(Debug)]
 			#(#[doc = #docs])*
@@ -1071,6 +956,7 @@
 					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;

--- a/crates/evm-coder/procedural/src/to_log.rs
+++ b/crates/evm-coder/procedural/src/to_log.rs
@@ -195,6 +195,8 @@
 					#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;

--- a/crates/evm-coder/src/abi.rs
+++ b/crates/evm-coder/src/abi.rs
@@ -26,6 +26,8 @@
 use crate::{
 	execution::{Error, ResultWithPostInfo, WithPostDispatchInfo},
 	types::*,
+	make_signature,
+	custom_signature::{SignatureUnit},
 };
 use crate::execution::Result;
 
@@ -340,18 +342,18 @@
 	}
 }
 
-/// [`AbiReader`] implements reading of many types, but it should
-/// be limited to types defined in spec
-///
-/// As this trait can't be made sealed,
-/// instead of having `impl AbiRead for T`, we have `impl AbiRead<T> for AbiReader`
-pub trait AbiRead<T> {
+/// [`AbiReader`] implements reading of many types.
+pub trait AbiRead {
 	/// Read item from current position, advanding decoder
-	fn abi_read(&mut self) -> Result<T>;
+	fn abi_read(reader: &mut AbiReader) -> Result<Self>
+	where
+		Self: Sized;
 }
 
 macro_rules! impl_abi_readable {
 	($ty:ty, $method:ident, $dynamic:literal) => {
+		impl sealed::CanBePlacedInVec for $ty {}
+
 		impl TypeHelper for $ty {
 			fn is_dynamic() -> bool {
 				$dynamic
@@ -361,16 +363,16 @@
 				ABI_ALIGNMENT
 			}
 		}
-		impl AbiRead<$ty> for AbiReader<'_> {
-			fn abi_read(&mut self) -> Result<$ty> {
-				self.$method()
+
+		impl AbiRead for $ty {
+			fn abi_read(reader: &mut AbiReader) -> Result<$ty> {
+				reader.$method()
 			}
 		}
 	};
 }
 
 impl_abi_readable!(bool, bool, false);
-impl_abi_readable!(uint8, uint8, false);
 impl_abi_readable!(uint32, uint32, false);
 impl_abi_readable!(uint64, uint64, false);
 impl_abi_readable!(uint128, uint128, false);
@@ -378,8 +380,21 @@
 impl_abi_readable!(bytes4, bytes4, false);
 impl_abi_readable!(address, address, false);
 impl_abi_readable!(string, string, true);
-// impl_abi_readable!(bytes, bytes, true);
 
+impl TypeHelper for uint8 {
+	fn is_dynamic() -> bool {
+		false
+	}
+	fn size() -> usize {
+		ABI_ALIGNMENT
+	}
+}
+impl AbiRead for uint8 {
+	fn abi_read(reader: &mut AbiReader) -> Result<uint8> {
+		reader.uint8()
+	}
+}
+
 impl TypeHelper for bytes {
 	fn is_dynamic() -> bool {
 		true
@@ -388,9 +403,9 @@
 		ABI_ALIGNMENT
 	}
 }
-impl AbiRead<bytes> for AbiReader<'_> {
-	fn abi_read(&mut self) -> Result<bytes> {
-		Ok(bytes(self.bytes()?))
+impl AbiRead for bytes {
+	fn abi_read(reader: &mut AbiReader) -> Result<bytes> {
+		Ok(bytes(reader.bytes()?))
 	}
 }
 
@@ -399,26 +414,57 @@
 	pub trait CanBePlacedInVec {}
 }
 
-impl sealed::CanBePlacedInVec for U256 {}
-impl sealed::CanBePlacedInVec for string {}
-impl sealed::CanBePlacedInVec for H160 {}
-
-impl<R: sealed::CanBePlacedInVec> AbiRead<Vec<R>> for AbiReader<'_>
-where
-	Self: AbiRead<R>,
-{
-	fn abi_read(&mut self) -> Result<Vec<R>> {
-		let mut sub = self.subresult(None)?;
+impl<R: AbiRead + sealed::CanBePlacedInVec> AbiRead for Vec<R> {
+	fn abi_read(reader: &mut AbiReader) -> Result<Vec<R>> {
+		let mut sub = reader.subresult(None)?;
 		let size = sub.uint32()? as usize;
 		sub.subresult_offset = sub.offset;
 		let mut out = Vec::with_capacity(size);
 		for _ in 0..size {
-			out.push(<Self as AbiRead<R>>::abi_read(&mut sub)?);
+			out.push(<R>::abi_read(&mut sub)?);
 		}
 		Ok(out)
 	}
 }
 
+impl<R: Signature> Signature for Vec<R> {
+	const SIGNATURE: SignatureUnit = make_signature!(new nameof(R::SIGNATURE) fixed("[]"));
+}
+
+impl sealed::CanBePlacedInVec for EthCrossAccount {}
+
+impl TypeHelper for EthCrossAccount {
+	fn is_dynamic() -> bool {
+		address::is_dynamic() || uint256::is_dynamic()
+	}
+
+	fn size() -> usize {
+		<address as TypeHelper>::size() + <uint256 as TypeHelper>::size()
+	}
+}
+
+impl AbiRead for EthCrossAccount {
+	fn abi_read(reader: &mut AbiReader) -> Result<EthCrossAccount> {
+		let size = if !EthCrossAccount::is_dynamic() {
+			Some(<EthCrossAccount as TypeHelper>::size())
+		} else {
+			None
+		};
+		let mut subresult = reader.subresult(size)?;
+		let eth = <address>::abi_read(&mut subresult)?;
+		let sub = <uint256>::abi_read(&mut subresult)?;
+
+		Ok(EthCrossAccount { eth, sub })
+	}
+}
+
+impl AbiWrite for EthCrossAccount {
+	fn abi_write(&self, writer: &mut AbiWriter) {
+		self.eth.abi_write(writer);
+		self.sub.abi_write(writer);
+	}
+}
+
 macro_rules! impl_tuples {
 	($($ident:ident)+) => {
 		impl<$($ident: TypeHelper,)+> TypeHelper for ($($ident,)+)
@@ -438,22 +484,23 @@
 				0 $(+ <$ident>::size())+
 			}
 		}
+
 		impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}
-		impl<$($ident),+> AbiRead<($($ident,)+)> for AbiReader<'_>
+
+		impl<$($ident),+> AbiRead for ($($ident,)+)
 		where
-			$(
-				Self: AbiRead<$ident>,
-			)+
+			$($ident: AbiRead,)+
 			($($ident,)+): TypeHelper,
 		{
-			fn abi_read(&mut self) -> Result<($($ident,)+)> {
+			fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {
 				let size = if !<($($ident,)+)>::is_dynamic() { Some(<($($ident,)+)>::size()) } else { None };
-				let mut subresult = self.subresult(size)?;
+				let mut subresult = reader.subresult(size)?;
 				Ok((
-					$(<Self as AbiRead<$ident>>::abi_read(&mut subresult)?,)+
+					$(<$ident>::abi_read(&mut subresult)?,)+
 				))
 			}
 		}
+
 		#[allow(non_snake_case)]
 		impl<$($ident),+> AbiWrite for ($($ident,)+)
 		where
@@ -470,6 +517,18 @@
 				}
 			}
 		}
+
+		impl<$($ident),+> Signature for ($($ident,)+)
+		where
+		$($ident: Signature,)+
+		{
+			const SIGNATURE: SignatureUnit = make_signature!(
+				new fixed("(")
+				$(nameof(<$ident>::SIGNATURE) fixed(","))+
+				shift_left(1)
+				fixed(")")
+			);
+		}
 	};
 }
 
@@ -630,7 +689,7 @@
 
 					let (call, mut decoder) = AbiReader::new_call(encoded_data).unwrap();
 					assert_eq!(call, u32::to_be_bytes(function_identifier));
-					let data = <AbiReader<'_> as AbiRead<$type>>::abi_read(&mut decoder).unwrap();
+					let data = <$type>::abi_read(&mut decoder).unwrap();
 					assert_eq!(data, decoded_data);
 
 					let mut writer = AbiWriter::new_call(function_identifier);
@@ -699,13 +758,13 @@
 				1ACF2D55
 				0000000000000000000000000000000000000000000000000000000000000020 // offset of (address, uint256)[]
 				0000000000000000000000000000000000000000000000000000000000000003 // length of (address, uint256)[]
-	
+
 				0000000000000000000000002D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC // address
 				000000000000000000000000000000000000000000000000000000000000000A // uint256
-	
+
 				000000000000000000000000AB8E3D9134955566483B11E6825C9223B6737B10 // address
 				0000000000000000000000000000000000000000000000000000000000000014 // uint256
-	
+
 				0000000000000000000000008C582BDF2953046705FC56F189385255EFC1BE18 // address
 				000000000000000000000000000000000000000000000000000000000000001E // uint256
 			"
@@ -836,8 +895,7 @@
 		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 =
-			<AbiReader<'_> as AbiRead<Vec<(uint256, string)>>>::abi_read(&mut decoder).unwrap();
+		let data = <Vec<(uint256, string)>>::abi_read(&mut decoder).unwrap();
 		assert_eq!(data, decoded_data.1);
 
 		let mut writer = AbiWriter::new_call(decoded_data.0);

--- a/crates/evm-coder/src/lib.rs
+++ b/crates/evm-coder/src/lib.rs
@@ -16,6 +16,7 @@
 
 #![doc = include_str!("../README.md")]
 #![deny(missing_docs)]
+#![macro_use]
 #![cfg_attr(not(feature = "std"), no_std)]
 #[cfg(not(feature = "std"))]
 extern crate alloc;
@@ -26,6 +27,8 @@
 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.
@@ -90,6 +93,7 @@
 pub use evm_coder_procedural::solidity;
 /// See [`solidity_interface`]
 pub use evm_coder_procedural::weight;
+pub use sha3_const;
 
 /// Derives [`ToLog`] for enum
 ///
@@ -104,6 +108,7 @@
 #[doc(hidden)]
 pub mod events;
 #[doc(hidden)]
+#[cfg(feature = "stubgen")]
 pub mod solidity;
 
 /// Solidity type definitions (aliases from solidity name to rust type)
@@ -114,28 +119,55 @@
 
 	#[cfg(not(feature = "std"))]
 	use alloc::{vec::Vec};
+	use pallet_evm::account::CrossAccountId;
 	use primitive_types::{U256, H160, H256};
+	use core::str::from_utf8;
+
+	use crate::custom_signature::SignatureUnit;
+
+	pub trait Signature {
+		const SIGNATURE: SignatureUnit;
+
+		fn as_str() -> &'static str {
+			from_utf8(&Self::SIGNATURE.data[..Self::SIGNATURE.len]).expect("bad utf-8")
+		}
+	}
+
+	impl Signature for bool {
+		const SIGNATURE: SignatureUnit = make_signature!(new fixed("bool"));
+	}
 
-	pub type address = H160;
+	macro_rules! define_simple_type {
+		(type $ident:ident = $ty:ty) => {
+			pub type $ident = $ty;
+			impl Signature for $ty {
+				const SIGNATURE: SignatureUnit = make_signature!(new fixed(stringify!($ident)));
+			}
+		};
+	}
 
-	pub type uint8 = u8;
-	pub type uint16 = u16;
-	pub type uint32 = u32;
-	pub type uint64 = u64;
-	pub type uint128 = u128;
-	pub type uint256 = U256;
+	define_simple_type!(type address = H160);
 
-	pub type bytes4 = [u8; 4];
+	define_simple_type!(type uint8 = u8);
+	define_simple_type!(type uint16 = u16);
+	define_simple_type!(type uint32 = u32);
+	define_simple_type!(type uint64 = u64);
+	define_simple_type!(type uint128 = u128);
+	define_simple_type!(type uint256 = U256);
+	define_simple_type!(type bytes4 = [u8; 4]);
 
-	pub type topic = H256;
+	define_simple_type!(type topic = H256);
 
 	#[cfg(not(feature = "std"))]
-	pub type string = ::alloc::string::String;
+	define_simple_type!(type string = ::alloc::string::String);
 	#[cfg(feature = "std")]
-	pub type string = ::std::string::String;
+	define_simple_type!(type string = ::std::string::String);
 
 	#[derive(Default, Debug)]
 	pub struct bytes(pub Vec<u8>);
+	impl Signature for bytes {
+		const SIGNATURE: SignatureUnit = make_signature!(new fixed("bytes"));
+	}
 
 	/// Solidity doesn't have `void` type, however we have special implementation
 	/// for empty tuple return type
@@ -166,6 +198,7 @@
 		}
 	}
 
+	#[allow(clippy::from_over_into)]
 	impl Into<Vec<u8>> for bytes {
 		fn into(self) -> Vec<u8> {
 			self.0
@@ -183,6 +216,76 @@
 			self.len() == 0
 		}
 	}
+
+	#[derive(Debug, Default)]
+	pub struct EthCrossAccount {
+		pub(crate) eth: address,
+		pub(crate) sub: uint256,
+	}
+
+	impl EthCrossAccount {
+		pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self
+		where
+			T: pallet_evm::account::Config,
+			T::AccountId: AsRef<[u8; 32]>,
+		{
+			if cross_account_id.is_canonical_substrate() {
+				Self {
+					eth: Default::default(),
+					sub: convert_cross_account_to_uint256::<T>(cross_account_id),
+				}
+			} else {
+				Self {
+					eth: *cross_account_id.as_eth(),
+					sub: Default::default(),
+				}
+			}
+		}
+
+		pub fn into_sub_cross_account<T>(&self) -> crate::execution::Result<T::CrossAccountId>
+		where
+			T: pallet_evm::account::Config,
+			T::AccountId: From<[u8; 32]>,
+		{
+			if self.eth == Default::default() && self.sub == Default::default() {
+				Err("All fields of cross account is zeroed".into())
+			} else if self.eth == Default::default() {
+				Ok(convert_uint256_to_cross_account::<T>(self.sub))
+			} else if self.sub == Default::default() {
+				Ok(T::CrossAccountId::from_eth(self.eth))
+			} else {
+				Err("All fields of cross account is non zeroed".into())
+			}
+		}
+	}
+
+	impl Signature for EthCrossAccount {
+		const SIGNATURE: SignatureUnit = make_signature!(new fixed("(address,uint256)"));
+	}
+
+	/// Convert `CrossAccountId` to `uint256`.
+	pub fn convert_cross_account_to_uint256<T: pallet_evm::account::Config>(
+		from: &T::CrossAccountId,
+	) -> uint256
+	where
+		T::AccountId: AsRef<[u8; 32]>,
+	{
+		let slice = from.as_sub().as_ref();
+		uint256::from_big_endian(slice)
+	}
+
+	/// Convert `uint256` to `CrossAccountId`.
+	pub fn convert_uint256_to_cross_account<T: pallet_evm::account::Config>(
+		from: uint256,
+	) -> T::CrossAccountId
+	where
+		T::AccountId: From<[u8; 32]>,
+	{
+		let mut new_admin_arr = [0_u8; 32];
+		from.to_big_endian(&mut new_admin_arr);
+		let account_id = T::AccountId::from(new_admin_arr);
+		T::CrossAccountId::from_sub(account_id)
+	}
 }
 
 /// Parseable EVM call, this trait should be implemented with [`solidity_interface`] macro
@@ -239,7 +342,7 @@
 			return Ok(None);
 		}
 		Ok(Some(Self::SupportsInterface {
-			interface_id: input.abi_read()?,
+			interface_id: types::bytes4::abi_read(input)?,
 		}))
 	}
 }
@@ -252,6 +355,7 @@
 #[macro_export]
 macro_rules! generate_stubgen {
 	($name:ident, $decl:ty, $is_impl:literal) => {
+		#[cfg(feature = "stubgen")]
 		#[test]
 		#[ignore]
 		fn $name() {

--- a/crates/evm-coder/src/solidity.rs
+++ b/crates/evm-coder/src/solidity.rs
@@ -32,7 +32,7 @@
 	cmp::Reverse,
 };
 use impl_trait_for_tuples::impl_for_tuples;
-use crate::types::*;
+use crate::{types::*, custom_signature::SignatureUnit};
 
 #[derive(Default)]
 pub struct TypeCollector {
@@ -72,6 +72,10 @@
 		self.anonymous.borrow_mut().insert(names, id);
 		format!("Tuple{}", id)
 	}
+	pub fn collect_struct<T: StructCollect>(&self) -> String {
+		self.collect(<T as StructCollect>::declaration());
+		<T as StructCollect>::name()
+	}
 	pub fn finish(self) -> Vec<string> {
 		let mut data = self.structs.into_inner().into_iter().collect::<Vec<_>>();
 		data.sort_by_key(|(_, id)| Reverse(*id));
@@ -79,6 +83,13 @@
 	}
 }
 
+pub trait StructCollect: 'static {
+	/// Structure name.
+	fn name() -> String;
+	/// Structure declaration.
+	fn declaration() -> String;
+}
+
 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
@@ -145,6 +156,7 @@
 impl sealed::CanBePlacedInVec for uint256 {}
 impl sealed::CanBePlacedInVec for string {}
 impl sealed::CanBePlacedInVec for address {}
+impl sealed::CanBePlacedInVec for EthCrossAccount {}
 
 impl<T: SolidityTypeName + sealed::CanBePlacedInVec> SolidityTypeName for Vec<T> {
 	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
@@ -161,6 +173,60 @@
 	}
 }
 
+impl SolidityTupleType for EthCrossAccount {
+	fn names(tc: &TypeCollector) -> Vec<string> {
+		let mut collected = Vec::with_capacity(Self::len());
+		{
+			let mut out = string::new();
+			address::solidity_name(&mut out, tc).expect("no fmt error");
+			collected.push(out);
+		}
+		{
+			let mut out = string::new();
+			uint256::solidity_name(&mut out, tc).expect("no fmt error");
+			collected.push(out);
+		}
+		collected
+	}
+
+	fn len() -> usize {
+		2
+	}
+}
+impl SolidityTypeName for EthCrossAccount {
+	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>())?;
+		address::solidity_default(writer, tc)?;
+		write!(writer, ",")?;
+		uint256::solidity_default(writer, tc)?;
+		write!(writer, ")")
+	}
+}
+
+impl StructCollect for EthCrossAccount {
+	fn name() -> String {
+		"EthCrossAccount".into()
+	}
+
+	fn declaration() -> String {
+		let mut str = String::new();
+		writeln!(str, "/// @dev Cross account struct").unwrap();
+		writeln!(str, "struct {} {{", Self::name()).unwrap();
+		writeln!(str, "\taddress eth;").unwrap();
+		writeln!(str, "\tuint256 sub;").unwrap();
+		writeln!(str, "}}").unwrap();
+		str
+	}
+}
+
 pub trait SolidityTupleType {
 	fn names(tc: &TypeCollector) -> Vec<String>;
 	fn len() -> usize;
@@ -418,9 +484,9 @@
 }
 pub struct SolidityFunction<A, R> {
 	pub docs: &'static [&'static str],
-	pub selector_str: &'static str,
 	pub selector: u32,
 	pub hide: bool,
+	pub custom_signature: SignatureUnit,
 	pub name: &'static str,
 	pub args: A,
 	pub result: R,
@@ -446,7 +512,7 @@
 		writeln!(
 			writer,
 			"\t{hide_comment}///  or in textual repr: {}",
-			self.selector_str
+			self.custom_signature.as_str().expect("bad utf-8")
 		)?;
 		write!(writer, "\t{hide_comment}function {}(", self.name)?;
 		self.args.solidity_name(writer, tc)?;

--- a/crates/evm-coder/tests/random.rs
+++ b/crates/evm-coder/tests/random.rs
@@ -17,6 +17,7 @@
 #![allow(dead_code)] // This test only checks that macros is not panicking
 
 use evm_coder::{ToLog, execution::Result, solidity_interface, types::*, solidity, weight};
+use evm_coder::{types::Signature};
 
 pub struct Impls;
 

--- a/crates/evm-coder/tests/solidity_generation.rs
+++ b/crates/evm-coder/tests/solidity_generation.rs
@@ -15,6 +15,7 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 use evm_coder::{execution::Result, generate_stubgen, solidity_interface, types::*};
+use evm_coder::{types::Signature};
 
 pub struct ERC20;
 

--- a/pallets/common/CHANGELOG.md
+++ b/pallets/common/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.1.10] - 2022-11-02
+### Changed
+ - Use named structure `EthCrossAccount` in eth functions.
+
 ## [0.1.9] - 2022-10-13
 
 ## Added

--- a/pallets/common/Cargo.toml
+++ b/pallets/common/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pallet-common"
-version = "0.1.9"
+version = "0.1.10"
 license = "GPLv3"
 edition = "2021"
 
@@ -45,3 +45,4 @@
     "up-data-structs/runtime-benchmarks",
 ]
 try-runtime = ["frame-support/try-runtime"]
+stubgen = ["evm-coder/stubgen"]

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -33,11 +33,7 @@
 
 use crate::{
 	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf,
-	eth::{
-		convert_cross_account_to_uint256, convert_cross_account_to_tuple,
-		convert_tuple_to_cross_account,
-	},
-	weights::WeightInfo,
+	eth::convert_cross_account_to_uint256, weights::WeightInfo,
 };
 
 /// Events for ethereum collection helper.
@@ -64,6 +60,7 @@
 /// Does not always represent a full collection, for RFT it is either
 /// collection (Implementing ERC721), or specific collection token (Implementing ERC20).
 pub trait CommonEvmHandler {
+	/// Raw compiled binary code of the contract stub
 	const CODE: &'static [u8];
 
 	/// Call precompiled handle.
@@ -229,13 +226,13 @@
 	fn set_collection_sponsor_cross(
 		&mut self,
 		caller: caller,
-		sponsor: (address, uint256),
+		sponsor: EthCrossAccount,
 	) -> Result<void> {
 		self.consume_store_reads_and_writes(1, 1)?;
 
 		check_is_owner_or_admin(caller, self)?;
 
-		let sponsor = convert_tuple_to_cross_account::<T>(sponsor)?;
+		let sponsor = sponsor.into_sub_cross_account::<T>()?;
 		self.set_sponsor(sponsor.as_sub().clone())
 			.map_err(dispatch_to_evm::<T>)?;
 		save(self)
@@ -386,12 +383,12 @@
 	fn add_collection_admin_cross(
 		&mut self,
 		caller: caller,
-		new_admin: (address, uint256),
+		new_admin: EthCrossAccount,
 	) -> Result<void> {
 		self.consume_store_writes(2)?;
 
 		let caller = T::CrossAccountId::from_eth(caller);
-		let new_admin = convert_tuple_to_cross_account::<T>(new_admin)?;
+		let new_admin = new_admin.into_sub_cross_account::<T>()?;
 		<Pallet<T>>::toggle_admin(self, &caller, &new_admin, true).map_err(dispatch_to_evm::<T>)?;
 		Ok(())
 	}
@@ -401,12 +398,12 @@
 	fn remove_collection_admin_cross(
 		&mut self,
 		caller: caller,
-		admin: (address, uint256),
+		admin: EthCrossAccount,
 	) -> Result<void> {
 		self.consume_store_writes(2)?;
 
 		let caller = T::CrossAccountId::from_eth(caller);
-		let admin = convert_tuple_to_cross_account::<T>(admin)?;
+		let admin = admin.into_sub_cross_account::<T>()?;
 		<Pallet<T>>::toggle_admin(self, &caller, &admin, false).map_err(dispatch_to_evm::<T>)?;
 		Ok(())
 	}
@@ -564,12 +561,12 @@
 	fn add_to_collection_allow_list_cross(
 		&mut self,
 		caller: caller,
-		user: (address, uint256),
+		user: EthCrossAccount,
 	) -> Result<void> {
 		self.consume_store_writes(1)?;
 
 		let caller = T::CrossAccountId::from_eth(caller);
-		let user = convert_tuple_to_cross_account::<T>(user)?;
+		let user = user.into_sub_cross_account::<T>()?;
 		Pallet::<T>::toggle_allowlist(self, &caller, &user, true).map_err(dispatch_to_evm::<T>)?;
 		Ok(())
 	}
@@ -592,12 +589,12 @@
 	fn remove_from_collection_allow_list_cross(
 		&mut self,
 		caller: caller,
-		user: (address, uint256),
+		user: EthCrossAccount,
 	) -> Result<void> {
 		self.consume_store_writes(1)?;
 
 		let caller = T::CrossAccountId::from_eth(caller);
-		let user = convert_tuple_to_cross_account::<T>(user)?;
+		let user = user.into_sub_cross_account::<T>()?;
 		Pallet::<T>::toggle_allowlist(self, &caller, &user, false).map_err(dispatch_to_evm::<T>)?;
 		Ok(())
 	}
@@ -637,8 +634,8 @@
 	///
 	/// @param user User cross account to verify
 	/// @return "true" if account is the owner or admin
-	fn is_owner_or_admin_cross(&self, user: (address, uint256)) -> Result<bool> {
-		let user = convert_tuple_to_cross_account::<T>(user)?;
+	fn is_owner_or_admin_cross(&self, user: EthCrossAccount) -> Result<bool> {
+		let user = user.into_sub_cross_account::<T>()?;
 		Ok(self.is_owner_or_admin(&user))
 	}
 
@@ -656,10 +653,10 @@
 
 	/// Get collection owner.
 	///
-	/// @return Tuple with sponsor address and his substrate mirror.
+	/// @return Tuble with sponsor address and his substrate mirror.
 	/// If address is canonical then substrate mirror is zero and vice versa.
-	fn collection_owner(&self) -> Result<(address, uint256)> {
-		Ok(convert_cross_account_to_tuple::<T>(
+	fn collection_owner(&self) -> Result<EthCrossAccount> {
+		Ok(EthCrossAccount::from_sub_cross_account::<T>(
 			&T::CrossAccountId::from_sub(self.owner.clone()),
 		))
 	}
@@ -682,9 +679,9 @@
 	///
 	/// @return Vector of tuples with admins address and his substrate mirror.
 	/// If address is canonical then substrate mirror is zero and vice versa.
-	fn collection_admins(&self) -> Result<Vec<(address, uint256)>> {
+	fn collection_admins(&self) -> Result<Vec<EthCrossAccount>> {
 		let result = crate::IsAdmin::<T>::iter_prefix((self.id,))
-			.map(|(admin, _)| crate::eth::convert_cross_account_to_tuple::<T>(&admin))
+			.map(|(admin, _)| EthCrossAccount::from_sub_cross_account::<T>(&admin))
 			.collect();
 		Ok(result)
 	}
@@ -693,11 +690,11 @@
 	///
 	/// @dev Owner can be changed only by current owner
 	/// @param newOwner new owner cross account
-	fn set_owner_cross(&mut self, caller: caller, new_owner: (address, uint256)) -> Result<void> {
+	fn set_owner_cross(&mut self, caller: caller, new_owner: EthCrossAccount) -> Result<void> {
 		self.consume_store_writes(1)?;
 
 		let caller = T::CrossAccountId::from_eth(caller);
-		let new_owner = convert_tuple_to_cross_account::<T>(new_owner)?;
+		let new_owner = new_owner.into_sub_cross_account::<T>()?;
 		self.set_owner_internal(caller, new_owner)
 			.map_err(dispatch_to_evm::<T>)
 	}

--- a/pallets/common/src/weights.rs
+++ b/pallets/common/src/weights.rs
@@ -26,6 +26,7 @@
 #![cfg_attr(rustfmt, rustfmt_skip)]
 #![allow(unused_parens)]
 #![allow(unused_imports)]
+#![allow(missing_docs)]
 #![allow(clippy::unnecessary_cast)]
 
 use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};

--- a/pallets/evm-contract-helpers/Cargo.toml
+++ b/pallets/evm-contract-helpers/Cargo.toml
@@ -27,7 +27,7 @@
 evm-coder = { default-features = false, path = '../../crates/evm-coder' }
 pallet-common = { default-features = false, path = '../../pallets/common' }
 pallet-evm-coder-substrate = { default-features = false, path = '../../pallets/evm-coder-substrate' }
-pallet-evm-transaction-payment = {  default-features = false, path = '../../pallets/evm-transaction-payment' }
+pallet-evm-transaction-payment = { default-features = false, path = '../../pallets/evm-transaction-payment' }
 up-data-structs = { default-features = false, path = '../../primitives/data-structs', features = [
     'serde1',
 ] }
@@ -52,3 +52,4 @@
     "up-sponsorship/std",
 ]
 try-runtime = ["frame-support/try-runtime"]
+stubgen = ["evm-coder/stubgen"]

--- a/pallets/evm-contract-helpers/src/eth.rs
+++ b/pallets/evm-contract-helpers/src/eth.rs
@@ -16,6 +16,7 @@
 
 //! Implementation of magic contract
 
+extern crate alloc;
 use core::marker::PhantomData;
 use evm_coder::{
 	abi::AbiWriter, execution::Result, generate_stubgen, solidity_interface, types::*, ToLog,

--- a/pallets/evm-contract-helpers/src/lib.rs
+++ b/pallets/evm-contract-helpers/src/lib.rs
@@ -172,7 +172,7 @@
 	>;
 
 	#[pallet::event]
-	#[pallet::generate_deposit(pub fn deposit_event)]
+	#[pallet::generate_deposit(fn deposit_event)]
 	pub enum Event<T: Config> {
 		/// Contract sponsor was set.
 		ContractSponsorSet(
@@ -350,6 +350,7 @@
 		pub fn sponsoring_mode(contract: H160) -> SponsoringModeT {
 			<SponsoringMode<T>>::get(contract)
 				.or_else(|| {
+					#[allow(deprecated)]
 					<SelfSponsoring<T>>::get(contract).then(|| SponsoringModeT::Allowlisted)
 				})
 				.unwrap_or_default()
@@ -362,6 +363,7 @@
 			} else {
 				<SponsoringMode<T>>::insert(contract, mode);
 			}
+			#[allow(deprecated)]
 			<SelfSponsoring<T>>::remove(contract)
 		}
 
@@ -424,6 +426,7 @@
 			_ => return None,
 		})
 	}
+	#[allow(dead_code)]
 	fn to_eth(self) -> u8 {
 		match self {
 			SponsoringModeT::Disabled => 0,

--- a/pallets/fungible/CHANGELOG.md
+++ b/pallets/fungible/CHANGELOG.md
@@ -2,6 +2,9 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.1.6] - 2022-11-02
+### Changed
+ - Use named structure `EthCrossAccount` in eth functions.
 
 ## [0.1.5] - 2022-08-29
 

--- a/pallets/fungible/Cargo.toml
+++ b/pallets/fungible/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pallet-fungible"
-version = "0.1.5"
+version = "0.1.6"
 license = "GPLv3"
 edition = "2021"
 
@@ -46,3 +46,4 @@
 ]
 runtime-benchmarks = ['frame-benchmarking', 'pallet-common/runtime-benchmarks']
 try-runtime = ["frame-support/try-runtime"]
+stubgen = ["evm-coder/stubgen", "pallet-common/stubgen"]

--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -16,10 +16,10 @@
 
 //! ERC-20 standart support implementation.
 
+extern crate alloc;
 use core::char::{REPLACEMENT_CHARACTER, decode_utf16};
 use core::convert::TryInto;
 use evm_coder::{ToLog, execution::*, generate_stubgen, solidity_interface, types::*, weight};
-use pallet_common::eth::convert_tuple_to_cross_account;
 use up_data_structs::CollectionMode;
 use pallet_common::erc::{CommonEvmHandler, PrecompileResult};
 use sp_std::vec::Vec;
@@ -158,11 +158,11 @@
 	fn approve_cross(
 		&mut self,
 		caller: caller,
-		spender: (address, uint256),
+		spender: EthCrossAccount,
 		amount: uint256,
 	) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		let spender = convert_tuple_to_cross_account::<T>(spender)?;
+		let spender = spender.into_sub_cross_account::<T>()?;
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
 
 		<Pallet<T>>::set_allowance(self, &caller, &spender, amount)
@@ -198,11 +198,11 @@
 	fn burn_from_cross(
 		&mut self,
 		caller: caller,
-		from: (address, uint256),
+		from: EthCrossAccount,
 		amount: uint256,
 	) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		let from = convert_tuple_to_cross_account::<T>(from)?;
+		let from = from.into_sub_cross_account::<T>()?;
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
 		let budget = self
 			.recorder
@@ -240,13 +240,13 @@
 	fn transfer_from_cross(
 		&mut self,
 		caller: caller,
-		from: (address, uint256),
-		to: (address, uint256),
+		from: EthCrossAccount,
+		to: EthCrossAccount,
 		amount: uint256,
 	) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		let from = convert_tuple_to_cross_account::<T>(from)?;
-		let to = convert_tuple_to_cross_account::<T>(to)?;
+		let from = from.into_sub_cross_account::<T>()?;
+		let to = to.into_sub_cross_account::<T>()?;
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
 		let budget = self
 			.recorder

binary blob — no preview

--- a/pallets/fungible/src/stubs/UniqueFungible.sol
+++ b/pallets/fungible/src/stubs/UniqueFungible.sol
@@ -38,7 +38,7 @@
 	/// @param properties Vector of properties key/value pair.
 	/// @dev EVM selector for this function is: 0x50b26b2a,
 	///  or in textual repr: setCollectionProperties((string,bytes)[])
-	function setCollectionProperties(Tuple10[] memory properties) public {
+	function setCollectionProperties(Tuple14[] memory properties) public {
 		require(false, stub_error);
 		properties;
 		dummy = 0;
@@ -87,11 +87,11 @@
 	/// @return Vector of properties key/value pairs.
 	/// @dev EVM selector for this function is: 0x285fb8e6,
 	///  or in textual repr: collectionProperties(string[])
-	function collectionProperties(string[] memory keys) public view returns (Tuple10[] memory) {
+	function collectionProperties(string[] memory keys) public view returns (Tuple14[] memory) {
 		require(false, stub_error);
 		keys;
 		dummy;
-		return new Tuple10[](0);
+		return new Tuple14[](0);
 	}
 
 	/// Set the sponsor of the collection.
@@ -114,7 +114,7 @@
 	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.
 	/// @dev EVM selector for this function is: 0x84a1d5a8,
 	///  or in textual repr: setCollectionSponsorCross((address,uint256))
-	function setCollectionSponsorCross(Tuple6 memory sponsor) public {
+	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {
 		require(false, stub_error);
 		sponsor;
 		dummy = 0;
@@ -152,10 +152,10 @@
 	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
 	/// @dev EVM selector for this function is: 0x6ec0a9f1,
 	///  or in textual repr: collectionSponsor()
-	function collectionSponsor() public view returns (Tuple6 memory) {
+	function collectionSponsor() public view returns (Tuple8 memory) {
 		require(false, stub_error);
 		dummy;
-		return Tuple6(0x0000000000000000000000000000000000000000, 0);
+		return Tuple8(0x0000000000000000000000000000000000000000, 0);
 	}
 
 	/// Set limits for the collection.
@@ -206,7 +206,7 @@
 	/// @param newAdmin Cross account administrator address.
 	/// @dev EVM selector for this function is: 0x859aa7d6,
 	///  or in textual repr: addCollectionAdminCross((address,uint256))
-	function addCollectionAdminCross(Tuple6 memory newAdmin) public {
+	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {
 		require(false, stub_error);
 		newAdmin;
 		dummy = 0;
@@ -216,7 +216,7 @@
 	/// @param admin Cross account administrator address.
 	/// @dev EVM selector for this function is: 0x6c0cd173,
 	///  or in textual repr: removeCollectionAdminCross((address,uint256))
-	function removeCollectionAdminCross(Tuple6 memory admin) public {
+	function removeCollectionAdminCross(EthCrossAccount memory admin) public {
 		require(false, stub_error);
 		admin;
 		dummy = 0;
@@ -307,7 +307,7 @@
 	/// @param user User cross account address.
 	/// @dev EVM selector for this function is: 0xa0184a3a,
 	///  or in textual repr: addToCollectionAllowListCross((address,uint256))
-	function addToCollectionAllowListCross(Tuple6 memory user) public {
+	function addToCollectionAllowListCross(EthCrossAccount memory user) public {
 		require(false, stub_error);
 		user;
 		dummy = 0;
@@ -329,7 +329,7 @@
 	/// @param user User cross account address.
 	/// @dev EVM selector for this function is: 0x09ba452a,
 	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))
-	function removeFromCollectionAllowListCross(Tuple6 memory user) public {
+	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {
 		require(false, stub_error);
 		user;
 		dummy = 0;
@@ -365,7 +365,7 @@
 	/// @return "true" if account is the owner or admin
 	/// @dev EVM selector for this function is: 0x3e75a905,
 	///  or in textual repr: isOwnerOrAdminCross((address,uint256))
-	function isOwnerOrAdminCross(Tuple6 memory user) public view returns (bool) {
+	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {
 		require(false, stub_error);
 		user;
 		dummy;
@@ -385,14 +385,14 @@
 
 	/// Get collection owner.
 	///
-	/// @return Tuple with sponsor address and his substrate mirror.
+	/// @return Tuble with sponsor address and his substrate mirror.
 	/// If address is canonical then substrate mirror is zero and vice versa.
 	/// @dev EVM selector for this function is: 0xdf727d3b,
 	///  or in textual repr: collectionOwner()
-	function collectionOwner() public view returns (Tuple6 memory) {
+	function collectionOwner() public view returns (EthCrossAccount memory) {
 		require(false, stub_error);
 		dummy;
-		return Tuple6(0x0000000000000000000000000000000000000000, 0);
+		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);
 	}
 
 	/// Changes collection owner to another account
@@ -413,10 +413,10 @@
 	/// If address is canonical then substrate mirror is zero and vice versa.
 	/// @dev EVM selector for this function is: 0x5813216b,
 	///  or in textual repr: collectionAdmins()
-	function collectionAdmins() public view returns (Tuple6[] memory) {
+	function collectionAdmins() public view returns (EthCrossAccount[] memory) {
 		require(false, stub_error);
 		dummy;
-		return new Tuple6[](0);
+		return new EthCrossAccount[](0);
 	}
 
 	/// Changes collection owner to another account
@@ -425,15 +425,21 @@
 	/// @param newOwner new owner cross account
 	/// @dev EVM selector for this function is: 0xe5c9913f,
 	///  or in textual repr: setOwnerCross((address,uint256))
-	function setOwnerCross(Tuple6 memory newOwner) public {
+	function setOwnerCross(EthCrossAccount memory newOwner) public {
 		require(false, stub_error);
 		newOwner;
 		dummy = 0;
 	}
 }
 
+/// @dev Cross account struct
+struct EthCrossAccount {
+	address eth;
+	uint256 sub;
+}
+
 /// @dev anonymous struct
-struct Tuple10 {
+struct Tuple14 {
 	string field_0;
 	bytes field_1;
 }
@@ -442,7 +448,7 @@
 contract ERC20UniqueExtensions is Dummy, ERC165 {
 	/// @dev EVM selector for this function is: 0x0ecd0ab0,
 	///  or in textual repr: approveCross((address,uint256),uint256)
-	function approveCross(Tuple6 memory spender, uint256 amount) public returns (bool) {
+	function approveCross(EthCrossAccount memory spender, uint256 amount) public returns (bool) {
 		require(false, stub_error);
 		spender;
 		amount;
@@ -472,7 +478,7 @@
 	/// @param amount The amount that will be burnt.
 	/// @dev EVM selector for this function is: 0xbb2f5a58,
 	///  or in textual repr: burnFromCross((address,uint256),uint256)
-	function burnFromCross(Tuple6 memory from, uint256 amount) public returns (bool) {
+	function burnFromCross(EthCrossAccount memory from, uint256 amount) public returns (bool) {
 		require(false, stub_error);
 		from;
 		amount;
@@ -484,7 +490,7 @@
 	/// @param amounts array of pairs of account address and amount
 	/// @dev EVM selector for this function is: 0x1acf2d55,
 	///  or in textual repr: mintBulk((address,uint256)[])
-	function mintBulk(Tuple6[] memory amounts) public returns (bool) {
+	function mintBulk(Tuple8[] memory amounts) public returns (bool) {
 		require(false, stub_error);
 		amounts;
 		dummy = 0;
@@ -494,8 +500,8 @@
 	/// @dev EVM selector for this function is: 0xd5cf430b,
 	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)
 	function transferFromCross(
-		Tuple6 memory from,
-		Tuple6 memory to,
+		EthCrossAccount memory from,
+		EthCrossAccount memory to,
 		uint256 amount
 	) public returns (bool) {
 		require(false, stub_error);
@@ -508,7 +514,7 @@
 }
 
 /// @dev anonymous struct
-struct Tuple6 {
+struct Tuple8 {
 	address field_0;
 	uint256 field_1;
 }

--- a/pallets/nonfungible/CHANGELOG.md
+++ b/pallets/nonfungible/CHANGELOG.md
@@ -3,6 +3,9 @@
 All notable changes to this project will be documented in this file.
 
 <!-- bureaucrate goes here -->
+## [v0.1.7] - 2022-11-02
+### Changed
+ - Use named structure `EthCrossAccount` in eth functions.
 
 ## [v0.1.6] - 2022-20-10
 

--- a/pallets/nonfungible/Cargo.toml
+++ b/pallets/nonfungible/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pallet-nonfungible"
-version = "0.1.6"
+version = "0.1.7"
 license = "GPLv3"
 edition = "2021"
 
@@ -52,3 +52,4 @@
     'up-data-structs/runtime-benchmarks',
 ]
 try-runtime = ["frame-support/try-runtime"]
+stubgen = ["evm-coder/stubgen", "pallet-common/stubgen"]

--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -35,7 +35,6 @@
 use pallet_common::{
 	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},
 	CollectionHandle, CollectionPropertyPermissions,
-	eth::convert_tuple_to_cross_account,
 };
 use pallet_evm::{account::CrossAccountId, PrecompileHandle};
 use pallet_evm_coder_substrate::call;
@@ -675,11 +674,11 @@
 	fn approve_cross(
 		&mut self,
 		caller: caller,
-		approved: (address, uint256),
+		approved: EthCrossAccount,
 		token_id: uint256,
 	) -> Result<void> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		let approved = convert_tuple_to_cross_account::<T>(approved)?;
+		let approved = approved.into_sub_cross_account::<T>()?;
 		let token = token_id.try_into()?;
 
 		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))
@@ -715,13 +714,13 @@
 	fn transfer_from_cross(
 		&mut self,
 		caller: caller,
-		from: (address, uint256),
-		to: (address, uint256),
+		from: EthCrossAccount,
+		to: EthCrossAccount,
 		token_id: uint256,
 	) -> Result<void> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		let from = convert_tuple_to_cross_account::<T>(from)?;
-		let to = convert_tuple_to_cross_account::<T>(to)?;
+		let from = from.into_sub_cross_account::<T>()?;
+		let to = to.into_sub_cross_account::<T>()?;
 		let token_id = token_id.try_into()?;
 		let budget = self
 			.recorder
@@ -761,11 +760,11 @@
 	fn burn_from_cross(
 		&mut self,
 		caller: caller,
-		from: (address, uint256),
+		from: EthCrossAccount,
 		token_id: uint256,
 	) -> Result<void> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		let from = convert_tuple_to_cross_account::<T>(from)?;
+		let from = from.into_sub_cross_account::<T>()?;
 		let token = token_id.try_into()?;
 		let budget = self
 			.recorder

binary blob — no preview

--- a/pallets/nonfungible/src/stubs/UniqueNFT.sol
+++ b/pallets/nonfungible/src/stubs/UniqueNFT.sol
@@ -67,7 +67,7 @@
 	/// @param properties settable properties
 	/// @dev EVM selector for this function is: 0x14ed3a6e,
 	///  or in textual repr: setProperties(uint256,(string,bytes)[])
-	function setProperties(uint256 tokenId, Tuple19[] memory properties) public {
+	function setProperties(uint256 tokenId, Tuple21[] memory properties) public {
 		require(false, stub_error);
 		tokenId;
 		properties;
@@ -124,7 +124,7 @@
 	/// @param properties Vector of properties key/value pair.
 	/// @dev EVM selector for this function is: 0x50b26b2a,
 	///  or in textual repr: setCollectionProperties((string,bytes)[])
-	function setCollectionProperties(Tuple19[] memory properties) public {
+	function setCollectionProperties(Tuple21[] memory properties) public {
 		require(false, stub_error);
 		properties;
 		dummy = 0;
@@ -173,11 +173,11 @@
 	/// @return Vector of properties key/value pairs.
 	/// @dev EVM selector for this function is: 0x285fb8e6,
 	///  or in textual repr: collectionProperties(string[])
-	function collectionProperties(string[] memory keys) public view returns (Tuple19[] memory) {
+	function collectionProperties(string[] memory keys) public view returns (Tuple21[] memory) {
 		require(false, stub_error);
 		keys;
 		dummy;
-		return new Tuple19[](0);
+		return new Tuple21[](0);
 	}
 
 	/// Set the sponsor of the collection.
@@ -200,7 +200,7 @@
 	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.
 	/// @dev EVM selector for this function is: 0x84a1d5a8,
 	///  or in textual repr: setCollectionSponsorCross((address,uint256))
-	function setCollectionSponsorCross(Tuple6 memory sponsor) public {
+	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {
 		require(false, stub_error);
 		sponsor;
 		dummy = 0;
@@ -238,10 +238,10 @@
 	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
 	/// @dev EVM selector for this function is: 0x6ec0a9f1,
 	///  or in textual repr: collectionSponsor()
-	function collectionSponsor() public view returns (Tuple6 memory) {
+	function collectionSponsor() public view returns (Tuple24 memory) {
 		require(false, stub_error);
 		dummy;
-		return Tuple6(0x0000000000000000000000000000000000000000, 0);
+		return Tuple24(0x0000000000000000000000000000000000000000, 0);
 	}
 
 	/// Set limits for the collection.
@@ -292,7 +292,7 @@
 	/// @param newAdmin Cross account administrator address.
 	/// @dev EVM selector for this function is: 0x859aa7d6,
 	///  or in textual repr: addCollectionAdminCross((address,uint256))
-	function addCollectionAdminCross(Tuple6 memory newAdmin) public {
+	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {
 		require(false, stub_error);
 		newAdmin;
 		dummy = 0;
@@ -302,7 +302,7 @@
 	/// @param admin Cross account administrator address.
 	/// @dev EVM selector for this function is: 0x6c0cd173,
 	///  or in textual repr: removeCollectionAdminCross((address,uint256))
-	function removeCollectionAdminCross(Tuple6 memory admin) public {
+	function removeCollectionAdminCross(EthCrossAccount memory admin) public {
 		require(false, stub_error);
 		admin;
 		dummy = 0;
@@ -393,7 +393,7 @@
 	/// @param user User cross account address.
 	/// @dev EVM selector for this function is: 0xa0184a3a,
 	///  or in textual repr: addToCollectionAllowListCross((address,uint256))
-	function addToCollectionAllowListCross(Tuple6 memory user) public {
+	function addToCollectionAllowListCross(EthCrossAccount memory user) public {
 		require(false, stub_error);
 		user;
 		dummy = 0;
@@ -415,7 +415,7 @@
 	/// @param user User cross account address.
 	/// @dev EVM selector for this function is: 0x09ba452a,
 	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))
-	function removeFromCollectionAllowListCross(Tuple6 memory user) public {
+	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {
 		require(false, stub_error);
 		user;
 		dummy = 0;
@@ -451,7 +451,7 @@
 	/// @return "true" if account is the owner or admin
 	/// @dev EVM selector for this function is: 0x3e75a905,
 	///  or in textual repr: isOwnerOrAdminCross((address,uint256))
-	function isOwnerOrAdminCross(Tuple6 memory user) public view returns (bool) {
+	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {
 		require(false, stub_error);
 		user;
 		dummy;
@@ -471,14 +471,14 @@
 
 	/// Get collection owner.
 	///
-	/// @return Tuple with sponsor address and his substrate mirror.
+	/// @return Tuble with sponsor address and his substrate mirror.
 	/// If address is canonical then substrate mirror is zero and vice versa.
 	/// @dev EVM selector for this function is: 0xdf727d3b,
 	///  or in textual repr: collectionOwner()
-	function collectionOwner() public view returns (Tuple6 memory) {
+	function collectionOwner() public view returns (EthCrossAccount memory) {
 		require(false, stub_error);
 		dummy;
-		return Tuple6(0x0000000000000000000000000000000000000000, 0);
+		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);
 	}
 
 	/// Changes collection owner to another account
@@ -499,10 +499,10 @@
 	/// If address is canonical then substrate mirror is zero and vice versa.
 	/// @dev EVM selector for this function is: 0x5813216b,
 	///  or in textual repr: collectionAdmins()
-	function collectionAdmins() public view returns (Tuple6[] memory) {
+	function collectionAdmins() public view returns (EthCrossAccount[] memory) {
 		require(false, stub_error);
 		dummy;
-		return new Tuple6[](0);
+		return new EthCrossAccount[](0);
 	}
 
 	/// Changes collection owner to another account
@@ -511,15 +511,27 @@
 	/// @param newOwner new owner cross account
 	/// @dev EVM selector for this function is: 0xe5c9913f,
 	///  or in textual repr: setOwnerCross((address,uint256))
-	function setOwnerCross(Tuple6 memory newOwner) public {
+	function setOwnerCross(EthCrossAccount memory newOwner) public {
 		require(false, stub_error);
 		newOwner;
 		dummy = 0;
 	}
 }
 
+/// @dev Cross account struct
+struct EthCrossAccount {
+	address eth;
+	uint256 sub;
+}
+
 /// @dev anonymous struct
-struct Tuple19 {
+struct Tuple24 {
+	address field_0;
+	uint256 field_1;
+}
+
+/// @dev anonymous struct
+struct Tuple21 {
 	string field_0;
 	bytes field_1;
 }
@@ -696,7 +708,7 @@
 	/// @param tokenId The NFT to approve
 	/// @dev EVM selector for this function is: 0x0ecd0ab0,
 	///  or in textual repr: approveCross((address,uint256),uint256)
-	function approveCross(Tuple6 memory approved, uint256 tokenId) public {
+	function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {
 		require(false, stub_error);
 		approved;
 		tokenId;
@@ -726,8 +738,8 @@
 	/// @dev EVM selector for this function is: 0xd5cf430b,
 	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)
 	function transferFromCross(
-		Tuple6 memory from,
-		Tuple6 memory to,
+		EthCrossAccount memory from,
+		EthCrossAccount memory to,
 		uint256 tokenId
 	) public {
 		require(false, stub_error);
@@ -760,7 +772,7 @@
 	/// @param tokenId The NFT to transfer
 	/// @dev EVM selector for this function is: 0xbb2f5a58,
 	///  or in textual repr: burnFromCross((address,uint256),uint256)
-	function burnFromCross(Tuple6 memory from, uint256 tokenId) public {
+	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {
 		require(false, stub_error);
 		from;
 		tokenId;
@@ -797,7 +809,7 @@
 	// /// @param tokens array of pairs of token ID and token URI for minted tokens
 	// /// @dev EVM selector for this function is: 0x36543006,
 	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])
-	// function mintBulkWithTokenURI(address to, Tuple8[] memory tokens) public returns (bool) {
+	// function mintBulkWithTokenURI(address to, Tuple10[] memory tokens) public returns (bool) {
 	// 	require(false, stub_error);
 	// 	to;
 	// 	tokens;
@@ -808,15 +820,9 @@
 }
 
 /// @dev anonymous struct
-struct Tuple8 {
+struct Tuple10 {
 	uint256 field_0;
 	string field_1;
-}
-
-/// @dev anonymous struct
-struct Tuple6 {
-	address field_0;
-	uint256 field_1;
 }
 
 /// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension

--- a/pallets/refungible/CHANGELOG.md
+++ b/pallets/refungible/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 All notable changes to this project will be documented in this file.
 
+## [v0.2.6] - 2022-11-02
+### Changed
+ - Use named structure `EthCrossAccount` in eth functions.
+
 ## [v0.2.5] - 2022-20-10
 
 ### Change

--- a/pallets/refungible/Cargo.toml
+++ b/pallets/refungible/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pallet-refungible"
-version = "0.2.5"
+version = "0.2.6"
 license = "GPLv3"
 edition = "2021"
 
@@ -26,7 +26,9 @@
 struct-versioning = { path = "../../crates/struct-versioning" }
 up-data-structs = { default-features = false, path = '../../primitives/data-structs' }
 ethereum = { version = "0.12.0", default-features = false }
-scale-info = { version = "2.0.1", default-features = false, features = ["derive",] }
+scale-info = { version = "2.0.1", default-features = false, features = [
+    "derive",
+] }
 derivative = { version = "2.2.0", features = ["use_core"] }
 
 [features]
@@ -52,3 +54,4 @@
     'up-data-structs/runtime-benchmarks',
 ]
 try-runtime = ["frame-support/try-runtime"]
+stubgen = ["evm-coder/stubgen", "pallet-common/stubgen"]

--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -30,7 +30,6 @@
 use pallet_common::{
 	CollectionHandle, CollectionPropertyPermissions,
 	erc::{CommonEvmHandler, CollectionCall, static_property::key},
-	eth::convert_tuple_to_cross_account,
 };
 use pallet_evm::{account::CrossAccountId, PrecompileHandle};
 use pallet_evm_coder_substrate::{call, dispatch_to_evm};
@@ -725,13 +724,13 @@
 	fn transfer_from_cross(
 		&mut self,
 		caller: caller,
-		from: (address, uint256),
-		to: (address, uint256),
+		from: EthCrossAccount,
+		to: EthCrossAccount,
 		token_id: uint256,
 	) -> Result<void> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		let from = convert_tuple_to_cross_account::<T>(from)?;
-		let to = convert_tuple_to_cross_account::<T>(to)?;
+		let from = from.into_sub_cross_account::<T>()?;
+		let to = to.into_sub_cross_account::<T>()?;
 		let token_id = token_id.try_into()?;
 		let budget = self
 			.recorder
@@ -780,11 +779,11 @@
 	fn burn_from_cross(
 		&mut self,
 		caller: caller,
-		from: (address, uint256),
+		from: EthCrossAccount,
 		token_id: uint256,
 	) -> Result<void> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		let from = convert_tuple_to_cross_account::<T>(from)?;
+		let from = from.into_sub_cross_account::<T>()?;
 		let token = token_id.try_into()?;
 		let budget = self
 			.recorder