git.delta.rocks / unique-network / refs/commits / 214592d86cdb

--- a/crates/evm-coder/src/lib.rs
+++ b/crates/evm-coder/src/lib.rs
@@ -132,7 +132,6 @@
 	use primitive_types::{U256, H160, H256};
 
 	pub type address = H160;
-	pub type uint256 = U256;
 	pub type bytes4 = [u8; 4];
 	pub type topic = H256;
 

--- a/pallets/common/src/eth.rs
+++ b/pallets/common/src/eth.rs
@@ -18,12 +18,9 @@
 
 use alloc::format;
 use sp_std::{vec, vec::Vec};
-use evm_coder::{
-	AbiCoder,
-	types::{uint256, address},
-};
+use evm_coder::{AbiCoder, types::address};
 pub use pallet_evm::{Config, account::CrossAccountId};
-use sp_core::H160;
+use sp_core::{H160, U256};
 use up_data_structs::CollectionId;
 
 // 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 1
@@ -55,8 +52,8 @@
 	address[0..16] == ETH_COLLECTION_PREFIX
 }
 
-/// Convert `uint256` to `CrossAccountId`.
-pub fn convert_uint256_to_cross_account<T: Config>(from: uint256) -> T::CrossAccountId
+/// Convert `U256` to `CrossAccountId`.
+pub fn convert_uint256_to_cross_account<T: Config>(from: U256) -> T::CrossAccountId
 where
 	T::AccountId: From<[u8; 32]>,
 {
@@ -70,7 +67,7 @@
 #[derive(Debug, Default, AbiCoder)]
 pub struct CrossAddress {
 	pub(crate) eth: address,
-	pub(crate) sub: uint256,
+	pub(crate) sub: U256,
 }
 
 impl CrossAddress {
@@ -97,7 +94,7 @@
 	{
 		Self {
 			eth: Default::default(),
-			sub: uint256::from_big_endian(account_id.as_ref()),
+			sub: U256::from_big_endian(account_id.as_ref()),
 		}
 	}
 	/// Converts [`CrossAddress`] to `CrossAccountId`.
@@ -187,7 +184,7 @@
 #[derive(Debug, Default, AbiCoder)]
 pub struct CollectionLimit {
 	field: CollectionLimitField,
-	value: Option<uint256>,
+	value: Option<U256>,
 }
 
 impl CollectionLimit {
@@ -393,12 +390,12 @@
 #[derive(Debug, Default, AbiCoder)]
 pub struct CollectionNesting {
 	token_owner: bool,
-	ids: Vec<uint256>,
+	ids: Vec<U256>,
 }
 
 impl CollectionNesting {
 	/// Create [`CollectionNesting`].
-	pub fn new(token_owner: bool, ids: Vec<uint256>) -> Self {
+	pub fn new(token_owner: bool, ids: Vec<U256>) -> Self {
 		Self { token_owner, ids }
 	}
 }

--- a/pallets/evm-contract-helpers/src/eth.rs
+++ b/pallets/evm-contract-helpers/src/eth.rs
@@ -261,7 +261,7 @@
 		&mut self,
 		caller: caller,
 		contract_address: address,
-		fee_limit: uint256,
+		fee_limit: U256,
 	) -> Result<()> {
 		self.recorder().consume_sload()?;
 		self.recorder().consume_sstore()?;
@@ -276,7 +276,7 @@
 	/// @param contractAddress Contract to get sponsoring fee limit of
 	/// @return uint256 Maximum amount of fee that could be spent by single
 	///  transaction
-	fn sponsoring_fee_limit(&self, contract_address: address) -> Result<uint256> {
+	fn sponsoring_fee_limit(&self, contract_address: address) -> Result<U256> {
 		self.recorder().consume_sload()?;
 
 		Ok(get_sponsoring_fee_limit::<T>(contract_address))
@@ -441,7 +441,7 @@
 	}
 }
 
-fn get_sponsoring_fee_limit<T: Config>(contract_address: address) -> uint256 {
+fn get_sponsoring_fee_limit<T: Config>(contract_address: address) -> U256 {
 	<SponsoringFeeLimit<T>>::get(contract_address)
 		.get(&0xffffffff)
 		.cloned()

32use pallet_evm::{account::CrossAccountId, PrecompileHandle};32use pallet_evm::{account::CrossAccountId, PrecompileHandle};
33use pallet_evm_coder_substrate::{call, dispatch_to_evm};33use pallet_evm_coder_substrate::{call, dispatch_to_evm};
34use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};34use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
35use sp_core::Get;35use sp_core::{U256, Get};
3636
37use crate::{37use crate::{
38	Allowance, Balance, Config, FungibleHandle, Pallet, SelfWeightOf, TotalSupply,38	Allowance, Balance, Config, FungibleHandle, Pallet, SelfWeightOf, TotalSupply,
46		from: address,46		from: address,
47		#[indexed]47		#[indexed]
48		to: address,48		to: address,
49		value: uint256,49		value: U256,
50	},50	},
51	Approval {51	Approval {
52		#[indexed]52		#[indexed]
53		owner: address,53		owner: address,
54		#[indexed]54		#[indexed]
55		spender: address,55		spender: address,
56		value: uint256,56		value: U256,
57	},57	},
58}58}
5959
67	fn symbol(&self) -> Result<string> {67	fn symbol(&self) -> Result<string> {
68		Ok(string::from_utf8_lossy(&self.token_prefix).into())68		Ok(string::from_utf8_lossy(&self.token_prefix).into())
69	}69	}
70	fn total_supply(&self) -> Result<uint256> {70	fn total_supply(&self) -> Result<U256> {
71		self.consume_store_reads(1)?;71		self.consume_store_reads(1)?;
72		Ok(<TotalSupply<T>>::get(self.id).into())72		Ok(<TotalSupply<T>>::get(self.id).into())
73	}73	}
79			unreachable!()79			unreachable!()
80		})80		})
81	}81	}
82	fn balance_of(&self, owner: address) -> Result<uint256> {82	fn balance_of(&self, owner: address) -> Result<U256> {
83		self.consume_store_reads(1)?;83		self.consume_store_reads(1)?;
84		let owner = T::CrossAccountId::from_eth(owner);84		let owner = T::CrossAccountId::from_eth(owner);
85		let balance = <Balance<T>>::get((self.id, owner));85		let balance = <Balance<T>>::get((self.id, owner));
86		Ok(balance.into())86		Ok(balance.into())
87	}87	}
88	#[weight(<SelfWeightOf<T>>::transfer())]88	#[weight(<SelfWeightOf<T>>::transfer())]
89	fn transfer(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {89	fn transfer(&mut self, caller: caller, to: address, amount: U256) -> Result<bool> {
90		let caller = T::CrossAccountId::from_eth(caller);90		let caller = T::CrossAccountId::from_eth(caller);
91		let to = T::CrossAccountId::from_eth(to);91		let to = T::CrossAccountId::from_eth(to);
92		let amount = amount.try_into().map_err(|_| "amount overflow")?;92		let amount = amount.try_into().map_err(|_| "amount overflow")?;
104		caller: caller,104		caller: caller,
105		from: address,105		from: address,
106		to: address,106		to: address,
107		amount: uint256,107		amount: U256,
108	) -> Result<bool> {108	) -> Result<bool> {
109		let caller = T::CrossAccountId::from_eth(caller);109		let caller = T::CrossAccountId::from_eth(caller);
110		let from = T::CrossAccountId::from_eth(from);110		let from = T::CrossAccountId::from_eth(from);
119		Ok(true)119		Ok(true)
120	}120	}
121	#[weight(<SelfWeightOf<T>>::approve())]121	#[weight(<SelfWeightOf<T>>::approve())]
122	fn approve(&mut self, caller: caller, spender: address, amount: uint256) -> Result<bool> {122	fn approve(&mut self, caller: caller, spender: address, amount: U256) -> Result<bool> {
123		let caller = T::CrossAccountId::from_eth(caller);123		let caller = T::CrossAccountId::from_eth(caller);
124		let spender = T::CrossAccountId::from_eth(spender);124		let spender = T::CrossAccountId::from_eth(spender);
125		let amount = amount.try_into().map_err(|_| "amount overflow")?;125		let amount = amount.try_into().map_err(|_| "amount overflow")?;
128			.map_err(dispatch_to_evm::<T>)?;128			.map_err(dispatch_to_evm::<T>)?;
129		Ok(true)129		Ok(true)
130	}130	}
131	fn allowance(&self, owner: address, spender: address) -> Result<uint256> {131	fn allowance(&self, owner: address, spender: address) -> Result<U256> {
132		self.consume_store_reads(1)?;132		self.consume_store_reads(1)?;
133		let owner = T::CrossAccountId::from_eth(owner);133		let owner = T::CrossAccountId::from_eth(owner);
134		let spender = T::CrossAccountId::from_eth(spender);134		let spender = T::CrossAccountId::from_eth(spender);
148	/// @param to account that will receive minted tokens148	/// @param to account that will receive minted tokens
149	/// @param amount amount of tokens to mint149	/// @param amount amount of tokens to mint
150	#[weight(<SelfWeightOf<T>>::create_item())]150	#[weight(<SelfWeightOf<T>>::create_item())]
151	fn mint(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {151	fn mint(&mut self, caller: caller, to: address, amount: U256) -> Result<bool> {
152		let caller = T::CrossAccountId::from_eth(caller);152		let caller = T::CrossAccountId::from_eth(caller);
153		let to = T::CrossAccountId::from_eth(to);153		let to = T::CrossAccountId::from_eth(to);
154		let amount = amount.try_into().map_err(|_| "amount overflow")?;154		let amount = amount.try_into().map_err(|_| "amount overflow")?;
178		&mut self,178		&mut self,
179		caller: caller,179		caller: caller,
180		to: pallet_common::eth::CrossAddress,180		to: pallet_common::eth::CrossAddress,
181		amount: uint256,181		amount: U256,
182	) -> Result<bool> {182	) -> Result<bool> {
183		let caller = T::CrossAccountId::from_eth(caller);183		let caller = T::CrossAccountId::from_eth(caller);
184		let to = to.into_sub_cross_account::<T>()?;184		let to = to.into_sub_cross_account::<T>()?;
196		&mut self,196		&mut self,
197		caller: caller,197		caller: caller,
198		spender: pallet_common::eth::CrossAddress,198		spender: pallet_common::eth::CrossAddress,
199		amount: uint256,199		amount: U256,
200	) -> Result<bool> {200	) -> Result<bool> {
201		let caller = T::CrossAccountId::from_eth(caller);201		let caller = T::CrossAccountId::from_eth(caller);
202		let spender = spender.into_sub_cross_account::<T>()?;202		let spender = spender.into_sub_cross_account::<T>()?;
214	/// @param amount The amount that will be burnt.214	/// @param amount The amount that will be burnt.
215	#[solidity(hide)]215	#[solidity(hide)]
216	#[weight(<SelfWeightOf<T>>::burn_from())]216	#[weight(<SelfWeightOf<T>>::burn_from())]
217	fn burn_from(&mut self, caller: caller, from: address, amount: uint256) -> Result<bool> {217	fn burn_from(&mut self, caller: caller, from: address, amount: U256) -> Result<bool> {
218		let caller = T::CrossAccountId::from_eth(caller);218		let caller = T::CrossAccountId::from_eth(caller);
219		let from = T::CrossAccountId::from_eth(from);219		let from = T::CrossAccountId::from_eth(from);
220		let amount = amount.try_into().map_err(|_| "amount overflow")?;220		let amount = amount.try_into().map_err(|_| "amount overflow")?;
237		&mut self,237		&mut self,
238		caller: caller,238		caller: caller,
239		from: pallet_common::eth::CrossAddress,239		from: pallet_common::eth::CrossAddress,
240		amount: uint256,240		amount: U256,
241	) -> Result<bool> {241	) -> Result<bool> {
242		let caller = T::CrossAccountId::from_eth(caller);242		let caller = T::CrossAccountId::from_eth(caller);
243		let from = from.into_sub_cross_account::<T>()?;243		let from = from.into_sub_cross_account::<T>()?;
254	/// Mint tokens for multiple accounts.254	/// Mint tokens for multiple accounts.
255	/// @param amounts array of pairs of account address and amount255	/// @param amounts array of pairs of account address and amount
256	#[weight(<SelfWeightOf<T>>::create_multiple_items_ex(amounts.len() as u32))]256	#[weight(<SelfWeightOf<T>>::create_multiple_items_ex(amounts.len() as u32))]
257	fn mint_bulk(&mut self, caller: caller, amounts: Vec<(address, uint256)>) -> Result<bool> {257	fn mint_bulk(&mut self, caller: caller, amounts: Vec<(address, U256)>) -> Result<bool> {
258		let caller = T::CrossAccountId::from_eth(caller);258		let caller = T::CrossAccountId::from_eth(caller);
259		let budget = self259		let budget = self
260			.recorder260			.recorder
279		&mut self,279		&mut self,
280		caller: caller,280		caller: caller,
281		to: pallet_common::eth::CrossAddress,281		to: pallet_common::eth::CrossAddress,
282		amount: uint256,282		amount: U256,
283	) -> Result<bool> {283	) -> Result<bool> {
284		let caller = T::CrossAccountId::from_eth(caller);284		let caller = T::CrossAccountId::from_eth(caller);
285		let to = to.into_sub_cross_account::<T>()?;285		let to = to.into_sub_cross_account::<T>()?;
298		caller: caller,298		caller: caller,
299		from: pallet_common::eth::CrossAddress,299		from: pallet_common::eth::CrossAddress,
300		to: pallet_common::eth::CrossAddress,300		to: pallet_common::eth::CrossAddress,
301		amount: uint256,301		amount: U256,
302	) -> Result<bool> {302	) -> Result<bool> {
303		let caller = T::CrossAccountId::from_eth(caller);303		let caller = T::CrossAccountId::from_eth(caller);
304		let from = from.into_sub_cross_account::<T>()?;304		let from = from.into_sub_cross_account::<T>()?;

--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -43,7 +43,7 @@
 use pallet_evm::{account::CrossAccountId, PrecompileHandle};
 use pallet_evm_coder_substrate::call;
 use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
-use sp_core::Get;
+use sp_core::{U256, Get};
 
 use crate::{
 	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,
@@ -122,7 +122,7 @@
 	fn set_property(
 		&mut self,
 		caller: caller,
-		token_id: uint256,
+		token_id: U256,
 		key: string,
 		value: bytes,
 	) -> Result<()> {
@@ -155,7 +155,7 @@
 	fn set_properties(
 		&mut self,
 		caller: caller,
-		token_id: uint256,
+		token_id: U256,
 		properties: Vec<eth::Property>,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -187,7 +187,7 @@
 	/// @param key Property key.
 	#[solidity(hide)]
 	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]
-	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {
+	fn delete_property(&mut self, token_id: U256, caller: caller, key: string) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
 		let key = <Vec<u8>>::from(key)
@@ -209,7 +209,7 @@
 	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]
 	fn delete_properties(
 		&mut self,
-		token_id: uint256,
+		token_id: U256,
 		caller: caller,
 		keys: Vec<string>,
 	) -> Result<()> {
@@ -239,7 +239,7 @@
 	/// @param tokenId ID of the token.
 	/// @param key Property key.
 	/// @return Property value bytes
-	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {
+	fn property(&self, token_id: U256, key: string) -> Result<bytes> {
 		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
 		let key = <Vec<u8>>::from(key)
 			.try_into()
@@ -265,7 +265,7 @@
 		#[indexed]
 		to: address,
 		#[indexed]
-		token_id: uint256,
+		token_id: U256,
 	},
 	/// @dev This emits when the approved address for an NFT is changed or
 	///  reaffirmed. The zero address indicates there is no approved address.
@@ -277,7 +277,7 @@
 		#[indexed]
 		approved: address,
 		#[indexed]
-		token_id: uint256,
+		token_id: U256,
 	},
 	/// @dev This emits when an operator is enabled or disabled for an owner.
 	///  The operator can manage all NFTs of the owner.
@@ -322,7 +322,7 @@
 	///
 	/// @return token's const_metadata
 	#[solidity(rename_selector = "tokenURI")]
-	fn token_uri(&self, token_id: uint256) -> Result<string> {
+	fn token_uri(&self, token_id: U256) -> Result<string> {
 		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
 
 		match get_token_property(self, token_id_u32, &key::url()).as_deref() {
@@ -368,12 +368,12 @@
 	/// @param index A counter less than `totalSupply()`
 	/// @return The token identifier for the `index`th NFT,
 	///  (sort order not specified)
-	fn token_by_index(&self, index: uint256) -> Result<uint256> {
+	fn token_by_index(&self, index: U256) -> Result<U256> {
 		Ok(index)
 	}
 
 	/// @dev Not implemented
-	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {
+	fn token_of_owner_by_index(&self, _owner: address, _index: U256) -> Result<U256> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
@@ -381,7 +381,7 @@
 	/// @notice Count NFTs tracked by this contract
 	/// @return A count of valid NFTs tracked by this contract, where each one of
 	///  them has an assigned and queryable owner not equal to the zero address
-	fn total_supply(&self) -> Result<uint256> {
+	fn total_supply(&self) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		Ok(<Pallet<T>>::total_supply(self).into())
 	}
@@ -396,7 +396,7 @@
 	///  function throws for queries about the zero address.
 	/// @param owner An address for whom to query the balance
 	/// @return The number of NFTs owned by `owner`, possibly zero
-	fn balance_of(&self, owner: address) -> Result<uint256> {
+	fn balance_of(&self, owner: address) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		let owner = T::CrossAccountId::from_eth(owner);
 		let balance = <AccountBalance<T>>::get((self.id, owner));
@@ -407,7 +407,7 @@
 	///  about them do throw.
 	/// @param tokenId The identifier for an NFT
 	/// @return The address of the owner of the NFT
-	fn owner_of(&self, token_id: uint256) -> Result<address> {
+	fn owner_of(&self, token_id: U256) -> Result<address> {
 		self.consume_store_reads(1)?;
 		let token: TokenId = token_id.try_into()?;
 		Ok(*<TokenData<T>>::get((self.id, token))
@@ -421,19 +421,14 @@
 		&mut self,
 		_from: address,
 		_to: address,
-		_token_id: uint256,
+		_token_id: U256,
 		_data: bytes,
 	) -> Result<()> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
 	/// @dev Not implemented
-	fn safe_transfer_from(
-		&mut self,
-		_from: address,
-		_to: address,
-		_token_id: uint256,
-	) -> Result<()> {
+	fn safe_transfer_from(&mut self, _from: address, _to: address, _token_id: U256) -> Result<()> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
@@ -453,7 +448,7 @@
 		caller: caller,
 		from: address,
 		to: address,
-		token_id: uint256,
+		token_id: U256,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
@@ -475,7 +470,7 @@
 	/// @param approved The new approved NFT controller
 	/// @param tokenId The NFT to approve
 	#[weight(<SelfWeightOf<T>>::approve())]
-	fn approve(&mut self, caller: caller, approved: address, token_id: uint256) -> Result<()> {
+	fn approve(&mut self, caller: caller, approved: address, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let approved = T::CrossAccountId::from_eth(approved);
 		let token = token_id.try_into()?;
@@ -505,7 +500,7 @@
 	}
 
 	/// @dev Not implemented
-	fn get_approved(&self, _token_id: uint256) -> Result<address> {
+	fn get_approved(&self, _token_id: U256) -> Result<address> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
@@ -528,7 +523,7 @@
 	///  operator of the current owner.
 	/// @param tokenId The NFT to approve
 	#[weight(<SelfWeightOf<T>>::burn_item())]
-	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<()> {
+	fn burn(&mut self, caller: caller, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let token = token_id.try_into()?;
 
@@ -544,8 +539,8 @@
 	/// @param to The new owner
 	/// @return uint256 The id of the newly minted token
 	#[weight(<SelfWeightOf<T>>::create_item())]
-	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {
-		let token_id: uint256 = <TokensMinted<T>>::get(self.id)
+	fn mint(&mut self, caller: caller, to: address) -> Result<U256> {
+		let token_id: U256 = <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
 			.ok_or("item id overflow")?
 			.into();
@@ -560,7 +555,7 @@
 	/// @param tokenId ID of the minted NFT
 	#[solidity(hide, rename_selector = "mint")]
 	#[weight(<SelfWeightOf<T>>::create_item())]
-	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {
+	fn mint_check_id(&mut self, caller: caller, to: address, token_id: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let token_id: u32 = token_id.try_into()?;
@@ -601,8 +596,8 @@
 		caller: caller,
 		to: address,
 		token_uri: string,
-	) -> Result<uint256> {
-		let token_id: uint256 = <TokensMinted<T>>::get(self.id)
+	) -> Result<U256> {
+		let token_id: U256 = <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
 			.ok_or("item id overflow")?
 			.into();
@@ -622,7 +617,7 @@
 		&mut self,
 		caller: caller,
 		to: address,
-		token_id: uint256,
+		token_id: U256,
 		token_uri: string,
 	) -> Result<bool> {
 		let key = key::url();
@@ -730,7 +725,7 @@
 	/// Returns the owner (in cross format) of the token.
 	///
 	/// @param tokenId Id for the token.
-	fn cross_owner_of(&self, token_id: uint256) -> Result<eth::CrossAddress> {
+	fn cross_owner_of(&self, token_id: U256) -> Result<eth::CrossAddress> {
 		Self::token_owner(&self, token_id.try_into()?)
 			.map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))
 			.ok_or(Error::Revert("key too large".into()))
@@ -741,7 +736,7 @@
 	/// @param tokenId Id for the token.
 	/// @param keys Properties keys. Empty keys for all propertyes.
 	/// @return Vector of properties key/value pairs.
-	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<eth::Property>> {
+	fn properties(&self, token_id: U256, keys: Vec<string>) -> Result<Vec<eth::Property>> {
 		let keys = keys
 			.into_iter()
 			.map(|key| {
@@ -772,7 +767,7 @@
 		&mut self,
 		caller: caller,
 		approved: eth::CrossAddress,
-		token_id: uint256,
+		token_id: U256,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let approved = approved.into_sub_cross_account::<T>()?;
@@ -789,7 +784,7 @@
 	/// @param to The new owner
 	/// @param tokenId The NFT to transfer
 	#[weight(<SelfWeightOf<T>>::transfer())]
-	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<()> {
+	fn transfer(&mut self, caller: caller, to: address, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let token = token_id.try_into()?;
@@ -811,7 +806,7 @@
 		&mut self,
 		caller: caller,
 		to: eth::CrossAddress,
-		token_id: uint256,
+		token_id: U256,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = to.into_sub_cross_account::<T>()?;
@@ -836,7 +831,7 @@
 		caller: caller,
 		from: eth::CrossAddress,
 		to: eth::CrossAddress,
-		token_id: uint256,
+		token_id: U256,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = from.into_sub_cross_account::<T>()?;
@@ -858,7 +853,7 @@
 	/// @param tokenId The NFT to transfer
 	#[solidity(hide)]
 	#[weight(<SelfWeightOf<T>>::burn_from())]
-	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<()> {
+	fn burn_from(&mut self, caller: caller, from: address, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
 		let token = token_id.try_into()?;
@@ -882,7 +877,7 @@
 		&mut self,
 		caller: caller,
 		from: eth::CrossAddress,
-		token_id: uint256,
+		token_id: U256,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = from.into_sub_cross_account::<T>()?;
@@ -897,7 +892,7 @@
 	}
 
 	/// @notice Returns next free NFT ID.
-	fn next_token_id(&self) -> Result<uint256> {
+	fn next_token_id(&self) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		Ok(<TokensMinted<T>>::get(self.id)
 			.checked_add(1)
@@ -912,7 +907,7 @@
 	/// @param tokenIds IDs of the minted NFTs
 	#[solidity(hide)]
 	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
-	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {
+	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<U256>) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let mut expected_index = <TokensMinted<T>>::get(self.id)
@@ -953,7 +948,7 @@
 		&mut self,
 		caller: caller,
 		to: address,
-		tokens: Vec<(uint256, string)>,
+		tokens: Vec<(U256, string)>,
 	) -> Result<bool> {
 		let key = key::url();
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -1005,7 +1000,7 @@
 		caller: caller,
 		to: eth::CrossAddress,
 		properties: Vec<eth::Property>,
-	) -> Result<uint256> {
+	) -> Result<U256> {
 		let token_id = <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
 			.ok_or("item id overflow")?;

--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -39,7 +39,7 @@
 use pallet_evm::{account::CrossAccountId, PrecompileHandle};
 use pallet_evm_coder_substrate::{call, dispatch_to_evm};
 use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
-use sp_core::{H160, Get};
+use sp_core::{H160, U256, Get};
 use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};
 use up_data_structs::{
 	CollectionId, CollectionPropertiesVec, mapping::TokenAddressMapping, Property, PropertyKey,
@@ -125,7 +125,7 @@
 	fn set_property(
 		&mut self,
 		caller: caller,
-		token_id: uint256,
+		token_id: U256,
 		key: string,
 		value: bytes,
 	) -> Result<()> {
@@ -158,7 +158,7 @@
 	fn set_properties(
 		&mut self,
 		caller: caller,
-		token_id: uint256,
+		token_id: U256,
 		properties: Vec<eth::Property>,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -190,7 +190,7 @@
 	/// @param key Property key.
 	#[solidity(hide)]
 	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]
-	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {
+	fn delete_property(&mut self, token_id: U256, caller: caller, key: string) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
 		let key = <Vec<u8>>::from(key)
@@ -212,7 +212,7 @@
 	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]
 	fn delete_properties(
 		&mut self,
-		token_id: uint256,
+		token_id: U256,
 		caller: caller,
 		keys: Vec<string>,
 	) -> Result<()> {
@@ -242,7 +242,7 @@
 	/// @param tokenId ID of the token.
 	/// @param key Property key.
 	/// @return Property value bytes
-	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {
+	fn property(&self, token_id: U256, key: string) -> Result<bytes> {
 		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
 		let key = <Vec<u8>>::from(key)
 			.try_into()
@@ -266,7 +266,7 @@
 		#[indexed]
 		to: address,
 		#[indexed]
-		token_id: uint256,
+		token_id: U256,
 	},
 	/// @dev Not supported
 	Approval {
@@ -275,7 +275,7 @@
 		#[indexed]
 		approved: address,
 		#[indexed]
-		token_id: uint256,
+		token_id: U256,
 	},
 	/// @dev Not supported
 	#[allow(dead_code)]
@@ -319,7 +319,7 @@
 	///
 	/// @return token's const_metadata
 	#[solidity(rename_selector = "tokenURI")]
-	fn token_uri(&self, token_id: uint256) -> Result<string> {
+	fn token_uri(&self, token_id: U256) -> Result<string> {
 		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
 
 		match get_token_property(self, token_id_u32, &key::url()).as_deref() {
@@ -365,12 +365,12 @@
 	/// @param index A counter less than `totalSupply()`
 	/// @return The token identifier for the `index`th NFT,
 	///  (sort order not specified)
-	fn token_by_index(&self, index: uint256) -> Result<uint256> {
+	fn token_by_index(&self, index: U256) -> Result<U256> {
 		Ok(index)
 	}
 
 	/// Not implemented
-	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {
+	fn token_of_owner_by_index(&self, _owner: address, _index: U256) -> Result<U256> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
@@ -378,7 +378,7 @@
 	/// @notice Count RFTs tracked by this contract
 	/// @return A count of valid RFTs tracked by this contract, where each one of
 	///  them has an assigned and queryable owner not equal to the zero address
-	fn total_supply(&self) -> Result<uint256> {
+	fn total_supply(&self) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		Ok(<Pallet<T>>::total_supply(self).into())
 	}
@@ -393,7 +393,7 @@
 	///  function throws for queries about the zero address.
 	/// @param owner An address for whom to query the balance
 	/// @return The number of RFTs owned by `owner`, possibly zero
-	fn balance_of(&self, owner: address) -> Result<uint256> {
+	fn balance_of(&self, owner: address) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		let owner = T::CrossAccountId::from_eth(owner);
 		let balance = <AccountBalance<T>>::get((self.id, owner));
@@ -407,7 +407,7 @@
 	///  the tokens that are partially owned.
 	/// @param tokenId The identifier for an RFT
 	/// @return The address of the owner of the RFT
-	fn owner_of(&self, token_id: uint256) -> Result<address> {
+	fn owner_of(&self, token_id: U256) -> Result<address> {
 		self.consume_store_reads(2)?;
 		let token = token_id.try_into()?;
 		let owner = <Pallet<T>>::token_owner(self.id, token);
@@ -422,7 +422,7 @@
 		&mut self,
 		_from: address,
 		_to: address,
-		_token_id: uint256,
+		_token_id: U256,
 		_data: bytes,
 	) -> Result<()> {
 		// TODO: Not implemetable
@@ -431,12 +431,7 @@
 
 	/// @dev Not implemented
 	#[solidity(rename_selector = "safeTransferFrom")]
-	fn safe_transfer_from(
-		&mut self,
-		_from: address,
-		_to: address,
-		_token_id: uint256,
-	) -> Result<()> {
+	fn safe_transfer_from(&mut self, _from: address, _to: address, _token_id: U256) -> Result<()> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
@@ -457,7 +452,7 @@
 		caller: caller,
 		from: address,
 		to: address,
-		token_id: uint256,
+		token_id: U256,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
@@ -477,7 +472,7 @@
 	}
 
 	/// @dev Not implemented
-	fn approve(&mut self, _caller: caller, _approved: address, _token_id: uint256) -> Result<()> {
+	fn approve(&mut self, _caller: caller, _approved: address, _token_id: U256) -> Result<()> {
 		Err("not implemented".into())
 	}
 
@@ -501,7 +496,7 @@
 	}
 
 	/// @dev Not implemented
-	fn get_approved(&self, _token_id: uint256) -> Result<address> {
+	fn get_approved(&self, _token_id: U256) -> Result<address> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
@@ -556,7 +551,7 @@
 	///  operator of the current owner.
 	/// @param tokenId The RFT to approve
 	#[weight(<SelfWeightOf<T>>::burn_item_fully())]
-	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<()> {
+	fn burn(&mut self, caller: caller, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let token = token_id.try_into()?;
 
@@ -575,8 +570,8 @@
 	/// @param to The new owner
 	/// @return uint256 The id of the newly minted token
 	#[weight(<SelfWeightOf<T>>::create_item())]
-	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {
-		let token_id: uint256 = <TokensMinted<T>>::get(self.id)
+	fn mint(&mut self, caller: caller, to: address) -> Result<U256> {
+		let token_id: U256 = <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
 			.ok_or("item id overflow")?
 			.into();
@@ -591,7 +586,7 @@
 	/// @param tokenId ID of the minted RFT
 	#[solidity(hide, rename_selector = "mint")]
 	#[weight(<SelfWeightOf<T>>::create_item())]
-	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {
+	fn mint_check_id(&mut self, caller: caller, to: address, token_id: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let token_id: u32 = token_id.try_into()?;
@@ -637,8 +632,8 @@
 		caller: caller,
 		to: address,
 		token_uri: string,
-	) -> Result<uint256> {
-		let token_id: uint256 = <TokensMinted<T>>::get(self.id)
+	) -> Result<U256> {
+		let token_id: U256 = <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
 			.ok_or("item id overflow")?
 			.into();
@@ -658,7 +653,7 @@
 		&mut self,
 		caller: caller,
 		to: address,
-		token_id: uint256,
+		token_id: U256,
 		token_uri: string,
 	) -> Result<bool> {
 		let key = key::url();
@@ -768,7 +763,7 @@
 	/// Returns the owner (in cross format) of the token.
 	///
 	/// @param tokenId Id for the token.
-	fn cross_owner_of(&self, token_id: uint256) -> Result<eth::CrossAddress> {
+	fn cross_owner_of(&self, token_id: U256) -> Result<eth::CrossAddress> {
 		Self::token_owner(&self, token_id.try_into()?)
 			.map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))
 			.ok_or(Error::Revert("key too large".into()))
@@ -779,7 +774,7 @@
 	/// @param tokenId Id for the token.
 	/// @param keys Properties keys. Empty keys for all propertyes.
 	/// @return Vector of properties key/value pairs.
-	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<eth::Property>> {
+	fn properties(&self, token_id: U256, keys: Vec<string>) -> Result<Vec<eth::Property>> {
 		let keys = keys
 			.into_iter()
 			.map(|key| {
@@ -805,7 +800,7 @@
 	/// @param to The new owner
 	/// @param tokenId The RFT to transfer
 	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]
-	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<()> {
+	fn transfer(&mut self, caller: caller, to: address, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let token = token_id.try_into()?;
@@ -832,7 +827,7 @@
 		&mut self,
 		caller: caller,
 		to: eth::CrossAddress,
-		token_id: uint256,
+		token_id: U256,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = to.into_sub_cross_account::<T>()?;
@@ -861,7 +856,7 @@
 		caller: caller,
 		from: eth::CrossAddress,
 		to: eth::CrossAddress,
-		token_id: uint256,
+		token_id: U256,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = from.into_sub_cross_account::<T>()?;
@@ -888,7 +883,7 @@
 	/// @param tokenId The RFT to transfer
 	#[solidity(hide)]
 	#[weight(<SelfWeightOf<T>>::burn_from())]
-	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<()> {
+	fn burn_from(&mut self, caller: caller, from: address, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
 		let token = token_id.try_into()?;
@@ -916,7 +911,7 @@
 		&mut self,
 		caller: caller,
 		from: eth::CrossAddress,
-		token_id: uint256,
+		token_id: U256,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = from.into_sub_cross_account::<T>()?;
@@ -934,7 +929,7 @@
 	}
 
 	/// @notice Returns next free RFT ID.
-	fn next_token_id(&self) -> Result<uint256> {
+	fn next_token_id(&self) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		Ok(<TokensMinted<T>>::get(self.id)
 			.checked_add(1)
@@ -949,7 +944,7 @@
 	/// @param tokenIds IDs of the minted RFTs
 	#[solidity(hide)]
 	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
-	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {
+	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<U256>) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let mut expected_index = <TokensMinted<T>>::get(self.id)
@@ -996,7 +991,7 @@
 		&mut self,
 		caller: caller,
 		to: address,
-		tokens: Vec<(uint256, string)>,
+		tokens: Vec<(U256, string)>,
 	) -> Result<bool> {
 		let key = key::url();
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -1054,7 +1049,7 @@
 		caller: caller,
 		to: eth::CrossAddress,
 		properties: Vec<eth::Property>,
-	) -> Result<uint256> {
+	) -> Result<U256> {
 		let token_id = <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
 			.ok_or("item id overflow")?;
@@ -1093,7 +1088,7 @@
 	/// Returns EVM address for refungible token
 	///
 	/// @param token ID of the token
-	fn token_contract_address(&self, token: uint256) -> Result<address> {
+	fn token_contract_address(&self, token: U256) -> Result<address> {
 		Ok(T::EvmTokenAddressMapping::token_to_address(
 			self.id,
 			token.try_into().map_err(|_| "token id overflow")?,

--- a/pallets/refungible/src/erc_token.rs
+++ b/pallets/refungible/src/erc_token.rs
@@ -37,6 +37,7 @@
 use pallet_evm_coder_substrate::{call, dispatch_to_evm, WithRecorder};
 use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
 use sp_std::vec::Vec;
+use sp_core::U256;
 use up_data_structs::TokenId;
 
 use crate::{
@@ -55,7 +56,7 @@
 		Ok(collection_id_to_address(self.id))
 	}
 
-	fn parent_token_id(&self) -> Result<uint256> {
+	fn parent_token_id(&self) -> Result<U256> {
 		Ok(self.1.into())
 	}
 }
@@ -71,7 +72,7 @@
 		from: address,
 		#[indexed]
 		to: address,
-		value: uint256,
+		value: U256,
 	},
 	/// @dev This event is emitted when the amount of tokens (value) is approved
 	/// by the owner to be used by the spender.
@@ -80,7 +81,7 @@
 		owner: address,
 		#[indexed]
 		spender: address,
-		value: uint256,
+		value: U256,
 	},
 }
 
@@ -103,7 +104,7 @@
 	}
 
 	/// @dev Total number of tokens in existence
-	fn total_supply(&self) -> Result<uint256> {
+	fn total_supply(&self) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		Ok(<TotalSupply<T>>::get((self.id, self.1)).into())
 	}
@@ -117,7 +118,7 @@
 	/// @dev Gets the balance of the specified address.
 	/// @param owner The address to query the balance of.
 	/// @return An uint256 representing the amount owned by the passed address.
-	fn balance_of(&self, owner: address) -> Result<uint256> {
+	fn balance_of(&self, owner: address) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		let owner = T::CrossAccountId::from_eth(owner);
 		let balance = <Balance<T>>::get((self.id, self.1, owner));
@@ -128,7 +129,7 @@
 	/// @param to The address to transfer to.
 	/// @param amount The amount to be transferred.
 	#[weight(<CommonWeights<T>>::transfer())]
-	fn transfer(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {
+	fn transfer(&mut self, caller: caller, to: address, amount: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -151,7 +152,7 @@
 		caller: caller,
 		from: address,
 		to: address,
-		amount: uint256,
+		amount: U256,
 	) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
@@ -174,7 +175,7 @@
 	/// @param spender The address which will spend the funds.
 	/// @param amount The amount of tokens to be spent.
 	#[weight(<SelfWeightOf<T>>::approve())]
-	fn approve(&mut self, caller: caller, spender: address, amount: uint256) -> Result<bool> {
+	fn approve(&mut self, caller: caller, spender: address, amount: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let spender = T::CrossAccountId::from_eth(spender);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -188,7 +189,7 @@
 	/// @param owner address The address which owns the funds.
 	/// @param spender address The address which will spend the funds.
 	/// @return A uint256 specifying the amount of tokens still available for the spender.
-	fn allowance(&self, owner: address, spender: address) -> Result<uint256> {
+	fn allowance(&self, owner: address, spender: address) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		let owner = T::CrossAccountId::from_eth(owner);
 		let spender = T::CrossAccountId::from_eth(spender);
@@ -208,7 +209,7 @@
 	/// @param amount The amount that will be burnt.
 	#[weight(<SelfWeightOf<T>>::burn_from())]
 	#[solidity(hide)]
-	fn burn_from(&mut self, caller: caller, from: address, amount: uint256) -> Result<bool> {
+	fn burn_from(&mut self, caller: caller, from: address, amount: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -230,7 +231,7 @@
 		&mut self,
 		caller: caller,
 		from: pallet_common::eth::CrossAddress,
-		amount: uint256,
+		amount: U256,
 	) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = from.into_sub_cross_account::<T>()?;
@@ -256,7 +257,7 @@
 		&mut self,
 		caller: caller,
 		spender: pallet_common::eth::CrossAddress,
-		amount: uint256,
+		amount: U256,
 	) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let spender = spender.into_sub_cross_account::<T>()?;
@@ -270,7 +271,7 @@
 	///  Throws if `msg.sender` doesn't owns all of the tokens.
 	/// @param amount New total amount of the tokens.
 	#[weight(<SelfWeightOf<T>>::repartition_item())]
-	fn repartition(&mut self, caller: caller, amount: uint256) -> Result<bool> {
+	fn repartition(&mut self, caller: caller, amount: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
 
@@ -286,7 +287,7 @@
 		&mut self,
 		caller: caller,
 		to: pallet_common::eth::CrossAddress,
-		amount: uint256,
+		amount: U256,
 	) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = to.into_sub_cross_account::<T>()?;
@@ -310,7 +311,7 @@
 		caller: caller,
 		from: pallet_common::eth::CrossAddress,
 		to: pallet_common::eth::CrossAddress,
-		amount: uint256,
+		amount: U256,
 	) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = from.into_sub_cross_account::<T>()?;

--- a/tests/src/eth/abi/nonFungible.json
+++ b/tests/src/eth/abi/nonFungible.json
@@ -51,6 +51,12 @@
   },
   {
     "anonymous": false,
+    "inputs": [],
+    "name": "MintingFinished",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
     "inputs": [
       {
         "indexed": true,
@@ -417,6 +423,13 @@
     "type": "function"
   },
   {
+    "inputs": [],
+    "name": "finishMinting",
+    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
     "inputs": [
       { "internalType": "uint256", "name": "tokenId", "type": "uint256" }
     ],
@@ -504,6 +517,13 @@
   },
   {
     "inputs": [],
+    "name": "mintingFinished",
+    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
     "name": "name",
     "outputs": [{ "internalType": "string", "name": "", "type": "string" }],
     "stateMutability": "view",

--- a/tests/src/eth/abi/reFungible.json
+++ b/tests/src/eth/abi/reFungible.json
@@ -51,6 +51,12 @@
   },
   {
     "anonymous": false,
+    "inputs": [],
+    "name": "MintingFinished",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
     "inputs": [
       {
         "indexed": true,
@@ -399,6 +405,13 @@
     "type": "function"
   },
   {
+    "inputs": [],
+    "name": "finishMinting",
+    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
     "inputs": [
       { "internalType": "uint256", "name": "tokenId", "type": "uint256" }
     ],
@@ -486,6 +499,13 @@
   },
   {
     "inputs": [],
+    "name": "mintingFinished",
+    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
     "name": "name",
     "outputs": [{ "internalType": "string", "name": "", "type": "string" }],
     "stateMutability": "view",

--- a/tests/src/eth/abi/reFungibleToken.json
+++ b/tests/src/eth/abi/reFungibleToken.json
@@ -98,6 +98,16 @@
   },
   {
     "inputs": [
+      { "internalType": "address", "name": "from", "type": "address" },
+      { "internalType": "uint256", "name": "amount", "type": "uint256" }
+    ],
+    "name": "burnFrom",
+    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
       {
         "components": [
           { "internalType": "address", "name": "eth", "type": "address" },