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

--- a/.docker/forkless-config/launch-config-forkless-data.j2
+++ b/.docker/forkless-config/launch-config-forkless-data.j2
@@ -107,7 +107,7 @@
                         "--rpc-cors=all",
                         "--unsafe-rpc-external",
                         "--unsafe-ws-external",
-                        "-lxcm=trace"
+                        "-lxcm=trace,parity_ws::handler=debug,jsonrpsee_core=trace,jsonrpsee-core=trace,jsonrpsee_ws_server=debug"
                     ]
                 },
                 {
@@ -119,7 +119,7 @@
                         "--rpc-cors=all",
                         "--unsafe-rpc-external",
                         "--unsafe-ws-external",
-                        "-lxcm=trace"
+                        "-lxcm=trace,parity_ws::handler=debug,jsonrpsee_core=trace,jsonrpsee-core=trace,jsonrpsee_ws_server=debug"
                     ]
                 }
             ]

--- a/.docker/forkless-config/launch-config-forkless-nodata.j2
+++ b/.docker/forkless-config/launch-config-forkless-nodata.j2
@@ -101,7 +101,7 @@
                         "--rpc-cors=all",
                         "--unsafe-rpc-external",
                         "--unsafe-ws-external",
-                        "-lxcm=trace",
+                        "-lxcm=trace,parity_ws::handler=debug,jsonrpsee_core=trace,jsonrpsee-core=trace,jsonrpsee_ws_server=debug",
                         "--ws-max-connections=1000"
                     ]
                 },
@@ -114,7 +114,7 @@
                         "--rpc-cors=all",
                         "--unsafe-rpc-external",
                         "--unsafe-ws-external",
-                        "-lxcm=trace",
+                        "-lxcm=trace,parity_ws::handler=debug,jsonrpsee_core=trace,jsonrpsee-core=trace,jsonrpsee_ws_server=debug",
                         "--ws-max-connections=1000"
                     ]
                 }

--- a/.docker/forkless-config/launch-config-node-update-only-v3.j2
+++ b/.docker/forkless-config/launch-config-node-update-only-v3.j2
@@ -101,7 +101,7 @@
                         "--rpc-cors=all",
                         "--unsafe-rpc-external",
                         "--unsafe-ws-external",
-                        "-lxcm=trace",
+                        "-lxcm=trace,parity_ws::handler=debug,jsonrpsee_core=trace,jsonrpsee-core=trace,jsonrpsee_ws_server=debug",
                         "--ws-max-connections=1000"
                     ]
                 },
@@ -114,7 +114,7 @@
                         "--rpc-cors=all",
                         "--unsafe-rpc-external",
                         "--unsafe-ws-external",
-                        "-lxcm=trace",
+                        "-lxcm=trace,parity_ws::handler=debug,jsonrpsee_core=trace,jsonrpsee-core=trace,jsonrpsee_ws_server=debug",
                         "--ws-max-connections=1000"
                     ]
                 }

--- a/.docker/xcm-config/launch-config-xcm-opal.json
+++ b/.docker/xcm-config/launch-config-xcm-opal.json
@@ -91,6 +91,7 @@
                     "name": "alice",
                     "flags": [
                        "--unsafe-rpc-external",
+                       "-lxcm=trace,parity_ws::handler=debug,jsonrpsee_core=trace,jsonrpsee-core=trace,jsonrpsee_ws_server=debug",
                        "--unsafe-ws-external"
 		    ]
                 }

--- a/.docker/xcm-config/launch-config-xcm-quartz.json
+++ b/.docker/xcm-config/launch-config-xcm-quartz.json
@@ -90,6 +90,7 @@
                     "rpcPort": 9933,
                     "name": "alice",
                     "flags": [
+                       "-lxcm=trace,parity_ws::handler=debug,jsonrpsee_core=trace,jsonrpsee-core=trace,jsonrpsee_ws_server=debug",
                        "--unsafe-rpc-external",
                        "--unsafe-ws-external"
 		    ]

--- a/.docker/xcm-config/launch-config-xcm-unique.json
+++ b/.docker/xcm-config/launch-config-xcm-unique.json
@@ -90,6 +90,7 @@
                     "rpcPort": 9933,
                     "name": "alice",
                     "flags": [
+                        "-lxcm=trace,parity_ws::handler=debug,jsonrpsee_core=trace,jsonrpsee-core=trace,jsonrpsee_ws_server=debug",
                         "--unsafe-rpc-external",
                         "--unsafe-ws-external"
 		    ]

--- 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"));
+
+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(value)
+		Ok(&segment.ident)
 	}
-	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",
-			)),
-		}
-	}
 	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,
@@ -728,11 +602,20 @@
 
 	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]]
+			};
 		}
 	}
 
@@ -836,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 {
@@ -851,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,
@@ -1027,30 +931,6 @@
 
 		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])*
@@ -1076,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
@@ -194,7 +194,9 @@
 				#(
 					#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.
@@ -230,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)
@@ -387,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(())
 	}
@@ -402,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(())
 	}
@@ -565,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(())
 	}
@@ -593,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(())
 	}
@@ -638,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))
 	}
 
@@ -657,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()),
 		))
 	}
@@ -683,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)
 	}
@@ -694,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/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/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
 

1[package]1[package]
2name = "pallet-fungible"2name = "pallet-fungible"
3version = "0.1.5"3version = "0.1.6"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66
46]46]
47runtime-benchmarks = ['frame-benchmarking', 'pallet-common/runtime-benchmarks']47runtime-benchmarks = ['frame-benchmarking', 'pallet-common/runtime-benchmarks']
48try-runtime = ["frame-support/try-runtime"]48try-runtime = ["frame-support/try-runtime"]
49stubgen = ["evm-coder/stubgen", "pallet-common/stubgen"]
4950

--- 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

binary blob — no preview

--- a/pallets/refungible/src/stubs/UniqueRefungible.sol
+++ b/pallets/refungible/src/stubs/UniqueRefungible.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, Tuple20[] 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(Tuple20[] 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 (Tuple20[] memory) {
 		require(false, stub_error);
 		keys;
 		dummy;
-		return new Tuple19[](0);
+		return new Tuple20[](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 (Tuple23 memory) {
 		require(false, stub_error);
 		dummy;
-		return Tuple6(0x0000000000000000000000000000000000000000, 0);
+		return Tuple23(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 Tuple23 {
+	address field_0;
+	uint256 field_1;
+}
+
+/// @dev anonymous struct
+struct Tuple20 {
 	string field_0;
 	bytes field_1;
 }
@@ -710,8 +722,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);
@@ -746,7 +758,7 @@
 	/// @param tokenId The RFT 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;
@@ -784,7 +796,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, Tuple9[] memory tokens) public returns (bool) {
 	// 	require(false, stub_error);
 	// 	to;
 	// 	tokens;
@@ -806,15 +818,9 @@
 }
 
 /// @dev anonymous struct
-struct Tuple8 {
+struct Tuple9 {
 	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/unique/src/eth/mod.rs
+++ b/pallets/unique/src/eth/mod.rs
@@ -20,14 +20,10 @@
 use ethereum as _;
 use evm_coder::{execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};
 use frame_support::traits::Get;
-
 use crate::Pallet;
 
 use pallet_common::{
-	CollectionById,
-	dispatch::CollectionDispatch,
-	erc::{static_property::key, CollectionHelpersEvents},
-	Pallet as PalletCommon,
+	CollectionById, dispatch::CollectionDispatch, erc::static_property::key, Pallet as PalletCommon,
 };
 use pallet_evm::{account::CrossAccountId, OnMethodCall, PrecompileHandle, PrecompileResult};
 use pallet_evm_coder_substrate::{dispatch_to_evm, SubstrateRecorder, WithRecorder};

--- a/runtime/unique/Cargo.toml
+++ b/runtime/unique/Cargo.toml
@@ -169,6 +169,7 @@
 ]
 limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing']
 unique-runtime = []
+stubgen = ["evm-coder/stubgen"]
 
 refungible = []
 scheduler = []

--- a/tests/src/eth/allowlist.test.ts
+++ b/tests/src/eth/allowlist.test.ts
@@ -89,21 +89,21 @@
     expect(await collectionEvm.methods.allowed(user).call({from: owner})).to.be.false;
   });
 
-  //itEth('Collection allowlist can be added and removed by [cross] address', async ({helper}) => {
-  //  const owner = await helper.eth.createAccountWithBalance(donor);
-  //  const user = donor;
-  //  
-  //  const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
-  //  const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
-  //  const userCross = helper.ethCrossAccount.fromKeyringPair(user);
-  //  
-  //  expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.false;
-  //  await collectionEvm.methods.addToCollectionAllowListCross(userCross).send({from: owner});
-  //  expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.true;
-  //  
-  //  await collectionEvm.methods.removeFromCollectionAllowListCross(userCross).send({from: owner});
-  //  expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.false;
-  //});
+  itEth('Collection allowlist can be added and removed by [cross] address', async ({helper}) => {
+    const owner = await helper.eth.createAccountWithBalance(donor);
+    const user = donor;
+    
+    const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
+    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
+    const userCross = helper.ethCrossAccount.fromKeyringPair(user);
+    
+    expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.false;
+    await collectionEvm.methods.addToCollectionAllowListCross(userCross).send({from: owner});
+    expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.true;
+    
+    await collectionEvm.methods.removeFromCollectionAllowListCross(userCross).send({from: owner});
+    expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.false;
+  });
 
   itEth('Collection allowlist can not be add and remove [eth] address by not owner', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
@@ -122,22 +122,22 @@
     expect(await collectionEvm.methods.allowed(user).call({from: owner})).to.be.true;
   });
 
-  //itEth('Collection allowlist can not be add and remove [cross] address by not owner', async ({helper}) => {
-  //  const owner = await helper.eth.createAccountWithBalance(donor);
-  //  const notOwner = await helper.eth.createAccountWithBalance(donor);
-  //  const user = donor;
-  //  
-  //  const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
-  //  const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
-  //  
-  //  expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.false;
-  //  const userCross = helper.ethCrossAccount.fromKeyringPair(user);
-  //  await expect(collectionEvm.methods.addToCollectionAllowListCross(userCross).call({from: notOwner})).to.be.rejectedWith('NoPermission');
-  //  expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.false;
-  //  await collectionEvm.methods.addToCollectionAllowListCross(userCross).send({from: owner});
-  //  
-  //  expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.true;
-  //  await expect(collectionEvm.methods.removeFromCollectionAllowListCross(userCross).call({from: notOwner})).to.be.rejectedWith('NoPermission');
-  //  expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.true;
-  //});
+  itEth('Collection allowlist can not be add and remove [cross] address by not owner', async ({helper}) => {
+    const owner = await helper.eth.createAccountWithBalance(donor);
+    const notOwner = await helper.eth.createAccountWithBalance(donor);
+    const user = donor;
+    
+    const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
+    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
+    
+    expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.false;
+    const userCross = helper.ethCrossAccount.fromKeyringPair(user);
+    await expect(collectionEvm.methods.addToCollectionAllowListCross(userCross).call({from: notOwner})).to.be.rejectedWith('NoPermission');
+    expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.false;
+    await collectionEvm.methods.addToCollectionAllowListCross(userCross).send({from: owner});
+    
+    expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.true;
+    await expect(collectionEvm.methods.removeFromCollectionAllowListCross(userCross).call({from: notOwner})).to.be.rejectedWith('NoPermission');
+    expect(await helper.collection.allowed(collectionId, {Substrate: user.address})).to.be.true;
+  });
 });

--- a/tests/src/eth/api/UniqueFungible.sol
+++ b/tests/src/eth/api/UniqueFungible.sol
@@ -28,7 +28,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) external;
+	function setCollectionProperties(Tuple14[] memory properties) external;
 
 	/// Delete collection property.
 	///
@@ -60,7 +60,7 @@
 	/// @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) external view returns (Tuple10[] memory);
+	function collectionProperties(string[] memory keys) external view returns (Tuple14[] memory);
 
 	/// Set the sponsor of the collection.
 	///
@@ -78,7 +78,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) external;
+	function setCollectionSponsorCross(EthCrossAccount memory sponsor) external;
 
 	/// Whether there is a pending sponsor.
 	/// @dev EVM selector for this function is: 0x058ac185,
@@ -102,7 +102,7 @@
 	/// @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() external view returns (Tuple6 memory);
+	function collectionSponsor() external view returns (Tuple8 memory);
 
 	/// Set limits for the collection.
 	/// @dev Throws error if limit not found.
@@ -138,13 +138,13 @@
 	/// @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) external;
+	function addCollectionAdminCross(EthCrossAccount memory newAdmin) external;
 
 	/// Remove collection admin.
 	/// @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) external;
+	function removeCollectionAdminCross(EthCrossAccount memory admin) external;
 
 	/// Add collection admin.
 	/// @param newAdmin Address of the added administrator.
@@ -201,7 +201,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) external;
+	function addToCollectionAllowListCross(EthCrossAccount memory user) external;
 
 	/// Remove the user from the allowed list.
 	///
@@ -215,7 +215,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) external;
+	function removeFromCollectionAllowListCross(EthCrossAccount memory user) external;
 
 	/// Switch permission for minting.
 	///
@@ -238,7 +238,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) external view returns (bool);
+	function isOwnerOrAdminCross(EthCrossAccount memory user) external view returns (bool);
 
 	/// Returns collection type
 	///
@@ -249,11 +249,11 @@
 
 	/// 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() external view returns (Tuple6 memory);
+	function collectionOwner() external view returns (EthCrossAccount memory);
 
 	/// Changes collection owner to another account
 	///
@@ -269,7 +269,7 @@
 	/// 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() external view returns (Tuple6[] memory);
+	function collectionAdmins() external view returns (EthCrossAccount[] memory);
 
 	/// Changes collection owner to another account
 	///
@@ -277,11 +277,17 @@
 	/// @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) external;
+	function setOwnerCross(EthCrossAccount memory newOwner) external;
+}
+
+/// @dev Cross account struct
+struct EthCrossAccount {
+	address eth;
+	uint256 sub;
 }
 
 /// @dev anonymous struct
-struct Tuple10 {
+struct Tuple14 {
 	string field_0;
 	bytes field_1;
 }
@@ -290,7 +296,7 @@
 interface 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) external returns (bool);
+	function approveCross(EthCrossAccount memory spender, uint256 amount) external returns (bool);
 
 	/// Burn tokens from account
 	/// @dev Function that burns an `amount` of the tokens of a given account,
@@ -308,25 +314,25 @@
 	/// @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) external returns (bool);
+	function burnFromCross(EthCrossAccount memory from, uint256 amount) external returns (bool);
 
 	/// Mint tokens for multiple accounts.
 	/// @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) external returns (bool);
+	function mintBulk(Tuple8[] memory amounts) external returns (bool);
 
 	/// @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
 	) external returns (bool);
 }
 
 /// @dev anonymous struct
-struct Tuple6 {
+struct Tuple8 {
 	address field_0;
 	uint256 field_1;
 }

--- a/tests/src/eth/api/UniqueNFT.sol
+++ b/tests/src/eth/api/UniqueNFT.sol
@@ -49,7 +49,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) external;
+	function setProperties(uint256 tokenId, Tuple21[] memory properties) external;
 
 	/// @notice Delete token property value.
 	/// @dev Throws error if `msg.sender` has no permission to edit the property.
@@ -85,7 +85,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) external;
+	function setCollectionProperties(Tuple21[] memory properties) external;
 
 	/// Delete collection property.
 	///
@@ -117,7 +117,7 @@
 	/// @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) external view returns (Tuple19[] memory);
+	function collectionProperties(string[] memory keys) external view returns (Tuple21[] memory);
 
 	/// Set the sponsor of the collection.
 	///
@@ -135,7 +135,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) external;
+	function setCollectionSponsorCross(EthCrossAccount memory sponsor) external;
 
 	/// Whether there is a pending sponsor.
 	/// @dev EVM selector for this function is: 0x058ac185,
@@ -159,7 +159,7 @@
 	/// @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() external view returns (Tuple6 memory);
+	function collectionSponsor() external view returns (Tuple24 memory);
 
 	/// Set limits for the collection.
 	/// @dev Throws error if limit not found.
@@ -195,13 +195,13 @@
 	/// @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) external;
+	function addCollectionAdminCross(EthCrossAccount memory newAdmin) external;
 
 	/// Remove collection admin.
 	/// @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) external;
+	function removeCollectionAdminCross(EthCrossAccount memory admin) external;
 
 	/// Add collection admin.
 	/// @param newAdmin Address of the added administrator.
@@ -258,7 +258,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) external;
+	function addToCollectionAllowListCross(EthCrossAccount memory user) external;
 
 	/// Remove the user from the allowed list.
 	///
@@ -272,7 +272,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) external;
+	function removeFromCollectionAllowListCross(EthCrossAccount memory user) external;
 
 	/// Switch permission for minting.
 	///
@@ -295,7 +295,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) external view returns (bool);
+	function isOwnerOrAdminCross(EthCrossAccount memory user) external view returns (bool);
 
 	/// Returns collection type
 	///
@@ -306,11 +306,11 @@
 
 	/// 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() external view returns (Tuple6 memory);
+	function collectionOwner() external view returns (EthCrossAccount memory);
 
 	/// Changes collection owner to another account
 	///
@@ -326,7 +326,7 @@
 	/// 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() external view returns (Tuple6[] memory);
+	function collectionAdmins() external view returns (EthCrossAccount[] memory);
 
 	/// Changes collection owner to another account
 	///
@@ -334,11 +334,23 @@
 	/// @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) external;
+	function setOwnerCross(EthCrossAccount memory newOwner) external;
+}
+
+/// @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;
 }
@@ -458,7 +470,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) external;
+	function approveCross(EthCrossAccount memory approved, uint256 tokenId) external;
 
 	/// @notice Transfer ownership of an NFT
 	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`
@@ -478,8 +490,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
 	) external;
 
@@ -501,7 +513,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) external;
+	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) external;
 
 	/// @notice Returns next free NFT ID.
 	/// @dev EVM selector for this function is: 0x75794a3c,
@@ -523,20 +535,14 @@
 	// /// @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) external returns (bool);
+	// function mintBulkWithTokenURI(address to, Tuple10[] memory tokens) external returns (bool);
 
 }
 
 /// @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/tests/src/eth/api/UniqueRefungible.sol
+++ b/tests/src/eth/api/UniqueRefungible.sol
@@ -49,7 +49,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) external;
+	function setProperties(uint256 tokenId, Tuple20[] memory properties) external;
 
 	/// @notice Delete token property value.
 	/// @dev Throws error if `msg.sender` has no permission to edit the property.
@@ -85,7 +85,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) external;
+	function setCollectionProperties(Tuple20[] memory properties) external;
 
 	/// Delete collection property.
 	///
@@ -117,7 +117,7 @@
 	/// @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) external view returns (Tuple19[] memory);
+	function collectionProperties(string[] memory keys) external view returns (Tuple20[] memory);
 
 	/// Set the sponsor of the collection.
 	///
@@ -135,7 +135,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) external;
+	function setCollectionSponsorCross(EthCrossAccount memory sponsor) external;
 
 	/// Whether there is a pending sponsor.
 	/// @dev EVM selector for this function is: 0x058ac185,
@@ -159,7 +159,7 @@
 	/// @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() external view returns (Tuple6 memory);
+	function collectionSponsor() external view returns (Tuple23 memory);
 
 	/// Set limits for the collection.
 	/// @dev Throws error if limit not found.
@@ -195,13 +195,13 @@
 	/// @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) external;
+	function addCollectionAdminCross(EthCrossAccount memory newAdmin) external;
 
 	/// Remove collection admin.
 	/// @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) external;
+	function removeCollectionAdminCross(EthCrossAccount memory admin) external;
 
 	/// Add collection admin.
 	/// @param newAdmin Address of the added administrator.
@@ -258,7 +258,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) external;
+	function addToCollectionAllowListCross(EthCrossAccount memory user) external;
 
 	/// Remove the user from the allowed list.
 	///
@@ -272,7 +272,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) external;
+	function removeFromCollectionAllowListCross(EthCrossAccount memory user) external;
 
 	/// Switch permission for minting.
 	///
@@ -295,7 +295,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) external view returns (bool);
+	function isOwnerOrAdminCross(EthCrossAccount memory user) external view returns (bool);
 
 	/// Returns collection type
 	///
@@ -306,11 +306,11 @@
 
 	/// 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() external view returns (Tuple6 memory);
+	function collectionOwner() external view returns (EthCrossAccount memory);
 
 	/// Changes collection owner to another account
 	///
@@ -326,7 +326,7 @@
 	/// 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() external view returns (Tuple6[] memory);
+	function collectionAdmins() external view returns (EthCrossAccount[] memory);
 
 	/// Changes collection owner to another account
 	///
@@ -334,11 +334,23 @@
 	/// @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) external;
+	function setOwnerCross(EthCrossAccount memory newOwner) external;
+}
+
+/// @dev Cross account struct
+struct EthCrossAccount {
+	address eth;
+	uint256 sub;
 }
 
 /// @dev anonymous struct
-struct Tuple19 {
+struct Tuple23 {
+	address field_0;
+	uint256 field_1;
+}
+
+/// @dev anonymous struct
+struct Tuple20 {
 	string field_0;
 	bytes field_1;
 }
@@ -467,8 +479,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
 	) external;
 
@@ -492,7 +504,7 @@
 	/// @param tokenId The RFT 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) external;
+	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) external;
 
 	/// @notice Returns next free RFT ID.
 	/// @dev EVM selector for this function is: 0x75794a3c,
@@ -515,7 +527,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) external returns (bool);
+	// function mintBulkWithTokenURI(address to, Tuple9[] memory tokens) external returns (bool);
 
 	/// Returns EVM address for refungible token
 	///
@@ -526,15 +538,9 @@
 }
 
 /// @dev anonymous struct
-struct Tuple8 {
+struct Tuple9 {
 	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/tests/src/eth/base.test.ts
+++ b/tests/src/eth/base.test.ts
@@ -116,7 +116,7 @@
     await checkInterface(helper, '0x780e9d63', true, true);
   });
 
-  itEth('ERC721UniqueExtensions - 0x244543ee - support', async ({helper}) => {
+  itEth('ERC721UniqueExtensions support', async ({helper}) => {
     await checkInterface(helper, '0x244543ee', true, true);
   });
 

--- a/tests/src/eth/collectionAdmin.test.ts
+++ b/tests/src/eth/collectionAdmin.test.ts
@@ -14,7 +14,10 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import {usingEthPlaygrounds, itEth, expect, EthUniqueHelper} from './util';
+import {expect} from 'chai';
+import {IEthCrossAccountId} from '../util/playgrounds/types';
+import {usingEthPlaygrounds, itEth} from './util';
+import {EthUniqueHelper} from './util/playgrounds/unique.dev';
 
 async function recordEthFee(helper: EthUniqueHelper, userAddress: string, call: () => Promise<any>) {
   const before = await helper.balance.getSubstrate(helper.address.ethToSubstrate(userAddress));
@@ -63,24 +66,25 @@
     expect(adminList).to.be.like([{Substrate: newAdmin.address}]);
   });
 
-  // itEth('Check adminlist', async ({helper, privateKey}) => {
-  //   const owner = await helper.eth.createAccountWithBalance(donor);
+  itEth('Check adminlist', async ({helper, privateKey}) => {
+    const owner = await helper.eth.createAccountWithBalance(donor);
         
-  //   const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
-  //   const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
+    const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
+    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
 
-  //   const admin1 = helper.eth.createAccount();
-  //   const admin2 = await privateKey('admin');
-  //   await collectionEvm.methods.addCollectionAdmin(admin1).send();
-  //   await collectionEvm.methods.addCollectionAdminCross(helper.ethCrossAccount.fromKeyringPair(admin2)).send();
+    const admin1 = helper.eth.createAccount();
+    const admin2 = await privateKey('admin');
+    const admin2Cross = helper.ethCrossAccount.fromKeyringPair(admin2);
+    await collectionEvm.methods.addCollectionAdmin(admin1).send();
+    await collectionEvm.methods.addCollectionAdminCross(admin2Cross).send();
 
-  //   const adminListRpc = await helper.collection.getAdmins(collectionId);
-  //   let adminListEth = await collectionEvm.methods.collectionAdmins().call();
-  //   adminListEth = adminListEth.map((element: IEthCrossAccountId) => {
-  //     return helper.address.convertCrossAccountFromEthCrossAcoount(element);
-  //   });
-  //   expect(adminListRpc).to.be.like(adminListEth);
-  // });
+    const adminListRpc = await helper.collection.getAdmins(collectionId);
+    let adminListEth = await collectionEvm.methods.collectionAdmins().call();
+    adminListEth = adminListEth.map((element: IEthCrossAccountId) => {
+      return helper.address.convertCrossAccountFromEthCrossAcoount(element);
+    });
+    expect(adminListRpc).to.be.like(adminListEth);
+  });
 
   itEth('Verify owner or admin', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
@@ -93,25 +97,6 @@
     await collectionEvm.methods.addCollectionAdmin(newAdmin).send();
     expect(await collectionEvm.methods.isOwnerOrAdmin(newAdmin).call()).to.be.true;
   });
-
-  // itEth.skip('Check adminlist', async ({helper, privateKey}) => {
-  //   const owner = await helper.eth.createAccountWithBalance(donor);
-        
-  //   const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
-  //   const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
-
-  //   const admin1 = helper.eth.createAccount();
-  //   const admin2 = await privateKey('admin');
-  //   await collectionEvm.methods.addCollectionAdmin(admin1).send();
-  //   await collectionEvm.methods.addCollectionAdminSubstrate(admin2.addressRaw).send();
-
-  //   const adminListRpc = await helper.collection.getAdmins(collectionId);
-  //   let adminListEth = await collectionEvm.methods.collectionAdmins().call();
-  //   adminListEth = adminListEth.map((element: IEthCrossAccountId) => {
-  //     return helper.address.convertCrossAccountFromEthCrossAcoount(element);
-  //   });
-  //   expect(adminListRpc).to.be.like(adminListEth);
-  // });
     
   itEth('(!negative tests!) Add admin by ADMIN is not allowed', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
@@ -146,7 +131,7 @@
     expect(adminList.length).to.be.eq(0);
   });
 
-  itEth.skip('(!negative tests!) Add substrate admin by ADMIN is not allowed', async ({helper}) => {
+  itEth('(!negative tests!) Add [cross] admin by ADMIN is not allowed', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
 
@@ -155,7 +140,8 @@
     await collectionEvm.methods.addCollectionAdmin(admin).send();
 
     const [notAdmin] = await helper.arrange.createAccounts([10n], donor);
-    await expect(collectionEvm.methods.addCollectionAdminSubstrate(notAdmin.addressRaw).call({from: admin}))
+    const notAdminCross = helper.ethCrossAccount.fromKeyringPair(notAdmin);
+    await expect(collectionEvm.methods.addCollectionAdminCross(notAdminCross).call({from: admin}))
       .to.be.rejectedWith('NoPermission');
 
     const adminList = await helper.callRpc('api.rpc.unique.adminlist', [collectionId]);
@@ -164,14 +150,15 @@
       .to.be.eq(admin.toLocaleLowerCase());
   });
 
-  itEth.skip('(!negative tests!) Add substrate admin by USER is not allowed', async ({helper}) => {
+  itEth('(!negative tests!) Add [cross] admin by USER is not allowed', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
 
     const notAdmin0 = await helper.eth.createAccountWithBalance(donor);
     const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
     const [notAdmin1] = await helper.arrange.createAccounts([10n], donor);
-    await expect(collectionEvm.methods.addCollectionAdminSubstrate(notAdmin1.addressRaw).call({from: notAdmin0}))
+    const notAdmin1Cross = helper.ethCrossAccount.fromKeyringPair(notAdmin1);
+    await expect(collectionEvm.methods.addCollectionAdminCross(notAdmin1Cross).call({from: notAdmin0}))
       .to.be.rejectedWith('NoPermission');
 
     const adminList = await helper.callRpc('api.rpc.unique.adminlist', [collectionId]);
@@ -208,20 +195,21 @@
     expect(adminList.length).to.be.eq(0);
   });
 
-  itEth.skip('Remove substrate admin by owner', async ({helper}) => {
+  itEth('Remove [cross] admin by owner', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
 
     const [newAdmin] = await helper.arrange.createAccounts([10n], donor);
+    const newAdminCross = helper.ethCrossAccount.fromKeyringPair(newAdmin);
     const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
-    await collectionEvm.methods.addCollectionAdminSubstrate(newAdmin.addressRaw).send();
+    await collectionEvm.methods.addCollectionAdminCross(newAdminCross).send();
     {
       const adminList = await helper.callRpc('api.rpc.unique.adminlist', [collectionId]);
       expect(adminList[0].asSubstrate.toString().toLocaleLowerCase())
         .to.be.eq(newAdmin.address.toLocaleLowerCase());
     }
 
-    await collectionEvm.methods.removeCollectionAdminSubstrate(newAdmin.addressRaw).send();
+    await collectionEvm.methods.removeCollectionAdminCross(newAdminCross).send();
     const adminList = await helper.callRpc('api.rpc.unique.adminlist', [collectionId]);
     expect(adminList.length).to.be.eq(0);
   });
@@ -268,17 +256,18 @@
     }
   });
 
-  itEth.skip('(!negative tests!) Remove substrate admin by ADMIN is not allowed', async ({helper}) => {
+  itEth('(!negative tests!) Remove [cross] admin by ADMIN is not allowed', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
 
     const [adminSub] = await helper.arrange.createAccounts([10n], donor);
+    const adminSubCross = helper.ethCrossAccount.fromKeyringPair(adminSub);
     const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
-    await collectionEvm.methods.addCollectionAdminSubstrate(adminSub.addressRaw).send();
+    await collectionEvm.methods.addCollectionAdminCross(adminSubCross).send();
     const adminEth = await helper.eth.createAccountWithBalance(donor);
     await collectionEvm.methods.addCollectionAdmin(adminEth).send();
 
-    await expect(collectionEvm.methods.removeCollectionAdminSubstrate(adminSub.addressRaw).call({from: adminEth}))
+    await expect(collectionEvm.methods.removeCollectionAdminCross(adminSubCross).call({from: adminEth}))
       .to.be.rejectedWith('NoPermission');
 
     const adminList = await helper.callRpc('api.rpc.unique.adminlist', [collectionId]);
@@ -288,16 +277,17 @@
       .to.be.deep.contains(adminEth.toLocaleLowerCase());
   });
 
-  itEth.skip('(!negative tests!) Remove substrate admin by USER is not allowed', async ({helper}) => {
+  itEth('(!negative tests!) Remove [cross] admin by USER is not allowed', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
 
     const [adminSub] = await helper.arrange.createAccounts([10n], donor);
+    const adminSubCross = helper.ethCrossAccount.fromKeyringPair(adminSub);
     const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
-    await collectionEvm.methods.addCollectionAdminSubstrate(adminSub.addressRaw).send();
+    await collectionEvm.methods.addCollectionAdminCross(adminSubCross).send();
     const notAdminEth = await helper.eth.createAccountWithBalance(donor);
 
-    await expect(collectionEvm.methods.removeCollectionAdminSubstrate(adminSub.addressRaw).call({from: notAdminEth}))
+    await expect(collectionEvm.methods.removeCollectionAdminCross(adminSubCross).call({from: notAdminEth}))
       .to.be.rejectedWith('NoPermission');
 
     const adminList = await helper.callRpc('api.rpc.unique.adminlist', [collectionId]);
@@ -358,19 +348,20 @@
     });
   });
 
-  itEth.skip('Change owner', async ({helper}) => {
+  itEth('Change owner [cross]', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const [newOwner] = await helper.arrange.createAccounts([10n], donor);
+    const newOwnerCross = helper.ethCrossAccount.fromKeyringPair(newOwner);
     const {collectionAddress} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
     const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
 
     expect(await collectionEvm.methods.isOwnerOrAdmin(owner).call()).to.be.true;
-    expect(await collectionEvm.methods.isOwnerOrAdminSubstrate(newOwner.addressRaw).call()).to.be.false;
+    expect(await collectionEvm.methods.isOwnerOrAdminCross(newOwnerCross).call()).to.be.false;
 
-    await collectionEvm.methods.setOwnerSubstrate(newOwner.addressRaw).send();
+    await collectionEvm.methods.setOwnerCross(newOwnerCross).send();
 
     expect(await collectionEvm.methods.isOwnerOrAdmin(owner).call()).to.be.false;
-    expect(await collectionEvm.methods.isOwnerOrAdminSubstrate(newOwner.addressRaw).call()).to.be.true;
+    expect(await collectionEvm.methods.isOwnerOrAdminCross(newOwnerCross).call()).to.be.true;
   });
 
   itEth.skip('change owner call fee', async ({helper}) => {
@@ -384,14 +375,15 @@
     expect(cost > 0);
   });
 
-  itEth.skip('(!negative tests!) call setOwner by non owner', async ({helper}) => {
+  itEth('(!negative tests!) call setOwner by non owner [cross]', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const otherReceiver = await helper.eth.createAccountWithBalance(donor);
     const [newOwner] = await helper.arrange.createAccounts([10n], donor);
+    const newOwnerCross = helper.ethCrossAccount.fromKeyringPair(newOwner);
     const {collectionAddress} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
     const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
 
-    await expect(collectionEvm.methods.setOwnerSubstrate(newOwner.addressRaw).send({from: otherReceiver})).to.be.rejected;
-    expect(await collectionEvm.methods.isOwnerOrAdminSubstrate(newOwner.addressRaw).call()).to.be.false;
+    await expect(collectionEvm.methods.setOwnerCross(newOwnerCross).send({from: otherReceiver})).to.be.rejected;
+    expect(await collectionEvm.methods.isOwnerOrAdminCross(newOwnerCross).call()).to.be.false;
   });
 });

--- a/tests/src/eth/createFTCollection.test.ts
+++ b/tests/src/eth/createFTCollection.test.ts
@@ -30,50 +30,6 @@
       donor = await privateKey({filename: __filename});
     });
   });
-
-  itEth('Create collection', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    
-    const name = 'CollectionEVM';
-    const description = 'Some description';
-    const prefix = 'token prefix';
-  
-    // todo:playgrounds this might fail when in async environment.
-    const collectionCountBefore = +(await helper.callRpc('api.rpc.unique.collectionStats')).created;
-
-    const {collectionId} = await helper.eth.createFungibleCollection(owner, name, DECIMALS, description, prefix);
-    
-    const collectionCountAfter = +(await helper.callRpc('api.rpc.unique.collectionStats')).created;
-    const data = (await helper.ft.getData(collectionId))!;
-
-    expect(collectionCountAfter - collectionCountBefore).to.be.eq(1);
-    expect(collectionId).to.be.eq(collectionCountAfter);
-    expect(data.name).to.be.eq(name);
-    expect(data.description).to.be.eq(description);
-    expect(data.raw.tokenPrefix).to.be.eq(prefix);
-    expect(data.raw.mode).to.be.deep.eq({Fungible: DECIMALS.toString()});
-  });
-
-  // todo:playgrounds this test will fail when in async environment.
-  itEth('Check collection address exist', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-
-    const expectedCollectionId = +(await helper.callRpc('api.rpc.unique.collectionStats')).created + 1;
-    const expectedCollectionAddress = helper.ethAddress.fromCollectionId(expectedCollectionId);
-    const collectionHelpers = helper.ethNativeContract.collectionHelpers(owner);
-
-    expect(await collectionHelpers.methods
-      .isCollectionExist(expectedCollectionAddress)
-      .call()).to.be.false;
-
-    
-    await helper.eth.createFungibleCollection(owner, 'A', DECIMALS, 'A', 'A');
-
-    
-    expect(await collectionHelpers.methods
-      .isCollectionExist(expectedCollectionAddress)
-      .call()).to.be.true;
-  });
   
   itEth('Set sponsorship', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);

--- a/tests/src/eth/createNFTCollection.test.ts
+++ b/tests/src/eth/createNFTCollection.test.ts
@@ -28,45 +28,6 @@
     });
   });
 
-  itEth('Create collection', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-
-    const name = 'CollectionEVM';
-    const description = 'Some description';
-    const prefix = 'token prefix';
-
-    // todo:playgrounds this might fail when in async environment.
-    const collectionCountBefore = +(await helper.callRpc('api.rpc.unique.collectionStats')).created;
-    const {collectionId, collectionAddress, events} = await helper.eth.createNFTCollection(owner, name, description, prefix);
-    
-    expect(events).to.be.deep.equal([
-      {
-        address: '0x6C4E9fE1AE37a41E93CEE429e8E1881aBdcbb54F',
-        event: 'CollectionCreated',
-        args: {
-          owner: owner,
-          collectionId: collectionAddress,
-        },
-      },
-    ]);
-    
-    const collectionCountAfter = +(await helper.callRpc('api.rpc.unique.collectionStats')).created;
-
-    const collection = helper.nft.getCollectionObject(collectionId);
-    const data = (await collection.getData())!;
-
-    expect(collectionCountAfter - collectionCountBefore).to.be.eq(1);
-    expect(collectionId).to.be.eq(collectionCountAfter);
-    expect(data.name).to.be.eq(name);
-    expect(data.description).to.be.eq(description);
-    expect(data.raw.tokenPrefix).to.be.eq(prefix);
-    expect(data.raw.mode).to.be.eq('NFT');
-
-    const options = await collection.getOptions();
-
-    expect(options.tokenPropertyPermissions).to.be.empty;
-  });
-
   itEth('Create collection with properties', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
 
@@ -107,27 +68,6 @@
         permission: {mutable: true, collectionAdmin: true, tokenOwner: false},
       },
     ]);
-  });
-
-  // this test will occasionally fail when in async environment.
-  itEth.skip('Check collection address exist', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-
-    const expectedCollectionId = +(await helper.callRpc('api.rpc.unique.collectionStats')).created + 1;
-    const expectedCollectionAddress = helper.ethAddress.fromCollectionId(expectedCollectionId);
-    const collectionHelpers = helper.ethNativeContract.collectionHelpers(owner);
-
-    expect(await collectionHelpers.methods
-      .isCollectionExist(expectedCollectionAddress)
-      .call()).to.be.false;
-
-    await collectionHelpers.methods
-      .createNFTCollection('A', 'A', 'A')
-      .send({value: Number(2n * helper.balance.getOneTokenNominal())});
-
-    expect(await collectionHelpers.methods
-      .isCollectionExist(expectedCollectionAddress)
-      .call()).to.be.true;
   });
 
   itEth('Set sponsorship', async ({helper}) => {

--- a/tests/src/eth/fungible.test.ts
+++ b/tests/src/eth/fungible.test.ts
@@ -52,11 +52,12 @@
 describe('Fungible: Plain calls', () => {
   let donor: IKeyringPair;
   let alice: IKeyringPair;
+  let owner: IKeyringPair;
 
   before(async function() {
     await usingEthPlaygrounds(async (helper, privateKey) => {
       donor = await privateKey({filename: __filename});
-      [alice] = await helper.arrange.createAccounts([20n], donor);
+      [alice, owner] = await helper.arrange.createAccounts([20n, 20n], donor);
     });
   });
 
@@ -148,21 +149,20 @@
     }
   });
 
-  itEth('Can perform burnFromCross()', async ({helper, privateKey}) => {
-    const alice = await privateKey('//Alice');
-    const sender = await helper.eth.createAccountWithBalance(alice, 100n);
+  itEth('Can perform burnFromCross()', async ({helper}) => {
+    const sender = await helper.eth.createAccountWithBalance(donor, 100n);
 
-    const collection = await helper.ft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'}, 0);
+    const collection = await helper.ft.mintCollection(owner, {name: 'A', description: 'B', tokenPrefix: 'C'}, 0);
 
-    await collection.mint(alice, 200n, {Substrate: alice.address});
-    await collection.approveTokens(alice, {Ethereum: sender}, 100n);
+    await collection.mint(owner, 200n, {Substrate: owner.address});
+    await collection.approveTokens(owner, {Ethereum: sender}, 100n);
 
     const address = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(address, 'ft');
 
-    const fromBalanceBefore = await collection.getBalance({Substrate: alice.address});
+    const fromBalanceBefore = await collection.getBalance({Substrate: owner.address});
     
-    const ownerCross = helper.ethCrossAccount.fromKeyringPair(alice);
+    const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);
     const result = await contract.methods.burnFromCross(ownerCross, 49).send({from: sender});
     const events = result.events;
 
@@ -171,7 +171,7 @@
         address: helper.ethAddress.fromCollectionId(collection.collectionId),
         event: 'Transfer',
         returnValues: {
-          from: helper.address.substrateToEth(alice.address),
+          from: helper.address.substrateToEth(owner.address),
           to: '0x0000000000000000000000000000000000000000',
           value: '49',
         },
@@ -179,7 +179,7 @@
       Approval: {
         address: helper.ethAddress.fromCollectionId(collection.collectionId),
         returnValues: {
-          owner: helper.address.substrateToEth(alice.address),
+          owner: helper.address.substrateToEth(owner.address),
           spender: sender,
           value: '51',
         },
@@ -187,7 +187,7 @@
       },
     });
 
-    const fromBalanceAfter = await collection.getBalance({Substrate: alice.address});
+    const fromBalanceAfter = await collection.getBalance({Substrate: owner.address});
     expect(fromBalanceBefore - fromBalanceAfter).to.be.eq(49n);
   });
 
@@ -261,23 +261,22 @@
   });
 
   itEth('Can perform transferFromCross()', async ({helper, privateKey}) => {
-    const alice = await privateKey('//Alice');
-    const sender = await helper.eth.createAccountWithBalance(alice, 100n);
+    const sender = await helper.eth.createAccountWithBalance(donor, 100n);
 
-    const collection = await helper.ft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'}, 0);
+    const collection = await helper.ft.mintCollection(owner, {name: 'A', description: 'B', tokenPrefix: 'C'}, 0);
 
     const receiver = helper.eth.createAccount();
 
-    await collection.mint(alice, 200n, {Substrate: alice.address});
-    await collection.approveTokens(alice, {Ethereum: sender}, 100n);
+    await collection.mint(owner, 200n, {Substrate: owner.address});
+    await collection.approveTokens(owner, {Ethereum: sender}, 100n);
 
     const address = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(address, 'ft');
 
-    const from = helper.ethCrossAccount.fromKeyringPair(alice);
+    const from = helper.ethCrossAccount.fromKeyringPair(owner);
     const to = helper.ethCrossAccount.fromAddress(receiver);
 
-    const fromBalanceBefore = await collection.getBalance({Substrate: alice.address});
+    const fromBalanceBefore = await collection.getBalance({Substrate: owner.address});
     const toBalanceBefore = await collection.getBalance({Ethereum: receiver});
     
     const result = await contract.methods.transferFromCross(from, to, 51).send({from: sender});
@@ -287,7 +286,7 @@
         address,
         event: 'Transfer',
         returnValues: {
-          from: helper.address.substrateToEth(alice.address),
+          from: helper.address.substrateToEth(owner.address),
           to: receiver,
           value: '51',
         },
@@ -296,13 +295,13 @@
         address,
         event: 'Approval',
         returnValues: {
-          owner: helper.address.substrateToEth(alice.address),
+          owner: helper.address.substrateToEth(owner.address),
           spender: sender,
           value: '49',
         },
       }});
 
-    const fromBalanceAfter = await collection.getBalance({Substrate: alice.address});
+    const fromBalanceAfter = await collection.getBalance({Substrate: owner.address});
     expect(fromBalanceBefore - fromBalanceAfter).to.be.eq(51n);
     const toBalanceAfter = await collection.getBalance({Ethereum: receiver});
     expect(toBalanceAfter - toBalanceBefore).to.be.eq(51n);
@@ -365,11 +364,12 @@
 describe('Fungible: Substrate calls', () => {
   let donor: IKeyringPair;
   let alice: IKeyringPair;
+  let owner: IKeyringPair;
 
   before(async function() {
     await usingEthPlaygrounds(async (helper, privateKey) => {
       donor = await privateKey({filename: __filename});
-      [alice] = await helper.arrange.createAccounts([20n], donor);
+      [alice, owner] = await helper.arrange.createAccounts([20n, 20n], donor);
     });
   });
 
@@ -455,20 +455,19 @@
   });
 
   itEth('Events emitted for transferFromCross()', async ({helper, privateKey}) => {
-    const alice = await privateKey('//Alice');
-    const sender = await helper.eth.createAccountWithBalance(alice, 100n);
+    const sender = await helper.eth.createAccountWithBalance(donor, 100n);
 
-    const collection = await helper.ft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'}, 0);
+    const collection = await helper.ft.mintCollection(owner, {name: 'A', description: 'B', tokenPrefix: 'C'}, 0);
 
     const receiver = helper.eth.createAccount();
 
-    await collection.mint(alice, 200n, {Substrate: alice.address});
-    await collection.approveTokens(alice, {Ethereum: sender}, 100n);
+    await collection.mint(owner, 200n, {Substrate: owner.address});
+    await collection.approveTokens(owner, {Ethereum: sender}, 100n);
 
     const address = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(address, 'ft');
 
-    const from = helper.ethCrossAccount.fromKeyringPair(alice);
+    const from = helper.ethCrossAccount.fromKeyringPair(owner);
     const to = helper.ethCrossAccount.fromAddress(receiver);
     
     const result = await contract.methods.transferFromCross(from, to, 51).send({from: sender});
@@ -478,7 +477,7 @@
         address,
         event: 'Transfer',
         returnValues: {
-          from: helper.address.substrateToEth(alice.address),
+          from: helper.address.substrateToEth(owner.address),
           to: receiver,
           value: '51',
         },
@@ -487,7 +486,7 @@
         address,
         event: 'Approval',
         returnValues: {
-          owner: helper.address.substrateToEth(alice.address),
+          owner: helper.address.substrateToEth(owner.address),
           spender: sender,
           value: '49',
         },

--- a/tests/src/eth/fungibleAbi.json
+++ b/tests/src/eth/fungibleAbi.json
@@ -62,10 +62,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "newAdmin",
         "type": "tuple"
       }
@@ -88,10 +88,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "user",
         "type": "tuple"
       }
@@ -134,10 +134,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "spender",
         "type": "tuple"
       },
@@ -171,10 +171,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "from",
         "type": "tuple"
       },
@@ -200,10 +200,10 @@
     "outputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6[]",
+        "internalType": "struct EthCrossAccount[]",
         "name": "",
         "type": "tuple[]"
       }
@@ -217,10 +217,10 @@
     "outputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "",
         "type": "tuple"
       }
@@ -239,7 +239,7 @@
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
         ],
-        "internalType": "struct Tuple10[]",
+        "internalType": "struct Tuple14[]",
         "name": "",
         "type": "tuple[]"
       }
@@ -263,7 +263,7 @@
           { "internalType": "address", "name": "field_0", "type": "address" },
           { "internalType": "uint256", "name": "field_1", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct Tuple8",
         "name": "",
         "type": "tuple"
       }
@@ -328,10 +328,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "user",
         "type": "tuple"
       }
@@ -358,7 +358,7 @@
           { "internalType": "address", "name": "field_0", "type": "address" },
           { "internalType": "uint256", "name": "field_1", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6[]",
+        "internalType": "struct Tuple8[]",
         "name": "amounts",
         "type": "tuple[]"
       }
@@ -388,10 +388,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "admin",
         "type": "tuple"
       }
@@ -421,10 +421,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "user",
         "type": "tuple"
       }
@@ -496,7 +496,7 @@
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
         ],
-        "internalType": "struct Tuple10[]",
+        "internalType": "struct Tuple14[]",
         "name": "properties",
         "type": "tuple[]"
       }
@@ -529,10 +529,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "sponsor",
         "type": "tuple"
       }
@@ -546,10 +546,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "newOwner",
         "type": "tuple"
       }
@@ -607,19 +607,19 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "from",
         "type": "tuple"
       },
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "to",
         "type": "tuple"
       },

--- a/tests/src/eth/nonFungible.test.ts
+++ b/tests/src/eth/nonFungible.test.ts
@@ -138,12 +138,14 @@
 
 describe('NFT: Plain calls', () => {
   let donor: IKeyringPair;
-  let alice: IKeyringPair;
+  let minter: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
 
   before(async function() {
     await usingEthPlaygrounds(async (helper, privateKey) => {
       donor = await privateKey({filename: __filename});
-      [alice] = await helper.arrange.createAccounts([10n], donor);
+      [minter, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
     });
   });
 
@@ -176,8 +178,8 @@
     const caller = await helper.eth.createAccountWithBalance(donor);
     const receiver = helper.eth.createAccount();
 
-    const collection = await helper.nft.mintCollection(alice);
-    await collection.addAdmin(alice, {Ethereum: caller});
+    const collection = await helper.nft.mintCollection(minter);
+    await collection.addAdmin(minter, {Ethereum: caller});
 
     const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', caller);
@@ -208,8 +210,8 @@
   itEth('Can perform burn()', async ({helper}) => {
     const caller = await helper.eth.createAccountWithBalance(donor);
 
-    const collection = await helper.nft.mintCollection(alice, {});
-    const {tokenId} = await collection.mintToken(alice, {Ethereum: caller});
+    const collection = await helper.nft.mintCollection(minter, {});
+    const {tokenId} = await collection.mintToken(minter, {Ethereum: caller});
 
     const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', caller);
@@ -229,8 +231,8 @@
     const owner = await helper.eth.createAccountWithBalance(donor);
     const spender = helper.eth.createAccount();
 
-    const collection = await helper.nft.mintCollection(alice, {});
-    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});
+    const collection = await helper.nft.mintCollection(minter, {});
+    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});
 
     const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
@@ -246,14 +248,13 @@
     }
   });
 
-  itEth('Can perform burnFromCross()', async ({helper, privateKey}) => {
-    const alice = await privateKey('//Alice');
-    const collection = await helper.nft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+  itEth('Can perform burnFromCross()', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const owner = await privateKey('//Bob');
-    const spender = await helper.eth.createAccountWithBalance(alice, 100n);
+    const owner = bob;
+    const spender = await helper.eth.createAccountWithBalance(donor, 100n);
 
-    const token = await collection.mintToken(alice, {Substrate: owner.address});
+    const token = await collection.mintToken(minter, {Substrate: owner.address});
 
     const address = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(address, 'nft');
@@ -276,14 +277,13 @@
     }
   });
 
-  itEth('Can perform approveCross()', async ({helper, privateKey}) => {
-    const alice = await privateKey('//Alice');
-    const collection = await helper.nft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+  itEth('Can perform approveCross()', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const owner = await helper.eth.createAccountWithBalance(alice, 100n);
-    const receiver = await privateKey('//Charlie');
+    const owner = await helper.eth.createAccountWithBalance(donor, 100n);
+    const receiver = charlie;
 
-    const token = await collection.mintToken(alice, {Ethereum: owner});
+    const token = await collection.mintToken(minter, {Ethereum: owner});
 
     const address = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(address, 'nft');
@@ -309,8 +309,8 @@
     const spender = await helper.eth.createAccountWithBalance(donor);
     const receiver = helper.eth.createAccount();
 
-    const collection = await helper.nft.mintCollection(alice, {});
-    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});
+    const collection = await helper.nft.mintCollection(minter, {});
+    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});
 
     const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
@@ -338,12 +338,46 @@
     }
   });
 
+  itEth('Can perform transferFromCross()', async ({helper, privateKey}) => {
+    const minter = await privateKey('//Alice');
+    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+
+    const owner = await privateKey('//Bob');
+    const spender = await helper.eth.createAccountWithBalance(donor);
+    const receiver = await privateKey('//Charlie');
+
+    const token = await collection.mintToken(minter, {Substrate: owner.address});
+
+    const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+    const contract = helper.ethNativeContract.collection(address, 'nft');
+
+    await token.approve(owner, {Ethereum: spender});
+
+    {
+      const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);
+      const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);
+      const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender});
+      const event = result.events.Transfer;
+      expect(event).to.be.like({
+        address: helper.ethAddress.fromCollectionId(collection.collectionId),
+        event: 'Transfer',
+        returnValues: {
+          from: helper.address.substrateToEth(owner.address),
+          to: helper.address.substrateToEth(receiver.address),
+          tokenId: token.tokenId.toString(),
+        },
+      });
+    }
+
+    expect(await token.getOwner()).to.be.like({Substrate: receiver.address});
+  });
+
   itEth('Can perform transfer()', async ({helper}) => {
-    const collection = await helper.nft.mintCollection(alice, {});
+    const collection = await helper.nft.mintCollection(minter, {});
     const owner = await helper.eth.createAccountWithBalance(donor);
     const receiver = helper.eth.createAccount();
 
-    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});
+    const {tokenId} = await collection.mintToken(minter, {Ethereum: owner});
 
     const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
@@ -373,11 +407,13 @@
 describe('NFT: Fees', () => {
   let donor: IKeyringPair;
   let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
 
   before(async function() {
     await usingEthPlaygrounds(async (helper, privateKey) => {
       donor = await privateKey({filename: __filename});
-      [alice] = await helper.arrange.createAccounts([10n], donor);
+      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
     });
   });
 
@@ -410,14 +446,14 @@
   });
 
   itEth('Can perform transferFromCross()', async ({helper, privateKey}) => {
-    const alice = await privateKey('//Alice');
-    const collection = await helper.nft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    const collectionMinter = alice;
+    const owner = bob;
+    const receiver = charlie;
+    const collection = await helper.nft.mintCollection(collectionMinter, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const owner = await privateKey('//Bob');
-    const spender = await helper.eth.createAccountWithBalance(alice, 100n);
-    const receiver = await privateKey('//Charlie');
+    const spender = await helper.eth.createAccountWithBalance(donor, 100n);
 
-    const token = await collection.mintToken(alice, {Substrate: owner.address});
+    const token = await collection.mintToken(collectionMinter, {Substrate: owner.address});
 
     const address = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(address, 'nft');

--- a/tests/src/eth/nonFungibleAbi.json
+++ b/tests/src/eth/nonFungibleAbi.json
@@ -93,10 +93,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "newAdmin",
         "type": "tuple"
       }
@@ -119,10 +119,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "user",
         "type": "tuple"
       }
@@ -155,10 +155,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "approved",
         "type": "tuple"
       },
@@ -201,10 +201,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "from",
         "type": "tuple"
       },
@@ -230,10 +230,10 @@
     "outputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6[]",
+        "internalType": "struct EthCrossAccount[]",
         "name": "",
         "type": "tuple[]"
       }
@@ -247,10 +247,10 @@
     "outputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "",
         "type": "tuple"
       }
@@ -269,7 +269,7 @@
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
         ],
-        "internalType": "struct Tuple19[]",
+        "internalType": "struct Tuple21[]",
         "name": "",
         "type": "tuple[]"
       }
@@ -293,7 +293,7 @@
           { "internalType": "address", "name": "field_0", "type": "address" },
           { "internalType": "uint256", "name": "field_1", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct Tuple24",
         "name": "",
         "type": "tuple"
       }
@@ -387,10 +387,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "user",
         "type": "tuple"
       }
@@ -470,10 +470,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "admin",
         "type": "tuple"
       }
@@ -503,10 +503,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "user",
         "type": "tuple"
       }
@@ -611,7 +611,7 @@
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
         ],
-        "internalType": "struct Tuple19[]",
+        "internalType": "struct Tuple21[]",
         "name": "properties",
         "type": "tuple[]"
       }
@@ -644,10 +644,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "sponsor",
         "type": "tuple"
       }
@@ -661,10 +661,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "newOwner",
         "type": "tuple"
       }
@@ -682,7 +682,7 @@
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
         ],
-        "internalType": "struct Tuple19[]",
+        "internalType": "struct Tuple21[]",
         "name": "properties",
         "type": "tuple[]"
       }
@@ -791,19 +791,19 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "from",
         "type": "tuple"
       },
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "to",
         "type": "tuple"
       },

--- a/tests/src/eth/reFungible.test.ts
+++ b/tests/src/eth/reFungible.test.ts
@@ -104,12 +104,16 @@
 
 describe('Refungible: Plain calls', () => {
   let donor: IKeyringPair;
+  let minter: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
 
   before(async function() {
     await usingEthPlaygrounds(async (helper, privateKey) => {
       requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
 
       donor = await privateKey({filename: __filename});
+      [minter, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
     });
   });
 
@@ -227,14 +231,13 @@
     }
   });
 
-  itEth('Can perform burnFrom()', async ({helper, privateKey}) => {
-    const alice = await privateKey('//Alice');
-    const collection = await helper.rft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+  itEth('Can perform burnFrom()', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const owner = await helper.eth.createAccountWithBalance(alice, 100n);
-    const spender = await helper.eth.createAccountWithBalance(alice, 100n);
+    const owner = await helper.eth.createAccountWithBalance(donor, 100n);
+    const spender = await helper.eth.createAccountWithBalance(donor, 100n);
 
-    const token = await collection.mintToken(alice, 100n, {Ethereum: owner});
+    const token = await collection.mintToken(minter, 100n, {Ethereum: owner});
 
     const address = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(address, 'rft');
@@ -260,15 +263,14 @@
 
     expect(await collection.getTokenBalance(token.tokenId, {Ethereum: owner})).to.be.eq(0n);
   });
-
-  itEth('Can perform burnFromCross()', async ({helper, privateKey}) => {
-    const alice = await privateKey('//Alice');
-    const collection = await helper.rft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const owner = await privateKey('//Bob');
-    const spender = await helper.eth.createAccountWithBalance(alice, 100n);
+  itEth('Can perform burnFromCross()', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    
+    const owner = bob;
+    const spender = await helper.eth.createAccountWithBalance(donor, 100n);
 
-    const token = await collection.mintToken(alice, 100n, {Substrate: owner.address});
+    const token = await collection.mintToken(minter, 100n, {Substrate: owner.address});
 
     const address = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(address, 'rft');
@@ -294,15 +296,14 @@
     expect(await collection.getTokenBalance(token.tokenId, {Substrate: owner.address})).to.be.eq(0n);
   });
 
-  itEth('Can perform transferFromCross()', async ({helper, privateKey}) => {
-    const alice = await privateKey('//Alice');
-    const collection = await helper.rft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+  itEth('Can perform transferFromCross()', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const owner = await privateKey('//Bob');
-    const spender = await helper.eth.createAccountWithBalance(alice, 100n);
-    const receiver = await privateKey('//Charlie');
+    const owner = bob;
+    const spender = await helper.eth.createAccountWithBalance(donor, 100n);
+    const receiver = charlie;
 
-    const token = await collection.mintToken(alice, 100n, {Substrate: owner.address});
+    const token = await collection.mintToken(minter, 100n, {Substrate: owner.address});
 
     const address = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(address, 'rft');

--- a/tests/src/eth/reFungibleAbi.json
+++ b/tests/src/eth/reFungibleAbi.json
@@ -93,10 +93,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "newAdmin",
         "type": "tuple"
       }
@@ -119,10 +119,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "user",
         "type": "tuple"
       }
@@ -183,10 +183,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "from",
         "type": "tuple"
       },
@@ -212,10 +212,10 @@
     "outputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6[]",
+        "internalType": "struct EthCrossAccount[]",
         "name": "",
         "type": "tuple[]"
       }
@@ -229,10 +229,10 @@
     "outputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "",
         "type": "tuple"
       }
@@ -251,7 +251,7 @@
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
         ],
-        "internalType": "struct Tuple19[]",
+        "internalType": "struct Tuple20[]",
         "name": "",
         "type": "tuple[]"
       }
@@ -275,7 +275,7 @@
           { "internalType": "address", "name": "field_0", "type": "address" },
           { "internalType": "uint256", "name": "field_1", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct Tuple23",
         "name": "",
         "type": "tuple"
       }
@@ -369,10 +369,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "user",
         "type": "tuple"
       }
@@ -452,10 +452,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "admin",
         "type": "tuple"
       }
@@ -485,10 +485,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "user",
         "type": "tuple"
       }
@@ -593,7 +593,7 @@
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
         ],
-        "internalType": "struct Tuple19[]",
+        "internalType": "struct Tuple20[]",
         "name": "properties",
         "type": "tuple[]"
       }
@@ -626,10 +626,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "sponsor",
         "type": "tuple"
       }
@@ -643,10 +643,10 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "newOwner",
         "type": "tuple"
       }
@@ -664,7 +664,7 @@
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
         ],
-        "internalType": "struct Tuple19[]",
+        "internalType": "struct Tuple20[]",
         "name": "properties",
         "type": "tuple[]"
       }
@@ -782,19 +782,19 @@
     "inputs": [
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "from",
         "type": "tuple"
       },
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+          { "internalType": "address", "name": "eth", "type": "address" },
+          { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-        "internalType": "struct Tuple6",
+        "internalType": "struct EthCrossAccount",
         "name": "to",
         "type": "tuple"
       },

--- a/tests/src/eth/scheduling.test.ts
+++ b/tests/src/eth/scheduling.test.ts
@@ -27,7 +27,8 @@
   });
 
   itEth.ifWithPallets('Successfully schedules and periodically executes an EVM contract', [Pallets.Scheduler], async ({helper, privateKey}) => {
-    const alice = await privateKey('//Alice');
+    const donor = await privateKey({filename: __filename});
+    const [alice] = await helper.arrange.createAccounts([1000n], donor);
 
     const scheduledId = await helper.arrange.makeScheduledId();
 

--- a/tests/src/eth/util/playgrounds/types.ts
+++ b/tests/src/eth/util/playgrounds/types.ts
@@ -14,10 +14,8 @@
   args: { [key: string]: string }
 };
 export interface TEthCrossAccount {
-  readonly 0: string,
-  readonly 1: string | Uint8Array,
-  readonly field_0: string,
-  readonly field_1: string | Uint8Array,
+  readonly eth: string,
+  readonly sub: string | Uint8Array,
 }
 
 export type EthProperty = string[];

--- a/tests/src/eth/util/playgrounds/unique.dev.ts
+++ b/tests/src/eth/util/playgrounds/unique.dev.ts
@@ -364,19 +364,15 @@
 export class EthCrossAccountGroup extends EthGroupBase {
   fromAddress(address: TEthereumAccount): TEthCrossAccount {
     return {
-      0: address,
-      1: '0',
-      field_0: address,
-      field_1: '0',
+      eth: address,
+      sub: '0',
     };
   }
 
   fromKeyringPair(keyring: IKeyringPair): TEthCrossAccount {
     return {
-      0: '0x0000000000000000000000000000000000000000',
-      1: keyring.addressRaw,
-      field_0: '0x0000000000000000000000000000000000000000',
-      field_1: keyring.addressRaw,
+      eth: '0x0000000000000000000000000000000000000000',
+      sub: keyring.addressRaw,
     };
   }
 }
@@ -387,9 +383,9 @@
 
   eth: EthGroup;
   ethAddress: EthAddressGroup;
+  ethCrossAccount: EthCrossAccountGroup;
   ethNativeContract: NativeContractGroup;
   ethContract: ContractGroup;
-  ethCrossAccount: EthCrossAccountGroup;
   ethProperty: EthPropertyGroup;
 
   constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {