git.delta.rocks / unique-network / refs/commits / 0257bf04211b

difftreelog

fix after rebase

Trubnikov Sergey2022-10-28parent: #cdd6fac.patch.diff
in: master

25 files changed

modifiedCargo.lockdiffbeforeafterboth
before · Cargo.lock
1047 packageslockfile v3
after · Cargo.lock
1012 packageslockfile v3
modifiedcrates/evm-coder/CHANGELOG.mddiffbeforeafterboth
--- a/crates/evm-coder/CHANGELOG.md
+++ b/crates/evm-coder/CHANGELOG.md
@@ -15,7 +15,7 @@
 
  - Implementation `AbiWrite` for tuples.
 
- ### Fixes 
+ ### Fixes
 
  - Tuple generation for solidity.
modifiedcrates/evm-coder/Cargo.tomldiffbeforeafterboth
--- a/crates/evm-coder/Cargo.toml
+++ b/crates/evm-coder/Cargo.toml
@@ -21,7 +21,7 @@
 # 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.29" }
+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
modifiedcrates/evm-coder/src/solidity.rsdiffbeforeafterboth
--- a/crates/evm-coder/src/solidity.rs
+++ b/crates/evm-coder/src/solidity.rs
@@ -522,7 +522,7 @@
 				self.custom_signature.as_str()
 			)?;
 		}
-		write!(writer, "\tfunction {}(", self.name)?;
+		write!(writer, "\t{hide_comment}function {}(", self.name)?;
 		self.args.solidity_name(writer, tc)?;
 		write!(writer, ")")?;
 		if is_impl {
modifiedpallets/fungible/src/stubs/UniqueFungible.rawdiffbeforeafterboth

binary blob — no preview

modifiedpallets/fungible/src/stubs/UniqueFungible.soldiffbeforeafterboth
--- a/pallets/fungible/src/stubs/UniqueFungible.sol
+++ b/pallets/fungible/src/stubs/UniqueFungible.sol
@@ -0,0 +1,643 @@
+// SPDX-License-Identifier: OTHER
+// This code is automatically generated
+
+pragma solidity >=0.8.0 <0.9.0;
+
+/// @dev common stubs holder
+contract Dummy {
+	uint8 dummy;
+	string stub_error = "this contract is implemented in native";
+}
+
+contract ERC165 is Dummy {
+	function supportsInterface(bytes4 interfaceID) external view returns (bool) {
+		require(false, stub_error);
+		interfaceID;
+		return true;
+	}
+}
+
+/// @title A contract that allows you to work with collections.
+/// @dev the ERC-165 identifier for this interface is 0xb3152af3
+contract Collection is Dummy, ERC165 {
+	/// Set collection property.
+	///
+	/// @param key Property key.
+	/// @param value Propery value.
+	/// @dev EVM selector for this function is: 0x2f073f66,
+	///  or in textual repr: setCollectionProperty(string,bytes)
+	function setCollectionProperty(string memory key, bytes memory value) public {
+		require(false, stub_error);
+		key;
+		value;
+		dummy = 0;
+	}
+
+	/// Set collection properties.
+	///
+	/// @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(Tuple14[] memory properties) public {
+		require(false, stub_error);
+		properties;
+		dummy = 0;
+	}
+
+	/// Delete collection property.
+	///
+	/// @param key Property key.
+	/// @dev EVM selector for this function is: 0x7b7debce,
+	///  or in textual repr: deleteCollectionProperty(string)
+	function deleteCollectionProperty(string memory key) public {
+		require(false, stub_error);
+		key;
+		dummy = 0;
+	}
+
+	/// Delete collection properties.
+	///
+	/// @param keys Properties keys.
+	/// @dev EVM selector for this function is: 0xee206ee3,
+	///  or in textual repr: deleteCollectionProperties(string[])
+	function deleteCollectionProperties(string[] memory keys) public {
+		require(false, stub_error);
+		keys;
+		dummy = 0;
+	}
+
+	/// Get collection property.
+	///
+	/// @dev Throws error if key not found.
+	///
+	/// @param key Property key.
+	/// @return bytes The property corresponding to the key.
+	/// @dev EVM selector for this function is: 0xcf24fd6d,
+	///  or in textual repr: collectionProperty(string)
+	function collectionProperty(string memory key) public view returns (bytes memory) {
+		require(false, stub_error);
+		key;
+		dummy;
+		return hex"";
+	}
+
+	/// Get collection properties.
+	///
+	/// @param keys Properties keys. Empty keys for all propertyes.
+	/// @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 (Tuple14[] memory) {
+		require(false, stub_error);
+		keys;
+		dummy;
+		return new Tuple14[](0);
+	}
+
+	/// Set the sponsor of the collection.
+	///
+	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
+	///
+	/// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.
+	/// @dev EVM selector for this function is: 0x7623402e,
+	///  or in textual repr: setCollectionSponsor(address)
+	function setCollectionSponsor(address sponsor) public {
+		require(false, stub_error);
+		sponsor;
+		dummy = 0;
+	}
+
+	/// Set the sponsor of the collection.
+	///
+	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
+	///
+	/// @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(EthCrossAccount)
+	///  or in the expanded repr: setCollectionSponsorCross((address,uint256))
+	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {
+		require(false, stub_error);
+		sponsor;
+		dummy = 0;
+	}
+
+	/// Whether there is a pending sponsor.
+	/// @dev EVM selector for this function is: 0x058ac185,
+	///  or in textual repr: hasCollectionPendingSponsor()
+	function hasCollectionPendingSponsor() public view returns (bool) {
+		require(false, stub_error);
+		dummy;
+		return false;
+	}
+
+	/// Collection sponsorship confirmation.
+	///
+	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.
+	/// @dev EVM selector for this function is: 0x3c50e97a,
+	///  or in textual repr: confirmCollectionSponsorship()
+	function confirmCollectionSponsorship() public {
+		require(false, stub_error);
+		dummy = 0;
+	}
+
+	/// Remove collection sponsor.
+	/// @dev EVM selector for this function is: 0x6e0326a3,
+	///  or in textual repr: removeCollectionSponsor()
+	function removeCollectionSponsor() public {
+		require(false, stub_error);
+		dummy = 0;
+	}
+
+	/// Get current sponsor.
+	///
+	/// @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 (Tuple8 memory) {
+		require(false, stub_error);
+		dummy;
+		return Tuple8(0x0000000000000000000000000000000000000000, 0);
+	}
+
+	/// Set limits for the collection.
+	/// @dev Throws error if limit not found.
+	/// @param limit Name of the limit. Valid names:
+	/// 	"accountTokenOwnershipLimit",
+	/// 	"sponsoredDataSize",
+	/// 	"sponsoredDataRateLimit",
+	/// 	"tokenLimit",
+	/// 	"sponsorTransferTimeout",
+	/// 	"sponsorApproveTimeout"
+	/// @param value Value of the limit.
+	/// @dev EVM selector for this function is: 0x6a3841db,
+	///  or in textual repr: setCollectionLimit(string,uint32)
+	function setCollectionLimit(string memory limit, uint32 value) public {
+		require(false, stub_error);
+		limit;
+		value;
+		dummy = 0;
+	}
+
+	/// Set limits for the collection.
+	/// @dev Throws error if limit not found.
+	/// @param limit Name of the limit. Valid names:
+	/// 	"ownerCanTransfer",
+	/// 	"ownerCanDestroy",
+	/// 	"transfersEnabled"
+	/// @param value Value of the limit.
+	/// @dev EVM selector for this function is: 0x993b7fba,
+	///  or in textual repr: setCollectionLimit(string,bool)
+	function setCollectionLimit(string memory limit, bool value) public {
+		require(false, stub_error);
+		limit;
+		value;
+		dummy = 0;
+	}
+
+	/// Get contract address.
+	/// @dev EVM selector for this function is: 0xf6b4dfb4,
+	///  or in textual repr: contractAddress()
+	function contractAddress() public view returns (address) {
+		require(false, stub_error);
+		dummy;
+		return 0x0000000000000000000000000000000000000000;
+	}
+
+	/// Add collection admin.
+	/// @param newAdmin Cross account administrator address.
+	/// @dev EVM selector for this function is: 0x859aa7d6,
+	///  or in textual repr: addCollectionAdminCross(EthCrossAccount)
+	///  or in the expanded repr: addCollectionAdminCross((address,uint256))
+	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {
+		require(false, stub_error);
+		newAdmin;
+		dummy = 0;
+	}
+
+	/// Remove collection admin.
+	/// @param admin Cross account administrator address.
+	/// @dev EVM selector for this function is: 0x6c0cd173,
+	///  or in textual repr: removeCollectionAdminCross(EthCrossAccount)
+	///  or in the expanded repr: removeCollectionAdminCross((address,uint256))
+	function removeCollectionAdminCross(EthCrossAccount memory admin) public {
+		require(false, stub_error);
+		admin;
+		dummy = 0;
+	}
+
+	/// Add collection admin.
+	/// @param newAdmin Address of the added administrator.
+	/// @dev EVM selector for this function is: 0x92e462c7,
+	///  or in textual repr: addCollectionAdmin(address)
+	function addCollectionAdmin(address newAdmin) public {
+		require(false, stub_error);
+		newAdmin;
+		dummy = 0;
+	}
+
+	/// Remove collection admin.
+	///
+	/// @param admin Address of the removed administrator.
+	/// @dev EVM selector for this function is: 0xfafd7b42,
+	///  or in textual repr: removeCollectionAdmin(address)
+	function removeCollectionAdmin(address admin) public {
+		require(false, stub_error);
+		admin;
+		dummy = 0;
+	}
+
+	/// Toggle accessibility of collection nesting.
+	///
+	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'
+	/// @dev EVM selector for this function is: 0x112d4586,
+	///  or in textual repr: setCollectionNesting(bool)
+	function setCollectionNesting(bool enable) public {
+		require(false, stub_error);
+		enable;
+		dummy = 0;
+	}
+
+	/// Toggle accessibility of collection nesting.
+	///
+	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'
+	/// @param collections Addresses of collections that will be available for nesting.
+	/// @dev EVM selector for this function is: 0x64872396,
+	///  or in textual repr: setCollectionNesting(bool,address[])
+	function setCollectionNesting(bool enable, address[] memory collections) public {
+		require(false, stub_error);
+		enable;
+		collections;
+		dummy = 0;
+	}
+
+	/// Set the collection access method.
+	/// @param mode Access mode
+	/// 	0 for Normal
+	/// 	1 for AllowList
+	/// @dev EVM selector for this function is: 0x41835d4c,
+	///  or in textual repr: setCollectionAccess(uint8)
+	function setCollectionAccess(uint8 mode) public {
+		require(false, stub_error);
+		mode;
+		dummy = 0;
+	}
+
+	/// Checks that user allowed to operate with collection.
+	///
+	/// @param user User address to check.
+	/// @dev EVM selector for this function is: 0xd63a8e11,
+	///  or in textual repr: allowed(address)
+	function allowed(address user) public view returns (bool) {
+		require(false, stub_error);
+		user;
+		dummy;
+		return false;
+	}
+
+	/// Add the user to the allowed list.
+	///
+	/// @param user Address of a trusted user.
+	/// @dev EVM selector for this function is: 0x67844fe6,
+	///  or in textual repr: addToCollectionAllowList(address)
+	function addToCollectionAllowList(address user) public {
+		require(false, stub_error);
+		user;
+		dummy = 0;
+	}
+
+	/// Add user to allowed list.
+	///
+	/// @param user User cross account address.
+	/// @dev EVM selector for this function is: 0xa0184a3a,
+	///  or in textual repr: addToCollectionAllowListCross(EthCrossAccount)
+	///  or in the expanded repr: addToCollectionAllowListCross((address,uint256))
+	function addToCollectionAllowListCross(EthCrossAccount memory user) public {
+		require(false, stub_error);
+		user;
+		dummy = 0;
+	}
+
+	/// Remove the user from the allowed list.
+	///
+	/// @param user Address of a removed user.
+	/// @dev EVM selector for this function is: 0x85c51acb,
+	///  or in textual repr: removeFromCollectionAllowList(address)
+	function removeFromCollectionAllowList(address user) public {
+		require(false, stub_error);
+		user;
+		dummy = 0;
+	}
+
+	/// Remove user from allowed list.
+	///
+	/// @param user User cross account address.
+	/// @dev EVM selector for this function is: 0x09ba452a,
+	///  or in textual repr: removeFromCollectionAllowListCross(EthCrossAccount)
+	///  or in the expanded repr: removeFromCollectionAllowListCross((address,uint256))
+	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {
+		require(false, stub_error);
+		user;
+		dummy = 0;
+	}
+
+	/// Switch permission for minting.
+	///
+	/// @param mode Enable if "true".
+	/// @dev EVM selector for this function is: 0x00018e84,
+	///  or in textual repr: setCollectionMintMode(bool)
+	function setCollectionMintMode(bool mode) public {
+		require(false, stub_error);
+		mode;
+		dummy = 0;
+	}
+
+	/// Check that account is the owner or admin of the collection
+	///
+	/// @param user account to verify
+	/// @return "true" if account is the owner or admin
+	/// @dev EVM selector for this function is: 0x9811b0c7,
+	///  or in textual repr: isOwnerOrAdmin(address)
+	function isOwnerOrAdmin(address user) public view returns (bool) {
+		require(false, stub_error);
+		user;
+		dummy;
+		return false;
+	}
+
+	/// Check that account is the owner or admin of the collection
+	///
+	/// @param user User cross account to verify
+	/// @return "true" if account is the owner or admin
+	/// @dev EVM selector for this function is: 0x3e75a905,
+	///  or in textual repr: isOwnerOrAdminCross(EthCrossAccount)
+	///  or in the expanded repr: isOwnerOrAdminCross((address,uint256))
+	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {
+		require(false, stub_error);
+		user;
+		dummy;
+		return false;
+	}
+
+	/// Returns collection type
+	///
+	/// @return `Fungible` or `NFT` or `ReFungible`
+	/// @dev EVM selector for this function is: 0xd34b55b8,
+	///  or in textual repr: uniqueCollectionType()
+	function uniqueCollectionType() public view returns (string memory) {
+		require(false, stub_error);
+		dummy;
+		return "";
+	}
+
+	/// Get collection owner.
+	///
+	/// @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 (EthCrossAccount memory) {
+		require(false, stub_error);
+		dummy;
+		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);
+	}
+
+	/// Changes collection owner to another account
+	///
+	/// @dev Owner can be changed only by current owner
+	/// @param newOwner new owner account
+	/// @dev EVM selector for this function is: 0x4f53e226,
+	///  or in textual repr: changeCollectionOwner(address)
+	function changeCollectionOwner(address newOwner) public {
+		require(false, stub_error);
+		newOwner;
+		dummy = 0;
+	}
+
+	/// Get collection administrators
+	///
+	/// @return Vector of tuples with admins address and his substrate mirror.
+	/// 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 (EthCrossAccount[] memory) {
+		require(false, stub_error);
+		dummy;
+		return new EthCrossAccount[](0);
+	}
+
+	/// Changes collection owner to another account
+	///
+	/// @dev Owner can be changed only by current owner
+	/// @param newOwner new owner cross account
+	/// @dev EVM selector for this function is: 0xe5c9913f,
+	///  or in textual repr: setOwnerCross(EthCrossAccount)
+	///  or in the expanded repr: setOwnerCross((address,uint256))
+	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 Tuple14 {
+	string field_0;
+	bytes field_1;
+}
+
+/// @dev the ERC-165 identifier for this interface is 0x032e5926
+contract ERC20UniqueExtensions is Dummy, ERC165 {
+	/// @dev EVM selector for this function is: 0x0ecd0ab0,
+	///  or in textual repr: approveCross(EthCrossAccount,uint256)
+	///  or in the expanded repr: approveCross((address,uint256),uint256)
+	function approveCross(EthCrossAccount memory spender, uint256 amount) public returns (bool) {
+		require(false, stub_error);
+		spender;
+		amount;
+		dummy = 0;
+		return false;
+	}
+
+	/// Burn tokens from account
+	/// @dev Function that burns an `amount` of the tokens of a given account,
+	/// deducting from the sender's allowance for said account.
+	/// @param from The account whose tokens will be burnt.
+	/// @param amount The amount that will be burnt.
+	/// @dev EVM selector for this function is: 0x79cc6790,
+	///  or in textual repr: burnFrom(address,uint256)
+	function burnFrom(address from, uint256 amount) public returns (bool) {
+		require(false, stub_error);
+		from;
+		amount;
+		dummy = 0;
+		return false;
+	}
+
+	/// Burn tokens from account
+	/// @dev Function that burns an `amount` of the tokens of a given account,
+	/// deducting from the sender's allowance for said account.
+	/// @param from The account whose tokens will be burnt.
+	/// @param amount The amount that will be burnt.
+	/// @dev EVM selector for this function is: 0xbb2f5a58,
+	///  or in textual repr: burnFromCross(EthCrossAccount,uint256)
+	///  or in the expanded repr: burnFromCross((address,uint256),uint256)
+	function burnFromCross(EthCrossAccount memory from, uint256 amount) public returns (bool) {
+		require(false, stub_error);
+		from;
+		amount;
+		dummy = 0;
+		return false;
+	}
+
+	/// 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(Tuple8[] memory amounts) public returns (bool) {
+		require(false, stub_error);
+		amounts;
+		dummy = 0;
+		return false;
+	}
+
+	/// @dev EVM selector for this function is: 0xd5cf430b,
+	///  or in textual repr: transferFromCross(EthCrossAccount,EthCrossAccount,uint256)
+	///  or in the expanded repr: transferFromCross((address,uint256),(address,uint256),uint256)
+	function transferFromCross(
+		EthCrossAccount memory from,
+		EthCrossAccount memory to,
+		uint256 amount
+	) public returns (bool) {
+		require(false, stub_error);
+		from;
+		to;
+		amount;
+		dummy = 0;
+		return false;
+	}
+}
+
+/// @dev anonymous struct
+struct Tuple8 {
+	address field_0;
+	uint256 field_1;
+}
+
+/// @dev the ERC-165 identifier for this interface is 0x40c10f19
+contract ERC20Mintable is Dummy, ERC165 {
+	/// Mint tokens for `to` account.
+	/// @param to account that will receive minted tokens
+	/// @param amount amount of tokens to mint
+	/// @dev EVM selector for this function is: 0x40c10f19,
+	///  or in textual repr: mint(address,uint256)
+	function mint(address to, uint256 amount) public returns (bool) {
+		require(false, stub_error);
+		to;
+		amount;
+		dummy = 0;
+		return false;
+	}
+}
+
+/// @dev inlined interface
+contract ERC20Events {
+	event Transfer(address indexed from, address indexed to, uint256 value);
+	event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+/// @dev the ERC-165 identifier for this interface is 0x942e8b22
+contract ERC20 is Dummy, ERC165, ERC20Events {
+	/// @dev EVM selector for this function is: 0x06fdde03,
+	///  or in textual repr: name()
+	function name() public view returns (string memory) {
+		require(false, stub_error);
+		dummy;
+		return "";
+	}
+
+	/// @dev EVM selector for this function is: 0x95d89b41,
+	///  or in textual repr: symbol()
+	function symbol() public view returns (string memory) {
+		require(false, stub_error);
+		dummy;
+		return "";
+	}
+
+	/// @dev EVM selector for this function is: 0x18160ddd,
+	///  or in textual repr: totalSupply()
+	function totalSupply() public view returns (uint256) {
+		require(false, stub_error);
+		dummy;
+		return 0;
+	}
+
+	/// @dev EVM selector for this function is: 0x313ce567,
+	///  or in textual repr: decimals()
+	function decimals() public view returns (uint8) {
+		require(false, stub_error);
+		dummy;
+		return 0;
+	}
+
+	/// @dev EVM selector for this function is: 0x70a08231,
+	///  or in textual repr: balanceOf(address)
+	function balanceOf(address owner) public view returns (uint256) {
+		require(false, stub_error);
+		owner;
+		dummy;
+		return 0;
+	}
+
+	/// @dev EVM selector for this function is: 0xa9059cbb,
+	///  or in textual repr: transfer(address,uint256)
+	function transfer(address to, uint256 amount) public returns (bool) {
+		require(false, stub_error);
+		to;
+		amount;
+		dummy = 0;
+		return false;
+	}
+
+	/// @dev EVM selector for this function is: 0x23b872dd,
+	///  or in textual repr: transferFrom(address,address,uint256)
+	function transferFrom(
+		address from,
+		address to,
+		uint256 amount
+	) public returns (bool) {
+		require(false, stub_error);
+		from;
+		to;
+		amount;
+		dummy = 0;
+		return false;
+	}
+
+	/// @dev EVM selector for this function is: 0x095ea7b3,
+	///  or in textual repr: approve(address,uint256)
+	function approve(address spender, uint256 amount) public returns (bool) {
+		require(false, stub_error);
+		spender;
+		amount;
+		dummy = 0;
+		return false;
+	}
+
+	/// @dev EVM selector for this function is: 0xdd62ed3e,
+	///  or in textual repr: allowance(address,address)
+	function allowance(address owner, address spender) public view returns (uint256) {
+		require(false, stub_error);
+		owner;
+		spender;
+		dummy;
+		return 0;
+	}
+}
+
+contract UniqueFungible is Dummy, ERC165, ERC20, ERC20Mintable, ERC20UniqueExtensions, Collection {}
modifiedpallets/nonfungible/src/erc.rsdiffbeforeafterboth
--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -20,7 +20,6 @@
 //! Method implementations are mostly doing parameter conversion and calling Nonfungible Pallet methods.
 
 extern crate alloc;
-use alloc::string::ToString;
 use core::{
 	char::{REPLACEMENT_CHARACTER, decode_utf16},
 	convert::TryInto,
@@ -44,7 +43,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;
modifiedpallets/nonfungible/src/stubs/UniqueNFT.rawdiffbeforeafterboth

binary blob — no preview

modifiedpallets/nonfungible/src/stubs/UniqueNFT.soldiffbeforeafterboth
--- 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;
@@ -104,19 +104,7 @@
 }
 
 /// @title A contract that allows you to work with collections.
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
 /// @dev the ERC-165 identifier for this interface is 0xb3152af3
-=======
-/// @dev the ERC-165 identifier for this interface is 0x674be726
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
-/// @dev the ERC-165 identifier for this interface is 0x943ee094
->>>>>>> fix: after rebase
-=======
-/// @dev the ERC-165 identifier for this interface is 0xefe988e0
->>>>>>> misk: update stubs
 contract Collection is Dummy, ERC165 {
 	/// Set collection property.
 	///
@@ -210,16 +198,10 @@
 	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
 	///
 	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0x403e96a7,
-	///  or in textual repr: setCollectionSponsorCross((address,uint256))
-	function setCollectionSponsorCross(Tuple6 memory sponsor) public {
-=======
 	/// @dev EVM selector for this function is: 0x84a1d5a8,
 	///  or in textual repr: setCollectionSponsorCross(EthCrossAccount)
 	///  or in the expanded repr: setCollectionSponsorCross((address,uint256))
 	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		sponsor;
 		dummy = 0;
@@ -257,31 +239,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()
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
-	function collectionSponsor() public view returns (Tuple6 memory) {
-		require(false, stub_error);
-		dummy;
-		return Tuple6(0x0000000000000000000000000000000000000000, 0);
-=======
-	function collectionSponsor() public view returns (Tuple19 memory) {
-		require(false, stub_error);
-		dummy;
-		return Tuple19(0x0000000000000000000000000000000000000000, 0);
->>>>>>> feat: add `EthCrossAccount` type
-=======
-	function collectionSponsor() public view returns (Tuple8 memory) {
-		require(false, stub_error);
-		dummy;
-		return Tuple8(0x0000000000000000000000000000000000000000, 0);
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
 	function collectionSponsor() public view returns (Tuple24 memory) {
 		require(false, stub_error);
 		dummy;
 		return Tuple24(0x0000000000000000000000000000000000000000, 0);
->>>>>>> misk: update stubs
 	}
 
 	/// Set limits for the collection.
@@ -330,16 +291,10 @@
 
 	/// Add collection admin.
 	/// @param newAdmin Cross account administrator address.
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0x62e3c7c2,
-	///  or in textual repr: addCollectionAdminCross((address,uint256))
-	function addCollectionAdminCross(Tuple6 memory newAdmin) public {
-=======
 	/// @dev EVM selector for this function is: 0x859aa7d6,
 	///  or in textual repr: addCollectionAdminCross(EthCrossAccount)
 	///  or in the expanded repr: addCollectionAdminCross((address,uint256))
 	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		newAdmin;
 		dummy = 0;
@@ -347,16 +302,10 @@
 
 	/// Remove collection admin.
 	/// @param admin Cross account administrator address.
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0x810d1503,
-	///  or in textual repr: removeCollectionAdminCross((address,uint256))
-	function removeCollectionAdminCross(Tuple6 memory admin) public {
-=======
 	/// @dev EVM selector for this function is: 0x6c0cd173,
 	///  or in textual repr: removeCollectionAdminCross(EthCrossAccount)
 	///  or in the expanded repr: removeCollectionAdminCross((address,uint256))
 	function removeCollectionAdminCross(EthCrossAccount memory admin) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		admin;
 		dummy = 0;
@@ -445,16 +394,10 @@
 	/// Add user to allowed list.
 	///
 	/// @param user User cross account address.
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0xf074da88,
-	///  or in textual repr: addToCollectionAllowListCross((address,uint256))
-	function addToCollectionAllowListCross(Tuple6 memory user) public {
-=======
 	/// @dev EVM selector for this function is: 0xa0184a3a,
 	///  or in textual repr: addToCollectionAllowListCross(EthCrossAccount)
 	///  or in the expanded repr: addToCollectionAllowListCross((address,uint256))
 	function addToCollectionAllowListCross(EthCrossAccount memory user) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		user;
 		dummy = 0;
@@ -474,16 +417,10 @@
 	/// Remove user from allowed list.
 	///
 	/// @param user User cross account address.
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0xc00df45c,
-	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))
-	function removeFromCollectionAllowListCross(Tuple6 memory user) public {
-=======
 	/// @dev EVM selector for this function is: 0x09ba452a,
 	///  or in textual repr: removeFromCollectionAllowListCross(EthCrossAccount)
 	///  or in the expanded repr: removeFromCollectionAllowListCross((address,uint256))
 	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		user;
 		dummy = 0;
@@ -517,16 +454,10 @@
 	///
 	/// @param user User cross account to verify
 	/// @return "true" if account is the owner or admin
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0x5aba3351,
-	///  or in textual repr: isOwnerOrAdminCross((address,uint256))
-	function isOwnerOrAdminCross(Tuple6 memory user) public view returns (bool) {
-=======
 	/// @dev EVM selector for this function is: 0x3e75a905,
 	///  or in textual repr: isOwnerOrAdminCross(EthCrossAccount)
 	///  or in the expanded repr: isOwnerOrAdminCross((address,uint256))
 	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		user;
 		dummy;
@@ -546,35 +477,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()
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
-	function collectionOwner() public view returns (Tuple6 memory) {
-		require(false, stub_error);
-		dummy;
-		return Tuple6(0x0000000000000000000000000000000000000000, 0);
-=======
-	function collectionOwner() public view returns (Tuple19 memory) {
-		require(false, stub_error);
-		dummy;
-		return Tuple19(0x0000000000000000000000000000000000000000, 0);
->>>>>>> feat: add `EthCrossAccount` type
-=======
-	function collectionOwner() public view returns (Tuple8 memory) {
-		require(false, stub_error);
-		dummy;
-		return Tuple8(0x0000000000000000000000000000000000000000, 0);
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
 	function collectionOwner() public view returns (EthCrossAccount memory) {
 		require(false, stub_error);
 		dummy;
 		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);
->>>>>>> misk: update stubs
 	}
 
 	/// Changes collection owner to another account
@@ -595,45 +505,26 @@
 	/// 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()
-<<<<<<< HEAD
-	function collectionAdmins() public view returns (Tuple6[] memory) {
-		require(false, stub_error);
-		dummy;
-		return new Tuple6[](0);
-=======
 	function collectionAdmins() public view returns (EthCrossAccount[] memory) {
 		require(false, stub_error);
 		dummy;
 		return new EthCrossAccount[](0);
->>>>>>> misk: update stubs
 	}
 
 	/// Changes collection owner to another account
 	///
 	/// @dev Owner can be changed only by current owner
 	/// @param newOwner new owner cross account
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0xbdff793d,
-	///  or in textual repr: setOwnerCross((address,uint256))
-	function setOwnerCross(Tuple6 memory newOwner) public {
-=======
 	/// @dev EVM selector for this function is: 0xe5c9913f,
 	///  or in textual repr: setOwnerCross(EthCrossAccount)
 	///  or in the expanded repr: setOwnerCross((address,uint256))
 	function setOwnerCross(EthCrossAccount memory newOwner) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		newOwner;
 		dummy = 0;
 	}
 }
 
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
-/// @dev anonymous struct
-struct Tuple19 {
-=======
 /// @dev Cross account struct
 struct EthCrossAccount {
 	address eth;
@@ -642,12 +533,16 @@
 
 /// @dev anonymous struct
 struct Tuple24 {
->>>>>>> misk: update stubs
 	address field_0;
 	uint256 field_1;
 }
 
-<<<<<<< HEAD
+/// @dev anonymous struct
+struct Tuple21 {
+	string field_0;
+	bytes field_1;
+}
+
 /// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 /// @dev See https://eips.ethereum.org/EIPS/eip-721
 /// @dev the ERC-165 identifier for this interface is 0x5b5e139f
@@ -689,20 +584,8 @@
 		dummy;
 		return "";
 	}
-}
-
-=======
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
-=======
->>>>>>> misk: update stubs
-/// @dev anonymous struct
-struct Tuple21 {
-	string field_0;
-	bytes field_1;
 }
 
->>>>>>> fix: after rebase
 /// @title ERC721 Token that can be irreversibly burned (destroyed).
 /// @dev the ERC-165 identifier for this interface is 0x42966c68
 contract ERC721Burnable is Dummy, ERC165 {
@@ -804,15 +687,7 @@
 }
 
 /// @title Unique extensions for ERC721.
-<<<<<<< HEAD
-<<<<<<< HEAD
 /// @dev the ERC-165 identifier for this interface is 0x244543ee
-=======
-/// @dev the ERC-165 identifier for this interface is 0xcc97cb35
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
-/// @dev the ERC-165 identifier for this interface is 0xb76006ac
->>>>>>> misk: update stubs
 contract ERC721UniqueExtensions is Dummy, ERC165 {
 	/// @notice A descriptive name for a collection of NFTs in this contract
 	/// @dev EVM selector for this function is: 0x06fdde03,
@@ -838,16 +713,10 @@
 	///  operator of the current owner.
 	/// @param approved The new substrate address approved NFT controller
 	/// @param tokenId The NFT to approve
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0x106fdb59,
-	///  or in textual repr: approveCross((address,uint256),uint256)
-	function approveCross(Tuple6 memory approved, uint256 tokenId) public {
-=======
 	/// @dev EVM selector for this function is: 0x0ecd0ab0,
 	///  or in textual repr: approveCross(EthCrossAccount,uint256)
 	///  or in the expanded repr: approveCross((address,uint256),uint256)
 	function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		approved;
 		tokenId;
@@ -878,13 +747,8 @@
 	///  or in textual repr: transferFromCross(EthCrossAccount,EthCrossAccount,uint256)
 	///  or in the expanded repr: transferFromCross((address,uint256),(address,uint256),uint256)
 	function transferFromCross(
-<<<<<<< HEAD
-		Tuple6 memory from,
-		Tuple6 memory to,
-=======
 		EthCrossAccount memory from,
 		EthCrossAccount memory to,
->>>>>>> feat: Add custum signature with unlimited nesting.
 		uint256 tokenId
 	) public {
 		require(false, stub_error);
@@ -915,16 +779,10 @@
 	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
 	/// @param from The current owner of the NFT
 	/// @param tokenId The NFT to transfer
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0xa8106d4a,
-	///  or in textual repr: burnFromCross((address,uint256),uint256)
-	function burnFromCross(Tuple6 memory from, uint256 tokenId) public {
-=======
 	/// @dev EVM selector for this function is: 0xbb2f5a58,
 	///  or in textual repr: burnFromCross(EthCrossAccount,uint256)
 	///  or in the expanded repr: burnFromCross((address,uint256),uint256)
 	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		from;
 		tokenId;
@@ -961,7 +819,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;
@@ -969,72 +827,14 @@
 	// 	return false;
 	// }
 
-<<<<<<< HEAD
 }
 
 /// @dev anonymous struct
-struct Tuple8 {
-=======
-	/// @notice Function to mint multiple tokens.
-	/// @dev `tokenIds` should be an array of consecutive numbers and first number
-	///  should be obtained with `nextTokenId` method
-	/// @param to The new owner
-	/// @param tokenIds IDs of the minted NFTs
-	/// @dev EVM selector for this function is: 0x44a9945e,
-	///  or in textual repr: mintBulk(address,uint256[])
-	function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {
-		require(false, stub_error);
-		to;
-		tokenIds;
-		dummy = 0;
-		return false;
-	}
-
-	/// @notice Function to mint multiple tokens with the given tokenUris.
-	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive
-	///  numbers and first number should be obtained with `nextTokenId` method
-	/// @param to The new owner
-	/// @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, Tuple12[] memory tokens) public returns (bool) {
-		require(false, stub_error);
-		to;
-		tokens;
-		dummy = 0;
-		return false;
-	}
-}
-
-/// @dev anonymous struct
-struct Tuple12 {
->>>>>>> feat: Add custum signature with unlimited nesting.
+struct Tuple10 {
 	uint256 field_0;
 	string field_1;
 }
 
-<<<<<<< HEAD
-<<<<<<< HEAD
-/// @dev anonymous struct
-struct Tuple6 {
-	address field_0;
-	uint256 field_1;
-=======
-/// @dev Cross account struct
-struct EthCrossAccount {
-	address eth;
-	uint256 sub;
->>>>>>> feat: add `EthCrossAccount` type
-}
-
-/// @dev anonymous struct
-struct Tuple8 {
-	address field_0;
-	uint256 field_1;
-}
-
-=======
->>>>>>> misk: update stubs
 /// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 /// @dev See https://eips.ethereum.org/EIPS/eip-721
 /// @dev the ERC-165 identifier for this interface is 0x780e9d63
modifiedpallets/refungible/src/stubs/UniqueRefungible.rawdiffbeforeafterboth

binary blob — no preview

modifiedpallets/refungible/src/stubs/UniqueRefungible.soldiffbeforeafterboth
--- 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;
@@ -199,14 +199,9 @@
 	///
 	/// @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,
-<<<<<<< HEAD
-	///  or in textual repr: setCollectionSponsorCross((address,uint256))
-	function setCollectionSponsorCross(Tuple6 memory sponsor) public {
-=======
 	///  or in textual repr: setCollectionSponsorCross(EthCrossAccount)
 	///  or in the expanded repr: setCollectionSponsorCross((address,uint256))
 	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		sponsor;
 		dummy = 0;
@@ -244,17 +239,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()
-<<<<<<< HEAD
-	function collectionSponsor() public view returns (Tuple6 memory) {
-		require(false, stub_error);
-		dummy;
-		return Tuple6(0x0000000000000000000000000000000000000000, 0);
-=======
 	function collectionSponsor() public view returns (Tuple23 memory) {
 		require(false, stub_error);
 		dummy;
 		return Tuple23(0x0000000000000000000000000000000000000000, 0);
->>>>>>> misk: update stubs
 	}
 
 	/// Set limits for the collection.
@@ -304,14 +292,9 @@
 	/// Add collection admin.
 	/// @param newAdmin Cross account administrator address.
 	/// @dev EVM selector for this function is: 0x859aa7d6,
-<<<<<<< HEAD
-	///  or in textual repr: addCollectionAdminCross((address,uint256))
-	function addCollectionAdminCross(Tuple6 memory newAdmin) public {
-=======
 	///  or in textual repr: addCollectionAdminCross(EthCrossAccount)
 	///  or in the expanded repr: addCollectionAdminCross((address,uint256))
 	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		newAdmin;
 		dummy = 0;
@@ -320,14 +303,9 @@
 	/// Remove collection admin.
 	/// @param admin Cross account administrator address.
 	/// @dev EVM selector for this function is: 0x6c0cd173,
-<<<<<<< HEAD
-	///  or in textual repr: removeCollectionAdminCross((address,uint256))
-	function removeCollectionAdminCross(Tuple6 memory admin) public {
-=======
 	///  or in textual repr: removeCollectionAdminCross(EthCrossAccount)
 	///  or in the expanded repr: removeCollectionAdminCross((address,uint256))
 	function removeCollectionAdminCross(EthCrossAccount memory admin) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		admin;
 		dummy = 0;
@@ -417,14 +395,9 @@
 	///
 	/// @param user User cross account address.
 	/// @dev EVM selector for this function is: 0xa0184a3a,
-<<<<<<< HEAD
-	///  or in textual repr: addToCollectionAllowListCross((address,uint256))
-	function addToCollectionAllowListCross(Tuple6 memory user) public {
-=======
 	///  or in textual repr: addToCollectionAllowListCross(EthCrossAccount)
 	///  or in the expanded repr: addToCollectionAllowListCross((address,uint256))
 	function addToCollectionAllowListCross(EthCrossAccount memory user) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		user;
 		dummy = 0;
@@ -445,14 +418,9 @@
 	///
 	/// @param user User cross account address.
 	/// @dev EVM selector for this function is: 0x09ba452a,
-<<<<<<< HEAD
-	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))
-	function removeFromCollectionAllowListCross(Tuple6 memory user) public {
-=======
 	///  or in textual repr: removeFromCollectionAllowListCross(EthCrossAccount)
 	///  or in the expanded repr: removeFromCollectionAllowListCross((address,uint256))
 	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		user;
 		dummy = 0;
@@ -487,14 +455,9 @@
 	/// @param user User cross account to verify
 	/// @return "true" if account is the owner or admin
 	/// @dev EVM selector for this function is: 0x3e75a905,
-<<<<<<< HEAD
-	///  or in textual repr: isOwnerOrAdminCross((address,uint256))
-	function isOwnerOrAdminCross(Tuple6 memory user) public view returns (bool) {
-=======
 	///  or in textual repr: isOwnerOrAdminCross(EthCrossAccount)
 	///  or in the expanded repr: isOwnerOrAdminCross((address,uint256))
 	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		user;
 		dummy;
@@ -514,21 +477,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()
-<<<<<<< HEAD
-	function collectionOwner() public view returns (Tuple6 memory) {
-		require(false, stub_error);
-		dummy;
-		return Tuple6(0x0000000000000000000000000000000000000000, 0);
-=======
 	function collectionOwner() public view returns (EthCrossAccount memory) {
 		require(false, stub_error);
 		dummy;
 		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);
->>>>>>> misk: update stubs
 	}
 
 	/// Changes collection owner to another account
@@ -549,17 +505,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()
-<<<<<<< HEAD
-	function collectionAdmins() public view returns (Tuple6[] memory) {
-		require(false, stub_error);
-		dummy;
-		return new Tuple6[](0);
-=======
 	function collectionAdmins() public view returns (EthCrossAccount[] memory) {
 		require(false, stub_error);
 		dummy;
 		return new EthCrossAccount[](0);
->>>>>>> misk: update stubs
 	}
 
 	/// Changes collection owner to another account
@@ -567,14 +516,9 @@
 	/// @dev Owner can be changed only by current owner
 	/// @param newOwner new owner cross account
 	/// @dev EVM selector for this function is: 0xe5c9913f,
-<<<<<<< HEAD
-	///  or in textual repr: setOwnerCross((address,uint256))
-	function setOwnerCross(Tuple6 memory newOwner) public {
-=======
 	///  or in textual repr: setOwnerCross(EthCrossAccount)
 	///  or in the expanded repr: setOwnerCross((address,uint256))
 	function setOwnerCross(EthCrossAccount memory newOwner) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		newOwner;
 		dummy = 0;
@@ -786,13 +730,8 @@
 	///  or in textual repr: transferFromCross(EthCrossAccount,EthCrossAccount,uint256)
 	///  or in the expanded repr: transferFromCross((address,uint256),(address,uint256),uint256)
 	function transferFromCross(
-<<<<<<< HEAD
-		Tuple6 memory from,
-		Tuple6 memory to,
-=======
 		EthCrossAccount memory from,
 		EthCrossAccount memory to,
->>>>>>> misk: update stubs
 		uint256 tokenId
 	) public {
 		require(false, stub_error);
@@ -826,14 +765,9 @@
 	/// @param from The current owner of the RFT
 	/// @param tokenId The RFT to transfer
 	/// @dev EVM selector for this function is: 0xbb2f5a58,
-<<<<<<< HEAD
-	///  or in textual repr: burnFromCross((address,uint256),uint256)
-	function burnFromCross(Tuple6 memory from, uint256 tokenId) public {
-=======
 	///  or in textual repr: burnFromCross(EthCrossAccount,uint256)
 	///  or in the expanded repr: burnFromCross((address,uint256),uint256)
 	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {
->>>>>>> misk: update stubs
 		require(false, stub_error);
 		from;
 		tokenId;
@@ -849,7 +783,6 @@
 		return 0;
 	}
 
-<<<<<<< HEAD
 	// /// @notice Function to mint multiple tokens.
 	// /// @dev `tokenIds` should be an array of consecutive numbers and first number
 	// ///  should be obtained with `nextTokenId` method
@@ -872,45 +805,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) public returns (bool) {
+	// function mintBulkWithTokenURI(address to, Tuple9[] memory tokens) public returns (bool) {
 	// 	require(false, stub_error);
 	// 	to;
 	// 	tokens;
 	// 	dummy = 0;
 	// 	return false;
 	// }
-=======
-	/// @notice Function to mint multiple tokens.
-	/// @dev `tokenIds` should be an array of consecutive numbers and first number
-	///  should be obtained with `nextTokenId` method
-	/// @param to The new owner
-	/// @param tokenIds IDs of the minted RFTs
-	/// @dev EVM selector for this function is: 0x44a9945e,
-	///  or in textual repr: mintBulk(address,uint256[])
-	function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {
-		require(false, stub_error);
-		to;
-		tokenIds;
-		dummy = 0;
-		return false;
-	}
 
-	/// @notice Function to mint multiple tokens with the given tokenUris.
-	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive
-	///  numbers and first number should be obtained with `nextTokenId` method
-	/// @param to The new owner
-	/// @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, Tuple11[] memory tokens) public returns (bool) {
-		require(false, stub_error);
-		to;
-		tokens;
-		dummy = 0;
-		return false;
-	}
->>>>>>> misk: update stubs
-
 	/// Returns EVM address for refungible token
 	///
 	/// @param token ID of the token
@@ -925,24 +827,11 @@
 }
 
 /// @dev anonymous struct
-<<<<<<< HEAD
-struct Tuple8 {
-=======
-struct Tuple11 {
->>>>>>> misk: update stubs
+struct Tuple9 {
 	uint256 field_0;
 	string field_1;
-}
-
-<<<<<<< HEAD
-/// @dev anonymous struct
-struct Tuple6 {
-	address field_0;
-	uint256 field_1;
 }
 
-=======
->>>>>>> misk: update stubs
 /// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 /// @dev See https://eips.ethereum.org/EIPS/eip-721
 /// @dev the ERC-165 identifier for this interface is 0x780e9d63
modifiedpallets/unique/src/eth/mod.rsdiffbeforeafterboth
--- a/pallets/unique/src/eth/mod.rs
+++ b/pallets/unique/src/eth/mod.rs
@@ -23,10 +23,9 @@
 	generate_stubgen, solidity, solidity_interface,
 	types::*,
 	custom_signature::{SignatureUnit, FunctionSignature, SignaturePreferences},
-	make_signature,
-, weight};
-use frame_support::{traits::Get, storage::StorageNMap};
-use crate::sp_api_hidden_includes_decl_storage::hidden_include::StorageDoubleMap;
+	make_signature, weight,
+};
+use frame_support::traits::Get;
 use crate::Pallet;
 
 use pallet_common::{
modifiedtests/src/eth/allowlist.test.tsdiffbeforeafterboth
--- a/tests/src/eth/allowlist.test.ts
+++ b/tests/src/eth/allowlist.test.ts
@@ -93,7 +93,7 @@
     const owner = await helper.eth.createAccountWithBalance(donor);
     const user = donor;
     
-    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
+    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);
     
@@ -127,7 +127,7 @@
     const notOwner = await helper.eth.createAccountWithBalance(donor);
     const user = donor;
     
-    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
+    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;
modifiedtests/src/eth/api/UniqueFungible.soldiffbeforeafterboth
--- a/tests/src/eth/api/UniqueFungible.sol
+++ b/tests/src/eth/api/UniqueFungible.sol
@@ -0,0 +1,409 @@
+// SPDX-License-Identifier: OTHER
+// This code is automatically generated
+
+pragma solidity >=0.8.0 <0.9.0;
+
+/// @dev common stubs holder
+interface Dummy {
+
+}
+
+interface ERC165 is Dummy {
+	function supportsInterface(bytes4 interfaceID) external view returns (bool);
+}
+
+/// @title A contract that allows you to work with collections.
+/// @dev the ERC-165 identifier for this interface is 0xb3152af3
+interface Collection is Dummy, ERC165 {
+	/// Set collection property.
+	///
+	/// @param key Property key.
+	/// @param value Propery value.
+	/// @dev EVM selector for this function is: 0x2f073f66,
+	///  or in textual repr: setCollectionProperty(string,bytes)
+	function setCollectionProperty(string memory key, bytes memory value) external;
+
+	/// Set collection properties.
+	///
+	/// @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(Tuple14[] memory properties) external;
+
+	/// Delete collection property.
+	///
+	/// @param key Property key.
+	/// @dev EVM selector for this function is: 0x7b7debce,
+	///  or in textual repr: deleteCollectionProperty(string)
+	function deleteCollectionProperty(string memory key) external;
+
+	/// Delete collection properties.
+	///
+	/// @param keys Properties keys.
+	/// @dev EVM selector for this function is: 0xee206ee3,
+	///  or in textual repr: deleteCollectionProperties(string[])
+	function deleteCollectionProperties(string[] memory keys) external;
+
+	/// Get collection property.
+	///
+	/// @dev Throws error if key not found.
+	///
+	/// @param key Property key.
+	/// @return bytes The property corresponding to the key.
+	/// @dev EVM selector for this function is: 0xcf24fd6d,
+	///  or in textual repr: collectionProperty(string)
+	function collectionProperty(string memory key) external view returns (bytes memory);
+
+	/// Get collection properties.
+	///
+	/// @param keys Properties keys. Empty keys for all propertyes.
+	/// @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 (Tuple14[] memory);
+
+	/// Set the sponsor of the collection.
+	///
+	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
+	///
+	/// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.
+	/// @dev EVM selector for this function is: 0x7623402e,
+	///  or in textual repr: setCollectionSponsor(address)
+	function setCollectionSponsor(address sponsor) external;
+
+	/// Set the sponsor of the collection.
+	///
+	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
+	///
+	/// @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(EthCrossAccount)
+	///  or in the expanded repr: setCollectionSponsorCross((address,uint256))
+	function setCollectionSponsorCross(EthCrossAccount memory sponsor) external;
+
+	/// Whether there is a pending sponsor.
+	/// @dev EVM selector for this function is: 0x058ac185,
+	///  or in textual repr: hasCollectionPendingSponsor()
+	function hasCollectionPendingSponsor() external view returns (bool);
+
+	/// Collection sponsorship confirmation.
+	///
+	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.
+	/// @dev EVM selector for this function is: 0x3c50e97a,
+	///  or in textual repr: confirmCollectionSponsorship()
+	function confirmCollectionSponsorship() external;
+
+	/// Remove collection sponsor.
+	/// @dev EVM selector for this function is: 0x6e0326a3,
+	///  or in textual repr: removeCollectionSponsor()
+	function removeCollectionSponsor() external;
+
+	/// Get current sponsor.
+	///
+	/// @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 (Tuple8 memory);
+
+	/// Set limits for the collection.
+	/// @dev Throws error if limit not found.
+	/// @param limit Name of the limit. Valid names:
+	/// 	"accountTokenOwnershipLimit",
+	/// 	"sponsoredDataSize",
+	/// 	"sponsoredDataRateLimit",
+	/// 	"tokenLimit",
+	/// 	"sponsorTransferTimeout",
+	/// 	"sponsorApproveTimeout"
+	/// @param value Value of the limit.
+	/// @dev EVM selector for this function is: 0x6a3841db,
+	///  or in textual repr: setCollectionLimit(string,uint32)
+	function setCollectionLimit(string memory limit, uint32 value) external;
+
+	/// Set limits for the collection.
+	/// @dev Throws error if limit not found.
+	/// @param limit Name of the limit. Valid names:
+	/// 	"ownerCanTransfer",
+	/// 	"ownerCanDestroy",
+	/// 	"transfersEnabled"
+	/// @param value Value of the limit.
+	/// @dev EVM selector for this function is: 0x993b7fba,
+	///  or in textual repr: setCollectionLimit(string,bool)
+	function setCollectionLimit(string memory limit, bool value) external;
+
+	/// Get contract address.
+	/// @dev EVM selector for this function is: 0xf6b4dfb4,
+	///  or in textual repr: contractAddress()
+	function contractAddress() external view returns (address);
+
+	/// Add collection admin.
+	/// @param newAdmin Cross account administrator address.
+	/// @dev EVM selector for this function is: 0x859aa7d6,
+	///  or in textual repr: addCollectionAdminCross(EthCrossAccount)
+	///  or in the expanded repr: addCollectionAdminCross((address,uint256))
+	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(EthCrossAccount)
+	///  or in the expanded repr: removeCollectionAdminCross((address,uint256))
+	function removeCollectionAdminCross(EthCrossAccount memory admin) external;
+
+	/// Add collection admin.
+	/// @param newAdmin Address of the added administrator.
+	/// @dev EVM selector for this function is: 0x92e462c7,
+	///  or in textual repr: addCollectionAdmin(address)
+	function addCollectionAdmin(address newAdmin) external;
+
+	/// Remove collection admin.
+	///
+	/// @param admin Address of the removed administrator.
+	/// @dev EVM selector for this function is: 0xfafd7b42,
+	///  or in textual repr: removeCollectionAdmin(address)
+	function removeCollectionAdmin(address admin) external;
+
+	/// Toggle accessibility of collection nesting.
+	///
+	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'
+	/// @dev EVM selector for this function is: 0x112d4586,
+	///  or in textual repr: setCollectionNesting(bool)
+	function setCollectionNesting(bool enable) external;
+
+	/// Toggle accessibility of collection nesting.
+	///
+	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'
+	/// @param collections Addresses of collections that will be available for nesting.
+	/// @dev EVM selector for this function is: 0x64872396,
+	///  or in textual repr: setCollectionNesting(bool,address[])
+	function setCollectionNesting(bool enable, address[] memory collections) external;
+
+	/// Set the collection access method.
+	/// @param mode Access mode
+	/// 	0 for Normal
+	/// 	1 for AllowList
+	/// @dev EVM selector for this function is: 0x41835d4c,
+	///  or in textual repr: setCollectionAccess(uint8)
+	function setCollectionAccess(uint8 mode) external;
+
+	/// Checks that user allowed to operate with collection.
+	///
+	/// @param user User address to check.
+	/// @dev EVM selector for this function is: 0xd63a8e11,
+	///  or in textual repr: allowed(address)
+	function allowed(address user) external view returns (bool);
+
+	/// Add the user to the allowed list.
+	///
+	/// @param user Address of a trusted user.
+	/// @dev EVM selector for this function is: 0x67844fe6,
+	///  or in textual repr: addToCollectionAllowList(address)
+	function addToCollectionAllowList(address user) external;
+
+	/// Add user to allowed list.
+	///
+	/// @param user User cross account address.
+	/// @dev EVM selector for this function is: 0xa0184a3a,
+	///  or in textual repr: addToCollectionAllowListCross(EthCrossAccount)
+	///  or in the expanded repr: addToCollectionAllowListCross((address,uint256))
+	function addToCollectionAllowListCross(EthCrossAccount memory user) external;
+
+	/// Remove the user from the allowed list.
+	///
+	/// @param user Address of a removed user.
+	/// @dev EVM selector for this function is: 0x85c51acb,
+	///  or in textual repr: removeFromCollectionAllowList(address)
+	function removeFromCollectionAllowList(address user) external;
+
+	/// Remove user from allowed list.
+	///
+	/// @param user User cross account address.
+	/// @dev EVM selector for this function is: 0x09ba452a,
+	///  or in textual repr: removeFromCollectionAllowListCross(EthCrossAccount)
+	///  or in the expanded repr: removeFromCollectionAllowListCross((address,uint256))
+	function removeFromCollectionAllowListCross(EthCrossAccount memory user) external;
+
+	/// Switch permission for minting.
+	///
+	/// @param mode Enable if "true".
+	/// @dev EVM selector for this function is: 0x00018e84,
+	///  or in textual repr: setCollectionMintMode(bool)
+	function setCollectionMintMode(bool mode) external;
+
+	/// Check that account is the owner or admin of the collection
+	///
+	/// @param user account to verify
+	/// @return "true" if account is the owner or admin
+	/// @dev EVM selector for this function is: 0x9811b0c7,
+	///  or in textual repr: isOwnerOrAdmin(address)
+	function isOwnerOrAdmin(address user) external view returns (bool);
+
+	/// Check that account is the owner or admin of the collection
+	///
+	/// @param user User cross account to verify
+	/// @return "true" if account is the owner or admin
+	/// @dev EVM selector for this function is: 0x3e75a905,
+	///  or in textual repr: isOwnerOrAdminCross(EthCrossAccount)
+	///  or in the expanded repr: isOwnerOrAdminCross((address,uint256))
+	function isOwnerOrAdminCross(EthCrossAccount memory user) external view returns (bool);
+
+	/// Returns collection type
+	///
+	/// @return `Fungible` or `NFT` or `ReFungible`
+	/// @dev EVM selector for this function is: 0xd34b55b8,
+	///  or in textual repr: uniqueCollectionType()
+	function uniqueCollectionType() external view returns (string memory);
+
+	/// Get collection owner.
+	///
+	/// @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 (EthCrossAccount memory);
+
+	/// Changes collection owner to another account
+	///
+	/// @dev Owner can be changed only by current owner
+	/// @param newOwner new owner account
+	/// @dev EVM selector for this function is: 0x4f53e226,
+	///  or in textual repr: changeCollectionOwner(address)
+	function changeCollectionOwner(address newOwner) external;
+
+	/// Get collection administrators
+	///
+	/// @return Vector of tuples with admins address and his substrate mirror.
+	/// 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 (EthCrossAccount[] memory);
+
+	/// Changes collection owner to another account
+	///
+	/// @dev Owner can be changed only by current owner
+	/// @param newOwner new owner cross account
+	/// @dev EVM selector for this function is: 0xe5c9913f,
+	///  or in textual repr: setOwnerCross(EthCrossAccount)
+	///  or in the expanded repr: setOwnerCross((address,uint256))
+	function setOwnerCross(EthCrossAccount memory newOwner) external;
+}
+
+/// @dev Cross account struct
+struct EthCrossAccount {
+	address eth;
+	uint256 sub;
+}
+
+/// @dev anonymous struct
+struct Tuple14 {
+	string field_0;
+	bytes field_1;
+}
+
+/// @dev the ERC-165 identifier for this interface is 0x032e5926
+interface ERC20UniqueExtensions is Dummy, ERC165 {
+	/// @dev EVM selector for this function is: 0x0ecd0ab0,
+	///  or in textual repr: approveCross(EthCrossAccount,uint256)
+	///  or in the expanded repr: approveCross((address,uint256),uint256)
+	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,
+	/// deducting from the sender's allowance for said account.
+	/// @param from The account whose tokens will be burnt.
+	/// @param amount The amount that will be burnt.
+	/// @dev EVM selector for this function is: 0x79cc6790,
+	///  or in textual repr: burnFrom(address,uint256)
+	function burnFrom(address from, uint256 amount) external returns (bool);
+
+	/// Burn tokens from account
+	/// @dev Function that burns an `amount` of the tokens of a given account,
+	/// deducting from the sender's allowance for said account.
+	/// @param from The account whose tokens will be burnt.
+	/// @param amount The amount that will be burnt.
+	/// @dev EVM selector for this function is: 0xbb2f5a58,
+	///  or in textual repr: burnFromCross(EthCrossAccount,uint256)
+	///  or in the expanded repr: burnFromCross((address,uint256),uint256)
+	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(Tuple8[] memory amounts) external returns (bool);
+
+	/// @dev EVM selector for this function is: 0xd5cf430b,
+	///  or in textual repr: transferFromCross(EthCrossAccount,EthCrossAccount,uint256)
+	///  or in the expanded repr: transferFromCross((address,uint256),(address,uint256),uint256)
+	function transferFromCross(
+		EthCrossAccount memory from,
+		EthCrossAccount memory to,
+		uint256 amount
+	) external returns (bool);
+}
+
+/// @dev anonymous struct
+struct Tuple8 {
+	address field_0;
+	uint256 field_1;
+}
+
+/// @dev the ERC-165 identifier for this interface is 0x40c10f19
+interface ERC20Mintable is Dummy, ERC165 {
+	/// Mint tokens for `to` account.
+	/// @param to account that will receive minted tokens
+	/// @param amount amount of tokens to mint
+	/// @dev EVM selector for this function is: 0x40c10f19,
+	///  or in textual repr: mint(address,uint256)
+	function mint(address to, uint256 amount) external returns (bool);
+}
+
+/// @dev inlined interface
+interface ERC20Events {
+	event Transfer(address indexed from, address indexed to, uint256 value);
+	event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+/// @dev the ERC-165 identifier for this interface is 0x942e8b22
+interface ERC20 is Dummy, ERC165, ERC20Events {
+	/// @dev EVM selector for this function is: 0x06fdde03,
+	///  or in textual repr: name()
+	function name() external view returns (string memory);
+
+	/// @dev EVM selector for this function is: 0x95d89b41,
+	///  or in textual repr: symbol()
+	function symbol() external view returns (string memory);
+
+	/// @dev EVM selector for this function is: 0x18160ddd,
+	///  or in textual repr: totalSupply()
+	function totalSupply() external view returns (uint256);
+
+	/// @dev EVM selector for this function is: 0x313ce567,
+	///  or in textual repr: decimals()
+	function decimals() external view returns (uint8);
+
+	/// @dev EVM selector for this function is: 0x70a08231,
+	///  or in textual repr: balanceOf(address)
+	function balanceOf(address owner) external view returns (uint256);
+
+	/// @dev EVM selector for this function is: 0xa9059cbb,
+	///  or in textual repr: transfer(address,uint256)
+	function transfer(address to, uint256 amount) external returns (bool);
+
+	/// @dev EVM selector for this function is: 0x23b872dd,
+	///  or in textual repr: transferFrom(address,address,uint256)
+	function transferFrom(
+		address from,
+		address to,
+		uint256 amount
+	) external returns (bool);
+
+	/// @dev EVM selector for this function is: 0x095ea7b3,
+	///  or in textual repr: approve(address,uint256)
+	function approve(address spender, uint256 amount) external returns (bool);
+
+	/// @dev EVM selector for this function is: 0xdd62ed3e,
+	///  or in textual repr: allowance(address,address)
+	function allowance(address owner, address spender) external view returns (uint256);
+}
+
+interface UniqueFungible is Dummy, ERC165, ERC20, ERC20Mintable, ERC20UniqueExtensions, Collection {}
modifiedtests/src/eth/api/UniqueNFT.soldiffbeforeafterboth
--- 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.
@@ -70,19 +70,7 @@
 }
 
 /// @title A contract that allows you to work with collections.
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
 /// @dev the ERC-165 identifier for this interface is 0xb3152af3
-=======
-/// @dev the ERC-165 identifier for this interface is 0x674be726
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
-/// @dev the ERC-165 identifier for this interface is 0x943ee094
->>>>>>> fix: after rebase
-=======
-/// @dev the ERC-165 identifier for this interface is 0xefe988e0
->>>>>>> misk: update stubs
 interface Collection is Dummy, ERC165 {
 	/// Set collection property.
 	///
@@ -145,16 +133,10 @@
 	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
 	///
 	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0x403e96a7,
-	///  or in textual repr: setCollectionSponsorCross((address,uint256))
-	function setCollectionSponsorCross(Tuple6 memory sponsor) external;
-=======
 	/// @dev EVM selector for this function is: 0x84a1d5a8,
 	///  or in textual repr: setCollectionSponsorCross(EthCrossAccount)
 	///  or in the expanded repr: setCollectionSponsorCross((address,uint256))
 	function setCollectionSponsorCross(EthCrossAccount memory sponsor) external;
->>>>>>> misk: update stubs
 
 	/// Whether there is a pending sponsor.
 	/// @dev EVM selector for this function is: 0x058ac185,
@@ -212,17 +194,6 @@
 
 	/// Add collection admin.
 	/// @param newAdmin Cross account administrator address.
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0x62e3c7c2,
-	///  or in textual repr: addCollectionAdminCross((address,uint256))
-	function addCollectionAdminCross(Tuple6 memory newAdmin) external;
-
-	/// Remove collection admin.
-	/// @param admin Cross account administrator address.
-	/// @dev EVM selector for this function is: 0x810d1503,
-	///  or in textual repr: removeCollectionAdminCross((address,uint256))
-	function removeCollectionAdminCross(Tuple6 memory admin) external;
-=======
 	/// @dev EVM selector for this function is: 0x859aa7d6,
 	///  or in textual repr: addCollectionAdminCross(EthCrossAccount)
 	///  or in the expanded repr: addCollectionAdminCross((address,uint256))
@@ -234,7 +205,6 @@
 	///  or in textual repr: removeCollectionAdminCross(EthCrossAccount)
 	///  or in the expanded repr: removeCollectionAdminCross((address,uint256))
 	function removeCollectionAdminCross(EthCrossAccount memory admin) external;
->>>>>>> misk: update stubs
 
 	/// Add collection admin.
 	/// @param newAdmin Address of the added administrator.
@@ -289,16 +259,10 @@
 	/// Add user to allowed list.
 	///
 	/// @param user User cross account address.
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0xf074da88,
-	///  or in textual repr: addToCollectionAllowListCross((address,uint256))
-	function addToCollectionAllowListCross(Tuple6 memory user) external;
-=======
 	/// @dev EVM selector for this function is: 0xa0184a3a,
 	///  or in textual repr: addToCollectionAllowListCross(EthCrossAccount)
 	///  or in the expanded repr: addToCollectionAllowListCross((address,uint256))
 	function addToCollectionAllowListCross(EthCrossAccount memory user) external;
->>>>>>> misk: update stubs
 
 	/// Remove the user from the allowed list.
 	///
@@ -310,16 +274,10 @@
 	/// Remove user from allowed list.
 	///
 	/// @param user User cross account address.
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0xc00df45c,
-	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))
-	function removeFromCollectionAllowListCross(Tuple6 memory user) external;
-=======
 	/// @dev EVM selector for this function is: 0x09ba452a,
 	///  or in textual repr: removeFromCollectionAllowListCross(EthCrossAccount)
 	///  or in the expanded repr: removeFromCollectionAllowListCross((address,uint256))
 	function removeFromCollectionAllowListCross(EthCrossAccount memory user) external;
->>>>>>> misk: update stubs
 
 	/// Switch permission for minting.
 	///
@@ -340,16 +298,10 @@
 	///
 	/// @param user User cross account to verify
 	/// @return "true" if account is the owner or admin
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0x5aba3351,
-	///  or in textual repr: isOwnerOrAdminCross((address,uint256))
-	function isOwnerOrAdminCross(Tuple6 memory user) external view returns (bool);
-=======
 	/// @dev EVM selector for this function is: 0x3e75a905,
 	///  or in textual repr: isOwnerOrAdminCross(EthCrossAccount)
 	///  or in the expanded repr: isOwnerOrAdminCross((address,uint256))
 	function isOwnerOrAdminCross(EthCrossAccount memory user) external view returns (bool);
->>>>>>> misk: update stubs
 
 	/// Returns collection type
 	///
@@ -360,7 +312,7 @@
 
 	/// 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()
@@ -380,21 +332,12 @@
 	/// 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()
-<<<<<<< HEAD
-	function collectionAdmins() external view returns (Tuple6[] memory);
-=======
 	function collectionAdmins() external view returns (EthCrossAccount[] memory);
->>>>>>> misk: update stubs
 
 	/// Changes collection owner to another account
 	///
 	/// @dev Owner can be changed only by current owner
 	/// @param newOwner new owner cross account
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0xbdff793d,
-	///  or in textual repr: setOwnerCross((address,uint256))
-	function setOwnerCross(Tuple6 memory newOwner) external;
-=======
 	/// @dev EVM selector for this function is: 0xe5c9913f,
 	///  or in textual repr: setOwnerCross(EthCrossAccount)
 	///  or in the expanded repr: setOwnerCross((address,uint256))
@@ -411,17 +354,14 @@
 struct Tuple24 {
 	address field_0;
 	uint256 field_1;
->>>>>>> misk: update stubs
 }
 
-<<<<<<< HEAD
 /// @dev anonymous struct
-struct Tuple19 {
-	address field_0;
-	uint256 field_1;
+struct Tuple21 {
+	string field_0;
+	bytes field_1;
 }
 
-<<<<<<< HEAD
 /// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 /// @dev See https://eips.ethereum.org/EIPS/eip-721
 /// @dev the ERC-165 identifier for this interface is 0x5b5e139f
@@ -450,18 +390,8 @@
 	/// @dev EVM selector for this function is: 0xc87b56dd,
 	///  or in textual repr: tokenURI(uint256)
 	function tokenURI(uint256 tokenId) external view returns (string memory);
-}
-
-=======
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
-/// @dev anonymous struct
-struct Tuple21 {
-	string field_0;
-	bytes field_1;
 }
 
->>>>>>> fix: after rebase
 /// @title ERC721 Token that can be irreversibly burned (destroyed).
 /// @dev the ERC-165 identifier for this interface is 0x42966c68
 interface ERC721Burnable is Dummy, ERC165 {
@@ -527,15 +457,7 @@
 }
 
 /// @title Unique extensions for ERC721.
-<<<<<<< HEAD
-<<<<<<< HEAD
 /// @dev the ERC-165 identifier for this interface is 0x244543ee
-=======
-/// @dev the ERC-165 identifier for this interface is 0xcc97cb35
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
-/// @dev the ERC-165 identifier for this interface is 0xb76006ac
->>>>>>> misk: update stubs
 interface ERC721UniqueExtensions is Dummy, ERC165 {
 	/// @notice A descriptive name for a collection of NFTs in this contract
 	/// @dev EVM selector for this function is: 0x06fdde03,
@@ -553,16 +475,10 @@
 	///  operator of the current owner.
 	/// @param approved The new substrate address approved NFT controller
 	/// @param tokenId The NFT to approve
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0x106fdb59,
-	///  or in textual repr: approveCross((address,uint256),uint256)
-	function approveCross(Tuple6 memory approved, uint256 tokenId) external;
-=======
 	/// @dev EVM selector for this function is: 0x0ecd0ab0,
 	///  or in textual repr: approveCross(EthCrossAccount,uint256)
 	///  or in the expanded repr: approveCross((address,uint256),uint256)
 	function approveCross(EthCrossAccount memory approved, uint256 tokenId) external;
->>>>>>> misk: update stubs
 
 	/// @notice Transfer ownership of an NFT
 	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`
@@ -583,13 +499,8 @@
 	///  or in textual repr: transferFromCross(EthCrossAccount,EthCrossAccount,uint256)
 	///  or in the expanded repr: transferFromCross((address,uint256),(address,uint256),uint256)
 	function transferFromCross(
-<<<<<<< HEAD
-		Tuple6 memory from,
-		Tuple6 memory to,
-=======
 		EthCrossAccount memory from,
 		EthCrossAccount memory to,
->>>>>>> feat: Add custum signature with unlimited nesting.
 		uint256 tokenId
 	) external;
 
@@ -609,22 +520,15 @@
 	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
 	/// @param from The current owner of the NFT
 	/// @param tokenId The NFT to transfer
-<<<<<<< HEAD
-	/// @dev EVM selector for this function is: 0xa8106d4a,
-	///  or in textual repr: burnFromCross((address,uint256),uint256)
-	function burnFromCross(Tuple6 memory from, uint256 tokenId) external;
-=======
 	/// @dev EVM selector for this function is: 0xbb2f5a58,
 	///  or in textual repr: burnFromCross(EthCrossAccount,uint256)
 	///  or in the expanded repr: burnFromCross((address,uint256),uint256)
 	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) external;
->>>>>>> misk: update stubs
 
 	/// @notice Returns next free NFT ID.
 	/// @dev EVM selector for this function is: 0x75794a3c,
 	///  or in textual repr: nextTokenId()
 	function nextTokenId() external view returns (uint256);
-<<<<<<< HEAD
 	// /// @notice Function to mint multiple tokens.
 	// /// @dev `tokenIds` should be an array of consecutive numbers and first number
 	// ///  should be obtained with `nextTokenId` method
@@ -641,54 +545,16 @@
 	// /// @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);
-}
-
-/// @dev anonymous struct
-struct Tuple8 {
-=======
+	// function mintBulkWithTokenURI(address to, Tuple10[] memory tokens) external returns (bool);
 
-	/// @notice Function to mint multiple tokens.
-	/// @dev `tokenIds` should be an array of consecutive numbers and first number
-	///  should be obtained with `nextTokenId` method
-	/// @param to The new owner
-	/// @param tokenIds IDs of the minted NFTs
-	/// @dev EVM selector for this function is: 0x44a9945e,
-	///  or in textual repr: mintBulk(address,uint256[])
-	function mintBulk(address to, uint256[] memory tokenIds) external returns (bool);
-
-	/// @notice Function to mint multiple tokens with the given tokenUris.
-	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive
-	///  numbers and first number should be obtained with `nextTokenId` method
-	/// @param to The new owner
-	/// @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, Tuple12[] memory tokens) external returns (bool);
 }
 
 /// @dev anonymous struct
-struct Tuple12 {
->>>>>>> feat: Add custum signature with unlimited nesting.
+struct Tuple10 {
 	uint256 field_0;
 	string field_1;
-}
-
-<<<<<<< HEAD
-/// @dev anonymous struct
-struct Tuple8 {
-	address field_0;
-	uint256 field_1;
 }
 
-/// @dev anonymous struct
-struct Tuple8 {
-	address field_0;
-	uint256 field_1;
-}
-
-=======
->>>>>>> misk: update stubs
 /// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 /// @dev See https://eips.ethereum.org/EIPS/eip-721
 /// @dev the ERC-165 identifier for this interface is 0x780e9d63
modifiedtests/src/eth/api/UniqueRefungible.soldiffbeforeafterboth
--- 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.
@@ -134,14 +134,9 @@
 	///
 	/// @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,
-<<<<<<< HEAD
-	///  or in textual repr: setCollectionSponsorCross((address,uint256))
-	function setCollectionSponsorCross(Tuple6 memory sponsor) external;
-=======
 	///  or in textual repr: setCollectionSponsorCross(EthCrossAccount)
 	///  or in the expanded repr: setCollectionSponsorCross((address,uint256))
 	function setCollectionSponsorCross(EthCrossAccount memory sponsor) external;
->>>>>>> misk: update stubs
 
 	/// Whether there is a pending sponsor.
 	/// @dev EVM selector for this function is: 0x058ac185,
@@ -165,11 +160,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()
-<<<<<<< HEAD
-	function collectionSponsor() external view returns (Tuple6 memory);
-=======
 	function collectionSponsor() external view returns (Tuple23 memory);
->>>>>>> misk: update stubs
 
 	/// Set limits for the collection.
 	/// @dev Throws error if limit not found.
@@ -204,26 +195,16 @@
 	/// Add collection admin.
 	/// @param newAdmin Cross account administrator address.
 	/// @dev EVM selector for this function is: 0x859aa7d6,
-<<<<<<< HEAD
-	///  or in textual repr: addCollectionAdminCross((address,uint256))
-	function addCollectionAdminCross(Tuple6 memory newAdmin) external;
-=======
 	///  or in textual repr: addCollectionAdminCross(EthCrossAccount)
 	///  or in the expanded repr: addCollectionAdminCross((address,uint256))
 	function addCollectionAdminCross(EthCrossAccount memory newAdmin) external;
->>>>>>> misk: update stubs
 
 	/// Remove collection admin.
 	/// @param admin Cross account administrator address.
 	/// @dev EVM selector for this function is: 0x6c0cd173,
-<<<<<<< HEAD
-	///  or in textual repr: removeCollectionAdminCross((address,uint256))
-	function removeCollectionAdminCross(Tuple6 memory admin) external;
-=======
 	///  or in textual repr: removeCollectionAdminCross(EthCrossAccount)
 	///  or in the expanded repr: removeCollectionAdminCross((address,uint256))
 	function removeCollectionAdminCross(EthCrossAccount memory admin) external;
->>>>>>> misk: update stubs
 
 	/// Add collection admin.
 	/// @param newAdmin Address of the added administrator.
@@ -279,14 +260,9 @@
 	///
 	/// @param user User cross account address.
 	/// @dev EVM selector for this function is: 0xa0184a3a,
-<<<<<<< HEAD
-	///  or in textual repr: addToCollectionAllowListCross((address,uint256))
-	function addToCollectionAllowListCross(Tuple6 memory user) external;
-=======
 	///  or in textual repr: addToCollectionAllowListCross(EthCrossAccount)
 	///  or in the expanded repr: addToCollectionAllowListCross((address,uint256))
 	function addToCollectionAllowListCross(EthCrossAccount memory user) external;
->>>>>>> misk: update stubs
 
 	/// Remove the user from the allowed list.
 	///
@@ -299,14 +275,9 @@
 	///
 	/// @param user User cross account address.
 	/// @dev EVM selector for this function is: 0x09ba452a,
-<<<<<<< HEAD
-	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))
-	function removeFromCollectionAllowListCross(Tuple6 memory user) external;
-=======
 	///  or in textual repr: removeFromCollectionAllowListCross(EthCrossAccount)
 	///  or in the expanded repr: removeFromCollectionAllowListCross((address,uint256))
 	function removeFromCollectionAllowListCross(EthCrossAccount memory user) external;
->>>>>>> misk: update stubs
 
 	/// Switch permission for minting.
 	///
@@ -328,14 +299,9 @@
 	/// @param user User cross account to verify
 	/// @return "true" if account is the owner or admin
 	/// @dev EVM selector for this function is: 0x3e75a905,
-<<<<<<< HEAD
-	///  or in textual repr: isOwnerOrAdminCross((address,uint256))
-	function isOwnerOrAdminCross(Tuple6 memory user) external view returns (bool);
-=======
 	///  or in textual repr: isOwnerOrAdminCross(EthCrossAccount)
 	///  or in the expanded repr: isOwnerOrAdminCross((address,uint256))
 	function isOwnerOrAdminCross(EthCrossAccount memory user) external view returns (bool);
->>>>>>> misk: update stubs
 
 	/// Returns collection type
 	///
@@ -346,15 +312,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()
-<<<<<<< HEAD
-	function collectionOwner() external view returns (Tuple6 memory);
-=======
 	function collectionOwner() external view returns (EthCrossAccount memory);
->>>>>>> misk: update stubs
 
 	/// Changes collection owner to another account
 	///
@@ -370,21 +332,13 @@
 	/// 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()
-<<<<<<< HEAD
-	function collectionAdmins() external view returns (Tuple6[] memory);
-=======
 	function collectionAdmins() external view returns (EthCrossAccount[] memory);
->>>>>>> misk: update stubs
 
 	/// Changes collection owner to another account
 	///
 	/// @dev Owner can be changed only by current owner
 	/// @param newOwner new owner cross account
 	/// @dev EVM selector for this function is: 0xe5c9913f,
-<<<<<<< HEAD
-	///  or in textual repr: setOwnerCross((address,uint256))
-	function setOwnerCross(Tuple6 memory newOwner) external;
-=======
 	///  or in textual repr: setOwnerCross(EthCrossAccount)
 	///  or in the expanded repr: setOwnerCross((address,uint256))
 	function setOwnerCross(EthCrossAccount memory newOwner) external;
@@ -400,7 +354,6 @@
 struct Tuple23 {
 	address field_0;
 	uint256 field_1;
->>>>>>> misk: update stubs
 }
 
 /// @dev anonymous struct
@@ -534,13 +487,8 @@
 	///  or in textual repr: transferFromCross(EthCrossAccount,EthCrossAccount,uint256)
 	///  or in the expanded repr: transferFromCross((address,uint256),(address,uint256),uint256)
 	function transferFromCross(
-<<<<<<< HEAD
-		Tuple6 memory from,
-		Tuple6 memory to,
-=======
 		EthCrossAccount memory from,
 		EthCrossAccount memory to,
->>>>>>> misk: update stubs
 		uint256 tokenId
 	) external;
 
@@ -563,21 +511,15 @@
 	/// @param from The current owner of the RFT
 	/// @param tokenId The RFT to transfer
 	/// @dev EVM selector for this function is: 0xbb2f5a58,
-<<<<<<< HEAD
-	///  or in textual repr: burnFromCross((address,uint256),uint256)
-	function burnFromCross(Tuple6 memory from, uint256 tokenId) external;
-=======
 	///  or in textual repr: burnFromCross(EthCrossAccount,uint256)
 	///  or in the expanded repr: burnFromCross((address,uint256),uint256)
 	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) external;
->>>>>>> misk: update stubs
 
 	/// @notice Returns next free RFT ID.
 	/// @dev EVM selector for this function is: 0x75794a3c,
 	///  or in textual repr: nextTokenId()
 	function nextTokenId() external view returns (uint256);
 
-<<<<<<< HEAD
 	// /// @notice Function to mint multiple tokens.
 	// /// @dev `tokenIds` should be an array of consecutive numbers and first number
 	// ///  should be obtained with `nextTokenId` method
@@ -594,26 +536,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);
-=======
-	/// @notice Function to mint multiple tokens.
-	/// @dev `tokenIds` should be an array of consecutive numbers and first number
-	///  should be obtained with `nextTokenId` method
-	/// @param to The new owner
-	/// @param tokenIds IDs of the minted RFTs
-	/// @dev EVM selector for this function is: 0x44a9945e,
-	///  or in textual repr: mintBulk(address,uint256[])
-	function mintBulk(address to, uint256[] memory tokenIds) external returns (bool);
-
-	/// @notice Function to mint multiple tokens with the given tokenUris.
-	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive
-	///  numbers and first number should be obtained with `nextTokenId` method
-	/// @param to The new owner
-	/// @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, Tuple11[] memory tokens) external returns (bool);
->>>>>>> misk: update stubs
+	// function mintBulkWithTokenURI(address to, Tuple9[] memory tokens) external returns (bool);
 
 	/// Returns EVM address for refungible token
 	///
@@ -624,24 +547,11 @@
 }
 
 /// @dev anonymous struct
-<<<<<<< HEAD
-struct Tuple8 {
-=======
-struct Tuple11 {
->>>>>>> misk: update stubs
+struct Tuple9 {
 	uint256 field_0;
 	string field_1;
-}
-
-<<<<<<< HEAD
-/// @dev anonymous struct
-struct Tuple6 {
-	address field_0;
-	uint256 field_1;
 }
 
-=======
->>>>>>> misk: update stubs
 /// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 /// @dev See https://eips.ethereum.org/EIPS/eip-721
 /// @dev the ERC-165 identifier for this interface is 0x780e9d63
modifiedtests/src/eth/base.test.tsdiffbeforeafterboth
--- a/tests/src/eth/base.test.ts
+++ b/tests/src/eth/base.test.ts
@@ -117,7 +117,7 @@
   });
 
   itEth('ERC721UniqueExtensions support', async ({helper}) => {
-    expect(await contract(helper).methods.supportsInterface('0xb76006ac').call()).to.be.true;
+    await checkInterface(helper, '0xb76006ac', true, true);
   });
 
   itEth('ERC721Burnable - 0x42966c68 - support', async ({helper}) => {
modifiedtests/src/eth/collectionAdmin.test.tsdiffbeforeafterboth
--- a/tests/src/eth/collectionAdmin.test.ts
+++ b/tests/src/eth/collectionAdmin.test.ts
@@ -14,8 +14,10 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
+import {expect} from 'chai';
 import {IEthCrossAccountId} from '../util/playgrounds/types';
-import {usingEthPlaygrounds, itEth, expect, EthUniqueHelper} from './util/playgrounds';
+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));
@@ -53,10 +55,10 @@
   itEth('Add cross account admin by owner', async ({helper, privateKey}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
         
-    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
+    const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
     const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
     
-    const newAdmin = privateKey('//Bob');
+    const newAdmin = await privateKey('//Bob');
     const newAdminCross = helper.ethCrossAccount.fromKeyringPair(newAdmin);
     await collectionEvm.methods.addCollectionAdminCross(newAdminCross).send();
 
@@ -67,11 +69,11 @@
   itEth('Check adminlist', async ({helper, privateKey}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
         
-    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
+    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 = privateKey('admin');
+    const admin2 = await privateKey('admin');
     await collectionEvm.methods.addCollectionAdmin(admin1).send();
     await collectionEvm.methods.addCollectionAdminSubstrate(admin2.addressRaw).send();
modifiedtests/src/eth/fungible.test.tsdiffbeforeafterboth
--- a/tests/src/eth/fungible.test.ts
+++ b/tests/src/eth/fungible.test.ts
@@ -149,20 +149,20 @@
   });
 
   itEth('Can perform burnFromCross()', async ({helper, privateKey}) => {
-    const alice = privateKey('//Alice');
-    const sender = await helper.eth.createAccountWithBalance(alice, 100n);
+    const owner = await privateKey('//Alice');
+    const sender = await helper.eth.createAccountWithBalance(donor);
 
-    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,23 @@
   });
 
   itEth('Can perform transferFromCross()', async ({helper, privateKey}) => {
-    const alice = privateKey('//Alice');
-    const sender = await helper.eth.createAccountWithBalance(alice, 100n);
+    const owner = await privateKey('//Alice');
+    const sender = await helper.eth.createAccountWithBalance(donor);
 
-    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 +287,7 @@
         address,
         event: 'Transfer',
         returnValues: {
-          from: helper.address.substrateToEth(alice.address),
+          from: helper.address.substrateToEth(owner.address),
           to: receiver,
           value: '51',
         },
@@ -296,13 +296,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);
@@ -455,20 +455,20 @@
   });
 
   itEth('Events emitted for transferFromCross()', async ({helper, privateKey}) => {
-    const alice = privateKey('//Alice');
-    const sender = await helper.eth.createAccountWithBalance(alice, 100n);
+    const owner = await privateKey('//Alice');
+    const sender = await helper.eth.createAccountWithBalance(donor);
 
-    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 +478,7 @@
         address,
         event: 'Transfer',
         returnValues: {
-          from: helper.address.substrateToEth(alice.address),
+          from: helper.address.substrateToEth(owner.address),
           to: receiver,
           value: '51',
         },
@@ -487,7 +487,7 @@
         address,
         event: 'Approval',
         returnValues: {
-          owner: helper.address.substrateToEth(alice.address),
+          owner: helper.address.substrateToEth(owner.address),
           spender: sender,
           value: '49',
         },
modifiedtests/src/eth/fungibleAbi.jsondiffbeforeafterboth
--- a/tests/src/eth/fungibleAbi.json
+++ b/tests/src/eth/fungibleAbi.json
@@ -62,13 +62,8 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "newAdmin",
@@ -93,13 +88,8 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "user",
@@ -144,13 +134,8 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "spender",
@@ -186,13 +171,8 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "from",
@@ -202,7 +182,6 @@
     ],
     "name": "burnFromCross",
     "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
-<<<<<<< HEAD
     "stateMutability": "nonpayable",
     "type": "function"
   },
@@ -212,8 +191,6 @@
     ],
     "name": "changeCollectionOwner",
     "outputs": [],
-=======
->>>>>>> misk: update stubs
     "stateMutability": "nonpayable",
     "type": "function"
   },
@@ -223,13 +200,8 @@
     "outputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount[]",
         "name": "",
@@ -245,13 +217,8 @@
     "outputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "",
@@ -361,13 +328,8 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "user",
@@ -426,13 +388,8 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "admin",
@@ -464,13 +421,8 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "user",
@@ -577,13 +529,8 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "sponsor",
@@ -597,26 +544,10 @@
   },
   {
     "inputs": [
-<<<<<<< HEAD
       {
         "components": [
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-=======
-      { "internalType": "address", "name": "newOwner", "type": "address" }
-    ],
-    "name": "setOwner",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "components": [
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "newOwner",
@@ -676,13 +607,8 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "from",
@@ -690,13 +616,8 @@
       },
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> misk: update stubs
         ],
         "internalType": "struct EthCrossAccount",
         "name": "to",
modifiedtests/src/eth/nonFungible.test.tsdiffbeforeafterboth
--- a/tests/src/eth/nonFungible.test.ts
+++ b/tests/src/eth/nonFungible.test.ts
@@ -247,13 +247,13 @@
   });
 
   itEth('Can perform burnFromCross()', async ({helper, privateKey}) => {
-    const alice = privateKey('//Alice');
-    const collection = await helper.nft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    const minter = await privateKey('//Alice');
+    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const owner = privateKey('//Bob');
-    const spender = await helper.eth.createAccountWithBalance(alice, 100n);
+    const owner = await privateKey('//Bob');
+    const spender = await helper.eth.createAccountWithBalance(donor);
 
-    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');
@@ -277,13 +277,13 @@
   });
 
   itEth('Can perform approveCross()', async ({helper, privateKey}) => {
-    const alice = privateKey('//Alice');
-    const collection = await helper.nft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    const minter = await privateKey('//Alice');
+    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const owner = await helper.eth.createAccountWithBalance(alice, 100n);
-    const receiver = privateKey('//Charlie');
+    const owner = await helper.eth.createAccountWithBalance(donor);
+    const receiver = await privateKey('//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');
@@ -410,11 +410,12 @@
   });
 
   itEth('Can perform transferFromCross()', async ({helper, privateKey}) => {
-    const collection = await helper.nft.mintCollection(donor, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    const minter = await privateKey('//Alice');
+    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const owner = privateKey('//Bob');
-    const spender = await helper.eth.createAccountWithBalance(donor, 100n);
-    const receiver = privateKey('//Charlie');
+    const owner = await privateKey('//Bob');
+    const spender = await helper.eth.createAccountWithBalance(donor);
+    const receiver = await privateKey('//Charlie');
 
     const token = await collection.mintToken(donor, {Substrate: owner.address});
modifiedtests/src/eth/nonFungibleAbi.jsondiffbeforeafterboth
--- a/tests/src/eth/nonFungibleAbi.json
+++ b/tests/src/eth/nonFungibleAbi.json
@@ -96,11 +96,7 @@
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "newAdmin",
         "type": "tuple"
       }
@@ -126,11 +122,7 @@
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "user",
         "type": "tuple"
       }
@@ -166,11 +158,7 @@
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "approved",
         "type": "tuple"
       },
@@ -216,11 +204,7 @@
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "from",
         "type": "tuple"
       },
@@ -249,11 +233,7 @@
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6[]",
-=======
         "internalType": "struct EthCrossAccount[]",
->>>>>>> misk: update stubs
         "name": "",
         "type": "tuple[]"
       }
@@ -270,19 +250,7 @@
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
-        "internalType": "struct Tuple19",
->>>>>>> feat: add `EthCrossAccount` type
-=======
-        "internalType": "struct Tuple8",
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "",
         "type": "tuple"
       }
@@ -291,10 +259,6 @@
     "type": "function"
   },
   {
-<<<<<<< HEAD
-<<<<<<< HEAD
-=======
->>>>>>> fix: after rebase
     "inputs": [
       { "internalType": "string[]", "name": "keys", "type": "string[]" }
     ],
@@ -305,23 +269,11 @@
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple19[]",
-=======
         "internalType": "struct Tuple21[]",
->>>>>>> fix: after rebase
         "name": "",
         "type": "tuple[]"
       }
     ],
-<<<<<<< HEAD
-=======
-    "inputs": [{ "internalType": "string", "name": "key", "type": "string" }],
-    "name": "collectionProperty",
-    "outputs": [{ "internalType": "bytes", "name": "", "type": "bytes" }],
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
->>>>>>> fix: after rebase
     "stateMutability": "view",
     "type": "function"
   },
@@ -341,19 +293,7 @@
           { "internalType": "address", "name": "field_0", "type": "address" },
           { "internalType": "uint256", "name": "field_1", "type": "uint256" }
         ],
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
-        "internalType": "struct Tuple19",
->>>>>>> feat: add `EthCrossAccount` type
-=======
-        "internalType": "struct Tuple8",
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
         "internalType": "struct Tuple24",
->>>>>>> misk: update stubs
         "name": "",
         "type": "tuple"
       }
@@ -376,10 +316,6 @@
     "type": "function"
   },
   {
-<<<<<<< HEAD
-<<<<<<< HEAD
-=======
->>>>>>> fix: after rebase
     "inputs": [
       { "internalType": "string[]", "name": "keys", "type": "string[]" }
     ],
@@ -389,11 +325,6 @@
     "type": "function"
   },
   {
-<<<<<<< HEAD
-=======
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
->>>>>>> fix: after rebase
     "inputs": [{ "internalType": "string", "name": "key", "type": "string" }],
     "name": "deleteCollectionProperty",
     "outputs": [],
@@ -459,11 +390,7 @@
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "user",
         "type": "tuple"
       }
@@ -474,68 +401,23 @@
     "type": "function"
   },
   {
-<<<<<<< HEAD
     "inputs": [{ "internalType": "address", "name": "to", "type": "address" }],
     "name": "mint",
     "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
-=======
-    "inputs": [
-      { "internalType": "address", "name": "to", "type": "address" },
-      { "internalType": "uint256", "name": "tokenId", "type": "uint256" }
-    ],
-    "name": "mint",
-    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
->>>>>>> feat: Add custum signature with unlimited nesting.
     "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [
       { "internalType": "address", "name": "to", "type": "address" },
-<<<<<<< HEAD
       { "internalType": "string", "name": "tokenUri", "type": "string" }
     ],
     "name": "mintWithTokenURI",
     "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
-=======
-      { "internalType": "uint256[]", "name": "tokenIds", "type": "uint256[]" }
-    ],
-    "name": "mintBulk",
-    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
     "stateMutability": "nonpayable",
     "type": "function"
   },
   {
-    "inputs": [
-      { "internalType": "address", "name": "to", "type": "address" },
-      {
-        "components": [
-          { "internalType": "uint256", "name": "field_0", "type": "uint256" },
-          { "internalType": "string", "name": "field_1", "type": "string" }
-        ],
-        "internalType": "struct Tuple12[]",
-        "name": "tokens",
-        "type": "tuple[]"
-      }
-    ],
-    "name": "mintBulkWithTokenURI",
-    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      { "internalType": "address", "name": "to", "type": "address" },
-      { "internalType": "uint256", "name": "tokenId", "type": "uint256" },
-      { "internalType": "string", "name": "tokenUri", "type": "string" }
-    ],
-    "name": "mintWithTokenURI",
-    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
->>>>>>> feat: Add custum signature with unlimited nesting.
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
     "inputs": [],
     "name": "mintingFinished",
     "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
@@ -591,11 +473,7 @@
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "admin",
         "type": "tuple"
       }
@@ -628,11 +506,7 @@
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "user",
         "type": "tuple"
       }
@@ -732,30 +606,15 @@
   },
   {
     "inputs": [
-<<<<<<< HEAD
-<<<<<<< HEAD
-=======
->>>>>>> fix: after rebase
       {
         "components": [
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple19[]",
-        "name": "properties",
-        "type": "tuple[]"
-      }
-=======
-      { "internalType": "string", "name": "key", "type": "string" },
-      { "internalType": "bytes", "name": "value", "type": "bytes" }
->>>>>>> feat: Add custum signature with unlimited nesting.
-=======
         "internalType": "struct Tuple21[]",
         "name": "properties",
         "type": "tuple[]"
       }
->>>>>>> fix: after rebase
     ],
     "name": "setCollectionProperties",
     "outputs": [],
@@ -788,11 +647,7 @@
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "sponsor",
         "type": "tuple"
       }
@@ -804,19 +659,15 @@
   },
   {
     "inputs": [
-<<<<<<< HEAD
       {
         "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"
       }
-=======
-      { "internalType": "address", "name": "newOwner", "type": "address" }
->>>>>>> feat: Add custum signature with unlimited nesting.
     ],
     "name": "setOwnerCross",
     "outputs": [],
@@ -828,26 +679,12 @@
       { "internalType": "uint256", "name": "tokenId", "type": "uint256" },
       {
         "components": [
-<<<<<<< HEAD
-<<<<<<< HEAD
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
-=======
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
->>>>>>> feat: Add custum signature with unlimited nesting.
         ],
-        "internalType": "struct Tuple19[]",
+        "internalType": "struct Tuple21[]",
         "name": "properties",
         "type": "tuple[]"
-=======
-          { "internalType": "address", "name": "eth", "type": "address" },
-          { "internalType": "uint256", "name": "sub", "type": "uint256" }
-        ],
-        "internalType": "struct EthCrossAccount",
-        "name": "newOwner",
-        "type": "tuple"
->>>>>>> misk: update stubs
       }
     ],
     "name": "setProperties",
@@ -954,37 +791,19 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> feat: Add custum signature with unlimited nesting.
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
         "internalType": "struct EthCrossAccount",
->>>>>>> feat: add `EthCrossAccount` type
         "name": "from",
         "type": "tuple"
       },
       {
         "components": [
-<<<<<<< HEAD
-          { "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" }
->>>>>>> feat: Add custum signature with unlimited nesting.
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
         "internalType": "struct EthCrossAccount",
->>>>>>> feat: add `EthCrossAccount` type
         "name": "to",
         "type": "tuple"
       },
modifiedtests/src/eth/reFungible.test.tsdiffbeforeafterboth
--- a/tests/src/eth/reFungible.test.ts
+++ b/tests/src/eth/reFungible.test.ts
@@ -228,13 +228,13 @@
   });
 
   itEth('Can perform burnFrom()', async ({helper, privateKey}) => {
-    const alice = privateKey('//Alice');
-    const collection = await helper.rft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    const minter = await privateKey('//Alice');
+    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);
+    const spender = await helper.eth.createAccountWithBalance(donor);
 
-    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');
@@ -262,13 +262,13 @@
   });
 
   itEth('Can perform burnFromCross()', async ({helper, privateKey}) => {
-    const alice = privateKey('//Alice');
-    const collection = await helper.rft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    const minter = await privateKey('//Alice');
+    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const owner = privateKey('//Bob');
-    const spender = await helper.eth.createAccountWithBalance(alice, 100n);
+    const owner = await privateKey('//Bob');
+    const spender = await helper.eth.createAccountWithBalance(donor);
 
-    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');
@@ -295,13 +295,14 @@
   });
 
   itEth('Can perform transferFromCross()', async ({helper, privateKey}) => {
-    const collection = await helper.rft.mintCollection(donor, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    const minter = await privateKey('//Alice');
+    const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const owner = privateKey('//Bob');
-    const spender = await helper.eth.createAccountWithBalance(donor, 100n);
-    const receiver = privateKey('//Charlie');
+    const owner = await privateKey('//Bob');
+    const spender = await helper.eth.createAccountWithBalance(donor);
+    const receiver = await privateKey('//Charlie');
 
-    const token = await collection.mintToken(donor, 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');
modifiedtests/src/eth/reFungibleAbi.jsondiffbeforeafterboth
--- a/tests/src/eth/reFungibleAbi.json
+++ b/tests/src/eth/reFungibleAbi.json
@@ -93,17 +93,10 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple6",
-=======
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "newAdmin",
         "type": "tuple"
       }
@@ -126,17 +119,10 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple6",
-=======
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "user",
         "type": "tuple"
       }
@@ -197,17 +183,10 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple6",
-=======
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "from",
         "type": "tuple"
       },
@@ -233,17 +212,10 @@
     "outputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple6[]",
-=======
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
         "internalType": "struct EthCrossAccount[]",
->>>>>>> misk: update stubs
         "name": "",
         "type": "tuple[]"
       }
@@ -257,17 +229,10 @@
     "outputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple6",
-=======
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "",
         "type": "tuple"
       }
@@ -310,11 +275,7 @@
           { "internalType": "address", "name": "field_0", "type": "address" },
           { "internalType": "uint256", "name": "field_1", "type": "uint256" }
         ],
-<<<<<<< HEAD
-        "internalType": "struct Tuple6",
-=======
         "internalType": "struct Tuple23",
->>>>>>> misk: update stubs
         "name": "",
         "type": "tuple"
       }
@@ -408,17 +369,10 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple6",
-=======
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "user",
         "type": "tuple"
       }
@@ -429,68 +383,23 @@
     "type": "function"
   },
   {
-<<<<<<< HEAD
     "inputs": [{ "internalType": "address", "name": "to", "type": "address" }],
     "name": "mint",
     "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
-=======
-    "inputs": [
-      { "internalType": "address", "name": "to", "type": "address" },
-      { "internalType": "uint256", "name": "tokenId", "type": "uint256" }
-    ],
-    "name": "mint",
-    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
->>>>>>> misk: update stubs
     "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [
       { "internalType": "address", "name": "to", "type": "address" },
-<<<<<<< HEAD
       { "internalType": "string", "name": "tokenUri", "type": "string" }
     ],
     "name": "mintWithTokenURI",
     "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
-=======
-      { "internalType": "uint256[]", "name": "tokenIds", "type": "uint256[]" }
-    ],
-    "name": "mintBulk",
-    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
     "stateMutability": "nonpayable",
     "type": "function"
   },
   {
-    "inputs": [
-      { "internalType": "address", "name": "to", "type": "address" },
-      {
-        "components": [
-          { "internalType": "uint256", "name": "field_0", "type": "uint256" },
-          { "internalType": "string", "name": "field_1", "type": "string" }
-        ],
-        "internalType": "struct Tuple11[]",
-        "name": "tokens",
-        "type": "tuple[]"
-      }
-    ],
-    "name": "mintBulkWithTokenURI",
-    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      { "internalType": "address", "name": "to", "type": "address" },
-      { "internalType": "uint256", "name": "tokenId", "type": "uint256" },
-      { "internalType": "string", "name": "tokenUri", "type": "string" }
-    ],
-    "name": "mintWithTokenURI",
-    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
->>>>>>> misk: update stubs
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
     "inputs": [],
     "name": "mintingFinished",
     "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
@@ -543,17 +452,10 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple6",
-=======
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "admin",
         "type": "tuple"
       }
@@ -583,17 +485,10 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple6",
-=======
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "user",
         "type": "tuple"
       }
@@ -731,17 +626,10 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple6",
-=======
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "sponsor",
         "type": "tuple"
       }
@@ -753,19 +641,15 @@
   },
   {
     "inputs": [
-<<<<<<< HEAD
       {
         "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"
       }
-=======
-      { "internalType": "address", "name": "newOwner", "type": "address" }
->>>>>>> misk: update stubs
     ],
     "name": "setOwnerCross",
     "outputs": [],
@@ -777,21 +661,12 @@
       { "internalType": "uint256", "name": "tokenId", "type": "uint256" },
       {
         "components": [
-<<<<<<< HEAD
           { "internalType": "string", "name": "field_0", "type": "string" },
           { "internalType": "bytes", "name": "field_1", "type": "bytes" }
         ],
-        "internalType": "struct Tuple19[]",
+        "internalType": "struct Tuple20[]",
         "name": "properties",
         "type": "tuple[]"
-=======
-          { "internalType": "address", "name": "eth", "type": "address" },
-          { "internalType": "uint256", "name": "sub", "type": "uint256" }
-        ],
-        "internalType": "struct EthCrossAccount",
-        "name": "newOwner",
-        "type": "tuple"
->>>>>>> misk: update stubs
       }
     ],
     "name": "setProperties",
@@ -907,33 +782,19 @@
     "inputs": [
       {
         "components": [
-<<<<<<< HEAD
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple6",
-=======
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "from",
         "type": "tuple"
       },
       {
         "components": [
-<<<<<<< HEAD
-          { "internalType": "address", "name": "field_0", "type": "address" },
-          { "internalType": "uint256", "name": "field_1", "type": "uint256" }
-        ],
-        "internalType": "struct Tuple6",
-=======
           { "internalType": "address", "name": "eth", "type": "address" },
           { "internalType": "uint256", "name": "sub", "type": "uint256" }
         ],
         "internalType": "struct EthCrossAccount",
->>>>>>> misk: update stubs
         "name": "to",
         "type": "tuple"
       },
modifiedtests/src/eth/util/playgrounds/unique.dev.tsdiffbeforeafterboth
--- a/tests/src/eth/util/playgrounds/unique.dev.ts
+++ b/tests/src/eth/util/playgrounds/unique.dev.ts
@@ -377,52 +377,13 @@
   }
 }
 
-export class EthCrossAccountGroup extends EthGroupBase {
-  fromAddress(address: TEthereumAccount): TEthCrossAccount {
-    return {
-      0: address,
-      1: '0',
-      field_0: address,
-      field_1: '0',
-    };
-  }
-
-  fromKeyringPair(keyring: IKeyringPair): TEthCrossAccount {
-    return {
-      0: '0x0000000000000000000000000000000000000000',
-      1: keyring.addressRaw,
-      field_0: '0x0000000000000000000000000000000000000000',
-      field_1: keyring.addressRaw,
-    };
-  }
-}
-
-export class EthCrossAccountGroup extends EthGroupBase {
-  fromAddress(address: TEthereumAccount): TEthCrossAccount {
-    return {
-      0: address,
-      1: '0',
-      field_0: address,
-      field_1: '0',
-    };
-  }
-
-  fromKeyringPair(keyring: IKeyringPair): TEthCrossAccount {
-    return {
-      0: '0x0000000000000000000000000000000000000000',
-      1: keyring.addressRaw,
-      field_0: '0x0000000000000000000000000000000000000000',
-      field_1: keyring.addressRaw,
-    };
-  }
-}
-
 export class EthUniqueHelper extends DevUniqueHelper {
   web3: Web3 | null = null;
   web3Provider: WebsocketProvider | null = null;
 
   eth: EthGroup;
   ethAddress: EthAddressGroup;
+  ethCrossAccount: EthCrossAccountGroup;
   ethNativeContract: NativeContractGroup;
   ethContract: ContractGroup;
   ethProperty: EthPropertyGroup;