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

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -25,7 +25,8 @@
 use pallet_evm_coder_substrate::dispatch_to_evm;
 use sp_std::vec::Vec;
 use up_data_structs::{
-	Property, SponsoringRateLimit, OwnerRestrictedSet, AccessMode, CollectionPermissions,
+	AccessMode, CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property,
+	SponsoringRateLimit,
 };
 use alloc::format;
 
@@ -408,6 +409,27 @@
 
 		save(self)
 	}
+
+	/// Check that account is the owner or admin of the collection
+	///
+	/// @return "true" if account is the owner or admin
+	fn verify_owner_or_admin(&mut self, caller: caller) -> Result<bool> {
+		Ok(check_is_owner_or_admin(caller, self)
+			.map(|_| true)
+			.unwrap_or(false))
+	}
+
+	/// Returns collection type
+	///
+	/// @return `Fungible` or `NFT` or `ReFungible`
+	fn unique_collection_type(&mut self) -> Result<string> {
+		let mode = match self.collection.mode {
+			CollectionMode::Fungible(_) => "Fungible",
+			CollectionMode::NFT => "NFT",
+			CollectionMode::ReFungible => "ReFungible",
+		};
+		Ok(mode.into())
+	}
 }
 
 fn check_is_owner_or_admin<T: Config>(
@@ -462,6 +484,11 @@
 		pub fn suffix() -> up_data_structs::PropertyKey {
 			property_key_from_bytes(b"suffix").expect(EXPECT_CONVERT_ERROR)
 		}
+
+		/// Key "parentNft".
+		pub fn parent_nft() -> up_data_structs::PropertyKey {
+			property_key_from_bytes(b"parentNft").expect(EXPECT_CONVERT_ERROR)
+		}
 	}
 
 	/// Values.

--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -1112,6 +1112,26 @@
 		sender: &T::CrossAccountId,
 		property_permission: PropertyKeyPermission,
 	) -> DispatchResult {
+		Self::set_scoped_property_permission(
+			collection,
+			sender,
+			PropertyScope::None,
+			property_permission,
+		)
+	}
+
+	/// Set collection property permission with scope.
+	///
+	/// * `collection` - Collection handler.
+	/// * `sender` - The owner or administrator of the collection.
+	/// * `scope` - Property scope.
+	/// * `property_permission` - Property permission.
+	pub fn set_scoped_property_permission(
+		collection: &CollectionHandle<T>,
+		sender: &T::CrossAccountId,
+		scope: PropertyScope,
+		property_permission: PropertyKeyPermission,
+	) -> DispatchResult {
 		collection.check_is_owner_or_admin(sender)?;
 
 		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);
@@ -1125,7 +1145,11 @@
 
 		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {
 			let property_permission = property_permission.clone();
-			permissions.try_set(property_permission.key, property_permission.permission)
+			permissions.try_scoped_set(
+				scope,
+				property_permission.key,
+				property_permission.permission,
+			)
 		})
 		.map_err(<Error<T>>::from)?;
 
@@ -1148,8 +1172,29 @@
 		sender: &T::CrossAccountId,
 		property_permissions: Vec<PropertyKeyPermission>,
 	) -> DispatchResult {
+		Self::set_scoped_token_property_permissions(
+			collection,
+			sender,
+			PropertyScope::None,
+			property_permissions,
+		)
+	}
+
+	/// Set token property permission with scope.
+	///
+	/// * `collection` - Collection handler.
+	/// * `sender` - The owner or administrator of the collection.
+	/// * `scope` - Property scope.
+	/// * `property_permissions` - Property permissions.
+	#[transactional]
+	pub fn set_scoped_token_property_permissions(
+		collection: &CollectionHandle<T>,
+		sender: &T::CrossAccountId,
+		scope: PropertyScope,
+		property_permissions: Vec<PropertyKeyPermission>,
+	) -> DispatchResult {
 		for prop_pemission in property_permissions {
-			Self::set_property_permission(collection, sender, prop_pemission)?;
+			Self::set_scoped_property_permission(collection, sender, scope, prop_pemission)?;
 		}
 
 		Ok(())
@@ -1429,6 +1474,9 @@
 			.saturating_mul(max_selfs.max(1) as u64)
 			.saturating_add(Self::burn_recursively_breadth_raw(max_breadth))
 	}
+
+	/// The price of retrieving token owner
+	fn token_owner() -> Weight;
 }
 
 /// Weight info extension trait for refungible pallet.
@@ -1567,7 +1615,7 @@
 	///
 	/// * `sender` - Must be either the owner of the token or its admin.
 	/// * `token_id` - The token for which the properties are being set.
-	/// * `properties` - Properties to be set.
+	/// * `property_permissions` - Property permissions to be set.
 	/// * `budget` - Budget for setting properties.
 	fn set_token_property_permissions(
 		&self,

--- a/pallets/fungible/src/common.rs
+++ b/pallets/fungible/src/common.rs
@@ -103,6 +103,10 @@
 		// Fungible tokens can't have children
 		0
 	}
+
+	fn token_owner() -> Weight {
+		0
+	}
 }
 
 /// Implementation of `CommonCollectionOperations` for `FungibleHandle`. It wraps FungibleHandle Pallete

--- a/pallets/fungible/src/stubs/UniqueFungible.sol
+++ b/pallets/fungible/src/stubs/UniqueFungible.sol
@@ -43,7 +43,91 @@
 	}
 }
 
-// Selector: 7d9262e6
+// Selector: 942e8b22
+contract ERC20 is Dummy, ERC165, ERC20Events {
+	// Selector: name() 06fdde03
+	function name() public view returns (string memory) {
+		require(false, stub_error);
+		dummy;
+		return "";
+	}
+
+	// Selector: symbol() 95d89b41
+	function symbol() public view returns (string memory) {
+		require(false, stub_error);
+		dummy;
+		return "";
+	}
+
+	// Selector: totalSupply() 18160ddd
+	function totalSupply() public view returns (uint256) {
+		require(false, stub_error);
+		dummy;
+		return 0;
+	}
+
+	// Selector: decimals() 313ce567
+	function decimals() public view returns (uint8) {
+		require(false, stub_error);
+		dummy;
+		return 0;
+	}
+
+	// Selector: balanceOf(address) 70a08231
+	function balanceOf(address owner) public view returns (uint256) {
+		require(false, stub_error);
+		owner;
+		dummy;
+		return 0;
+	}
+
+	// Selector: transfer(address,uint256) a9059cbb
+	function transfer(address to, uint256 amount) public returns (bool) {
+		require(false, stub_error);
+		to;
+		amount;
+		dummy = 0;
+		return false;
+	}
+
+	// Selector: transferFrom(address,address,uint256) 23b872dd
+	function transferFrom(
+		address from,
+		address to,
+		uint256 amount
+	) public returns (bool) {
+		require(false, stub_error);
+		from;
+		to;
+		amount;
+		dummy = 0;
+		return false;
+	}
+
+	// Selector: approve(address,uint256) 095ea7b3
+	function approve(address spender, uint256 amount) public returns (bool) {
+		require(false, stub_error);
+		spender;
+		amount;
+		dummy = 0;
+		return false;
+	}
+
+	// Selector: allowance(address,address) dd62ed3e
+	function allowance(address owner, address spender)
+		public
+		view
+		returns (uint256)
+	{
+		require(false, stub_error);
+		owner;
+		spender;
+		dummy;
+		return 0;
+	}
+}
+
+// Selector: aa7d570d
 contract Collection is Dummy, ERC165 {
 	// Set collection property.
 	//
@@ -267,90 +351,24 @@
 		require(false, stub_error);
 		mode;
 		dummy = 0;
-	}
-}
-
-// Selector: 942e8b22
-contract ERC20 is Dummy, ERC165, ERC20Events {
-	// Selector: name() 06fdde03
-	function name() public view returns (string memory) {
-		require(false, stub_error);
-		dummy;
-		return "";
 	}
 
-	// Selector: symbol() 95d89b41
-	function symbol() public view returns (string memory) {
-		require(false, stub_error);
-		dummy;
-		return "";
-	}
-
-	// Selector: totalSupply() 18160ddd
-	function totalSupply() public view returns (uint256) {
-		require(false, stub_error);
-		dummy;
-		return 0;
-	}
-
-	// Selector: decimals() 313ce567
-	function decimals() public view returns (uint8) {
-		require(false, stub_error);
-		dummy;
-		return 0;
-	}
-
-	// Selector: balanceOf(address) 70a08231
-	function balanceOf(address owner) public view returns (uint256) {
-		require(false, stub_error);
-		owner;
-		dummy;
-		return 0;
-	}
-
-	// Selector: transfer(address,uint256) a9059cbb
-	function transfer(address to, uint256 amount) public returns (bool) {
-		require(false, stub_error);
-		to;
-		amount;
-		dummy = 0;
-		return false;
-	}
-
-	// Selector: transferFrom(address,address,uint256) 23b872dd
-	function transferFrom(
-		address from,
-		address to,
-		uint256 amount
-	) public returns (bool) {
+	// Check that account is the owner or admin of the collection
+	//
+	// @return "true" if account is the owner or admin
+	//
+	// Selector: verifyOwnerOrAdmin() 04a46053
+	function verifyOwnerOrAdmin() public returns (bool) {
 		require(false, stub_error);
-		from;
-		to;
-		amount;
 		dummy = 0;
 		return false;
 	}
 
-	// Selector: approve(address,uint256) 095ea7b3
-	function approve(address spender, uint256 amount) public returns (bool) {
+	// Selector: uniqueCollectionType() d34b55b8
+	function uniqueCollectionType() public returns (string memory) {
 		require(false, stub_error);
-		spender;
-		amount;
 		dummy = 0;
-		return false;
-	}
-
-	// Selector: allowance(address,address) dd62ed3e
-	function allowance(address owner, address spender)
-		public
-		view
-		returns (uint256)
-	{
-		require(false, stub_error);
-		owner;
-		spender;
-		dummy;
-		return 0;
+		return "";
 	}
 }
 

--- a/pallets/nonfungible/src/benchmarking.rs
+++ b/pallets/nonfungible/src/benchmarking.rs
@@ -17,11 +17,14 @@
 use super::*;
 use crate::{Pallet, Config, NonfungibleHandle};
 
-use sp_std::prelude::*;
-use pallet_common::benchmarking::{create_collection_raw, property_key, property_value};
 use frame_benchmarking::{benchmarks, account};
+use pallet_common::{
+	bench_init,
+	benchmarking::{create_collection_raw, property_key, property_value},
+	CommonCollectionOperations,
+};
+use sp_std::prelude::*;
 use up_data_structs::{CollectionMode, MAX_ITEMS_PER_BATCH, MAX_PROPERTIES_PER_ITEM, budget::Unlimited};
-use pallet_common::bench_init;
 
 const SEED: u32 = 1;
 
@@ -208,4 +211,13 @@
 		<Pallet<T>>::set_token_properties(&collection, &owner, item, props.into_iter(), false, &Unlimited)?;
 		let to_delete = (0..b).map(|k| property_key(k as usize)).collect::<Vec<_>>();
 	}: {<Pallet<T>>::delete_token_properties(&collection, &owner, item, to_delete.into_iter(), &Unlimited)?}
+
+	token_owner {
+		bench_init!{
+			owner: sub; collection: collection(owner);
+			owner: cross_from_sub;
+		};
+		let item = create_max_item(&collection, &owner, owner.clone())?;
+
+	}: {collection.token_owner(item)}
 }

--- a/pallets/nonfungible/src/common.rs
+++ b/pallets/nonfungible/src/common.rs
@@ -118,6 +118,10 @@
 		<SelfWeightOf<T>>::burn_recursively_breadth_plus_self_plus_self_per_each_raw(amount)
 			.saturating_sub(Self::burn_recursively_self_raw().saturating_mul(amount as u64 + 1))
 	}
+
+	fn token_owner() -> Weight {
+		0 //<SelfWeightOf<T>>::token_owner()
+	}
 }
 
 fn map_create_data<T: Config>(

--- a/pallets/nonfungible/src/lib.rs
+++ b/pallets/nonfungible/src/lib.rs
@@ -784,6 +784,23 @@
 		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)
 	}
 
+	/// Set property permissions for the token with scope.
+	///
+	/// Sender should be the owner or admin of token's collection.
+	pub fn set_scoped_token_property_permissions(
+		collection: &CollectionHandle<T>,
+		sender: &T::CrossAccountId,
+		scope: PropertyScope,
+		property_permissions: Vec<PropertyKeyPermission>,
+	) -> DispatchResult {
+		<PalletCommon<T>>::set_scoped_token_property_permissions(
+			collection,
+			sender,
+			scope,
+			property_permissions,
+		)
+	}
+
 	/// Set property permissions for the collection.
 	///
 	/// Sender should be the owner or admin of the collection.

--- a/pallets/nonfungible/src/stubs/UniqueNFT.sol
+++ b/pallets/nonfungible/src/stubs/UniqueNFT.sol
@@ -415,7 +415,7 @@
 	}
 }
 
-// Selector: 7d9262e6
+// Selector: aa7d570d
 contract Collection is Dummy, ERC165 {
 	// Set collection property.
 	//
@@ -640,6 +640,24 @@
 		mode;
 		dummy = 0;
 	}
+
+	// Check that account is the owner or admin of the collection
+	//
+	// @return "true" if account is the owner or admin
+	//
+	// Selector: verifyOwnerOrAdmin() 04a46053
+	function verifyOwnerOrAdmin() public returns (bool) {
+		require(false, stub_error);
+		dummy = 0;
+		return false;
+	}
+
+	// Selector: uniqueCollectionType() d34b55b8
+	function uniqueCollectionType() public returns (string memory) {
+		require(false, stub_error);
+		dummy = 0;
+		return "";
+	}
 }
 
 // Selector: d74d154f

--- a/pallets/nonfungible/src/weights.rs
+++ b/pallets/nonfungible/src/weights.rs
@@ -3,7 +3,7 @@
 //! Autogenerated weights for pallet_nonfungible
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2022-07-20, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2022-08-01, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
 
 // Executed Command:
@@ -46,6 +46,7 @@
 	fn set_token_property_permissions(b: u32, ) -> Weight;
 	fn set_token_properties(b: u32, ) -> Weight;
 	fn delete_token_properties(b: u32, ) -> Weight;
+	fn token_owner() -> Weight;
 }
 
 /// Weights for pallet_nonfungible using the Substrate node and recommended hardware.
@@ -56,7 +57,7 @@
 	// Storage: Nonfungible TokenData (r:0 w:1)
 	// Storage: Nonfungible Owned (r:0 w:1)
 	fn create_item() -> Weight {
-		(20_328_000 as Weight)
+		(20_909_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(2 as Weight))
 			.saturating_add(T::DbWeight::get().writes(4 as Weight))
 	}
@@ -65,9 +66,9 @@
 	// Storage: Nonfungible TokenData (r:0 w:4)
 	// Storage: Nonfungible Owned (r:0 w:4)
 	fn create_multiple_items(b: u32, ) -> Weight {
-		(10_134_000 as Weight)
-			// Standard Error: 3_000
-			.saturating_add((4_927_000 as Weight).saturating_mul(b as Weight))
+		(12_601_000 as Weight)
+			// Standard Error: 1_000
+			.saturating_add((4_920_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(T::DbWeight::get().reads(2 as Weight))
 			.saturating_add(T::DbWeight::get().writes(2 as Weight))
 			.saturating_add(T::DbWeight::get().writes((2 as Weight).saturating_mul(b as Weight)))
@@ -77,9 +78,9 @@
 	// Storage: Nonfungible TokenData (r:0 w:4)
 	// Storage: Nonfungible Owned (r:0 w:4)
 	fn create_multiple_items_ex(b: u32, ) -> Weight {
-		(5_710_000 as Weight)
-			// Standard Error: 4_000
-			.saturating_add((7_578_000 as Weight).saturating_mul(b as Weight))
+		(0 as Weight)
+			// Standard Error: 3_000
+			.saturating_add((7_734_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
@@ -93,7 +94,7 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_item() -> Weight {
-		(28_433_000 as Weight)
+		(29_746_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(5 as Weight))
 			.saturating_add(T::DbWeight::get().writes(5 as Weight))
 	}
@@ -105,7 +106,7 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_recursively_self_raw() -> Weight {
-		(34_435_000 as Weight)
+		(36_077_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(5 as Weight))
 			.saturating_add(T::DbWeight::get().writes(5 as Weight))
 	}
@@ -119,8 +120,8 @@
 	// Storage: Common CollectionById (r:1 w:0)
 	fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 1_539_000
-			.saturating_add((304_456_000 as Weight).saturating_mul(b as Weight))
+			// Standard Error: 1_605_000
+			.saturating_add((312_391_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(T::DbWeight::get().reads(7 as Weight))
 			.saturating_add(T::DbWeight::get().reads((4 as Weight).saturating_mul(b as Weight)))
 			.saturating_add(T::DbWeight::get().writes(6 as Weight))
@@ -131,14 +132,14 @@
 	// Storage: Nonfungible Allowance (r:1 w:0)
 	// Storage: Nonfungible Owned (r:0 w:2)
 	fn transfer() -> Weight {
-		(24_376_000 as Weight)
+		(25_248_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(4 as Weight))
 			.saturating_add(T::DbWeight::get().writes(5 as Weight))
 	}
 	// Storage: Nonfungible TokenData (r:1 w:0)
 	// Storage: Nonfungible Allowance (r:1 w:1)
 	fn approve() -> Weight {
-		(15_890_000 as Weight)
+		(16_321_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(2 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
@@ -147,7 +148,7 @@
 	// Storage: Nonfungible AccountBalance (r:2 w:2)
 	// Storage: Nonfungible Owned (r:0 w:2)
 	fn transfer_from() -> Weight {
-		(28_634_000 as Weight)
+		(29_325_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(4 as Weight))
 			.saturating_add(T::DbWeight::get().writes(6 as Weight))
 	}
@@ -159,15 +160,15 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_from() -> Weight {
-		(32_201_000 as Weight)
+		(33_323_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(5 as Weight))
 			.saturating_add(T::DbWeight::get().writes(6 as Weight))
 	}
 	// Storage: Common CollectionPropertyPermissions (r:1 w:1)
 	fn set_token_property_permissions(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 57_000
-			.saturating_add((15_232_000 as Weight).saturating_mul(b as Weight))
+			// Standard Error: 62_000
+			.saturating_add((16_222_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
@@ -175,8 +176,8 @@
 	// Storage: Nonfungible TokenProperties (r:1 w:1)
 	fn set_token_properties(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 1_648_000
-			.saturating_add((288_654_000 as Weight).saturating_mul(b as Weight))
+			// Standard Error: 1_750_000
+			.saturating_add((304_476_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(T::DbWeight::get().reads(2 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
@@ -184,11 +185,16 @@
 	// Storage: Nonfungible TokenProperties (r:1 w:1)
 	fn delete_token_properties(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 1_632_000
-			.saturating_add((289_190_000 as Weight).saturating_mul(b as Weight))
+			// Standard Error: 1_638_000
+			.saturating_add((294_096_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(T::DbWeight::get().reads(2 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Nonfungible TokenData (r:1 w:0)
+	fn token_owner() -> Weight {
+		(2_986_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
+	}
 }
 
 // For backwards compatibility and tests
@@ -198,7 +204,7 @@
 	// Storage: Nonfungible TokenData (r:0 w:1)
 	// Storage: Nonfungible Owned (r:0 w:1)
 	fn create_item() -> Weight {
-		(20_328_000 as Weight)
+		(20_909_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
 	}
@@ -207,9 +213,9 @@
 	// Storage: Nonfungible TokenData (r:0 w:4)
 	// Storage: Nonfungible Owned (r:0 w:4)
 	fn create_multiple_items(b: u32, ) -> Weight {
-		(10_134_000 as Weight)
-			// Standard Error: 3_000
-			.saturating_add((4_927_000 as Weight).saturating_mul(b as Weight))
+		(12_601_000 as Weight)
+			// Standard Error: 1_000
+			.saturating_add((4_920_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
 			.saturating_add(RocksDbWeight::get().writes((2 as Weight).saturating_mul(b as Weight)))
@@ -219,9 +225,9 @@
 	// Storage: Nonfungible TokenData (r:0 w:4)
 	// Storage: Nonfungible Owned (r:0 w:4)
 	fn create_multiple_items_ex(b: u32, ) -> Weight {
-		(5_710_000 as Weight)
-			// Standard Error: 4_000
-			.saturating_add((7_578_000 as Weight).saturating_mul(b as Weight))
+		(0 as Weight)
+			// Standard Error: 3_000
+			.saturating_add((7_734_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
@@ -235,7 +241,7 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_item() -> Weight {
-		(28_433_000 as Weight)
+		(29_746_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(5 as Weight))
 	}
@@ -247,7 +253,7 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_recursively_self_raw() -> Weight {
-		(34_435_000 as Weight)
+		(36_077_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(5 as Weight))
 	}
@@ -261,8 +267,8 @@
 	// Storage: Common CollectionById (r:1 w:0)
 	fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 1_539_000
-			.saturating_add((304_456_000 as Weight).saturating_mul(b as Weight))
+			// Standard Error: 1_605_000
+			.saturating_add((312_391_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(RocksDbWeight::get().reads(7 as Weight))
 			.saturating_add(RocksDbWeight::get().reads((4 as Weight).saturating_mul(b as Weight)))
 			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
@@ -273,14 +279,14 @@
 	// Storage: Nonfungible Allowance (r:1 w:0)
 	// Storage: Nonfungible Owned (r:0 w:2)
 	fn transfer() -> Weight {
-		(24_376_000 as Weight)
+		(25_248_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(5 as Weight))
 	}
 	// Storage: Nonfungible TokenData (r:1 w:0)
 	// Storage: Nonfungible Allowance (r:1 w:1)
 	fn approve() -> Weight {
-		(15_890_000 as Weight)
+		(16_321_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
@@ -289,7 +295,7 @@
 	// Storage: Nonfungible AccountBalance (r:2 w:2)
 	// Storage: Nonfungible Owned (r:0 w:2)
 	fn transfer_from() -> Weight {
-		(28_634_000 as Weight)
+		(29_325_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
 	}
@@ -301,15 +307,15 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_from() -> Weight {
-		(32_201_000 as Weight)
+		(33_323_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
 	}
 	// Storage: Common CollectionPropertyPermissions (r:1 w:1)
 	fn set_token_property_permissions(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 57_000
-			.saturating_add((15_232_000 as Weight).saturating_mul(b as Weight))
+			// Standard Error: 62_000
+			.saturating_add((16_222_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
@@ -317,8 +323,8 @@
 	// Storage: Nonfungible TokenProperties (r:1 w:1)
 	fn set_token_properties(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 1_648_000
-			.saturating_add((288_654_000 as Weight).saturating_mul(b as Weight))
+			// Standard Error: 1_750_000
+			.saturating_add((304_476_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
@@ -326,9 +332,14 @@
 	// Storage: Nonfungible TokenProperties (r:1 w:1)
 	fn delete_token_properties(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 1_632_000
-			.saturating_add((289_190_000 as Weight).saturating_mul(b as Weight))
+			// Standard Error: 1_638_000
+			.saturating_add((294_096_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Nonfungible TokenData (r:1 w:0)
+	fn token_owner() -> Weight {
+		(2_986_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
+	}
 }

--- a/pallets/refungible/src/benchmarking.rs
+++ b/pallets/refungible/src/benchmarking.rs
@@ -17,16 +17,19 @@
 use super::*;
 use crate::{Pallet, Config, RefungibleHandle};
 
-use sp_std::prelude::*;
-use pallet_common::benchmarking::{create_collection_raw, property_key, property_value, create_data};
+use core::convert::TryInto;
+use core::iter::IntoIterator;
 use frame_benchmarking::{benchmarks, account};
+use pallet_common::{
+	bench_init,
+	benchmarking::{create_collection_raw, property_key, property_value, create_data},
+};
+use sp_core::H160;
+use sp_std::prelude::*;
 use up_data_structs::{
 	CollectionMode, MAX_ITEMS_PER_BATCH, MAX_PROPERTIES_PER_ITEM, CUSTOM_DATA_LIMIT,
 	budget::Unlimited,
 };
-use pallet_common::bench_init;
-use core::convert::TryInto;
-use core::iter::IntoIterator;
 
 const SEED: u32 = 1;
 
@@ -44,6 +47,7 @@
 		properties: Default::default(),
 	}
 }
+
 fn create_max_item<T: Config>(
 	collection: &RefungibleHandle<T>,
 	sender: &T::CrossAccountId,
@@ -59,11 +63,12 @@
 ) -> Result<RefungibleHandle<T>, DispatchError> {
 	create_collection_raw(
 		owner,
-		CollectionMode::NFT,
+		CollectionMode::ReFungible,
 		<Pallet<T>>::init_collection,
 		RefungibleHandle::cast,
 	)
 }
+
 benchmarks! {
 	create_item {
 		bench_init!{
@@ -277,4 +282,21 @@
 		};
 		let item = create_max_item(&collection, &sender, [(owner.clone(), 100)])?;
 	}: {<Pallet<T>>::repartition(&collection, &owner, item, 200)?}
+
+	set_parent_nft_unchecked {
+		bench_init!{
+			owner: sub; collection: collection(owner);
+			sender: cross_from_sub(owner); owner: cross_sub;
+		};
+		let item = create_max_item(&collection, &sender, [(owner.clone(), 100)])?;
+
+	}: {<Pallet<T>>::set_parent_nft_unchecked(&collection, item, owner,  T::CrossAccountId::from_eth(H160::default()))?}
+
+	token_owner {
+		bench_init!{
+			owner: sub; collection: collection(owner);
+			sender: cross_from_sub(owner); owner: cross_sub;
+		};
+		let item = create_max_item(&collection, &sender, [(owner.clone(), 100)])?;
+	}: {<Pallet<T>>::token_owner(collection.id, item)}
 }

--- a/pallets/refungible/src/common.rs
+++ b/pallets/refungible/src/common.rs
@@ -148,6 +148,10 @@
 		// Refungible token can't have children
 		0
 	}
+
+	fn token_owner() -> Weight {
+		0 //<SelfWeightOf<T>>::token_owner()
+	}
 }
 
 fn map_create_data<T: Config>(

--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -41,8 +41,8 @@
 use sp_core::H160;
 use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};
 use up_data_structs::{
-	CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission,
-	PropertyPermission, TokenId,
+	CollectionId, CollectionPropertiesVec, mapping::TokenAddressMapping, Property, PropertyKey,
+	PropertyKeyPermission, PropertyPermission, TokenId,
 };
 
 use crate::{
@@ -413,7 +413,7 @@
 }
 
 /// Returns amount of pieces of `token` that `owner` have
-fn balance<T: Config>(
+pub fn balance<T: Config>(
 	collection: &RefungibleHandle<T>,
 	token: TokenId,
 	owner: &T::CrossAccountId,
@@ -424,7 +424,7 @@
 }
 
 /// Throws if `owner_balance` is lower than total amount of `token` pieces
-fn ensure_single_owner<T: Config>(
+pub fn ensure_single_owner<T: Config>(
 	collection: &RefungibleHandle<T>,
 	token: TokenId,
 	owner_balance: u128,
@@ -788,6 +788,16 @@
 			.map_err(dispatch_to_evm::<T>)?;
 		Ok(true)
 	}
+
+	/// Returns EVM address for refungible token
+	///
+	/// @param token ID of the token
+	fn token_contract_address(&self, token: uint256) -> Result<address> {
+		Ok(T::EvmTokenAddressMapping::token_to_address(
+			self.id,
+			token.try_into().map_err(|_| "token id overflow")?,
+		))
+	}
 }
 
 #[solidity_interface(

--- a/pallets/refungible/src/erc_token.rs
+++ b/pallets/refungible/src/erc_token.rs
@@ -20,29 +20,89 @@
 //! Method implementations are mostly doing parameter conversion and calling Nonfungible Pallet methods.
 
 extern crate alloc;
+
+#[cfg(not(feature = "std"))]
+use alloc::format;
+
 use core::{
 	char::{REPLACEMENT_CHARACTER, decode_utf16},
 	convert::TryInto,
 	ops::Deref,
 };
-use evm_coder::{ToLog, execution::*, generate_stubgen, solidity_interface, types::*, weight};
+use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};
 use pallet_common::{
 	CommonWeightInfo,
-	erc::{CommonEvmHandler, PrecompileResult},
+	erc::{CommonEvmHandler, PrecompileResult, static_property::key},
+	eth::map_eth_to_id,
 };
 use pallet_evm::{account::CrossAccountId, PrecompileHandle};
 use pallet_evm_coder_substrate::{call, dispatch_to_evm, WithRecorder};
 use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
+use sp_core::H160;
 use sp_std::vec::Vec;
-use up_data_structs::TokenId;
+use up_data_structs::{mapping::TokenAddressMapping, PropertyScope, TokenId};
 
 use crate::{
 	Allowance, Balance, common::CommonWeights, Config, Pallet, RefungibleHandle, SelfWeightOf,
-	weights::WeightInfo, TotalSupply,
+	TokenProperties, TotalSupply, weights::WeightInfo,
 };
 
 pub struct RefungibleTokenHandle<T: Config>(pub RefungibleHandle<T>, pub TokenId);
 
+#[solidity_interface(name = "ERC1633")]
+impl<T: Config> RefungibleTokenHandle<T> {
+	fn parent_token(&self) -> Result<address> {
+		self.consume_store_reads(2)?;
+		let props = <TokenProperties<T>>::get((self.id, self.1));
+		let key = key::parent_nft();
+
+		let key_scoped = PropertyScope::Eth
+			.apply(key)
+			.expect("property key shouldn't exceed length limit");
+		let value = props.get(&key_scoped).ok_or("key not found")?;
+		Ok(H160::from_slice(value.as_slice()))
+	}
+
+	fn parent_token_id(&self) -> Result<uint256> {
+		self.consume_store_reads(2)?;
+		let props = <TokenProperties<T>>::get((self.id, self.1));
+		let key = key::parent_nft();
+
+		let key_scoped = PropertyScope::Eth
+			.apply(key)
+			.expect("property key shouldn't exceed length limit");
+		let value = props.get(&key_scoped).ok_or("key not found")?;
+		let nft_token_address = H160::from_slice(value.as_slice());
+		let nft_token_account = T::CrossAccountId::from_eth(nft_token_address);
+		let (_, token_id) = T::CrossTokenAddressMapping::address_to_token(&nft_token_account)
+			.ok_or("parent NFT should contain NFT token address")?;
+
+		Ok(token_id.into())
+	}
+}
+
+#[solidity_interface(name = "ERC1633UniqueExtensions")]
+impl<T: Config> RefungibleTokenHandle<T> {
+	#[solidity(rename_selector = "setParentNFT")]
+	#[weight(<CommonWeights<T>>::token_owner() + <SelfWeightOf<T>>::set_parent_nft_unchecked())]
+	fn set_parent_nft(
+		&mut self,
+		caller: caller,
+		collection: address,
+		nft_id: uint256,
+	) -> Result<bool> {
+		self.consume_store_reads(1)?;
+		let caller = T::CrossAccountId::from_eth(caller);
+		let nft_collection = map_eth_to_id(&collection).ok_or("collection not found")?;
+		let nft_token = nft_id.try_into()?;
+
+		<Pallet<T>>::set_parent_nft(&self.0, self.1, caller, nft_collection, nft_token)
+			.map_err(dispatch_to_evm::<T>)?;
+
+		Ok(true)
+	}
+}
+
 #[derive(ToLog)]
 pub enum ERC20Events {
 	/// @dev This event is emitted when the amount of tokens (value) is sent
@@ -239,7 +299,10 @@
 	}
 }
 
-#[solidity_interface(name = "UniqueRefungibleToken", is(ERC20, ERC20UniqueExtensions,))]
+#[solidity_interface(
+	name = "UniqueRefungibleToken",
+	is(ERC20, ERC20UniqueExtensions, ERC1633, ERC1633UniqueExtensions)
+)]
 impl<T: Config> RefungibleTokenHandle<T> where T::AccountId: From<[u8; 32]> {}
 
 generate_stubgen!(gen_impl, UniqueRefungibleTokenCall<()>, true);

--- a/pallets/refungible/src/lib.rs
+++ b/pallets/refungible/src/lib.rs
@@ -99,8 +99,12 @@
 use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};
 use pallet_evm_coder_substrate::WithRecorder;
 use pallet_common::{
-	CommonCollectionOperations, Error as CommonError, Event as CommonEvent,
-	eth::collection_id_to_address, Pallet as PalletCommon,
+	CollectionHandle, CommonCollectionOperations,
+	dispatch::CollectionDispatch,
+	erc::static_property::{key, property_value_from_bytes},
+	Error as CommonError,
+	eth::collection_id_to_address,
+	Event as CommonEvent, Pallet as PalletCommon,
 };
 use pallet_structure::Pallet as PalletStructure;
 use scale_info::TypeInfo;
@@ -108,10 +112,10 @@
 use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};
 use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};
 use up_data_structs::{
-	AccessMode, budget::Budget, CollectionId, CreateCollectionData, CustomDataLimit,
-	mapping::TokenAddressMapping, MAX_REFUNGIBLE_PIECES, MAX_ITEMS_PER_BATCH, TokenId, Property,
+	AccessMode, budget::Budget, CollectionId, CollectionMode, CollectionPropertiesVec, CreateCollectionData, CustomDataLimit,
+	mapping::TokenAddressMapping, MAX_ITEMS_PER_BATCH, MAX_REFUNGIBLE_PIECES, Property,
 	PropertyKey, PropertyKeyPermission, PropertyPermission, PropertyScope, PropertyValue,
-	TrySetProperty, CollectionPropertiesVec,
+	TokenId, TrySetProperty,
 };
 use frame_support::BoundedBTreeMap;
 use derivative::Derivative;
@@ -1341,6 +1345,20 @@
 		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)
 	}
 
+	pub fn set_scoped_token_property_permissions(
+		collection: &RefungibleHandle<T>,
+		sender: &T::CrossAccountId,
+		scope: PropertyScope,
+		property_permissions: Vec<PropertyKeyPermission>,
+	) -> DispatchResult {
+		<PalletCommon<T>>::set_scoped_token_property_permissions(
+			collection,
+			sender,
+			scope,
+			property_permissions,
+		)
+	}
+
 	/// Returns 10 token in no particular order.
 	///
 	/// There is no direct way to get token holders in ascending order,
@@ -1362,4 +1380,68 @@
 			Some(res)
 		}
 	}
+
+	/// Sets the NFT token as a parent for the RFT token
+	///
+	/// Throws if `sender` is not the owner of the NFT token.
+	/// Throws if `sender` is not the owner of all of the RFT token pieces.
+	pub fn set_parent_nft(
+		collection: &RefungibleHandle<T>,
+		rft_token_id: TokenId,
+		sender: T::CrossAccountId,
+		nft_collection: CollectionId,
+		nft_token: TokenId,
+	) -> DispatchResult {
+		let handle = <CollectionHandle<T>>::try_get(nft_collection)?;
+		if handle.mode != CollectionMode::NFT {
+			return Err("Only NFT token could be parent to RFT".into());
+		}
+		let dispatch = T::CollectionDispatch::dispatch(handle);
+		let dispatch = dispatch.as_dyn();
+
+		let owner = dispatch.token_owner(nft_token).ok_or("owner not found")?;
+		if owner != sender {
+			return Err("Only owned token could be set as parent".into());
+		}
+
+		let nft_token_address =
+			T::CrossTokenAddressMapping::token_to_address(nft_collection, nft_token);
+
+		Self::set_parent_nft_unchecked(collection, rft_token_id, sender, nft_token_address)
+	}
+
+	/// Sets the NFT token as a parent for the RFT token
+	///
+	/// `sender` should be the owner of the NFT token.
+	/// Throws if `sender` is not the owner of all of the RFT token pieces.
+	pub fn set_parent_nft_unchecked(
+		collection: &RefungibleHandle<T>,
+		rft_token_id: TokenId,
+		sender: T::CrossAccountId,
+		nft_token_address: T::CrossAccountId,
+	) -> DispatchResult {
+		let owner_balance = <Balance<T>>::get((collection.id, rft_token_id, &sender));
+		let total_supply = <TotalSupply<T>>::get((collection.id, rft_token_id));
+		if total_supply != owner_balance {
+			return Err("token has multiple owners".into());
+		}
+
+		let parent_nft_property_key = key::parent_nft();
+
+		let parent_nft_property_value =
+			property_value_from_bytes(&nft_token_address.as_eth().to_fixed_bytes())
+				.expect("address should fit in value length limit");
+
+		<Pallet<T>>::set_scoped_token_property(
+			collection.id,
+			rft_token_id,
+			PropertyScope::Eth,
+			Property {
+				key: parent_nft_property_key,
+				value: parent_nft_property_value,
+			},
+		)?;
+
+		Ok(())
+	}
 }

binary blob — no preview

--- a/pallets/refungible/src/stubs/UniqueRefungible.sol
+++ b/pallets/refungible/src/stubs/UniqueRefungible.sol
@@ -413,7 +413,100 @@
 	}
 }
 
-// Selector: 7d9262e6
+// Selector: 7c3bef89
+contract ERC721UniqueExtensions is Dummy, ERC165 {
+	// @notice Transfer ownership of an RFT
+	// @dev Throws unless `msg.sender` is the current owner. Throws if `to`
+	//  is the zero address. Throws if `tokenId` is not a valid RFT.
+	//  Throws if RFT pieces have multiple owners.
+	// @param to The new owner
+	// @param tokenId The RFT to transfer
+	// @param _value Not used for an RFT
+	//
+	// Selector: transfer(address,uint256) a9059cbb
+	function transfer(address to, uint256 tokenId) public {
+		require(false, stub_error);
+		to;
+		tokenId;
+		dummy = 0;
+	}
+
+	// @notice Burns a specific ERC721 token.
+	// @dev Throws unless `msg.sender` is the current owner or an authorized
+	//  operator for this RFT. Throws if `from` is not the current owner. Throws
+	//  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.
+	//  Throws if RFT pieces have multiple owners.
+	// @param from The current owner of the RFT
+	// @param tokenId The RFT to transfer
+	// @param _value Not used for an RFT
+	//
+	// Selector: burnFrom(address,uint256) 79cc6790
+	function burnFrom(address from, uint256 tokenId) public {
+		require(false, stub_error);
+		from;
+		tokenId;
+		dummy = 0;
+	}
+
+	// @notice Returns next free RFT ID.
+	//
+	// Selector: nextTokenId() 75794a3c
+	function nextTokenId() public view returns (uint256) {
+		require(false, stub_error);
+		dummy;
+		return 0;
+	}
+
+	// @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
+	//
+	// Selector: mintBulk(address,uint256[]) 44a9945e
+	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
+	//
+	// Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006
+	function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)
+		public
+		returns (bool)
+	{
+		require(false, stub_error);
+		to;
+		tokens;
+		dummy = 0;
+		return false;
+	}
+
+	// Returns EVM address for refungible token
+	//
+	// @param token ID of the token
+	//
+	// Selector: tokenContractAddress(uint256) ab76fac6
+	function tokenContractAddress(uint256 token) public view returns (address) {
+		require(false, stub_error);
+		token;
+		dummy;
+		return 0x0000000000000000000000000000000000000000;
+	}
+}
+
+// Selector: aa7d570d
 contract Collection is Dummy, ERC165 {
 	// Set collection property.
 	//
@@ -636,88 +729,29 @@
 	function setCollectionMintMode(bool mode) public {
 		require(false, stub_error);
 		mode;
-		dummy = 0;
-	}
-}
-
-// Selector: d74d154f
-contract ERC721UniqueExtensions is Dummy, ERC165 {
-	// @notice Transfer ownership of an RFT
-	// @dev Throws unless `msg.sender` is the current owner. Throws if `to`
-	//  is the zero address. Throws if `tokenId` is not a valid RFT.
-	//  Throws if RFT pieces have multiple owners.
-	// @param to The new owner
-	// @param tokenId The RFT to transfer
-	// @param _value Not used for an RFT
-	//
-	// Selector: transfer(address,uint256) a9059cbb
-	function transfer(address to, uint256 tokenId) public {
-		require(false, stub_error);
-		to;
-		tokenId;
-		dummy = 0;
-	}
-
-	// @notice Burns a specific ERC721 token.
-	// @dev Throws unless `msg.sender` is the current owner or an authorized
-	//  operator for this RFT. Throws if `from` is not the current owner. Throws
-	//  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.
-	//  Throws if RFT pieces have multiple owners.
-	// @param from The current owner of the RFT
-	// @param tokenId The RFT to transfer
-	// @param _value Not used for an RFT
-	//
-	// Selector: burnFrom(address,uint256) 79cc6790
-	function burnFrom(address from, uint256 tokenId) public {
-		require(false, stub_error);
-		from;
-		tokenId;
 		dummy = 0;
 	}
 
-	// @notice Returns next free RFT ID.
+	// Check that account is the owner or admin of the collection
 	//
-	// Selector: nextTokenId() 75794a3c
-	function nextTokenId() public view returns (uint256) {
-		require(false, stub_error);
-		dummy;
-		return 0;
-	}
-
-	// @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
+	// @return "true" if account is the owner or admin
 	//
-	// Selector: mintBulk(address,uint256[]) 44a9945e
-	function mintBulk(address to, uint256[] memory tokenIds)
-		public
-		returns (bool)
-	{
+	// Selector: verifyOwnerOrAdmin() 04a46053
+	function verifyOwnerOrAdmin() 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
+	// Returns collection type
 	//
-	// Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006
-	function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)
-		public
-		returns (bool)
-	{
+	// @return `Fungible` or `NFT` or `ReFungible`
+	//
+	// Selector: uniqueCollectionType() d34b55b8
+	function uniqueCollectionType() public returns (string memory) {
 		require(false, stub_error);
-		to;
-		tokens;
 		dummy = 0;
-		return false;
+		return "";
 	}
 }
 

--- a/pallets/refungible/src/stubs/UniqueRefungibleToken.sol
+++ b/pallets/refungible/src/stubs/UniqueRefungibleToken.sol
@@ -31,6 +31,38 @@
 	);
 }
 
+// Selector: 042f1106
+contract ERC1633UniqueExtensions is Dummy, ERC165 {
+	// Selector: setParentNFT(address,uint256) 042f1106
+	function setParentNFT(address collection, uint256 nftId)
+		public
+		returns (bool)
+	{
+		require(false, stub_error);
+		collection;
+		nftId;
+		dummy = 0;
+		return false;
+	}
+}
+
+// Selector: 5755c3f2
+contract ERC1633 is Dummy, ERC165 {
+	// Selector: parentToken() 80a54001
+	function parentToken() public view returns (address) {
+		require(false, stub_error);
+		dummy;
+		return 0x0000000000000000000000000000000000000000;
+	}
+
+	// Selector: parentTokenId() d7f083f3
+	function parentTokenId() public view returns (uint256) {
+		require(false, stub_error);
+		dummy;
+		return 0;
+	}
+}
+
 // Selector: 942e8b22
 contract ERC20 is Dummy, ERC165, ERC20Events {
 	// @return the name of the token.
@@ -178,4 +210,11 @@
 	}
 }
 
-contract UniqueRefungibleToken is Dummy, ERC165, ERC20, ERC20UniqueExtensions {}
+contract UniqueRefungibleToken is
+	Dummy,
+	ERC165,
+	ERC20,
+	ERC20UniqueExtensions,
+	ERC1633,
+	ERC1633UniqueExtensions
+{}

3//! Autogenerated weights for pallet_refungible3//! Autogenerated weights for pallet_refungible
4//!4//!
5//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev5//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
6//! DATE: 2022-07-20, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`6//! DATE: 2022-08-01, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
7//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 10247//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
88
9// Executed Command:9// Executed Command:
53	fn set_token_properties(b: u32, ) -> Weight;53	fn set_token_properties(b: u32, ) -> Weight;
54	fn delete_token_properties(b: u32, ) -> Weight;54	fn delete_token_properties(b: u32, ) -> Weight;
55	fn repartition_item() -> Weight;55	fn repartition_item() -> Weight;
56	fn set_parent_nft_unchecked() -> Weight;
57	fn token_owner() -> Weight;
56}58}
5759
58/// Weights for pallet_refungible using the Substrate node and recommended hardware.60/// Weights for pallet_refungible using the Substrate node and recommended hardware.
65	// Storage: Refungible TokenData (r:0 w:1)67	// Storage: Refungible TokenData (r:0 w:1)
66	// Storage: Refungible Owned (r:0 w:1)68	// Storage: Refungible Owned (r:0 w:1)
67	fn create_item() -> Weight {69	fn create_item() -> Weight {
68		(21_310_000 as Weight)70		(25_197_000 as Weight)
69			.saturating_add(T::DbWeight::get().reads(2 as Weight))71			.saturating_add(T::DbWeight::get().reads(2 as Weight))
70			.saturating_add(T::DbWeight::get().writes(6 as Weight))72			.saturating_add(T::DbWeight::get().writes(6 as Weight))
71	}73	}
76	// Storage: Refungible TokenData (r:0 w:4)78	// Storage: Refungible TokenData (r:0 w:4)
77	// Storage: Refungible Owned (r:0 w:4)79	// Storage: Refungible Owned (r:0 w:4)
78	fn create_multiple_items(b: u32, ) -> Weight {80	fn create_multiple_items(b: u32, ) -> Weight {
79		(9_552_000 as Weight)81		(10_852_000 as Weight)
80			// Standard Error: 2_00082			// Standard Error: 2_000
81			.saturating_add((7_056_000 as Weight).saturating_mul(b as Weight))83			.saturating_add((8_087_000 as Weight).saturating_mul(b as Weight))
82			.saturating_add(T::DbWeight::get().reads(2 as Weight))84			.saturating_add(T::DbWeight::get().reads(2 as Weight))
83			.saturating_add(T::DbWeight::get().writes(2 as Weight))85			.saturating_add(T::DbWeight::get().writes(2 as Weight))
84			.saturating_add(T::DbWeight::get().writes((4 as Weight).saturating_mul(b as Weight)))86			.saturating_add(T::DbWeight::get().writes((4 as Weight).saturating_mul(b as Weight)))
90	// Storage: Refungible TokenData (r:0 w:4)92	// Storage: Refungible TokenData (r:0 w:4)
91	// Storage: Refungible Owned (r:0 w:4)93	// Storage: Refungible Owned (r:0 w:4)
92	fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight {94	fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight {
93		(4_857_000 as Weight)95		(9_978_000 as Weight)
94			// Standard Error: 2_00096			// Standard Error: 2_000
95			.saturating_add((9_838_000 as Weight).saturating_mul(b as Weight))97			.saturating_add((10_848_000 as Weight).saturating_mul(b as Weight))
96			.saturating_add(T::DbWeight::get().reads(1 as Weight))98			.saturating_add(T::DbWeight::get().reads(1 as Weight))
97			.saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))99			.saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))
98			.saturating_add(T::DbWeight::get().writes(1 as Weight))100			.saturating_add(T::DbWeight::get().writes(1 as Weight))
105	// Storage: Refungible Balance (r:0 w:4)107	// Storage: Refungible Balance (r:0 w:4)
106	// Storage: Refungible Owned (r:0 w:4)108	// Storage: Refungible Owned (r:0 w:4)
107	fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight {109	fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight {
108		(11_335_000 as Weight)110		(15_419_000 as Weight)
109			// Standard Error: 2_000111			// Standard Error: 2_000
110			.saturating_add((6_784_000 as Weight).saturating_mul(b as Weight))112			.saturating_add((7_813_000 as Weight).saturating_mul(b as Weight))
111			.saturating_add(T::DbWeight::get().reads(1 as Weight))113			.saturating_add(T::DbWeight::get().reads(1 as Weight))
112			.saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))114			.saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))
113			.saturating_add(T::DbWeight::get().writes(3 as Weight))115			.saturating_add(T::DbWeight::get().writes(3 as Weight))
118	// Storage: Refungible AccountBalance (r:1 w:1)120	// Storage: Refungible AccountBalance (r:1 w:1)
119	// Storage: Refungible Owned (r:0 w:1)121	// Storage: Refungible Owned (r:0 w:1)
120	fn burn_item_partial() -> Weight {122	fn burn_item_partial() -> Weight {
121		(21_239_000 as Weight)123		(25_578_000 as Weight)
122			.saturating_add(T::DbWeight::get().reads(3 as Weight))124			.saturating_add(T::DbWeight::get().reads(3 as Weight))
123			.saturating_add(T::DbWeight::get().writes(4 as Weight))125			.saturating_add(T::DbWeight::get().writes(4 as Weight))
124	}126	}
130	// Storage: Refungible Owned (r:0 w:1)132	// Storage: Refungible Owned (r:0 w:1)
131	// Storage: Refungible TokenProperties (r:0 w:1)133	// Storage: Refungible TokenProperties (r:0 w:1)
132	fn burn_item_fully() -> Weight {134	fn burn_item_fully() -> Weight {
133		(29_426_000 as Weight)135		(33_593_000 as Weight)
134			.saturating_add(T::DbWeight::get().reads(4 as Weight))136			.saturating_add(T::DbWeight::get().reads(4 as Weight))
135			.saturating_add(T::DbWeight::get().writes(7 as Weight))137			.saturating_add(T::DbWeight::get().writes(7 as Weight))
136	}138	}
137	// Storage: Refungible Balance (r:2 w:2)139	// Storage: Refungible Balance (r:2 w:2)
138	fn transfer_normal() -> Weight {140	fn transfer_normal() -> Weight {
139		(17_743_000 as Weight)141		(21_049_000 as Weight)
140			.saturating_add(T::DbWeight::get().reads(2 as Weight))142			.saturating_add(T::DbWeight::get().reads(2 as Weight))
141			.saturating_add(T::DbWeight::get().writes(2 as Weight))143			.saturating_add(T::DbWeight::get().writes(2 as Weight))
142	}144	}
143	// Storage: Refungible Balance (r:2 w:2)145	// Storage: Refungible Balance (r:2 w:2)
144	// Storage: Refungible AccountBalance (r:1 w:1)146	// Storage: Refungible AccountBalance (r:1 w:1)
145	// Storage: Refungible Owned (r:0 w:1)147	// Storage: Refungible Owned (r:0 w:1)
146	fn transfer_creating() -> Weight {148	fn transfer_creating() -> Weight {
147		(20_699_000 as Weight)149		(24_646_000 as Weight)
148			.saturating_add(T::DbWeight::get().reads(3 as Weight))150			.saturating_add(T::DbWeight::get().reads(3 as Weight))
149			.saturating_add(T::DbWeight::get().writes(4 as Weight))151			.saturating_add(T::DbWeight::get().writes(4 as Weight))
150	}152	}
151	// Storage: Refungible Balance (r:2 w:2)153	// Storage: Refungible Balance (r:2 w:2)
152	// Storage: Refungible AccountBalance (r:1 w:1)154	// Storage: Refungible AccountBalance (r:1 w:1)
153	// Storage: Refungible Owned (r:0 w:1)155	// Storage: Refungible Owned (r:0 w:1)
154	fn transfer_removing() -> Weight {156	fn transfer_removing() -> Weight {
155		(22_833_000 as Weight)157		(26_570_000 as Weight)
156			.saturating_add(T::DbWeight::get().reads(3 as Weight))158			.saturating_add(T::DbWeight::get().reads(3 as Weight))
157			.saturating_add(T::DbWeight::get().writes(4 as Weight))159			.saturating_add(T::DbWeight::get().writes(4 as Weight))
158	}160	}
159	// Storage: Refungible Balance (r:2 w:2)161	// Storage: Refungible Balance (r:2 w:2)
160	// Storage: Refungible AccountBalance (r:2 w:2)162	// Storage: Refungible AccountBalance (r:2 w:2)
161	// Storage: Refungible Owned (r:0 w:2)163	// Storage: Refungible Owned (r:0 w:2)
162	fn transfer_creating_removing() -> Weight {164	fn transfer_creating_removing() -> Weight {
163		(24_936_000 as Weight)165		(28_906_000 as Weight)
164			.saturating_add(T::DbWeight::get().reads(4 as Weight))166			.saturating_add(T::DbWeight::get().reads(4 as Weight))
165			.saturating_add(T::DbWeight::get().writes(6 as Weight))167			.saturating_add(T::DbWeight::get().writes(6 as Weight))
166	}168	}
167	// Storage: Refungible Balance (r:1 w:0)169	// Storage: Refungible Balance (r:1 w:0)
168	// Storage: Refungible Allowance (r:0 w:1)170	// Storage: Refungible Allowance (r:0 w:1)
169	fn approve() -> Weight {171	fn approve() -> Weight {
170		(13_446_000 as Weight)172		(16_451_000 as Weight)
171			.saturating_add(T::DbWeight::get().reads(1 as Weight))173			.saturating_add(T::DbWeight::get().reads(1 as Weight))
172			.saturating_add(T::DbWeight::get().writes(1 as Weight))174			.saturating_add(T::DbWeight::get().writes(1 as Weight))
173	}175	}
174	// Storage: Refungible Allowance (r:1 w:1)176	// Storage: Refungible Allowance (r:1 w:1)
175	// Storage: Refungible Balance (r:2 w:2)177	// Storage: Refungible Balance (r:2 w:2)
176	fn transfer_from_normal() -> Weight {178	fn transfer_from_normal() -> Weight {
177		(24_777_000 as Weight)179		(29_545_000 as Weight)
178			.saturating_add(T::DbWeight::get().reads(3 as Weight))180			.saturating_add(T::DbWeight::get().reads(3 as Weight))
179			.saturating_add(T::DbWeight::get().writes(3 as Weight))181			.saturating_add(T::DbWeight::get().writes(3 as Weight))
180	}182	}
183	// Storage: Refungible AccountBalance (r:1 w:1)185	// Storage: Refungible AccountBalance (r:1 w:1)
184	// Storage: Refungible Owned (r:0 w:1)186	// Storage: Refungible Owned (r:0 w:1)
185	fn transfer_from_creating() -> Weight {187	fn transfer_from_creating() -> Weight {
186		(28_483_000 as Weight)188		(33_392_000 as Weight)
187			.saturating_add(T::DbWeight::get().reads(4 as Weight))189			.saturating_add(T::DbWeight::get().reads(4 as Weight))
188			.saturating_add(T::DbWeight::get().writes(5 as Weight))190			.saturating_add(T::DbWeight::get().writes(5 as Weight))
189	}191	}
192	// Storage: Refungible AccountBalance (r:1 w:1)194	// Storage: Refungible AccountBalance (r:1 w:1)
193	// Storage: Refungible Owned (r:0 w:1)195	// Storage: Refungible Owned (r:0 w:1)
194	fn transfer_from_removing() -> Weight {196	fn transfer_from_removing() -> Weight {
195		(29_896_000 as Weight)197		(35_446_000 as Weight)
196			.saturating_add(T::DbWeight::get().reads(4 as Weight))198			.saturating_add(T::DbWeight::get().reads(4 as Weight))
197			.saturating_add(T::DbWeight::get().writes(5 as Weight))199			.saturating_add(T::DbWeight::get().writes(5 as Weight))
198	}200	}
201	// Storage: Refungible AccountBalance (r:2 w:2)203	// Storage: Refungible AccountBalance (r:2 w:2)
202	// Storage: Refungible Owned (r:0 w:2)204	// Storage: Refungible Owned (r:0 w:2)
203	fn transfer_from_creating_removing() -> Weight {205	fn transfer_from_creating_removing() -> Weight {
204		(32_070_000 as Weight)206		(37_762_000 as Weight)
205			.saturating_add(T::DbWeight::get().reads(5 as Weight))207			.saturating_add(T::DbWeight::get().reads(5 as Weight))
206			.saturating_add(T::DbWeight::get().writes(7 as Weight))208			.saturating_add(T::DbWeight::get().writes(7 as Weight))
207	}209	}
214	// Storage: Refungible Owned (r:0 w:1)216	// Storage: Refungible Owned (r:0 w:1)
215	// Storage: Refungible TokenProperties (r:0 w:1)217	// Storage: Refungible TokenProperties (r:0 w:1)
216	fn burn_from() -> Weight {218	fn burn_from() -> Weight {
217		(36_789_000 as Weight)219		(42_620_000 as Weight)
218			.saturating_add(T::DbWeight::get().reads(5 as Weight))220			.saturating_add(T::DbWeight::get().reads(5 as Weight))
219			.saturating_add(T::DbWeight::get().writes(8 as Weight))221			.saturating_add(T::DbWeight::get().writes(8 as Weight))
220	}222	}
221	// Storage: Common CollectionPropertyPermissions (r:1 w:1)223	// Storage: Common CollectionPropertyPermissions (r:1 w:1)
222	fn set_token_property_permissions(b: u32, ) -> Weight {224	fn set_token_property_permissions(b: u32, ) -> Weight {
223		(0 as Weight)225		(0 as Weight)
224			// Standard Error: 62_000226			// Standard Error: 65_000
225			.saturating_add((15_803_000 as Weight).saturating_mul(b as Weight))227			.saturating_add((16_513_000 as Weight).saturating_mul(b as Weight))
226			.saturating_add(T::DbWeight::get().reads(1 as Weight))228			.saturating_add(T::DbWeight::get().reads(1 as Weight))
227			.saturating_add(T::DbWeight::get().writes(1 as Weight))229			.saturating_add(T::DbWeight::get().writes(1 as Weight))
228	}230	}
229	// Storage: Common CollectionPropertyPermissions (r:1 w:0)231	// Storage: Common CollectionPropertyPermissions (r:1 w:0)
230	// Storage: Refungible TokenProperties (r:1 w:1)232	// Storage: Refungible TokenProperties (r:1 w:1)
231	fn set_token_properties(b: u32, ) -> Weight {233	fn set_token_properties(b: u32, ) -> Weight {
232		(0 as Weight)234		(0 as Weight)
233			// Standard Error: 1_668_000235			// Standard Error: 1_583_000
234			.saturating_add((302_308_000 as Weight).saturating_mul(b as Weight))236			.saturating_add((291_392_000 as Weight).saturating_mul(b as Weight))
235			.saturating_add(T::DbWeight::get().reads(2 as Weight))237			.saturating_add(T::DbWeight::get().reads(2 as Weight))
236			.saturating_add(T::DbWeight::get().writes(1 as Weight))238			.saturating_add(T::DbWeight::get().writes(1 as Weight))
237	}239	}
238	// Storage: Common CollectionPropertyPermissions (r:1 w:0)240	// Storage: Common CollectionPropertyPermissions (r:1 w:0)
239	// Storage: Refungible TokenProperties (r:1 w:1)241	// Storage: Refungible TokenProperties (r:1 w:1)
240	fn delete_token_properties(b: u32, ) -> Weight {242	fn delete_token_properties(b: u32, ) -> Weight {
241		(0 as Weight)243		(0 as Weight)
242			// Standard Error: 1_619_000244			// Standard Error: 1_699_000
243			.saturating_add((294_574_000 as Weight).saturating_mul(b as Weight))245			.saturating_add((293_270_000 as Weight).saturating_mul(b as Weight))
244			.saturating_add(T::DbWeight::get().reads(2 as Weight))246			.saturating_add(T::DbWeight::get().reads(2 as Weight))
245			.saturating_add(T::DbWeight::get().writes(1 as Weight))247			.saturating_add(T::DbWeight::get().writes(1 as Weight))
246	}248	}
247	// Storage: Refungible TotalSupply (r:1 w:1)249	// Storage: Refungible TotalSupply (r:1 w:1)
248	// Storage: Refungible Balance (r:1 w:1)250	// Storage: Refungible Balance (r:1 w:1)
249	fn repartition_item() -> Weight {251	fn repartition_item() -> Weight {
250		(8_325_000 as Weight)252		(19_206_000 as Weight)
251			.saturating_add(T::DbWeight::get().reads(2 as Weight))253			.saturating_add(T::DbWeight::get().reads(2 as Weight))
252			.saturating_add(T::DbWeight::get().writes(2 as Weight))254			.saturating_add(T::DbWeight::get().writes(2 as Weight))
253	}255	}
256	// Storage: Refungible Balance (r:1 w:0)
257	// Storage: Refungible TotalSupply (r:1 w:0)
258	// Storage: Refungible TokenProperties (r:1 w:1)
259	fn set_parent_nft_unchecked() -> Weight {
260		(10_189_000 as Weight)
261			.saturating_add(T::DbWeight::get().reads(3 as Weight))
262			.saturating_add(T::DbWeight::get().writes(1 as Weight))
263	}
264	// Storage: Refungible Balance (r:2 w:0)
265	fn token_owner() -> Weight {
266		(8_205_000 as Weight)
267			.saturating_add(T::DbWeight::get().reads(2 as Weight))
268	}
254}269}
255270
256// For backwards compatibility and tests271// For backwards compatibility and tests
262	// Storage: Refungible TokenData (r:0 w:1)277	// Storage: Refungible TokenData (r:0 w:1)
263	// Storage: Refungible Owned (r:0 w:1)278	// Storage: Refungible Owned (r:0 w:1)
264	fn create_item() -> Weight {279	fn create_item() -> Weight {
265		(21_310_000 as Weight)280		(25_197_000 as Weight)
266			.saturating_add(RocksDbWeight::get().reads(2 as Weight))281			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
267			.saturating_add(RocksDbWeight::get().writes(6 as Weight))282			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
268	}283	}
273	// Storage: Refungible TokenData (r:0 w:4)288	// Storage: Refungible TokenData (r:0 w:4)
274	// Storage: Refungible Owned (r:0 w:4)289	// Storage: Refungible Owned (r:0 w:4)
275	fn create_multiple_items(b: u32, ) -> Weight {290	fn create_multiple_items(b: u32, ) -> Weight {
276		(9_552_000 as Weight)291		(10_852_000 as Weight)
277			// Standard Error: 2_000292			// Standard Error: 2_000
278			.saturating_add((7_056_000 as Weight).saturating_mul(b as Weight))293			.saturating_add((8_087_000 as Weight).saturating_mul(b as Weight))
279			.saturating_add(RocksDbWeight::get().reads(2 as Weight))294			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
280			.saturating_add(RocksDbWeight::get().writes(2 as Weight))295			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
281			.saturating_add(RocksDbWeight::get().writes((4 as Weight).saturating_mul(b as Weight)))296			.saturating_add(RocksDbWeight::get().writes((4 as Weight).saturating_mul(b as Weight)))
287	// Storage: Refungible TokenData (r:0 w:4)302	// Storage: Refungible TokenData (r:0 w:4)
288	// Storage: Refungible Owned (r:0 w:4)303	// Storage: Refungible Owned (r:0 w:4)
289	fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight {304	fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight {
290		(4_857_000 as Weight)305		(9_978_000 as Weight)
291			// Standard Error: 2_000306			// Standard Error: 2_000
292			.saturating_add((9_838_000 as Weight).saturating_mul(b as Weight))307			.saturating_add((10_848_000 as Weight).saturating_mul(b as Weight))
293			.saturating_add(RocksDbWeight::get().reads(1 as Weight))308			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
294			.saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))309			.saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))
295			.saturating_add(RocksDbWeight::get().writes(1 as Weight))310			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
302	// Storage: Refungible Balance (r:0 w:4)317	// Storage: Refungible Balance (r:0 w:4)
303	// Storage: Refungible Owned (r:0 w:4)318	// Storage: Refungible Owned (r:0 w:4)
304	fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight {319	fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight {
305		(11_335_000 as Weight)320		(15_419_000 as Weight)
306			// Standard Error: 2_000321			// Standard Error: 2_000
307			.saturating_add((6_784_000 as Weight).saturating_mul(b as Weight))322			.saturating_add((7_813_000 as Weight).saturating_mul(b as Weight))
308			.saturating_add(RocksDbWeight::get().reads(1 as Weight))323			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
309			.saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))324			.saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))
310			.saturating_add(RocksDbWeight::get().writes(3 as Weight))325			.saturating_add(RocksDbWeight::get().writes(3 as Weight))
315	// Storage: Refungible AccountBalance (r:1 w:1)330	// Storage: Refungible AccountBalance (r:1 w:1)
316	// Storage: Refungible Owned (r:0 w:1)331	// Storage: Refungible Owned (r:0 w:1)
317	fn burn_item_partial() -> Weight {332	fn burn_item_partial() -> Weight {
318		(21_239_000 as Weight)333		(25_578_000 as Weight)
319			.saturating_add(RocksDbWeight::get().reads(3 as Weight))334			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
320			.saturating_add(RocksDbWeight::get().writes(4 as Weight))335			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
321	}336	}
327	// Storage: Refungible Owned (r:0 w:1)342	// Storage: Refungible Owned (r:0 w:1)
328	// Storage: Refungible TokenProperties (r:0 w:1)343	// Storage: Refungible TokenProperties (r:0 w:1)
329	fn burn_item_fully() -> Weight {344	fn burn_item_fully() -> Weight {
330		(29_426_000 as Weight)345		(33_593_000 as Weight)
331			.saturating_add(RocksDbWeight::get().reads(4 as Weight))346			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
332			.saturating_add(RocksDbWeight::get().writes(7 as Weight))347			.saturating_add(RocksDbWeight::get().writes(7 as Weight))
333	}348	}
334	// Storage: Refungible Balance (r:2 w:2)349	// Storage: Refungible Balance (r:2 w:2)
335	fn transfer_normal() -> Weight {350	fn transfer_normal() -> Weight {
336		(17_743_000 as Weight)351		(21_049_000 as Weight)
337			.saturating_add(RocksDbWeight::get().reads(2 as Weight))352			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
338			.saturating_add(RocksDbWeight::get().writes(2 as Weight))353			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
339	}354	}
340	// Storage: Refungible Balance (r:2 w:2)355	// Storage: Refungible Balance (r:2 w:2)
341	// Storage: Refungible AccountBalance (r:1 w:1)356	// Storage: Refungible AccountBalance (r:1 w:1)
342	// Storage: Refungible Owned (r:0 w:1)357	// Storage: Refungible Owned (r:0 w:1)
343	fn transfer_creating() -> Weight {358	fn transfer_creating() -> Weight {
344		(20_699_000 as Weight)359		(24_646_000 as Weight)
345			.saturating_add(RocksDbWeight::get().reads(3 as Weight))360			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
346			.saturating_add(RocksDbWeight::get().writes(4 as Weight))361			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
347	}362	}
348	// Storage: Refungible Balance (r:2 w:2)363	// Storage: Refungible Balance (r:2 w:2)
349	// Storage: Refungible AccountBalance (r:1 w:1)364	// Storage: Refungible AccountBalance (r:1 w:1)
350	// Storage: Refungible Owned (r:0 w:1)365	// Storage: Refungible Owned (r:0 w:1)
351	fn transfer_removing() -> Weight {366	fn transfer_removing() -> Weight {
352		(22_833_000 as Weight)367		(26_570_000 as Weight)
353			.saturating_add(RocksDbWeight::get().reads(3 as Weight))368			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
354			.saturating_add(RocksDbWeight::get().writes(4 as Weight))369			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
355	}370	}
356	// Storage: Refungible Balance (r:2 w:2)371	// Storage: Refungible Balance (r:2 w:2)
357	// Storage: Refungible AccountBalance (r:2 w:2)372	// Storage: Refungible AccountBalance (r:2 w:2)
358	// Storage: Refungible Owned (r:0 w:2)373	// Storage: Refungible Owned (r:0 w:2)
359	fn transfer_creating_removing() -> Weight {374	fn transfer_creating_removing() -> Weight {
360		(24_936_000 as Weight)375		(28_906_000 as Weight)
361			.saturating_add(RocksDbWeight::get().reads(4 as Weight))376			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
362			.saturating_add(RocksDbWeight::get().writes(6 as Weight))377			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
363	}378	}
364	// Storage: Refungible Balance (r:1 w:0)379	// Storage: Refungible Balance (r:1 w:0)
365	// Storage: Refungible Allowance (r:0 w:1)380	// Storage: Refungible Allowance (r:0 w:1)
366	fn approve() -> Weight {381	fn approve() -> Weight {
367		(13_446_000 as Weight)382		(16_451_000 as Weight)
368			.saturating_add(RocksDbWeight::get().reads(1 as Weight))383			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
369			.saturating_add(RocksDbWeight::get().writes(1 as Weight))384			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
370	}385	}
371	// Storage: Refungible Allowance (r:1 w:1)386	// Storage: Refungible Allowance (r:1 w:1)
372	// Storage: Refungible Balance (r:2 w:2)387	// Storage: Refungible Balance (r:2 w:2)
373	fn transfer_from_normal() -> Weight {388	fn transfer_from_normal() -> Weight {
374		(24_777_000 as Weight)389		(29_545_000 as Weight)
375			.saturating_add(RocksDbWeight::get().reads(3 as Weight))390			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
376			.saturating_add(RocksDbWeight::get().writes(3 as Weight))391			.saturating_add(RocksDbWeight::get().writes(3 as Weight))
377	}392	}
380	// Storage: Refungible AccountBalance (r:1 w:1)395	// Storage: Refungible AccountBalance (r:1 w:1)
381	// Storage: Refungible Owned (r:0 w:1)396	// Storage: Refungible Owned (r:0 w:1)
382	fn transfer_from_creating() -> Weight {397	fn transfer_from_creating() -> Weight {
383		(28_483_000 as Weight)398		(33_392_000 as Weight)
384			.saturating_add(RocksDbWeight::get().reads(4 as Weight))399			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
385			.saturating_add(RocksDbWeight::get().writes(5 as Weight))400			.saturating_add(RocksDbWeight::get().writes(5 as Weight))
386	}401	}
389	// Storage: Refungible AccountBalance (r:1 w:1)404	// Storage: Refungible AccountBalance (r:1 w:1)
390	// Storage: Refungible Owned (r:0 w:1)405	// Storage: Refungible Owned (r:0 w:1)
391	fn transfer_from_removing() -> Weight {406	fn transfer_from_removing() -> Weight {
392		(29_896_000 as Weight)407		(35_446_000 as Weight)
393			.saturating_add(RocksDbWeight::get().reads(4 as Weight))408			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
394			.saturating_add(RocksDbWeight::get().writes(5 as Weight))409			.saturating_add(RocksDbWeight::get().writes(5 as Weight))
395	}410	}
398	// Storage: Refungible AccountBalance (r:2 w:2)413	// Storage: Refungible AccountBalance (r:2 w:2)
399	// Storage: Refungible Owned (r:0 w:2)414	// Storage: Refungible Owned (r:0 w:2)
400	fn transfer_from_creating_removing() -> Weight {415	fn transfer_from_creating_removing() -> Weight {
401		(32_070_000 as Weight)416		(37_762_000 as Weight)
402			.saturating_add(RocksDbWeight::get().reads(5 as Weight))417			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
403			.saturating_add(RocksDbWeight::get().writes(7 as Weight))418			.saturating_add(RocksDbWeight::get().writes(7 as Weight))
404	}419	}
411	// Storage: Refungible Owned (r:0 w:1)426	// Storage: Refungible Owned (r:0 w:1)
412	// Storage: Refungible TokenProperties (r:0 w:1)427	// Storage: Refungible TokenProperties (r:0 w:1)
413	fn burn_from() -> Weight {428	fn burn_from() -> Weight {
414		(36_789_000 as Weight)429		(42_620_000 as Weight)
415			.saturating_add(RocksDbWeight::get().reads(5 as Weight))430			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
416			.saturating_add(RocksDbWeight::get().writes(8 as Weight))431			.saturating_add(RocksDbWeight::get().writes(8 as Weight))
417	}432	}
418	// Storage: Common CollectionPropertyPermissions (r:1 w:1)433	// Storage: Common CollectionPropertyPermissions (r:1 w:1)
419	fn set_token_property_permissions(b: u32, ) -> Weight {434	fn set_token_property_permissions(b: u32, ) -> Weight {
420		(0 as Weight)435		(0 as Weight)
421			// Standard Error: 62_000436			// Standard Error: 65_000
422			.saturating_add((15_803_000 as Weight).saturating_mul(b as Weight))437			.saturating_add((16_513_000 as Weight).saturating_mul(b as Weight))
423			.saturating_add(RocksDbWeight::get().reads(1 as Weight))438			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
424			.saturating_add(RocksDbWeight::get().writes(1 as Weight))439			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
425	}440	}
426	// Storage: Common CollectionPropertyPermissions (r:1 w:0)441	// Storage: Common CollectionPropertyPermissions (r:1 w:0)
427	// Storage: Refungible TokenProperties (r:1 w:1)442	// Storage: Refungible TokenProperties (r:1 w:1)
428	fn set_token_properties(b: u32, ) -> Weight {443	fn set_token_properties(b: u32, ) -> Weight {
429		(0 as Weight)444		(0 as Weight)
430			// Standard Error: 1_668_000445			// Standard Error: 1_583_000
431			.saturating_add((302_308_000 as Weight).saturating_mul(b as Weight))446			.saturating_add((291_392_000 as Weight).saturating_mul(b as Weight))
432			.saturating_add(RocksDbWeight::get().reads(2 as Weight))447			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
433			.saturating_add(RocksDbWeight::get().writes(1 as Weight))448			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
434	}449	}
435	// Storage: Common CollectionPropertyPermissions (r:1 w:0)450	// Storage: Common CollectionPropertyPermissions (r:1 w:0)
436	// Storage: Refungible TokenProperties (r:1 w:1)451	// Storage: Refungible TokenProperties (r:1 w:1)
437	fn delete_token_properties(b: u32, ) -> Weight {452	fn delete_token_properties(b: u32, ) -> Weight {
438		(0 as Weight)453		(0 as Weight)
439			// Standard Error: 1_619_000454			// Standard Error: 1_699_000
440			.saturating_add((294_574_000 as Weight).saturating_mul(b as Weight))455			.saturating_add((293_270_000 as Weight).saturating_mul(b as Weight))
441			.saturating_add(RocksDbWeight::get().reads(2 as Weight))456			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
442			.saturating_add(RocksDbWeight::get().writes(1 as Weight))457			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
443	}458	}
444	// Storage: Refungible TotalSupply (r:1 w:1)459	// Storage: Refungible TotalSupply (r:1 w:1)
445	// Storage: Refungible Balance (r:1 w:1)460	// Storage: Refungible Balance (r:1 w:1)
446	fn repartition_item() -> Weight {461	fn repartition_item() -> Weight {
447		(8_325_000 as Weight)462		(19_206_000 as Weight)
448			.saturating_add(RocksDbWeight::get().reads(2 as Weight))463			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
449			.saturating_add(RocksDbWeight::get().writes(2 as Weight))464			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
450	}465	}
466	// Storage: Refungible Balance (r:1 w:0)
467	// Storage: Refungible TotalSupply (r:1 w:0)
468	// Storage: Refungible TokenProperties (r:1 w:1)
469	fn set_parent_nft_unchecked() -> Weight {
470		(10_189_000 as Weight)
471			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
472			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
473	}
474	// Storage: Refungible Balance (r:2 w:0)
475	fn token_owner() -> Weight {
476		(8_205_000 as Weight)
477			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
478	}
451}479}
452480