git.delta.rocks / unique-network / refs/commits / 3750ef0fdbd1

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6320,7 +6320,7 @@
 
 [[package]]
 name = "pallet-refungible"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -12733,7 +12733,7 @@
 
 [[package]]
 name = "up-data-structs"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "derivative",
  "frame-support",

--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -966,7 +966,7 @@
 				),
 			);
 			<T as Config>::Currency::settle(
-				&owner.as_sub(),
+				owner.as_sub(),
 				imbalance,
 				WithdrawReasons::TRANSFER,
 				ExistenceRequirement::KeepAlive,

--- a/pallets/nonfungible/src/benchmarking.rs
+++ b/pallets/nonfungible/src/benchmarking.rs
@@ -183,7 +183,7 @@
 			value: property_value(),
 		}).collect::<Vec<_>>();
 		let item = create_max_item(&collection, &owner, owner.clone())?;
-	}: {<Pallet<T>>::set_token_properties(&collection, &owner, item, props, false, &Unlimited)?}
+	}: {<Pallet<T>>::set_token_properties(&collection, &owner, item, props.into_iter(), false, &Unlimited)?}
 
 	delete_token_properties {
 		let b in 0..MAX_PROPERTIES_PER_ITEM;
@@ -205,7 +205,7 @@
 			value: property_value(),
 		}).collect::<Vec<_>>();
 		let item = create_max_item(&collection, &owner, owner.clone())?;
-		<Pallet<T>>::set_token_properties(&collection, &owner, item, props, false, &Unlimited)?;
+		<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, &Unlimited)?}
+	}: {<Pallet<T>>::delete_token_properties(&collection, &owner, item, to_delete.into_iter(), &Unlimited)?}
 }

--- 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-06-15, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2022-07-20, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
 
 // Executed Command:
@@ -56,7 +56,7 @@
 	// Storage: Nonfungible TokenData (r:0 w:1)
 	// Storage: Nonfungible Owned (r:0 w:1)
 	fn create_item() -> Weight {
-		(24_135_000 as Weight)
+		(20_328_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(2 as Weight))
 			.saturating_add(T::DbWeight::get().writes(4 as Weight))
 	}
@@ -65,9 +65,9 @@
 	// Storage: Nonfungible TokenData (r:0 w:4)
 	// Storage: Nonfungible Owned (r:0 w:4)
 	fn create_multiple_items(b: u32, ) -> Weight {
-		(21_952_000 as Weight)
-			// Standard Error: 5_000
-			.saturating_add((4_727_000 as Weight).saturating_mul(b as Weight))
+		(10_134_000 as Weight)
+			// Standard Error: 3_000
+			.saturating_add((4_927_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 +77,9 @@
 	// Storage: Nonfungible TokenData (r:0 w:4)
 	// Storage: Nonfungible Owned (r:0 w:4)
 	fn create_multiple_items_ex(b: u32, ) -> Weight {
-		(10_432_000 as Weight)
-			// Standard Error: 6_000
-			.saturating_add((7_383_000 as Weight).saturating_mul(b as Weight))
+		(5_710_000 as Weight)
+			// Standard Error: 4_000
+			.saturating_add((7_578_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 +93,7 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_item() -> Weight {
-		(29_798_000 as Weight)
+		(28_433_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(5 as Weight))
 			.saturating_add(T::DbWeight::get().writes(5 as Weight))
 	}
@@ -105,7 +105,7 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_recursively_self_raw() -> Weight {
-		(37_955_000 as Weight)
+		(34_435_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(5 as Weight))
 			.saturating_add(T::DbWeight::get().writes(5 as Weight))
 	}
@@ -119,8 +119,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_349_000
-			.saturating_add((275_145_000 as Weight).saturating_mul(b as Weight))
+			// Standard Error: 1_539_000
+			.saturating_add((304_456_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 +131,14 @@
 	// Storage: Nonfungible Allowance (r:1 w:0)
 	// Storage: Nonfungible Owned (r:0 w:2)
 	fn transfer() -> Weight {
-		(27_867_000 as Weight)
+		(24_376_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 {
-		(18_824_000 as Weight)
+		(15_890_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(2 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
@@ -147,7 +147,7 @@
 	// Storage: Nonfungible AccountBalance (r:2 w:2)
 	// Storage: Nonfungible Owned (r:0 w:2)
 	fn transfer_from() -> Weight {
-		(32_879_000 as Weight)
+		(28_634_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(4 as Weight))
 			.saturating_add(T::DbWeight::get().writes(6 as Weight))
 	}
@@ -159,7 +159,7 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_from() -> Weight {
-		(37_061_000 as Weight)
+		(32_201_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(5 as Weight))
 			.saturating_add(T::DbWeight::get().writes(6 as Weight))
 	}
@@ -167,28 +167,26 @@
 	fn set_token_property_permissions(b: u32, ) -> Weight {
 		(0 as Weight)
 			// Standard Error: 57_000
-			.saturating_add((15_149_000 as Weight).saturating_mul(b as Weight))
+			.saturating_add((15_232_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))
 	}
 	// Storage: Common CollectionPropertyPermissions (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:1 w:0)
 	// Storage: Nonfungible TokenProperties (r:1 w:1)
 	fn set_token_properties(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 2_278_000
-			.saturating_add((409_613_000 as Weight).saturating_mul(b as Weight))
-			.saturating_add(T::DbWeight::get().reads(3 as Weight))
+			// Standard Error: 1_648_000
+			.saturating_add((288_654_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: Common CollectionPropertyPermissions (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:1 w:0)
 	// Storage: Nonfungible TokenProperties (r:1 w:1)
 	fn delete_token_properties(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 2_234_000
-			.saturating_add((408_185_000 as Weight).saturating_mul(b as Weight))
-			.saturating_add(T::DbWeight::get().reads(3 as Weight))
+			// Standard Error: 1_632_000
+			.saturating_add((289_190_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))
 	}
 }
@@ -200,7 +198,7 @@
 	// Storage: Nonfungible TokenData (r:0 w:1)
 	// Storage: Nonfungible Owned (r:0 w:1)
 	fn create_item() -> Weight {
-		(24_135_000 as Weight)
+		(20_328_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
 	}
@@ -209,9 +207,9 @@
 	// Storage: Nonfungible TokenData (r:0 w:4)
 	// Storage: Nonfungible Owned (r:0 w:4)
 	fn create_multiple_items(b: u32, ) -> Weight {
-		(21_952_000 as Weight)
-			// Standard Error: 5_000
-			.saturating_add((4_727_000 as Weight).saturating_mul(b as Weight))
+		(10_134_000 as Weight)
+			// Standard Error: 3_000
+			.saturating_add((4_927_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)))
@@ -221,9 +219,9 @@
 	// Storage: Nonfungible TokenData (r:0 w:4)
 	// Storage: Nonfungible Owned (r:0 w:4)
 	fn create_multiple_items_ex(b: u32, ) -> Weight {
-		(10_432_000 as Weight)
-			// Standard Error: 6_000
-			.saturating_add((7_383_000 as Weight).saturating_mul(b as Weight))
+		(5_710_000 as Weight)
+			// Standard Error: 4_000
+			.saturating_add((7_578_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))
@@ -237,7 +235,7 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_item() -> Weight {
-		(29_798_000 as Weight)
+		(28_433_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(5 as Weight))
 	}
@@ -249,7 +247,7 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_recursively_self_raw() -> Weight {
-		(37_955_000 as Weight)
+		(34_435_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(5 as Weight))
 	}
@@ -263,8 +261,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_349_000
-			.saturating_add((275_145_000 as Weight).saturating_mul(b as Weight))
+			// Standard Error: 1_539_000
+			.saturating_add((304_456_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))
@@ -275,14 +273,14 @@
 	// Storage: Nonfungible Allowance (r:1 w:0)
 	// Storage: Nonfungible Owned (r:0 w:2)
 	fn transfer() -> Weight {
-		(27_867_000 as Weight)
+		(24_376_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 {
-		(18_824_000 as Weight)
+		(15_890_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
@@ -291,7 +289,7 @@
 	// Storage: Nonfungible AccountBalance (r:2 w:2)
 	// Storage: Nonfungible Owned (r:0 w:2)
 	fn transfer_from() -> Weight {
-		(32_879_000 as Weight)
+		(28_634_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
 	}
@@ -303,7 +301,7 @@
 	// Storage: Nonfungible Owned (r:0 w:1)
 	// Storage: Nonfungible TokenProperties (r:0 w:1)
 	fn burn_from() -> Weight {
-		(37_061_000 as Weight)
+		(32_201_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
 	}
@@ -311,28 +309,26 @@
 	fn set_token_property_permissions(b: u32, ) -> Weight {
 		(0 as Weight)
 			// Standard Error: 57_000
-			.saturating_add((15_149_000 as Weight).saturating_mul(b as Weight))
+			.saturating_add((15_232_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 	// Storage: Common CollectionPropertyPermissions (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:1 w:0)
 	// Storage: Nonfungible TokenProperties (r:1 w:1)
 	fn set_token_properties(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 2_278_000
-			.saturating_add((409_613_000 as Weight).saturating_mul(b as Weight))
-			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
+			// Standard Error: 1_648_000
+			.saturating_add((288_654_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: Common CollectionPropertyPermissions (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:1 w:0)
 	// Storage: Nonfungible TokenProperties (r:1 w:1)
 	fn delete_token_properties(b: u32, ) -> Weight {
 		(0 as Weight)
-			// Standard Error: 2_234_000
-			.saturating_add((408_185_000 as Weight).saturating_mul(b as Weight))
-			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
+			// Standard Error: 1_632_000
+			.saturating_add((289_190_000 as Weight).saturating_mul(b as Weight))
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 }

--- a/pallets/refungible/Cargo.toml
+++ b/pallets/refungible/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pallet-refungible"
-version = "0.1.0"
+version = "0.1.1"
 license = "GPLv3"
 edition = "2021"
 

--- a/pallets/refungible/src/benchmarking.rs
+++ b/pallets/refungible/src/benchmarking.rs
@@ -18,9 +18,12 @@
 use crate::{Pallet, Config, RefungibleHandle};
 
 use sp_std::prelude::*;
-use pallet_common::benchmarking::{create_collection_raw, create_data};
+use pallet_common::benchmarking::{create_collection_raw, property_key, property_value, create_data};
 use frame_benchmarking::{benchmarks, account};
-use up_data_structs::{CollectionMode, MAX_ITEMS_PER_BATCH, CUSTOM_DATA_LIMIT, budget::Unlimited};
+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;
@@ -38,6 +41,7 @@
 			.collect::<BTreeMap<_, _>>()
 			.try_into()
 			.unwrap(),
+		properties: Default::default(),
 	}
 }
 fn create_max_item<T: Config>(
@@ -204,6 +208,68 @@
 		<Pallet<T>>::set_allowance(&collection, &sender, &burner, item, 200)?;
 	}: {<Pallet<T>>::burn_from(&collection, &burner, &sender, item, 200, &Unlimited)?}
 
+	set_token_property_permissions {
+		let b in 0..MAX_PROPERTIES_PER_ITEM;
+		bench_init!{
+			owner: sub; collection: collection(owner);
+			owner: cross_from_sub;
+		};
+		let perms = (0..b).map(|k| PropertyKeyPermission {
+			key: property_key(k as usize),
+			permission: PropertyPermission {
+				mutable: false,
+				collection_admin: false,
+				token_owner: false,
+			},
+		}).collect::<Vec<_>>();
+	}: {<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?}
+
+	set_token_properties {
+		let b in 0..MAX_PROPERTIES_PER_ITEM;
+		bench_init!{
+			owner: sub; collection: collection(owner);
+			owner: cross_from_sub;
+		};
+		let perms = (0..b).map(|k| PropertyKeyPermission {
+			key: property_key(k as usize),
+			permission: PropertyPermission {
+				mutable: false,
+				collection_admin: true,
+				token_owner: true,
+			},
+		}).collect::<Vec<_>>();
+		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
+		let props = (0..b).map(|k| Property {
+			key: property_key(k as usize),
+			value: property_value(),
+		}).collect::<Vec<_>>();
+		let item = create_max_item(&collection, &owner, [(owner.clone(), 200)])?;
+	}: {<Pallet<T>>::set_token_properties(&collection, &owner, item, props.into_iter(), false, &Unlimited)?}
+
+	delete_token_properties {
+		let b in 0..MAX_PROPERTIES_PER_ITEM;
+		bench_init!{
+			owner: sub; collection: collection(owner);
+			owner: cross_from_sub;
+		};
+		let perms = (0..b).map(|k| PropertyKeyPermission {
+			key: property_key(k as usize),
+			permission: PropertyPermission {
+				mutable: true,
+				collection_admin: true,
+				token_owner: true,
+			},
+		}).collect::<Vec<_>>();
+		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
+		let props = (0..b).map(|k| Property {
+			key: property_key(k as usize),
+			value: property_value(),
+		}).collect::<Vec<_>>();
+		let item = create_max_item(&collection, &owner, [(owner.clone(), 200)])?;
+		<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)?}
+
 	repartition_item {
 		bench_init!{
 			owner: sub; collection: collection(owner);

--- a/pallets/refungible/src/common.rs
+++ b/pallets/refungible/src/common.rs
@@ -20,9 +20,12 @@
 use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, traits::Get};
 use up_data_structs::{
 	CollectionId, TokenId, CreateItemExData, CreateRefungibleExData, budget::Budget, Property,
-	PropertyKey, PropertyValue, PropertyKeyPermission, CreateItemData,
+	PropertyKey, PropertyValue, PropertyKeyPermission, CreateItemData, CollectionPropertiesVec,
 };
-use pallet_common::{CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight};
+use pallet_common::{
+	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight,
+	weights::WeightInfo as _,
+};
 use pallet_structure::Error as StructureError;
 use sp_runtime::{DispatchError};
 use sp_std::{vec::Vec, vec};
@@ -41,6 +44,14 @@
 	};
 }
 
+fn properties_weight<T: Config>(properties: &CollectionPropertiesVec) -> u64 {
+	if properties.len() > 0 {
+		<CommonWeights<T>>::set_token_properties(properties.len() as u32)
+	} else {
+		0
+	}
+}
+
 pub struct CommonWeights<T: Config>(PhantomData<T>);
 impl<T: Config> CommonWeightInfo<T::CrossAccountId> for CommonWeights<T> {
 	fn create_item() -> Weight {
@@ -48,16 +59,31 @@
 	}
 
 	fn create_multiple_items(data: &[CreateItemData]) -> Weight {
-		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32)
+		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32).saturating_add(
+			data.iter()
+				.map(|data| match data {
+					CreateItemData::ReFungible(rft_data) => {
+						properties_weight::<T>(&rft_data.properties)
+					}
+					_ => 0,
+				})
+				.fold(0, |a, b| a.saturating_add(b)),
+		)
 	}
 
 	fn create_multiple_items_ex(call: &CreateItemExData<T::CrossAccountId>) -> Weight {
 		match call {
 			CreateItemExData::RefungibleMultipleOwners(i) => {
 				<SelfWeightOf<T>>::create_multiple_items_ex_multiple_owners(i.users.len() as u32)
+					.saturating_add(properties_weight::<T>(&i.properties))
 			}
 			CreateItemExData::RefungibleMultipleItems(i) => {
 				<SelfWeightOf<T>>::create_multiple_items_ex_multiple_items(i.len() as u32)
+					.saturating_add(
+						i.iter()
+							.map(|d| properties_weight::<T>(&d.properties))
+							.fold(0, |a, b| a.saturating_add(b)),
+					)
 			}
 			_ => 0,
 		}
@@ -67,29 +93,24 @@
 		max_weight_of!(burn_item_partial(), burn_item_fully())
 	}
 
-	fn set_collection_properties(_amount: u32) -> Weight {
-		// Error
-		0
+	fn set_collection_properties(amount: u32) -> Weight {
+		<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)
 	}
 
-	fn delete_collection_properties(_amount: u32) -> Weight {
-		// Error
-		0
+	fn delete_collection_properties(amount: u32) -> Weight {
+		<pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)
 	}
 
-	fn set_token_properties(_amount: u32) -> Weight {
-		// Error
-		0
+	fn set_token_properties(amount: u32) -> Weight {
+		<SelfWeightOf<T>>::set_token_properties(amount)
 	}
 
-	fn delete_token_properties(_amount: u32) -> Weight {
-		// Error
-		0
+	fn delete_token_properties(amount: u32) -> Weight {
+		<SelfWeightOf<T>>::delete_token_properties(amount)
 	}
 
-	fn set_token_property_permissions(_amount: u32) -> Weight {
-		// Error
-		0
+	fn set_token_property_permissions(amount: u32) -> Weight {
+		<SelfWeightOf<T>>::set_token_property_permissions(amount)
 	}
 
 	fn transfer() -> Weight {
@@ -140,6 +161,7 @@
 				out.insert(to.clone(), data.pieces);
 				out.try_into().expect("limit > 0")
 			},
+			properties: data.properties,
 		}),
 		_ => fail!(<Error<T>>::NotRefungibleDataUsedToMintFungibleCollectionToken),
 	}
@@ -297,46 +319,85 @@
 
 	fn set_collection_properties(
 		&self,
-		_sender: T::CrossAccountId,
-		_property: Vec<Property>,
+		sender: T::CrossAccountId,
+		properties: Vec<Property>,
 	) -> DispatchResultWithPostInfo {
-		fail!(<Error<T>>::SettingPropertiesNotAllowed)
+		let weight = <CommonWeights<T>>::set_collection_properties(properties.len() as u32);
+
+		with_weight(
+			<Pallet<T>>::set_collection_properties(self, &sender, properties),
+			weight,
+		)
 	}
 
 	fn delete_collection_properties(
 		&self,
-		_sender: &T::CrossAccountId,
-		_property_keys: Vec<PropertyKey>,
+		sender: &T::CrossAccountId,
+		property_keys: Vec<PropertyKey>,
 	) -> DispatchResultWithPostInfo {
-		fail!(<Error<T>>::SettingPropertiesNotAllowed)
+		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);
+
+		with_weight(
+			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),
+			weight,
+		)
 	}
 
 	fn set_token_properties(
 		&self,
-		_sender: T::CrossAccountId,
-		_token_id: TokenId,
-		_property: Vec<Property>,
-		_nesting_budget: &dyn Budget,
+		sender: T::CrossAccountId,
+		token_id: TokenId,
+		properties: Vec<Property>,
+		nesting_budget: &dyn Budget,
 	) -> DispatchResultWithPostInfo {
-		fail!(<Error<T>>::SettingPropertiesNotAllowed)
+		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);
+
+		with_weight(
+			<Pallet<T>>::set_token_properties(
+				self,
+				&sender,
+				token_id,
+				properties.into_iter(),
+				false,
+				nesting_budget,
+			),
+			weight,
+		)
 	}
 
 	fn set_token_property_permissions(
 		&self,
-		_sender: &T::CrossAccountId,
-		_property_permissions: Vec<PropertyKeyPermission>,
+		sender: &T::CrossAccountId,
+		property_permissions: Vec<PropertyKeyPermission>,
 	) -> DispatchResultWithPostInfo {
-		fail!(<Error<T>>::SettingPropertiesNotAllowed)
+		let weight =
+			<CommonWeights<T>>::set_token_property_permissions(property_permissions.len() as u32);
+
+		with_weight(
+			<Pallet<T>>::set_token_property_permissions(self, sender, property_permissions),
+			weight,
+		)
 	}
 
 	fn delete_token_properties(
 		&self,
-		_sender: T::CrossAccountId,
-		_token_id: TokenId,
-		_property_keys: Vec<PropertyKey>,
-		_nesting_budget: &dyn Budget,
+		sender: T::CrossAccountId,
+		token_id: TokenId,
+		property_keys: Vec<PropertyKey>,
+		nesting_budget: &dyn Budget,
 	) -> DispatchResultWithPostInfo {
-		fail!(<Error<T>>::SettingPropertiesNotAllowed)
+		let weight = <CommonWeights<T>>::delete_token_properties(property_keys.len() as u32);
+
+		with_weight(
+			<Pallet<T>>::delete_token_properties(
+				self,
+				&sender,
+				token_id,
+				property_keys.into_iter(),
+				nesting_budget,
+			),
+			weight,
+		)
 	}
 
 	fn check_nesting(
@@ -373,8 +434,8 @@
 		TokenId(<TokensMinted<T>>::get(self.id))
 	}
 
-	fn token_owner(&self, _token: TokenId) -> Option<T::CrossAccountId> {
-		None
+	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId> {
+		<Pallet<T>>::token_owner(self.id, token)
 	}
 
 	fn token_property(&self, _token_id: TokenId, _key: &PropertyKey) -> Option<PropertyValue> {

--- a/pallets/refungible/src/lib.rs
+++ b/pallets/refungible/src/lib.rs
@@ -87,15 +87,20 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use frame_support::{ensure, BoundedVec};
+use frame_support::{ensure, fail, BoundedVec, transactional, storage::with_transaction};
 use up_data_structs::{
 	AccessMode, CollectionId, CustomDataLimit, MAX_REFUNGIBLE_PIECES, TokenId,
 	CreateCollectionData, CreateRefungibleExData, mapping::TokenAddressMapping, budget::Budget,
+	Property, PropertyScope, TrySetProperty, PropertyKey, PropertyValue, PropertyPermission,
+	PropertyKeyPermission,
 };
 use pallet_evm::account::CrossAccountId;
-use pallet_common::{Error as CommonError, Event as CommonEvent, Pallet as PalletCommon};
+use pallet_common::{
+	Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,
+	CommonCollectionOperations as _,
+};
 use pallet_structure::Pallet as PalletStructure;
-use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};
+use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};
 use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};
 use core::ops::Deref;
 use codec::{Encode, Decode, MaxEncodedLen};
@@ -175,6 +180,15 @@
 		QueryKind = ValueQuery,
 	>;
 
+	#[pallet::storage]
+	#[pallet::getter(fn token_properties)]
+	pub type TokenProperties<T: Config> = StorageNMap<
+		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),
+		Value = up_data_structs::Properties,
+		QueryKind = ValueQuery,
+		OnEmpty = up_data_structs::TokenProperties,
+	>;
+
 	/// Total amount of pieces for token
 	#[pallet::storage]
 	pub type TotalSupply<T: Config> = StorageNMap<
@@ -278,6 +292,34 @@
 	pub fn token_exists(collection: &RefungibleHandle<T>, token: TokenId) -> bool {
 		<TotalSupply<T>>::contains_key((collection.id, token))
 	}
+
+	pub fn set_scoped_token_property(
+		collection_id: CollectionId,
+		token_id: TokenId,
+		scope: PropertyScope,
+		property: Property,
+	) -> DispatchResult {
+		TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {
+			properties.try_scoped_set(scope, property.key, property.value)
+		})
+		.map_err(<CommonError<T>>::from)?;
+
+		Ok(())
+	}
+
+	pub fn set_scoped_token_properties(
+		collection_id: CollectionId,
+		token_id: TokenId,
+		scope: PropertyScope,
+		properties: impl Iterator<Item = Property>,
+	) -> DispatchResult {
+		TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {
+			stored_properties.try_scoped_set_from_iter(scope, properties)
+		})
+		.map_err(<CommonError<T>>::from)?;
+
+		Ok(())
+	}
 }
 
 // unchecked calls skips any permission checks
@@ -339,6 +381,7 @@
 
 		<TokensBurnt<T>>::insert(collection.id, burnt);
 		<TokenData<T>>::remove((collection.id, token_id));
+		<TokenProperties<T>>::remove((collection.id, token_id));
 		<TotalSupply<T>>::remove((collection.id, token_id));
 		<Balance<T>>::remove_prefix((collection.id, token_id), None);
 		<Allowance<T>>::remove_prefix((collection.id, token_id), None);
@@ -427,6 +470,170 @@
 		Ok(())
 	}
 
+	#[transactional]
+	fn modify_token_properties(
+		collection: &RefungibleHandle<T>,
+		sender: &T::CrossAccountId,
+		token_id: TokenId,
+		properties: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,
+		is_token_create: bool,
+		nesting_budget: &dyn Budget,
+	) -> DispatchResult {
+		let is_collection_admin = || collection.is_owner_or_admin(sender);
+		let is_token_owner = || -> Result<bool, DispatchError> {
+			let balance = collection.balance(sender.clone(), token_id);
+			let total_pieces: u128 =
+				Self::total_pieces(collection.id, token_id).unwrap_or(u128::MAX);
+			if balance != total_pieces {
+				return Ok(false);
+			}
+
+			let is_bundle_owner = <PalletStructure<T>>::check_indirectly_owned(
+				sender.clone(),
+				collection.id,
+				token_id,
+				None,
+				nesting_budget,
+			)?;
+
+			Ok(is_bundle_owner)
+		};
+
+		for (key, value) in properties {
+			let permission = <PalletCommon<T>>::property_permissions(collection.id)
+				.get(&key)
+				.cloned()
+				.unwrap_or_else(PropertyPermission::none);
+
+			let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))
+				.get(&key)
+				.is_some();
+
+			match permission {
+				PropertyPermission { mutable: false, .. } if is_property_exists => {
+					return Err(<CommonError<T>>::NoPermission.into());
+				}
+
+				PropertyPermission {
+					collection_admin,
+					token_owner,
+					..
+				} => {
+					//TODO: investigate threats during public minting.
+					let is_token_create =
+						is_token_create && (collection_admin || token_owner) && value.is_some();
+					if !(is_token_create
+						|| (collection_admin && is_collection_admin())
+						|| (token_owner && is_token_owner()?))
+					{
+						fail!(<CommonError<T>>::NoPermission);
+					}
+				}
+			}
+
+			match value {
+				Some(value) => {
+					<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {
+						properties.try_set(key.clone(), value)
+					})
+					.map_err(<CommonError<T>>::from)?;
+
+					<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(
+						collection.id,
+						token_id,
+						key,
+					));
+				}
+				None => {
+					<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {
+						properties.remove(&key)
+					})
+					.map_err(<CommonError<T>>::from)?;
+
+					<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(
+						collection.id,
+						token_id,
+						key,
+					));
+				}
+			}
+		}
+
+		Ok(())
+	}
+
+	pub fn set_token_properties(
+		collection: &RefungibleHandle<T>,
+		sender: &T::CrossAccountId,
+		token_id: TokenId,
+		properties: impl Iterator<Item = Property>,
+		is_token_create: bool,
+		nesting_budget: &dyn Budget,
+	) -> DispatchResult {
+		Self::modify_token_properties(
+			collection,
+			sender,
+			token_id,
+			properties.map(|p| (p.key, Some(p.value))),
+			is_token_create,
+			nesting_budget,
+		)
+	}
+
+	pub fn set_token_property(
+		collection: &RefungibleHandle<T>,
+		sender: &T::CrossAccountId,
+		token_id: TokenId,
+		property: Property,
+		nesting_budget: &dyn Budget,
+	) -> DispatchResult {
+		let is_token_create = false;
+
+		Self::set_token_properties(
+			collection,
+			sender,
+			token_id,
+			[property].into_iter(),
+			is_token_create,
+			nesting_budget,
+		)
+	}
+
+	pub fn delete_token_properties(
+		collection: &RefungibleHandle<T>,
+		sender: &T::CrossAccountId,
+		token_id: TokenId,
+		property_keys: impl Iterator<Item = PropertyKey>,
+		nesting_budget: &dyn Budget,
+	) -> DispatchResult {
+		let is_token_create = false;
+
+		Self::modify_token_properties(
+			collection,
+			sender,
+			token_id,
+			property_keys.into_iter().map(|key| (key, None)),
+			is_token_create,
+			nesting_budget,
+		)
+	}
+
+	pub fn delete_token_property(
+		collection: &RefungibleHandle<T>,
+		sender: &T::CrossAccountId,
+		token_id: TokenId,
+		property_key: PropertyKey,
+		nesting_budget: &dyn Budget,
+	) -> DispatchResult {
+		Self::delete_token_properties(
+			collection,
+			sender,
+			token_id,
+			[property_key].into_iter(),
+			nesting_budget,
+		)
+	}
+
 	/// Transfer RFT token pieces from one account to another.
 	///
 	/// If the sender is no longer owns any pieces after the `transfer` than she stops being an owner of the token.
@@ -629,32 +836,58 @@
 
 		// =========
 
+		with_transaction(|| {
+			for (i, data) in data.iter().enumerate() {
+				let token_id = first_token_id + i as u32 + 1;
+				<TotalSupply<T>>::insert((collection.id, token_id), totals[i]);
+
+				<TokenData<T>>::insert(
+					(collection.id, token_id),
+					ItemData {
+						const_data: data.const_data.clone(),
+					},
+				);
+
+				for (user, amount) in data.users.iter() {
+					if *amount == 0 {
+						continue;
+					}
+					<Balance<T>>::insert((collection.id, token_id, &user), amount);
+					<Owned<T>>::insert((collection.id, &user, TokenId(token_id)), true);
+					<PalletStructure<T>>::nest_if_sent_to_token_unchecked(
+						user,
+						collection.id,
+						TokenId(token_id),
+					);
+				}
+
+				if let Err(e) = Self::set_token_properties(
+					collection,
+					sender,
+					TokenId(token_id),
+					data.properties.clone().into_iter(),
+					true,
+					nesting_budget,
+				) {
+					return TransactionOutcome::Rollback(Err(e));
+				}
+			}
+			TransactionOutcome::Commit(Ok(()))
+		})?;
+
 		<TokensMinted<T>>::insert(collection.id, tokens_minted);
+
 		for (account, balance) in balances {
 			<AccountBalance<T>>::insert((collection.id, account), balance);
 		}
+
 		for (i, token) in data.into_iter().enumerate() {
 			let token_id = first_token_id + i as u32 + 1;
-			<TotalSupply<T>>::insert((collection.id, token_id), totals[i]);
-
-			<TokenData<T>>::insert(
-				(collection.id, token_id),
-				ItemData {
-					const_data: token.const_data,
-				},
-			);
 
 			for (user, amount) in token.users.into_iter() {
 				if amount == 0 {
 					continue;
 				}
-				<Balance<T>>::insert((collection.id, token_id, &user), amount);
-				<Owned<T>>::insert((collection.id, &user, TokenId(token_id)), true);
-				<PalletStructure<T>>::nest_if_sent_to_token_unchecked(
-					&user,
-					collection.id,
-					TokenId(token_id),
-				);
 
 				// TODO: ERC20 transfer event
 				<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(
@@ -849,10 +1082,10 @@
 		);
 		ensure!(amount > 0, <CommonError<T>>::TokenValueTooLow);
 		// Ensure user owns all pieces
-		let total_supply = <TotalSupply<T>>::get((collection.id, token));
+		let total_pieces = Self::total_pieces(collection.id, token).unwrap_or(u128::MAX);
 		let balance = <Balance<T>>::get((collection.id, token, owner));
 		ensure!(
-			total_supply == balance,
+			total_pieces == balance,
 			<Error<T>>::RepartitionWhileNotOwningAllPieces
 		);
 
@@ -861,7 +1094,44 @@
 		Ok(())
 	}
 
+	fn token_owner(collection_id: CollectionId, token_id: TokenId) -> Option<T::CrossAccountId> {
+		let mut owner = None;
+		let mut count = 0;
+		for key in Balance::<T>::iter_key_prefix((collection_id, token_id)) {
+			count += 1;
+			if count > 1 {
+				return None;
+			}
+			owner = Some(key);
+		}
+		owner
+	}
+
 	fn total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<u128> {
 		<TotalSupply<T>>::try_get((collection_id, token_id)).ok()
 	}
+
+	pub fn set_collection_properties(
+		collection: &RefungibleHandle<T>,
+		sender: &T::CrossAccountId,
+		properties: Vec<Property>,
+	) -> DispatchResult {
+		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)
+	}
+
+	pub fn delete_collection_properties(
+		collection: &RefungibleHandle<T>,
+		sender: &T::CrossAccountId,
+		property_keys: Vec<PropertyKey>,
+	) -> DispatchResult {
+		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)
+	}
+
+	pub fn set_token_property_permissions(
+		collection: &RefungibleHandle<T>,
+		sender: &T::CrossAccountId,
+		property_permissions: Vec<PropertyKeyPermission>,
+	) -> DispatchResult {
+		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)
+	}
 }

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-06-27, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`6//! DATE: 2022-07-20, 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:
49	fn transfer_from_removing() -> Weight;49	fn transfer_from_removing() -> Weight;
50	fn transfer_from_creating_removing() -> Weight;50	fn transfer_from_creating_removing() -> Weight;
51	fn burn_from() -> Weight;51	fn burn_from() -> Weight;
52	fn set_token_property_permissions(b: u32, ) -> Weight;
53	fn set_token_properties(b: u32, ) -> Weight;
54	fn delete_token_properties(b: u32, ) -> Weight;
52	fn repartition_item() -> Weight;55	fn repartition_item() -> Weight;
53}56}
5457
62	// Storage: Refungible TokenData (r:0 w:1)65	// Storage: Refungible TokenData (r:0 w:1)
63	// Storage: Refungible Owned (r:0 w:1)66	// Storage: Refungible Owned (r:0 w:1)
64	fn create_item() -> Weight {67	fn create_item() -> Weight {
65		(17_553_000 as Weight)68		(21_310_000 as Weight)
66			.saturating_add(T::DbWeight::get().reads(2 as Weight))69			.saturating_add(T::DbWeight::get().reads(2 as Weight))
67			.saturating_add(T::DbWeight::get().writes(6 as Weight))70			.saturating_add(T::DbWeight::get().writes(6 as Weight))
68	}71	}
73	// Storage: Refungible TokenData (r:0 w:4)76	// Storage: Refungible TokenData (r:0 w:4)
74	// Storage: Refungible Owned (r:0 w:4)77	// Storage: Refungible Owned (r:0 w:4)
75	fn create_multiple_items(b: u32, ) -> Weight {78	fn create_multiple_items(b: u32, ) -> Weight {
76		(10_654_000 as Weight)79		(9_552_000 as Weight)
77			// Standard Error: 1_00080			// Standard Error: 2_000
78			.saturating_add((5_114_000 as Weight).saturating_mul(b as Weight))81			.saturating_add((7_056_000 as Weight).saturating_mul(b as Weight))
79			.saturating_add(T::DbWeight::get().reads(2 as Weight))82			.saturating_add(T::DbWeight::get().reads(2 as Weight))
80			.saturating_add(T::DbWeight::get().writes(2 as Weight))83			.saturating_add(T::DbWeight::get().writes(2 as Weight))
81			.saturating_add(T::DbWeight::get().writes((4 as Weight).saturating_mul(b as Weight)))84			.saturating_add(T::DbWeight::get().writes((4 as Weight).saturating_mul(b as Weight)))
87	// Storage: Refungible TokenData (r:0 w:4)90	// Storage: Refungible TokenData (r:0 w:4)
88	// Storage: Refungible Owned (r:0 w:4)91	// Storage: Refungible Owned (r:0 w:4)
89	fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight {92	fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight {
90		(3_587_000 as Weight)93		(4_857_000 as Weight)
91			// Standard Error: 2_00094			// Standard Error: 2_000
92			.saturating_add((7_931_000 as Weight).saturating_mul(b as Weight))95			.saturating_add((9_838_000 as Weight).saturating_mul(b as Weight))
93			.saturating_add(T::DbWeight::get().reads(1 as Weight))96			.saturating_add(T::DbWeight::get().reads(1 as Weight))
94			.saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))97			.saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))
95			.saturating_add(T::DbWeight::get().writes(1 as Weight))98			.saturating_add(T::DbWeight::get().writes(1 as Weight))
102	// Storage: Refungible Balance (r:0 w:4)105	// Storage: Refungible Balance (r:0 w:4)
103	// Storage: Refungible Owned (r:0 w:4)106	// Storage: Refungible Owned (r:0 w:4)
104	fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight {107	fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight {
105		(1_980_000 as Weight)108		(11_335_000 as Weight)
106			// Standard Error: 2_000109			// Standard Error: 2_000
107			.saturating_add((6_305_000 as Weight).saturating_mul(b as Weight))110			.saturating_add((6_784_000 as Weight).saturating_mul(b as Weight))
108			.saturating_add(T::DbWeight::get().reads(1 as Weight))111			.saturating_add(T::DbWeight::get().reads(1 as Weight))
109			.saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))112			.saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))
110			.saturating_add(T::DbWeight::get().writes(3 as Weight))113			.saturating_add(T::DbWeight::get().writes(3 as Weight))
115	// Storage: Refungible AccountBalance (r:1 w:1)118	// Storage: Refungible AccountBalance (r:1 w:1)
116	// Storage: Refungible Owned (r:0 w:1)119	// Storage: Refungible Owned (r:0 w:1)
117	fn burn_item_partial() -> Weight {120	fn burn_item_partial() -> Weight {
118		(21_010_000 as Weight)121		(21_239_000 as Weight)
119			.saturating_add(T::DbWeight::get().reads(3 as Weight))122			.saturating_add(T::DbWeight::get().reads(3 as Weight))
120			.saturating_add(T::DbWeight::get().writes(4 as Weight))123			.saturating_add(T::DbWeight::get().writes(4 as Weight))
121	}124	}
125	// Storage: Refungible TokensBurnt (r:1 w:1)128	// Storage: Refungible TokensBurnt (r:1 w:1)
126	// Storage: Refungible TokenData (r:0 w:1)129	// Storage: Refungible TokenData (r:0 w:1)
127	// Storage: Refungible Owned (r:0 w:1)130	// Storage: Refungible Owned (r:0 w:1)
131	// Storage: Refungible TokenProperties (r:0 w:1)
128	fn burn_item_fully() -> Weight {132	fn burn_item_fully() -> Weight {
129		(28_413_000 as Weight)133		(29_426_000 as Weight)
130			.saturating_add(T::DbWeight::get().reads(4 as Weight))134			.saturating_add(T::DbWeight::get().reads(4 as Weight))
131			.saturating_add(T::DbWeight::get().writes(6 as Weight))135			.saturating_add(T::DbWeight::get().writes(7 as Weight))
132	}136	}
133	// Storage: Refungible Balance (r:2 w:2)137	// Storage: Refungible Balance (r:2 w:2)
134	fn transfer_normal() -> Weight {138	fn transfer_normal() -> Weight {
135		(17_513_000 as Weight)139		(17_743_000 as Weight)
136			.saturating_add(T::DbWeight::get().reads(2 as Weight))140			.saturating_add(T::DbWeight::get().reads(2 as Weight))
137			.saturating_add(T::DbWeight::get().writes(2 as Weight))141			.saturating_add(T::DbWeight::get().writes(2 as Weight))
138	}142	}
139	// Storage: Refungible Balance (r:2 w:2)143	// Storage: Refungible Balance (r:2 w:2)
140	// Storage: Refungible AccountBalance (r:1 w:1)144	// Storage: Refungible AccountBalance (r:1 w:1)
141	// Storage: Refungible Owned (r:0 w:1)145	// Storage: Refungible Owned (r:0 w:1)
142	fn transfer_creating() -> Weight {146	fn transfer_creating() -> Weight {
143		(20_469_000 as Weight)147		(20_699_000 as Weight)
144			.saturating_add(T::DbWeight::get().reads(3 as Weight))148			.saturating_add(T::DbWeight::get().reads(3 as Weight))
145			.saturating_add(T::DbWeight::get().writes(4 as Weight))149			.saturating_add(T::DbWeight::get().writes(4 as Weight))
146	}150	}
147	// Storage: Refungible Balance (r:2 w:2)151	// Storage: Refungible Balance (r:2 w:2)
148	// Storage: Refungible AccountBalance (r:1 w:1)152	// Storage: Refungible AccountBalance (r:1 w:1)
149	// Storage: Refungible Owned (r:0 w:1)153	// Storage: Refungible Owned (r:0 w:1)
150	fn transfer_removing() -> Weight {154	fn transfer_removing() -> Weight {
151		(22_472_000 as Weight)155		(22_833_000 as Weight)
152			.saturating_add(T::DbWeight::get().reads(3 as Weight))156			.saturating_add(T::DbWeight::get().reads(3 as Weight))
153			.saturating_add(T::DbWeight::get().writes(4 as Weight))157			.saturating_add(T::DbWeight::get().writes(4 as Weight))
154	}158	}
155	// Storage: Refungible Balance (r:2 w:2)159	// Storage: Refungible Balance (r:2 w:2)
156	// Storage: Refungible AccountBalance (r:2 w:2)160	// Storage: Refungible AccountBalance (r:2 w:2)
157	// Storage: Refungible Owned (r:0 w:2)161	// Storage: Refungible Owned (r:0 w:2)
158	fn transfer_creating_removing() -> Weight {162	fn transfer_creating_removing() -> Weight {
159		(24_866_000 as Weight)163		(24_936_000 as Weight)
160			.saturating_add(T::DbWeight::get().reads(4 as Weight))164			.saturating_add(T::DbWeight::get().reads(4 as Weight))
161			.saturating_add(T::DbWeight::get().writes(6 as Weight))165			.saturating_add(T::DbWeight::get().writes(6 as Weight))
162	}166	}
163	// Storage: Refungible Balance (r:1 w:0)167	// Storage: Refungible Balance (r:1 w:0)
164	// Storage: Refungible Allowance (r:0 w:1)168	// Storage: Refungible Allowance (r:0 w:1)
165	fn approve() -> Weight {169	fn approve() -> Weight {
166		(13_475_000 as Weight)170		(13_446_000 as Weight)
167			.saturating_add(T::DbWeight::get().reads(1 as Weight))171			.saturating_add(T::DbWeight::get().reads(1 as Weight))
168			.saturating_add(T::DbWeight::get().writes(1 as Weight))172			.saturating_add(T::DbWeight::get().writes(1 as Weight))
169	}173	}
170	// Storage: Refungible Allowance (r:1 w:1)174	// Storage: Refungible Allowance (r:1 w:1)
171	// Storage: Refungible Balance (r:2 w:2)175	// Storage: Refungible Balance (r:2 w:2)
172	fn transfer_from_normal() -> Weight {176	fn transfer_from_normal() -> Weight {
173		(24_707_000 as Weight)177		(24_777_000 as Weight)
174			.saturating_add(T::DbWeight::get().reads(3 as Weight))178			.saturating_add(T::DbWeight::get().reads(3 as Weight))
175			.saturating_add(T::DbWeight::get().writes(3 as Weight))179			.saturating_add(T::DbWeight::get().writes(3 as Weight))
176	}180	}
179	// Storage: Refungible AccountBalance (r:1 w:1)183	// Storage: Refungible AccountBalance (r:1 w:1)
180	// Storage: Refungible Owned (r:0 w:1)184	// Storage: Refungible Owned (r:0 w:1)
181	fn transfer_from_creating() -> Weight {185	fn transfer_from_creating() -> Weight {
182		(27_812_000 as Weight)186		(28_483_000 as Weight)
183			.saturating_add(T::DbWeight::get().reads(4 as Weight))187			.saturating_add(T::DbWeight::get().reads(4 as Weight))
184			.saturating_add(T::DbWeight::get().writes(5 as Weight))188			.saturating_add(T::DbWeight::get().writes(5 as Weight))
185	}189	}
188	// Storage: Refungible AccountBalance (r:1 w:1)192	// Storage: Refungible AccountBalance (r:1 w:1)
189	// Storage: Refungible Owned (r:0 w:1)193	// Storage: Refungible Owned (r:0 w:1)
190	fn transfer_from_removing() -> Weight {194	fn transfer_from_removing() -> Weight {
191		(29_966_000 as Weight)195		(29_896_000 as Weight)
192			.saturating_add(T::DbWeight::get().reads(4 as Weight))196			.saturating_add(T::DbWeight::get().reads(4 as Weight))
193			.saturating_add(T::DbWeight::get().writes(5 as Weight))197			.saturating_add(T::DbWeight::get().writes(5 as Weight))
194	}198	}
197	// Storage: Refungible AccountBalance (r:2 w:2)201	// Storage: Refungible AccountBalance (r:2 w:2)
198	// Storage: Refungible Owned (r:0 w:2)202	// Storage: Refungible Owned (r:0 w:2)
199	fn transfer_from_creating_removing() -> Weight {203	fn transfer_from_creating_removing() -> Weight {
200		(31_660_000 as Weight)204		(32_070_000 as Weight)
201			.saturating_add(T::DbWeight::get().reads(5 as Weight))205			.saturating_add(T::DbWeight::get().reads(5 as Weight))
202			.saturating_add(T::DbWeight::get().writes(7 as Weight))206			.saturating_add(T::DbWeight::get().writes(7 as Weight))
203	}207	}
208	// Storage: Refungible TokensBurnt (r:1 w:1)212	// Storage: Refungible TokensBurnt (r:1 w:1)
209	// Storage: Refungible TokenData (r:0 w:1)213	// Storage: Refungible TokenData (r:0 w:1)
210	// Storage: Refungible Owned (r:0 w:1)214	// Storage: Refungible Owned (r:0 w:1)
215	// Storage: Refungible TokenProperties (r:0 w:1)
211	fn burn_from() -> Weight {216	fn burn_from() -> Weight {
212		(36_248_000 as Weight)217		(36_789_000 as Weight)
213			.saturating_add(T::DbWeight::get().reads(5 as Weight))218			.saturating_add(T::DbWeight::get().reads(5 as Weight))
214			.saturating_add(T::DbWeight::get().writes(7 as Weight))219			.saturating_add(T::DbWeight::get().writes(8 as Weight))
215	}220	}
221	// Storage: Common CollectionPropertyPermissions (r:1 w:1)
222	fn set_token_property_permissions(b: u32, ) -> Weight {
223		(0 as Weight)
224			// Standard Error: 62_000
225			.saturating_add((15_803_000 as Weight).saturating_mul(b as Weight))
226			.saturating_add(T::DbWeight::get().reads(1 as Weight))
227			.saturating_add(T::DbWeight::get().writes(1 as Weight))
228	}
229	// Storage: Common CollectionPropertyPermissions (r:1 w:0)
230	// Storage: Refungible TokenProperties (r:1 w:1)
231	fn set_token_properties(b: u32, ) -> Weight {
232		(0 as Weight)
233			// Standard Error: 1_668_000
234			.saturating_add((302_308_000 as Weight).saturating_mul(b as Weight))
235			.saturating_add(T::DbWeight::get().reads(2 as Weight))
236			.saturating_add(T::DbWeight::get().writes(1 as Weight))
237	}
238	// Storage: Common CollectionPropertyPermissions (r:1 w:0)
239	// Storage: Refungible TokenProperties (r:1 w:1)
240	fn delete_token_properties(b: u32, ) -> Weight {
241		(0 as Weight)
242			// Standard Error: 1_619_000
243			.saturating_add((294_574_000 as Weight).saturating_mul(b as Weight))
244			.saturating_add(T::DbWeight::get().reads(2 as Weight))
245			.saturating_add(T::DbWeight::get().writes(1 as Weight))
246	}
216	// Storage: Refungible TotalSupply (r:1 w:1)247	// Storage: Refungible TotalSupply (r:1 w:1)
217	// Storage: Refungible Balance (r:1 w:1)248	// Storage: Refungible Balance (r:1 w:1)
218	fn repartition_item() -> Weight {249	fn repartition_item() -> Weight {
219		(8_226_000 as Weight)250		(8_325_000 as Weight)
220			.saturating_add(T::DbWeight::get().reads(2 as Weight))251			.saturating_add(T::DbWeight::get().reads(2 as Weight))
221			.saturating_add(T::DbWeight::get().writes(2 as Weight))252			.saturating_add(T::DbWeight::get().writes(2 as Weight))
222	}253	}
231	// Storage: Refungible TokenData (r:0 w:1)262	// Storage: Refungible TokenData (r:0 w:1)
232	// Storage: Refungible Owned (r:0 w:1)263	// Storage: Refungible Owned (r:0 w:1)
233	fn create_item() -> Weight {264	fn create_item() -> Weight {
234		(17_553_000 as Weight)265		(21_310_000 as Weight)
235			.saturating_add(RocksDbWeight::get().reads(2 as Weight))266			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
236			.saturating_add(RocksDbWeight::get().writes(6 as Weight))267			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
237	}268	}
242	// Storage: Refungible TokenData (r:0 w:4)273	// Storage: Refungible TokenData (r:0 w:4)
243	// Storage: Refungible Owned (r:0 w:4)274	// Storage: Refungible Owned (r:0 w:4)
244	fn create_multiple_items(b: u32, ) -> Weight {275	fn create_multiple_items(b: u32, ) -> Weight {
245		(10_654_000 as Weight)276		(9_552_000 as Weight)
246			// Standard Error: 1_000277			// Standard Error: 2_000
247			.saturating_add((5_114_000 as Weight).saturating_mul(b as Weight))278			.saturating_add((7_056_000 as Weight).saturating_mul(b as Weight))
248			.saturating_add(RocksDbWeight::get().reads(2 as Weight))279			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
249			.saturating_add(RocksDbWeight::get().writes(2 as Weight))280			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
250			.saturating_add(RocksDbWeight::get().writes((4 as Weight).saturating_mul(b as Weight)))281			.saturating_add(RocksDbWeight::get().writes((4 as Weight).saturating_mul(b as Weight)))
256	// Storage: Refungible TokenData (r:0 w:4)287	// Storage: Refungible TokenData (r:0 w:4)
257	// Storage: Refungible Owned (r:0 w:4)288	// Storage: Refungible Owned (r:0 w:4)
258	fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight {289	fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight {
259		(3_587_000 as Weight)290		(4_857_000 as Weight)
260			// Standard Error: 2_000291			// Standard Error: 2_000
261			.saturating_add((7_931_000 as Weight).saturating_mul(b as Weight))292			.saturating_add((9_838_000 as Weight).saturating_mul(b as Weight))
262			.saturating_add(RocksDbWeight::get().reads(1 as Weight))293			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
263			.saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))294			.saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(b as Weight)))
264			.saturating_add(RocksDbWeight::get().writes(1 as Weight))295			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
271	// Storage: Refungible Balance (r:0 w:4)302	// Storage: Refungible Balance (r:0 w:4)
272	// Storage: Refungible Owned (r:0 w:4)303	// Storage: Refungible Owned (r:0 w:4)
273	fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight {304	fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight {
274		(1_980_000 as Weight)305		(11_335_000 as Weight)
275			// Standard Error: 2_000306			// Standard Error: 2_000
276			.saturating_add((6_305_000 as Weight).saturating_mul(b as Weight))307			.saturating_add((6_784_000 as Weight).saturating_mul(b as Weight))
277			.saturating_add(RocksDbWeight::get().reads(1 as Weight))308			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
278			.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)))
279			.saturating_add(RocksDbWeight::get().writes(3 as Weight))310			.saturating_add(RocksDbWeight::get().writes(3 as Weight))
284	// Storage: Refungible AccountBalance (r:1 w:1)315	// Storage: Refungible AccountBalance (r:1 w:1)
285	// Storage: Refungible Owned (r:0 w:1)316	// Storage: Refungible Owned (r:0 w:1)
286	fn burn_item_partial() -> Weight {317	fn burn_item_partial() -> Weight {
287		(21_010_000 as Weight)318		(21_239_000 as Weight)
288			.saturating_add(RocksDbWeight::get().reads(3 as Weight))319			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
289			.saturating_add(RocksDbWeight::get().writes(4 as Weight))320			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
290	}321	}
294	// Storage: Refungible TokensBurnt (r:1 w:1)325	// Storage: Refungible TokensBurnt (r:1 w:1)
295	// Storage: Refungible TokenData (r:0 w:1)326	// Storage: Refungible TokenData (r:0 w:1)
296	// Storage: Refungible Owned (r:0 w:1)327	// Storage: Refungible Owned (r:0 w:1)
328	// Storage: Refungible TokenProperties (r:0 w:1)
297	fn burn_item_fully() -> Weight {329	fn burn_item_fully() -> Weight {
298		(28_413_000 as Weight)330		(29_426_000 as Weight)
299			.saturating_add(RocksDbWeight::get().reads(4 as Weight))331			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
300			.saturating_add(RocksDbWeight::get().writes(6 as Weight))332			.saturating_add(RocksDbWeight::get().writes(7 as Weight))
301	}333	}
302	// Storage: Refungible Balance (r:2 w:2)334	// Storage: Refungible Balance (r:2 w:2)
303	fn transfer_normal() -> Weight {335	fn transfer_normal() -> Weight {
304		(17_513_000 as Weight)336		(17_743_000 as Weight)
305			.saturating_add(RocksDbWeight::get().reads(2 as Weight))337			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
306			.saturating_add(RocksDbWeight::get().writes(2 as Weight))338			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
307	}339	}
308	// Storage: Refungible Balance (r:2 w:2)340	// Storage: Refungible Balance (r:2 w:2)
309	// Storage: Refungible AccountBalance (r:1 w:1)341	// Storage: Refungible AccountBalance (r:1 w:1)
310	// Storage: Refungible Owned (r:0 w:1)342	// Storage: Refungible Owned (r:0 w:1)
311	fn transfer_creating() -> Weight {343	fn transfer_creating() -> Weight {
312		(20_469_000 as Weight)344		(20_699_000 as Weight)
313			.saturating_add(RocksDbWeight::get().reads(3 as Weight))345			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
314			.saturating_add(RocksDbWeight::get().writes(4 as Weight))346			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
315	}347	}
316	// Storage: Refungible Balance (r:2 w:2)348	// Storage: Refungible Balance (r:2 w:2)
317	// Storage: Refungible AccountBalance (r:1 w:1)349	// Storage: Refungible AccountBalance (r:1 w:1)
318	// Storage: Refungible Owned (r:0 w:1)350	// Storage: Refungible Owned (r:0 w:1)
319	fn transfer_removing() -> Weight {351	fn transfer_removing() -> Weight {
320		(22_472_000 as Weight)352		(22_833_000 as Weight)
321			.saturating_add(RocksDbWeight::get().reads(3 as Weight))353			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
322			.saturating_add(RocksDbWeight::get().writes(4 as Weight))354			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
323	}355	}
324	// Storage: Refungible Balance (r:2 w:2)356	// Storage: Refungible Balance (r:2 w:2)
325	// Storage: Refungible AccountBalance (r:2 w:2)357	// Storage: Refungible AccountBalance (r:2 w:2)
326	// Storage: Refungible Owned (r:0 w:2)358	// Storage: Refungible Owned (r:0 w:2)
327	fn transfer_creating_removing() -> Weight {359	fn transfer_creating_removing() -> Weight {
328		(24_866_000 as Weight)360		(24_936_000 as Weight)
329			.saturating_add(RocksDbWeight::get().reads(4 as Weight))361			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
330			.saturating_add(RocksDbWeight::get().writes(6 as Weight))362			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
331	}363	}
332	// Storage: Refungible Balance (r:1 w:0)364	// Storage: Refungible Balance (r:1 w:0)
333	// Storage: Refungible Allowance (r:0 w:1)365	// Storage: Refungible Allowance (r:0 w:1)
334	fn approve() -> Weight {366	fn approve() -> Weight {
335		(13_475_000 as Weight)367		(13_446_000 as Weight)
336			.saturating_add(RocksDbWeight::get().reads(1 as Weight))368			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
337			.saturating_add(RocksDbWeight::get().writes(1 as Weight))369			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
338	}370	}
339	// Storage: Refungible Allowance (r:1 w:1)371	// Storage: Refungible Allowance (r:1 w:1)
340	// Storage: Refungible Balance (r:2 w:2)372	// Storage: Refungible Balance (r:2 w:2)
341	fn transfer_from_normal() -> Weight {373	fn transfer_from_normal() -> Weight {
342		(24_707_000 as Weight)374		(24_777_000 as Weight)
343			.saturating_add(RocksDbWeight::get().reads(3 as Weight))375			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
344			.saturating_add(RocksDbWeight::get().writes(3 as Weight))376			.saturating_add(RocksDbWeight::get().writes(3 as Weight))
345	}377	}
348	// Storage: Refungible AccountBalance (r:1 w:1)380	// Storage: Refungible AccountBalance (r:1 w:1)
349	// Storage: Refungible Owned (r:0 w:1)381	// Storage: Refungible Owned (r:0 w:1)
350	fn transfer_from_creating() -> Weight {382	fn transfer_from_creating() -> Weight {
351		(27_812_000 as Weight)383		(28_483_000 as Weight)
352			.saturating_add(RocksDbWeight::get().reads(4 as Weight))384			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
353			.saturating_add(RocksDbWeight::get().writes(5 as Weight))385			.saturating_add(RocksDbWeight::get().writes(5 as Weight))
354	}386	}
357	// Storage: Refungible AccountBalance (r:1 w:1)389	// Storage: Refungible AccountBalance (r:1 w:1)
358	// Storage: Refungible Owned (r:0 w:1)390	// Storage: Refungible Owned (r:0 w:1)
359	fn transfer_from_removing() -> Weight {391	fn transfer_from_removing() -> Weight {
360		(29_966_000 as Weight)392		(29_896_000 as Weight)
361			.saturating_add(RocksDbWeight::get().reads(4 as Weight))393			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
362			.saturating_add(RocksDbWeight::get().writes(5 as Weight))394			.saturating_add(RocksDbWeight::get().writes(5 as Weight))
363	}395	}
366	// Storage: Refungible AccountBalance (r:2 w:2)398	// Storage: Refungible AccountBalance (r:2 w:2)
367	// Storage: Refungible Owned (r:0 w:2)399	// Storage: Refungible Owned (r:0 w:2)
368	fn transfer_from_creating_removing() -> Weight {400	fn transfer_from_creating_removing() -> Weight {
369		(31_660_000 as Weight)401		(32_070_000 as Weight)
370			.saturating_add(RocksDbWeight::get().reads(5 as Weight))402			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
371			.saturating_add(RocksDbWeight::get().writes(7 as Weight))403			.saturating_add(RocksDbWeight::get().writes(7 as Weight))
372	}404	}
377	// Storage: Refungible TokensBurnt (r:1 w:1)409	// Storage: Refungible TokensBurnt (r:1 w:1)
378	// Storage: Refungible TokenData (r:0 w:1)410	// Storage: Refungible TokenData (r:0 w:1)
379	// Storage: Refungible Owned (r:0 w:1)411	// Storage: Refungible Owned (r:0 w:1)
412	// Storage: Refungible TokenProperties (r:0 w:1)
380	fn burn_from() -> Weight {413	fn burn_from() -> Weight {
381		(36_248_000 as Weight)414		(36_789_000 as Weight)
382			.saturating_add(RocksDbWeight::get().reads(5 as Weight))415			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
383			.saturating_add(RocksDbWeight::get().writes(7 as Weight))416			.saturating_add(RocksDbWeight::get().writes(8 as Weight))
417	}
418	// Storage: Common CollectionPropertyPermissions (r:1 w:1)
419	fn set_token_property_permissions(b: u32, ) -> Weight {
420		(0 as Weight)
421			// Standard Error: 62_000
422			.saturating_add((15_803_000 as Weight).saturating_mul(b as Weight))
423			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
424			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
425	}
426	// Storage: Common CollectionPropertyPermissions (r:1 w:0)
427	// Storage: Refungible TokenProperties (r:1 w:1)
428	fn set_token_properties(b: u32, ) -> Weight {
429		(0 as Weight)
430			// Standard Error: 1_668_000
431			.saturating_add((302_308_000 as Weight).saturating_mul(b as Weight))
432			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
433			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
434	}
435	// Storage: Common CollectionPropertyPermissions (r:1 w:0)
436	// Storage: Refungible TokenProperties (r:1 w:1)
437	fn delete_token_properties(b: u32, ) -> Weight {
438		(0 as Weight)
439			// Standard Error: 1_619_000
440			.saturating_add((294_574_000 as Weight).saturating_mul(b as Weight))
441			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
442			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
384	}443	}
385	// Storage: Refungible TotalSupply (r:1 w:1)444	// Storage: Refungible TotalSupply (r:1 w:1)
386	// Storage: Refungible Balance (r:1 w:1)445	// Storage: Refungible Balance (r:1 w:1)
387	fn repartition_item() -> Weight {446	fn repartition_item() -> Weight {
388		(8_226_000 as Weight)447		(8_325_000 as Weight)
389			.saturating_add(RocksDbWeight::get().reads(2 as Weight))448			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
390			.saturating_add(RocksDbWeight::get().writes(2 as Weight))449			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
391	}450	}

--- a/primitives/data-structs/Cargo.toml
+++ b/primitives/data-structs/Cargo.toml
@@ -6,7 +6,7 @@
 license = 'GPLv3'
 homepage = "https://unique.network"
 repository = 'https://github.com/UniqueNetwork/unique-chain'
-version = '0.1.0'
+version = '0.1.1'
 
 [dependencies]
 scale-info = { version = "2.0.1", default-features = false, features = [

--- a/primitives/data-structs/src/lib.rs
+++ b/primitives/data-structs/src/lib.rs
@@ -534,7 +534,12 @@
 	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
 	#[derivative(Debug(format_with = "bounded::vec_debug"))]
 	pub const_data: BoundedVec<u8, CustomDataLimit>,
+
 	pub pieces: u128,
+
+	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
+	#[derivative(Debug(format_with = "bounded::vec_debug"))]
+	pub properties: CollectionPropertiesVec,
 }
 
 #[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]
@@ -568,6 +573,8 @@
 	pub const_data: BoundedVec<u8, CustomDataLimit>,
 	#[derivative(Debug(format_with = "bounded::map_debug"))]
 	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,
+	#[derivative(Debug(format_with = "bounded::vec_debug"))]
+	pub properties: CollectionPropertiesVec,
 }
 
 #[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]

--- a/tests/src/createMultipleItems.test.ts
+++ b/tests/src/createMultipleItems.test.ts
@@ -376,14 +376,26 @@
       // ReFungible
       const collectionIdReFungible =
         await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-      const argsReFungible = [
-        {ReFungible: ['1'.repeat(2049), 10]},
-        {ReFungible: ['2'.repeat(2049), 10]},
-        {ReFungible: ['3'.repeat(2049), 10]},
-      ];
-      const createMultipleItemsTxFungible = api.tx.unique
-        .createMultipleItems(collectionIdReFungible, normalizeAccountId(alice.address), argsReFungible);
-      await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTxFungible)).to.be.rejected;
+      {
+        const argsReFungible = [
+          {ReFungible: ['1'.repeat(2049), 10, []]},
+          {ReFungible: ['2'.repeat(2049), 10, []]},
+          {ReFungible: ['3'.repeat(2049), 10, []]},
+        ];
+        const createMultipleItemsTxFungible = api.tx.unique
+          .createMultipleItems(collectionIdReFungible, normalizeAccountId(alice.address), argsReFungible);
+        await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTxFungible)).to.be.rejected;
+      }
+      {
+        const argsReFungible = [
+          {ReFungible: {properties: [{key: 'key', value: 'A'.repeat(32769)}]}},
+          {ReFungible: {properties: [{key: 'key', value: 'B'.repeat(32769)}]}},
+          {ReFungible: {properties: [{key: 'key', value: 'C'.repeat(32769)}]}},
+        ];
+        const createMultipleItemsTxFungible = api.tx.unique
+          .createMultipleItems(collectionIdReFungible, normalizeAccountId(alice.address), argsReFungible);
+        await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTxFungible)).to.be.rejected;
+      }
     });
   });
 

--- a/tests/src/interfaces/augment-api-query.ts
+++ b/tests/src/interfaces/augment-api-query.ts
@@ -408,6 +408,7 @@
        **/
       owned: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, u32]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr, u32]>;
       tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<PalletRefungibleItemData>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
       tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
       tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
       totalSupply: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;

--- a/tests/src/interfaces/default/types.ts
+++ b/tests/src/interfaces/default/types.ts
@@ -2461,12 +2461,14 @@
 export interface UpDataStructsCreateReFungibleData extends Struct {
   readonly constData: Bytes;
   readonly pieces: u128;
+  readonly properties: Vec<UpDataStructsProperty>;
 }
 
 /** @name UpDataStructsCreateRefungibleExData */
 export interface UpDataStructsCreateRefungibleExData extends Struct {
   readonly constData: Bytes;
   readonly users: BTreeMap<PalletEvmAccountBasicCrossAccountIdRepr, u128>;
+  readonly properties: Vec<UpDataStructsProperty>;
 }
 
 /** @name UpDataStructsNestingPermissions */

--- a/tests/src/interfaces/lookup.ts
+++ b/tests/src/interfaces/lookup.ts
@@ -1502,7 +1502,8 @@
    **/
   UpDataStructsCreateReFungibleData: {
     constData: 'Bytes',
-    pieces: 'u128'
+    pieces: 'u128',
+    properties: 'Vec<UpDataStructsProperty>'
   },
   /**
    * Lookup193: up_data_structs::CreateItemExData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
@@ -1527,7 +1528,8 @@
    **/
   UpDataStructsCreateRefungibleExData: {
     constData: 'Bytes',
-    users: 'BTreeMap<PalletEvmAccountBasicCrossAccountIdRepr, u128>'
+    users: 'BTreeMap<PalletEvmAccountBasicCrossAccountIdRepr, u128>',
+    properties: 'Vec<UpDataStructsProperty>'
   },
   /**
    * Lookup204: pallet_unique_scheduler::pallet::Call<T>

--- a/tests/src/interfaces/types-lookup.ts
+++ b/tests/src/interfaces/types-lookup.ts
@@ -1629,6 +1629,7 @@
   export interface UpDataStructsCreateReFungibleData extends Struct {
     readonly constData: Bytes;
     readonly pieces: u128;
+    readonly properties: Vec<UpDataStructsProperty>;
   }
 
   /** @name UpDataStructsCreateItemExData (193) */
@@ -1654,6 +1655,7 @@
   export interface UpDataStructsCreateRefungibleExData extends Struct {
     readonly constData: Bytes;
     readonly users: BTreeMap<PalletEvmAccountBasicCrossAccountIdRepr, u128>;
+    readonly properties: Vec<UpDataStructsProperty>;
   }
 
   /** @name PalletUniqueSchedulerCall (204) */

--- a/tests/src/nesting/properties.test.ts
+++ b/tests/src/nesting/properties.test.ts
@@ -2,6 +2,7 @@
 import usingApi, {executeTransaction} from '../substrate/substrate-api';
 import {
   addCollectionAdminExpectSuccess,
+  CollectionMode,
   createCollectionExpectSuccess,
   setCollectionPermissionsExpectSuccess,
   createItemExpectSuccess,
@@ -23,9 +24,9 @@
     });
   });
 
-  it('Makes sure collectionById supplies required fields', async () => {
+  async function testMakeSureSuppliesRequired(mode: CollectionMode) {
     await usingApi(async api => {
-      const collectionId = await createCollectionExpectSuccess();
+      const collectionId = await createCollectionExpectSuccess({mode: mode});
 
       const collectionOption = await api.rpc.unique.collectionById(collectionId);
       expect(collectionOption.isSome).to.be.true;
@@ -57,7 +58,15 @@
       expect(collection.tokenPropertyPermissions.toHuman()).to.be.deep.equal(propertyPermissions);
       expect(collection.properties.toHuman()).to.be.deep.equal(collectionProperties);
     });
+  }
+
+  it('Makes sure collectionById supplies required fields for NFT', async () => {
+    await testMakeSureSuppliesRequired({type: 'NFT'});
   });
+
+  it('Makes sure collectionById supplies required fields for ReFungible', async () => {
+    await testMakeSureSuppliesRequired({type: 'ReFungible'});
+  });
 });
 
 // ---------- COLLECTION PROPERTIES
@@ -79,9 +88,10 @@
     });
   });
 
-  it('Sets properties for a collection', async () => {
+
+  async function testSetsPropertiesForCollection(mode: string) {
     await usingApi(async api => {
-      const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: 'NFT'}));
+      const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: mode}));
       const {collectionId} = getCreateCollectionResult(events);
 
       // As owner
@@ -106,48 +116,54 @@
         {key: 'black_hole', value: ''},
       ]);
     });
+  }
+  it('Sets properties for a NFT collection', async () => {
+    await testSetsPropertiesForCollection('NFT');
   });
+  it('Sets properties for a ReFungible collection', async () => {
+    await testSetsPropertiesForCollection('ReFungible');
+  });
 
-  it('Check valid names for collection properties keys', async () => {
+  async function testCheckValidNames(mode: string) {
     await usingApi(async api => {
-      const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: 'NFT'}));
+      const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: mode}));
       const {collectionId} = getCreateCollectionResult(events);
-
+  
       // alpha symbols
       await expect(executeTransaction(
         api, 
         bob, 
         api.tx.unique.setCollectionProperties(collectionId, [{key: 'alpha'}]), 
       )).to.not.be.rejected;
-
+  
       // numeric symbols
       await expect(executeTransaction(
         api, 
         bob, 
         api.tx.unique.setCollectionProperties(collectionId, [{key: '123'}]), 
       )).to.not.be.rejected;
-
+  
       // underscore symbol
       await expect(executeTransaction(
         api, 
         bob, 
         api.tx.unique.setCollectionProperties(collectionId, [{key: 'black_hole'}]), 
       )).to.not.be.rejected;
-
+  
       // dash symbol
       await expect(executeTransaction(
         api, 
         bob, 
         api.tx.unique.setCollectionProperties(collectionId, [{key: 'semi-automatic'}]), 
       )).to.not.be.rejected;
-
+  
       // underscore symbol
       await expect(executeTransaction(
         api, 
         bob, 
         api.tx.unique.setCollectionProperties(collectionId, [{key: 'build.rs'}]), 
       )).to.not.be.rejected;
-
+  
       const propertyKeys = ['alpha', '123', 'black_hole', 'semi-automatic', 'build.rs'];
       const properties = (await api.rpc.unique.collectionProperties(collectionId, propertyKeys)).toHuman();
       expect(properties).to.be.deep.equal([
@@ -158,54 +174,72 @@
         {key: 'build.rs', value: ''},
       ]);
     });
+  }
+  it('Check valid names for NFT collection properties keys', async () => {
+    await testCheckValidNames('NFT');
+  });
+  it('Check valid names for ReFungible collection properties keys', async () => {
+    await testCheckValidNames('ReFungible');
   });
 
-  it('Changes properties of a collection', async () => {
+  async function testChangesProperties(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-
+      const collection = await createCollectionExpectSuccess({mode: mode});
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole'}]), 
       )).to.not.be.rejected;
-
+  
       // Mutate the properties
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'bonded'}, {key: 'black_hole', value: 'LIGO'}]), 
       )).to.not.be.rejected;
-
+  
       const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();
       expect(properties).to.be.deep.equal([
         {key: 'electron', value: 'bonded'},
         {key: 'black_hole', value: 'LIGO'},
       ]);
     });
+  }
+  it('Changes properties of a NFT collection', async () => {
+    await testChangesProperties({type: 'NFT'});
+  });
+  it('Changes properties of a ReFungible collection', async () => {
+    await testChangesProperties({type: 'ReFungible'});
   });
 
-  it('Deletes properties of a collection', async () => {
+  async function testDeleteProperties(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-
+      const collection = await createCollectionExpectSuccess({mode: mode});
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]), 
       )).to.not.be.rejected;
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.deleteCollectionProperties(collection, ['electron']), 
       )).to.not.be.rejected;
-
+  
       const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();
       expect(properties).to.be.deep.equal([
         {key: 'black_hole', value: 'LIGO'},
       ]);
-    });
+    });  
+  }
+  it('Deletes properties of a NFT collection', async () => {
+    await testDeleteProperties({type: 'NFT'});
+  });
+  it('Deletes properties of a ReFungible collection', async () => {
+    await testDeleteProperties({type: 'ReFungible'});
   });
 });
 
@@ -217,10 +251,10 @@
     });
   });
   
-  it('Fails to set properties in a collection if not its onwer/administrator', async () => {
+  async function testFailsSetPropertiesIfNotOwnerOrAdmin(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-
+      const collection = await createCollectionExpectSuccess({mode: mode});
+  
       await expect(executeTransaction(
         api, 
         bob, 
@@ -230,14 +264,20 @@
       const properties = (await api.query.common.collectionProperties(collection)).toJSON();
       expect(properties.map).to.be.empty;
       expect(properties.consumedSpace).to.equal(0);
-    });
+    });  
+  }
+  it('Fails to set properties in a NFT collection if not its onwer/administrator', async () => {
+    await testFailsSetPropertiesIfNotOwnerOrAdmin({type: 'NFT'});
   });
+  it('Fails to set properties in a ReFungible collection if not its onwer/administrator', async () => {
+    await testFailsSetPropertiesIfNotOwnerOrAdmin({type: 'ReFungible'});
+  });
   
-  it('Fails to set properties that exceed the limits', async () => {
+  async function testFailsSetPropertiesThatExeedLimits(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
+      const collection = await createCollectionExpectSuccess({mode: mode});
       const spaceLimit = (await api.query.common.collectionProperties(collection)).toJSON().spaceLimit as number; 
-
+  
       // Mute the general tx parsing error, too many bytes to process
       {
         console.error = () => {};
@@ -247,10 +287,10 @@
           api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))}]), 
         )).to.be.rejected;
       }
-
+  
       let properties = (await api.rpc.unique.collectionProperties(collection, ['electron'])).toJSON();
       expect(properties).to.be.empty;
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
@@ -259,16 +299,22 @@
           {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))}, 
         ]), 
       )).to.be.rejectedWith(/common\.NoSpaceForProperty/);
-
+  
       properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black hole'])).toJSON();
       expect(properties).to.be.empty;
-    });
+    });  
+  }
+  it('Fails to set properties that exceed the limits (NFT)', async () => {
+    await testFailsSetPropertiesThatExeedLimits({type: 'NFT'});
+  });
+  it('Fails to set properties that exceed the limits (ReFungible)', async () => {
+    await testFailsSetPropertiesThatExeedLimits({type: 'ReFungible'});
   });
   
-  it('Fails to set more properties than it is allowed', async () => {
+  async function testFailsSetMorePropertiesThanAllowed(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-
+      const collection = await createCollectionExpectSuccess({mode: mode});
+  
       const propertiesToBeSet = [];
       for (let i = 0; i < 65; i++) {
         propertiesToBeSet.push({
@@ -276,29 +322,35 @@
           value: Math.random() > 0.5 ? 'high' : 'low',
         });
       }
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setCollectionProperties(collection, propertiesToBeSet), 
       )).to.be.rejectedWith(/common\.PropertyLimitReached/);
-
+  
       const properties = (await api.query.common.collectionProperties(collection)).toJSON();
       expect(properties.map).to.be.empty;
       expect(properties.consumedSpace).to.equal(0);
-    });
+    });  
+  }
+  it('Fails to set more properties than it is allowed (NFT)', async () => {
+    await testFailsSetMorePropertiesThanAllowed({type: 'NFT'});
   });
-
-  it('Fails to set properties with invalid names', async () => {
+  it('Fails to set more properties than it is allowed (ReFungible)', async () => {
+    await testFailsSetMorePropertiesThanAllowed({type: 'ReFungible'});
+  });
+  
+  async function testFailsSetPropertiesWithInvalidNames(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-
+      const collection = await createCollectionExpectSuccess({mode: mode});
+  
       const invalidProperties = [
         [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],
         [{key: 'Mr/Sandman', value: 'Bring me a gene'}],
         [{key: 'déjà vu', value: 'hmm...'}],
       ];
-
+  
       for (let i = 0; i < invalidProperties.length; i++) {
         await expect(executeTransaction(
           api, 
@@ -306,13 +358,13 @@
           api.tx.unique.setCollectionProperties(collection, invalidProperties[i]), 
         ), `on rejecting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
       }
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setCollectionProperties(collection, [{key: '', value: 'nothing must not exist'}]), 
       ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
@@ -320,14 +372,14 @@
           {key: 'CRISPR-Cas9', value: 'rewriting nature!'},
         ]), 
       ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;
-
+  
       const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat('');
-
+  
       const properties = (await api.rpc.unique.collectionProperties(collection, keys)).toHuman();
       expect(properties).to.be.deep.equal([
         {key: 'CRISPR-Cas9', value: 'rewriting nature!'},
       ]);
-
+  
       for (let i = 0; i < invalidProperties.length; i++) {
         await expect(executeTransaction(
           api, 
@@ -336,7 +388,13 @@
         ), `on trying to delete the non-existent badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
       }
     });
+  }
+  it('Fails to set properties with invalid names (NFT)', async () => {
+    await testFailsSetPropertiesWithInvalidNames({type: 'NFT'});
   });
+  it('Fails to set properties with invalid names (ReFungible)', async () => {
+    await testFailsSetPropertiesWithInvalidNames({type: 'ReFungible'});
+  });
 });
 
 // ---------- ACCESS RIGHTS
@@ -357,54 +415,66 @@
     });
   });
   
-  it('Sets access rights to properties of a collection', async () => {
+  async function testSetsAccessRightsToProperties(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-
+      const collection = await createCollectionExpectSuccess({mode: mode});
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true}}]), 
       )).to.not.be.rejected;
-
+  
       await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'mindgame', permission: {collectionAdmin: true, tokenOwner: false}}]), 
       )).to.not.be.rejected;
-
+  
       const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery', 'mindgame'])).toHuman();
       expect(propertyRights).to.be.deep.equal([
         {key: 'skullduggery', permission: {'mutable': true, 'collectionAdmin': false, 'tokenOwner': false}},
         {key: 'mindgame', permission: {'mutable': false, 'collectionAdmin': true, 'tokenOwner': false}},
       ]);
-    });
+    });  
+  }
+  it('Sets access rights to properties of a collection (NFT)', async () => {
+    await testSetsAccessRightsToProperties({type: 'NFT'});
   });
+  it('Sets access rights to properties of a collection (ReFungible)', async () => {
+    await testSetsAccessRightsToProperties({type: 'ReFungible'});
+  });
   
-  it('Changes access rights to properties of a collection', async () => {
+  async function testChangesAccessRightsToProperty(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-
+      const collection = await createCollectionExpectSuccess({mode: mode});
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]), 
       )).to.not.be.rejected;
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), 
       )).to.not.be.rejected;
-
+  
       const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();
       expect(propertyRights).to.be.deep.equal([
         {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},
       ]);
     });
+  }
+  it('Changes access rights to properties of a NFT collection', async () => {
+    await testChangesAccessRightsToProperty({type: 'NFT'});
   });
+  it('Changes access rights to properties of a ReFungible collection', async () => {
+    await testChangesAccessRightsToProperty({type: 'ReFungible'});
+  });
 });
 
 describe('Negative Integration Test: Access Rights to Token Properties', () => {
@@ -415,25 +485,31 @@
     });
   });
 
-  it('Prevents from setting access rights to properties of a collection if not an onwer/admin', async () => {
+  async function testPreventsFromSettingAccessRightsNotAdminOrOwner(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-
+      const collection = await createCollectionExpectSuccess({mode: mode});
+  
       await expect(executeTransaction(
         api, 
         bob, 
         api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]), 
       )).to.be.rejectedWith(/common\.NoPermission/);
-
+  
       const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toJSON();
       expect(propertyRights).to.be.empty;
     });
+  }
+  it('Prevents from setting access rights to properties of a NFT collection if not an onwer/admin', async () => {
+    await testPreventsFromSettingAccessRightsNotAdminOrOwner({type: 'NFT'});
   });
+  it('Prevents from setting access rights to properties of a ReFungible collection if not an onwer/admin', async () => {
+    await testPreventsFromSettingAccessRightsNotAdminOrOwner({type: 'ReFungible'});
+  });
 
-  it('Prevents from adding too many possible properties', async () => {
+  async function testPreventFromAddingTooManyPossibleProperties(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-
+      const collection = await createCollectionExpectSuccess({mode: mode});
+  
       const constitution = [];
       for (let i = 0; i < 65; i++) {
         constitution.push({
@@ -441,51 +517,63 @@
           permission: Math.random() > 0.5 ? {mutable: true, collectionAdmin: true, tokenOwner: true} : {},
         });
       }
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setTokenPropertyPermissions(collection, constitution), 
       )).to.be.rejectedWith(/common\.PropertyLimitReached/);
-
+  
       const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON();
       expect(propertyRights).to.be.empty;
-    });
+    });  
+  }
+  it('Prevents from adding too many possible properties (NFT)', async () => {
+    await testPreventFromAddingTooManyPossibleProperties({type: 'NFT'});
   });
+  it('Prevents from adding too many possible properties (ReFungible)', async () => {
+    await testPreventFromAddingTooManyPossibleProperties({type: 'ReFungible'});
+  });
 
-  it('Prevents access rights to be modified if constant', async () => {
+  async function testPreventAccessRightsModifiedIfConstant(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-
+      const collection = await createCollectionExpectSuccess({mode: mode});
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), 
       )).to.not.be.rejected;
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {}}]), 
       )).to.be.rejectedWith(/common\.NoPermission/);
-
+  
       const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();
       expect(propertyRights).to.deep.equal([
         {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},
       ]);
-    });
+    });  
+  }
+  it('Prevents access rights to be modified if constant (NFT)', async () => {
+    await testPreventAccessRightsModifiedIfConstant({type: 'NFT'});
+  });
+  it('Prevents access rights to be modified if constant (ReFungible)', async () => {
+    await testPreventAccessRightsModifiedIfConstant({type: 'ReFungible'});
   });
 
-  it('Prevents adding properties with invalid names', async () => {
+  async function testPreventsAddingPropertiesWithInvalidNames(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-
+      const collection = await createCollectionExpectSuccess({mode: mode});
+  
       const invalidProperties = [
         [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],
         [{key: 'G#4', permission: {tokenOwner: true}}],
         [{key: 'HÆMILTON', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}],
       ];
-
+  
       for (let i = 0; i < invalidProperties.length; i++) {
         await expect(executeTransaction(
           api, 
@@ -493,13 +581,13 @@
           api.tx.unique.setTokenPropertyPermissions(collection, invalidProperties[i]), 
         ), `on setting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
       }
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setTokenPropertyPermissions(collection, [{key: '', permission: {}}]), 
       ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);
-
+  
       const correctKey = '--0x03116e387820CA05'; // PolkadotJS would parse this as an already encoded hex-string
       await expect(executeTransaction(
         api, 
@@ -508,30 +596,33 @@
           {key: correctKey, permission: {collectionAdmin: true}},
         ]), 
       ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;
-
+  
       const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat(correctKey).concat('');
-
+  
       const propertyRights = (await api.rpc.unique.propertyPermissions(collection, keys)).toHuman();
       expect(propertyRights).to.be.deep.equal([
         {key: correctKey, permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},
       ]);
     });
+  }
+  it('Prevents adding properties with invalid names (NFT)', async () => {
+    await testPreventsAddingPropertiesWithInvalidNames({type: 'NFT'});
+  });
+  it('Prevents adding properties with invalid names (ReFungible)', async () => {
+    await testPreventsAddingPropertiesWithInvalidNames({type: 'ReFungible'});
   });
 });
 
 // ---------- TOKEN PROPERTIES
 
 describe('Integration Test: Token Properties', () => {
-  let collection: number;
-  let token: number;
-  let nestedToken: number;
   let permissions: {permission: any, signers: IKeyringPair[]}[];
 
   before(async () => {
     await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
-      charlie = privateKeyWrapper('//Charlie');
+      alice = privateKeyWrapper('//Alice'); // collection owner
+      bob = privateKeyWrapper('//Bob'); // collection admin
+      charlie = privateKeyWrapper('//Charlie'); // token owner
 
       permissions = [
         {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob]},
@@ -543,36 +634,34 @@
       ];
     });
   });
-
-  beforeEach(async () => {
-    await usingApi(async () => {
-      collection = await createCollectionExpectSuccess();
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
-
-      token = await createItemExpectSuccess(alice, collection, 'NFT');
-      nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});
-
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      await transferExpectSuccess(collection, token, alice, charlie);
-    });
-  });
   
-  it('Reads yet empty properties of a token', async () => {
+  async function testReadsYetEmptyProperties(mode: CollectionMode) {
     await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-      const token = await createItemExpectSuccess(alice, collection, 'NFT');
+      const collection = await createCollectionExpectSuccess({mode: mode});
+      const token = await createItemExpectSuccess(alice, collection, mode.type);
   
       const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
       expect(properties.map).to.be.empty;
       expect(properties.consumedSpace).to.be.equal(0);
-
+  
       const tokenData = (await api.rpc.unique.tokenData(collection, token, ['anything'])).toJSON().properties;
       expect(tokenData).to.be.empty;
     });
+  }
+  it('Reads yet empty properties of a token (NFT)', async () => {
+    await testReadsYetEmptyProperties({type: 'NFT'});
   });
+  it('Reads yet empty properties of a token (ReFungible)', async () => {
+    await testReadsYetEmptyProperties({type: 'ReFungible'});
+  });
 
-  it('Assigns properties to a token according to permissions', async () => {
+  async function testAssignPropertiesAccordingToPermissions(mode: CollectionMode, pieces: number) {
     await usingApi(async api => {
+      const collection = await createCollectionExpectSuccess({mode: mode});
+      const token = await createItemExpectSuccess(alice, collection, mode.type);
+      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
+      await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);
+
       const propertyKeys: string[] = [];
       let i = 0;
       for (const permission of permissions) {
@@ -603,10 +692,21 @@
         expect(tokensData[i].value).to.be.equal('Serotonin increase');
       }
     });
+  }
+  it('Assigns properties to a token according to permissions (NFT)', async () => {
+    await testAssignPropertiesAccordingToPermissions({type: 'NFT'}, 1);
+  });
+  it('Assigns properties to a token according to permissions (ReFungible)', async () => {
+    await testAssignPropertiesAccordingToPermissions({type: 'ReFungible'}, 100);
   });
 
-  it('Changes properties of a token according to permissions', async () => {
+  async function testChangesPropertiesAccordingPermission(mode: CollectionMode, pieces: number) {
     await usingApi(async api => {
+      const collection = await createCollectionExpectSuccess({mode: mode});
+      const token = await createItemExpectSuccess(alice, collection, mode.type);
+      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
+      await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);
+
       const propertyKeys: string[] = [];
       let i = 0;
       for (const permission of permissions) {
@@ -615,29 +715,29 @@
         for (const signer of permission.signers) {
           const key = i + '_' + signer.address;
           propertyKeys.push(key);
-
+  
           await expect(executeTransaction(
             api, 
             alice, 
             api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
           ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;
-
+  
           await expect(executeTransaction(
             api, 
             signer, 
             api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 
           ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;
-
+  
           await expect(executeTransaction(
             api, 
             signer, 
             api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin stable'}]), 
           ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected;
         }
-
+  
         i++;
       }
-
+  
       const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toHuman() as any[];
       const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toHuman().properties as any[];
       for (let i = 0; i < properties.length; i++) {
@@ -645,32 +745,43 @@
         expect(tokensData[i].value).to.be.equal('Serotonin stable');
       }
     });
+  }
+  it('Changes properties of a token according to permissions (NFT)', async () => {
+    await testChangesPropertiesAccordingPermission({type: 'NFT'}, 1);
   });
+  it('Changes properties of a token according to permissions (ReFungible)', async () => {
+    await testChangesPropertiesAccordingPermission({type: 'ReFungible'}, 100);
+  });
 
-  it('Deletes properties of a token according to permissions', async () => {
+  async function testDeletePropertiesAccordingPermission(mode: CollectionMode, pieces: number) {
     await usingApi(async api => {
+      const collection = await createCollectionExpectSuccess({mode: mode});
+      const token = await createItemExpectSuccess(alice, collection, mode.type);
+      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
+      await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);
+
       const propertyKeys: string[] = [];
       let i = 0;
-
+  
       for (const permission of permissions) {
         if (!permission.permission.mutable) continue;
         
         for (const signer of permission.signers) {
           const key = i + '_' + signer.address;
           propertyKeys.push(key);
-
+  
           await expect(executeTransaction(
             api, 
             alice, 
             api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
           ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;
-
+  
           await expect(executeTransaction(
             api, 
             signer, 
             api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 
           ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;
-
+  
           await expect(executeTransaction(
             api, 
             signer, 
@@ -680,17 +791,30 @@
         
         i++;
       }
-
+  
       const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toJSON() as any[];
       expect(properties).to.be.empty;
       const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toJSON().properties as any[];
       expect(tokensData).to.be.empty;
       expect((await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace).to.be.equal(0);
     });
+  }
+  it('Deletes properties of a token according to permissions (NFT)', async () => {
+    await testDeletePropertiesAccordingPermission({type: 'NFT'}, 1);
   });
+  it('Deletes properties of a token according to permissions (ReFungible)', async () => {
+    await testDeletePropertiesAccordingPermission({type: 'ReFungible'}, 100);
+  });
 
   it('Assigns properties to a nested token according to permissions', async () => {
     await usingApi(async api => {
+      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
+      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
+      const token = await createItemExpectSuccess(alice, collection, 'NFT');
+      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});
+      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
+      await transferExpectSuccess(collection, token, alice, charlie);
+
       const propertyKeys: string[] = [];
       let i = 0;
       for (const permission of permissions) {
@@ -725,6 +849,13 @@
 
   it('Changes properties of a nested token according to permissions', async () => {
     await usingApi(async api => {
+      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
+      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
+      const token = await createItemExpectSuccess(alice, collection, 'NFT');
+      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});
+      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
+      await transferExpectSuccess(collection, token, alice, charlie);
+
       const propertyKeys: string[] = [];
       let i = 0;
       for (const permission of permissions) {
@@ -767,6 +898,13 @@
 
   it('Deletes properties of a nested token according to permissions', async () => {
     await usingApi(async api => {
+      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
+      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
+      const token = await createItemExpectSuccess(alice, collection, 'NFT');
+      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});
+      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
+      await transferExpectSuccess(collection, token, alice, charlie);
+
       const propertyKeys: string[] = [];
       let i = 0;
 
@@ -832,11 +970,11 @@
     });
   });
 
-  beforeEach(async () => {
-    collection = await createCollectionExpectSuccess();
-    token = await createItemExpectSuccess(alice, collection, 'NFT');
+  async function prepare(mode: CollectionMode, pieces: number) {
+    collection = await createCollectionExpectSuccess({mode: mode});
+    token = await createItemExpectSuccess(alice, collection, mode.type);
     await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-    await transferExpectSuccess(collection, token, alice, charlie);
+    await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);
         
     await usingApi(async api => {
       let i = 0;
@@ -848,71 +986,89 @@
           alice, 
           api.tx.unique.setTokenPropertyPermissions(collection, [{key: `${i}`, permission: passage.permission}]), 
         ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;
-
+  
         await expect(executeTransaction(
           api, 
           signer, 
           api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin increase'}]), 
         ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;
-
+  
         i++;
       }
-
+  
       originalSpace = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace as number;
-    });
-  });
+    }); 
+  }
 
-  it('Forbids changing/deleting properties of a token if the user is outside of permissions', async () => {
+  async function testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(mode: CollectionMode, pieces: number) {
+    await prepare(mode, pieces);
+  
     await usingApi(async api => {
       let i = -1;
       for (const forbiddance of constitution) {
         i++;
         if (!forbiddance.permission.mutable) continue;
-
+  
         await expect(executeTransaction(
           api, 
           forbiddance.sinner, 
           api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 
         ), `on failing to change property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);
-
+  
         await expect(executeTransaction(
           api, 
           forbiddance.sinner, 
           api.tx.unique.deleteTokenProperties(collection, token, [`${i}`]), 
         ), `on failing to delete property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);
       }
-
+  
       const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
       expect(properties.consumedSpace).to.be.equal(originalSpace);
     });
+  }
+  it('Forbids changing/deleting properties of a token if the user is outside of permissions (NFT)', async () => {
+    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions({type: 'NFT'}, 1);
   });
+  it('Forbids changing/deleting properties of a token if the user is outside of permissions (ReFungible)', async () => {
+    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions({type: 'ReFungible'}, 100);
+  });
 
-  it('Forbids changing/deleting properties of a token if the property is permanent (immutable)', async () => {
+  async function testForbidsChangingDeletingPropertiesIfPropertyImmutable(mode: CollectionMode, pieces: number) {
+    await prepare(mode, pieces);
+    
     await usingApi(async api => {
       let i = -1;
       for (const permission of constitution) {
         i++;
         if (permission.permission.mutable) continue;
-
+  
         await expect(executeTransaction(
           api, 
           permission.signers[0], 
           api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 
         ), `on failing to change property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);
-
+  
         await expect(executeTransaction(
           api, 
           permission.signers[0], 
           api.tx.unique.deleteTokenProperties(collection, token, [i.toString()]), 
         ), `on failing to delete property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);
       }
-
+  
       const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
       expect(properties.consumedSpace).to.be.equal(originalSpace);
-    });
+    });  
+  }
+  it('Forbids changing/deleting properties of a token if the property is permanent (immutable) (NFT)', async () => {
+    await testForbidsChangingDeletingPropertiesIfPropertyImmutable({type: 'NFT'}, 1);
   });
+  it('Forbids changing/deleting properties of a token if the property is permanent (immutable) (ReFungible)', async () => {
+    await testForbidsChangingDeletingPropertiesIfPropertyImmutable({type: 'ReFungible'}, 100);
+  });
+
+  async function testForbidsAddingPropertiesIfPropertyNotDeclared(mode: CollectionMode, pieces: number) {
+    await prepare(mode, pieces);
 
-  it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission', async () => {
     await usingApi(async api => {
       await expect(executeTransaction(
         api, 
@@ -925,20 +1081,28 @@
         alice, 
         api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'now-existent', permission: {}}]), 
       ), 'on setting a new non-permitted property').to.not.be.rejected;
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
         api.tx.unique.setTokenProperties(collection, token, [{key: 'now-existent', value: 'I exist!'}]), 
       ), 'on failing to add a property forbidden by the \'None\' permission').to.be.rejectedWith(/common\.NoPermission/);
-
+  
       expect((await api.rpc.unique.tokenProperties(collection, token, ['non-existent', 'now-existent'])).toJSON()).to.be.empty;
       const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
       expect(properties.consumedSpace).to.be.equal(originalSpace);
     });
+  }
+  it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (NFT)', async () => {
+    await testForbidsAddingPropertiesIfPropertyNotDeclared({type: 'NFT'}, 1);
+  });
+  it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (ReFungible)', async () => {
+    await testForbidsAddingPropertiesIfPropertyNotDeclared({type: 'ReFungible'}, 100);
   });
 
-  it('Forbids adding too many properties to a token', async () => {
+  async function testForbidsAddingTooManyProperties(mode: CollectionMode, pieces: number) {
+    await prepare(mode, pieces);
+
     await usingApi(async api => {
       await expect(executeTransaction(
         api, 
@@ -948,7 +1112,7 @@
           {key: 'young_years', permission: {collectionAdmin: true, tokenOwner: true}},
         ]), 
       ), 'on setting a new non-permitted property').to.not.be.rejected;
-
+  
       // Mute the general tx parsing error
       {
         console.error = () => {};
@@ -958,7 +1122,7 @@
           api.tx.unique.setCollectionProperties(collection, [{key: 'a_holy_book', value: 'word '.repeat(6554)}]), 
         )).to.be.rejected;
       }
-
+  
       await expect(executeTransaction(
         api, 
         alice, 
@@ -967,10 +1131,107 @@
           {key: 'young_years', value: 'neverending'.repeat(1490)},
         ]), 
       )).to.be.rejectedWith(/common\.NoSpaceForProperty/);
-
+  
       expect((await api.rpc.unique.tokenProperties(collection, token, ['a_holy_book', 'young_years'])).toJSON()).to.be.empty;
       const propertiesMap = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
       expect(propertiesMap.consumedSpace).to.be.equal(originalSpace);
     });
+  }
+  it('Forbids adding too many properties to a token (NFT)', async () => {
+    await testForbidsAddingTooManyProperties({type: 'NFT'}, 1);
+  });
+  it('Forbids adding too many properties to a token (ReFungible)', async () => {
+    await testForbidsAddingTooManyProperties({type: 'ReFungible'}, 100);
+  });
+});
+
+describe('ReFungible token properties permissions tests', () => {
+  let collection: number;
+  let token: number;
+
+  before(async () => {
+    await usingApi(async (api, privateKeyWrapper) => {
+      alice = privateKeyWrapper('//Alice');
+      bob = privateKeyWrapper('//Bob');
+      charlie = privateKeyWrapper('//Charlie');
+    });
+  });
+
+  beforeEach(async () => {
+    await usingApi(async api => {
+      collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
+      token = await createItemExpectSuccess(alice, collection, 'ReFungible');
+      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
+
+      await expect(executeTransaction(
+        api, 
+        alice, 
+        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'key', permission: {mutable:true, tokenOwner: true}}]), 
+      )).to.not.be.rejected;
+    });
+  });
+
+  it('Forbids add token property with tokenOwher==true but signer have\'t all pieces', async () => {
+    await usingApi(async api => {
+      await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');
+  
+      await expect(executeTransaction(
+        api, 
+        alice, 
+        api.tx.unique.setTokenProperties(collection, token, [
+          {key: 'key', value: 'word'}, 
+        ]), 
+      )).to.be.rejectedWith(/common\.NoPermission/);
+    });
+  });
+
+  it('Forbids mutate token property with tokenOwher==true but signer have\'t all pieces', async () => {
+    await usingApi(async api => {
+      await expect(executeTransaction(
+        api, 
+        alice, 
+        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'key', permission: {mutable:true, tokenOwner: true}}]), 
+      )).to.not.be.rejected;
+  
+      await expect(executeTransaction(
+        api, 
+        alice, 
+        api.tx.unique.setTokenProperties(collection, token, [
+          {key: 'key', value: 'word'}, 
+        ]), 
+      )).to.be.not.rejected;
+
+      await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');
+  
+      await expect(executeTransaction(
+        api, 
+        alice, 
+        api.tx.unique.setTokenProperties(collection, token, [
+          {key: 'key', value: 'bad word'}, 
+        ]), 
+      )).to.be.rejectedWith(/common\.NoPermission/);
+    });
+  });
+
+  it('Forbids delete token property with tokenOwher==true but signer have\'t all pieces', async () => {
+    await usingApi(async api => {
+      await expect(executeTransaction(
+        api, 
+        alice, 
+        api.tx.unique.setTokenProperties(collection, token, [
+          {key: 'key', value: 'word'}, 
+        ]), 
+      )).to.be.not.rejected;
+
+      await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');
+  
+      await expect(executeTransaction(
+        api, 
+        alice, 
+        api.tx.unique.deleteTokenProperties(collection, token, [
+          'key',
+        ]), 
+      )).to.be.rejectedWith(/common\.NoPermission/);
+    });
   });
 });

--- a/tests/src/refungible.test.ts
+++ b/tests/src/refungible.test.ts
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import {default as usingApi} from './substrate/substrate-api';
+import {default as usingApi, executeTransaction} from './substrate/substrate-api';
 import {IKeyringPair} from '@polkadot/types/types';
 import {
   createCollectionExpectSuccess,
@@ -30,6 +30,8 @@
   transfer,
   burnItem,
   repartitionRFT,
+  createCollectionWithPropsExpectSuccess,
+  getDetailedCollectionInfo,
 } from './util/helpers';
 
 import chai from 'chai';
@@ -187,3 +189,26 @@
     });
   });
 });
+
+describe('Test Refungible properties:', () => {
+  before(async () => {
+    await usingApi(async (api, privateKeyWrapper) => {
+      alice = privateKeyWrapper('//Alice');
+      bob = privateKeyWrapper('//Bob');
+    });
+  });
+  
+  it('Сreate new collection with properties', async () => {
+    await usingApi(async api => {
+      const properties = [{key: 'key1', value: 'val1'}];
+      const propertyPermissions = [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}];
+      const collectionId = await createCollectionWithPropsExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'ReFungible'},
+        properties: properties,
+        propPerm: propertyPermissions, 
+      });
+      const collection = (await getDetailedCollectionInfo(api, collectionId))!;
+      expect(collection.properties.toHuman()).to.be.deep.equal(properties);
+      expect(collection.tokenPropertyPermissions.toHuman()).to.be.deep.equal(propertyPermissions);
+    });
+  });
+});

--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -284,7 +284,7 @@
   type: 'ReFungible';
 }
 
-type CollectionMode = Nft | Fungible | ReFungible;
+export type CollectionMode = Nft | Fungible | ReFungible;
 
 export type Property = {
   key: any,
@@ -1414,7 +1414,7 @@
       tx = api.tx.unique.createItem(collectionId, to, createData as any);
     }
 
-    const events = await submitTransactionAsync(sender, tx);
+    const events = await executeTransaction(api, sender, tx);
     const result = getCreateItemResult(events);
 
     const itemCountAfter = await getLastTokenId(api, collectionId);