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

--- a/node/src/chain_spec.rs
+++ b/node/src/chain_spec.rs
@@ -159,17 +159,18 @@
                 1,
                 CollectionType {
                     owner: get_account_id_from_seed::<sr25519::Public>("Alice"),
-                    mode: CollectionMode::NFT(50),
+                    mode: CollectionMode::NFT,
                     access: AccessMode::Normal,
                     decimal_points: 0,
                     name: vec![],
                     description: vec![],
                     token_prefix: vec![],
-                    custom_data_size: 50,
                     mint_mode: false,
                     offchain_schema: vec![],
                     sponsor: get_account_id_from_seed::<sr25519::Public>("Alice"),
                     unconfirmed_sponsor: get_account_id_from_seed::<sr25519::Public>("Alice"),
+                    const_on_chain_schema: vec![],
+                    variable_on_chain_schema: vec![]
                 },
             )],
             nft_item_id: vec![],

--- a/pallets/nft/src/benchmarking.rs
+++ b/pallets/nft/src/benchmarking.rs
@@ -9,6 +9,19 @@
 
     const SEED: u32 = 1;
 
+    fn default_nft_data() -> CreateItemData {
+        CreateItemData::NFT(CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] })
+    }
+    
+    fn default_fungible_data () -> CreateItemData {
+        CreateItemData::Fungible(CreateFungibleData { })
+    }
+    
+    fn default_re_fungible_data () -> CreateItemData {
+        CreateItemData::ReFungible(CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] })
+    }
+
+
     benchmarks! {
 
         _ {}
@@ -17,7 +30,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = account("caller", 0, SEED);
         }: create_collection(RawOrigin::Signed(caller.clone()), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode)
         verify {
@@ -28,7 +41,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
         }: destroy_collection(RawOrigin::Signed(caller.clone()), 2)
@@ -37,7 +50,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             let whitelist_account: T::AccountId = account("admin", 0, SEED);
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
@@ -47,7 +60,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             let whitelist_account: T::AccountId = account("admin", 0, SEED);
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
@@ -58,7 +71,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
         }: set_public_access_mode(RawOrigin::Signed(caller.clone()), 2, AccessMode::WhiteList)
@@ -67,7 +80,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
         }: set_mint_permission(RawOrigin::Signed(caller.clone()), 2, true)
@@ -76,7 +89,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
             let new_owner: T::AccountId = account("admin", 0, SEED);
@@ -86,7 +99,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
             let new_admin: T::AccountId = account("admin", 0, SEED);
@@ -96,7 +109,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
             let new_admin: T::AccountId = account("admin", 0, SEED);
@@ -107,7 +120,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
         }: set_collection_sponsor(RawOrigin::Signed(caller.clone()), 2, caller.clone())
@@ -116,7 +129,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
             Nft::<T>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone())?;
@@ -126,7 +139,7 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
             Nft::<T>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone())?;
@@ -138,26 +151,32 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
-
-        }: create_item(RawOrigin::Signed(caller.clone()), 2, [1,2,3].to_vec(), caller.clone())
+            let data = default_nft_data();
+            
+        }: create_item(RawOrigin::Signed(caller.clone()), 2, caller.clone(), data)
 
         #[extra]
         create_item_nft_large {
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
-            let mut item_large: Vec<u8> = Vec::new(); 
+            let nft_data = CreateNftData {
+                const_data: vec![],
+                variable_data: vec![]
+            };
             for i in 0..1998 {
-                item_large.push(10);
+                nft_data.const_data.push(10);
+                nft_data.variable_data.push(10);
             }
+            let mut data = CreateItemData::NFT(nft_data);
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
 
-        }: create_item(RawOrigin::Signed(caller.clone()), 2, item_large, caller.clone())
+        }: create_item(RawOrigin::Signed(caller.clone()), 2, caller.clone(), data)
 
         // fungible item
         create_item_fungible {
@@ -167,28 +186,31 @@
             let mode: CollectionMode = CollectionMode::Fungible(3);
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
+            let data = default_fungible_data();
 
-        }: create_item(RawOrigin::Signed(caller.clone()), 2, [].to_vec(), caller.clone())
+        }: create_item(RawOrigin::Signed(caller.clone()), 2, caller.clone(), data)
 
         // refungible item
         create_item_refungible {
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::ReFungible(3, 3);
+            let mode: CollectionMode = CollectionMode::ReFungible(3);
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
+            let data = default_re_fungible_data();
 
-        }: create_item(RawOrigin::Signed(caller.clone()), 2, [1,2,3].to_vec(), caller.clone())
+        }: create_item(RawOrigin::Signed(caller.clone()), 2, caller.clone(), data)
 
         burn_item {
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
-            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, [1, 2, 3].to_vec(), caller.clone())?;
+            let data = default_nft_data();
+            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
 
         }: burn_item(RawOrigin::Signed(caller.clone()), 2, 1)
 
@@ -196,11 +218,12 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(2000);
+            let mode: CollectionMode = CollectionMode::NFT;
             let recipient: T::AccountId = account("recipient", 0, SEED);
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
-            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, [1, 2, 3].to_vec(), caller.clone())?;
+            let data = default_nft_data();
+            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
 
         }: transfer(RawOrigin::Signed(caller.clone()), recipient.clone(), 2, 1, 1)
         
@@ -212,7 +235,8 @@
             let recipient: T::AccountId = account("recipient", 0, SEED);
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
-            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, [].to_vec(), caller.clone())?;
+            let data = default_fungible_data();
+            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
 
         }: transfer(RawOrigin::Signed(caller.clone()), recipient.clone(), 2, 1, 1)
 
@@ -220,11 +244,12 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::ReFungible(3,3);
+            let mode: CollectionMode = CollectionMode::ReFungible(3);
             let recipient: T::AccountId = account("recipient", 0, SEED);
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
-            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, [1,2,3].to_vec(), caller.clone())?;
+            let data = default_re_fungible_data();
+            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
 
         }: transfer(RawOrigin::Signed(caller.clone()), recipient.clone(), 2, 1, 1)
 
@@ -232,11 +257,12 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::ReFungible(3,3);
+            let mode: CollectionMode = CollectionMode::ReFungible(3);
             let recipient: T::AccountId = account("recipient", 0, SEED);
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
-            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, [1,2,3].to_vec(), caller.clone())?;
+            let data = default_re_fungible_data();
+            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
 
         }: approve(RawOrigin::Signed(caller.clone()), recipient.clone(), 2, 1)
 
@@ -245,11 +271,12 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::NFT(300);
+            let mode: CollectionMode = CollectionMode::NFT;
             let recipient: T::AccountId = account("recipient", 0, SEED);
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
-            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, [1,2,3].to_vec(), caller.clone())?;
+            let data = default_nft_data();
+            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
             Nft::<T>::approve(RawOrigin::Signed(caller.clone()).into(), recipient.clone(), 2, 1)?;
 
         }: transfer_from(RawOrigin::Signed(caller.clone()), caller.clone(), recipient.clone(), 2, 1, 1)
@@ -263,7 +290,8 @@
             let recipient: T::AccountId = account("recipient", 0, SEED);
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
-            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, [].to_vec(), caller.clone())?;
+            let data = default_fungible_data();
+            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
             Nft::<T>::approve(RawOrigin::Signed(caller.clone()).into(), recipient.clone(), 2, 1)?;
 
         }: transfer_from(RawOrigin::Signed(caller.clone()), caller.clone(), recipient.clone(), 2, 1, 1)
@@ -273,11 +301,12 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::ReFungible(3,3);
+            let mode: CollectionMode = CollectionMode::ReFungible(3);
             let recipient: T::AccountId = account("recipient", 0, SEED);
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
-            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, [1,2,3].to_vec(), caller.clone())?;
+            let data = default_re_fungible_data();
+            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
             Nft::<T>::approve(RawOrigin::Signed(caller.clone()).into(), recipient.clone(), 2, 1)?;
 
         }: transfer_from(RawOrigin::Signed(caller.clone()), caller.clone(), recipient.clone(), 2, 1, 1)
@@ -286,9 +315,39 @@
             let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
             let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
             let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
-            let mode: CollectionMode = CollectionMode::ReFungible(3,3);
+            let mode: CollectionMode = CollectionMode::ReFungible(3);
             let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
             Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
 
         }: set_offchain_schema(RawOrigin::Signed(caller.clone()), 2, [1,2,3].to_vec())
-    }
\ No newline at end of file
+
+        set_const_on_chain_schema {
+            let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
+            let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
+            let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
+            let mode: CollectionMode = CollectionMode::ReFungible(3);
+            let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
+            Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
+        }: set_const_on_chain_schema(RawOrigin::Signed(caller.clone()), 2, [1,2,3].to_vec())
+        
+        set_variable_on_chain_schema {
+            let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
+            let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
+            let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
+            let mode: CollectionMode = CollectionMode::ReFungible(3);
+            let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
+            Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
+        }: set_variable_on_chain_schema(RawOrigin::Signed(caller.clone()), 2, [1,2,3].to_vec())
+
+        set_variable_meta_data {
+            let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
+            let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
+            let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
+            let mode: CollectionMode = CollectionMode::NFT;
+            let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
+            Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
+            let data = default_nft_data();
+            Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
+
+        }: set_variable_meta_data(RawOrigin::Signed(caller.clone()), 2, 1, [1, 2, 3].to_vec())
+}
\ No newline at end of file

--- a/pallets/nft/src/default_weights.rs
+++ b/pallets/nft/src/default_weights.rs
@@ -92,4 +92,19 @@
             .saturating_add(DbWeight::get().reads(2 as Weight))
             .saturating_add(DbWeight::get().writes(1 as Weight))
     }
+    fn set_const_on_chain_schema() -> Weight {
+        (11_100_000 as Weight)
+            .saturating_add(DbWeight::get().reads(2 as Weight))
+            .saturating_add(DbWeight::get().writes(1 as Weight))
+    }
+    fn set_variable_on_chain_schema() -> Weight {
+        (11_100_000 as Weight)
+            .saturating_add(DbWeight::get().reads(2 as Weight))
+            .saturating_add(DbWeight::get().writes(1 as Weight))
+    }
+    fn set_variable_meta_data() -> Weight {
+        (17_500_000 as Weight)
+            .saturating_add(DbWeight::get().reads(2 as Weight))
+            .saturating_add(DbWeight::get().writes(1 as Weight))
+    }
 }

10pub use frame_support::{10pub use frame_support::{
11    construct_runtime, decl_event, decl_module, decl_storage,11    construct_runtime, decl_event, decl_module, decl_storage,
12    dispatch::DispatchResult,12    dispatch::DispatchResult,
13    ensure, parameter_types,13    ensure, parameter_types, fail,
14    traits::{14    traits::{
15        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,15        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,
16        Randomness, WithdrawReason,16        Randomness, WithdrawReason,
53#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]53#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
54pub enum CollectionMode {54pub enum CollectionMode {
55    Invalid,55    Invalid,
56    // custom data size56    NFT,
57    NFT(u32),
58    // decimal points57    // decimal points
59    Fungible(u32),58    Fungible(u32),
60    // custom data size and decimal points59    // decimal points
61    ReFungible(u32, u32),60    ReFungible(u32),
62}61}
6362
64impl Into<u8> for CollectionMode {63impl Into<u8> for CollectionMode {
65    fn into(self) -> u8 {64    fn into(self) -> u8 {
66        match self {65        match self {
67            CollectionMode::Invalid => 0,66            CollectionMode::Invalid => 0,
68            CollectionMode::NFT(_) => 1,67            CollectionMode::NFT => 1,
69            CollectionMode::Fungible(_) => 2,68            CollectionMode::Fungible(_) => 2,
70            CollectionMode::ReFungible(_, _) => 3,69            CollectionMode::ReFungible(_) => 3,
71        }70        }
72    }71    }
73}72}
107    pub name: Vec<u16>,        // 64 include null escape char106    pub name: Vec<u16>,        // 64 include null escape char
108    pub description: Vec<u16>, // 256 include null escape char107    pub description: Vec<u16>, // 256 include null escape char
109    pub token_prefix: Vec<u8>, // 16 include null escape char108    pub token_prefix: Vec<u8>, // 16 include null escape char
110    pub custom_data_size: u32,
111    pub mint_mode: bool,109    pub mint_mode: bool,
112    pub offchain_schema: Vec<u8>,110    pub offchain_schema: Vec<u8>,
113    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender111    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender
114    pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship112    pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship
113    pub variable_on_chain_schema: Vec<u8>, //
114    pub const_on_chain_schema: Vec<u8>, //
115}115}
116116
117#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]117#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
126pub struct NftItemType<AccountId> {126pub struct NftItemType<AccountId> {
127    pub collection: u64,127    pub collection: u64,
128    pub owner: AccountId,128    pub owner: AccountId,
129    pub data: Vec<u8>,129    pub const_data: Vec<u8>,
130    pub variable_data: Vec<u8>,
130}131}
131132
132#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]133#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
142pub struct ReFungibleItemType<AccountId> {143pub struct ReFungibleItemType<AccountId> {
143    pub collection: u64,144    pub collection: u64,
144    pub owner: Vec<Ownership<AccountId>>,145    pub owner: Vec<Ownership<AccountId>>,
145    pub data: Vec<u8>,146    pub const_data: Vec<u8>,
147    pub variable_data: Vec<u8>,
146}148}
147149
148#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]150#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
197    fn set_collection_sponsor() -> Weight;199    fn set_collection_sponsor() -> Weight;
198    fn confirm_sponsorship() -> Weight;200    fn confirm_sponsorship() -> Weight;
199    fn remove_collection_sponsor() -> Weight;201    fn remove_collection_sponsor() -> Weight;
200    fn create_item(s: usize, ) -> Weight;202    fn create_item(s: usize) -> Weight;
201    fn burn_item() -> Weight;203    fn burn_item() -> Weight;
202    fn transfer() -> Weight;204    fn transfer() -> Weight;
203    fn approve() -> Weight;205    fn approve() -> Weight;
204    fn transfer_from() -> Weight;206    fn transfer_from() -> Weight;
205    fn set_offchain_schema() -> Weight;207    fn set_offchain_schema() -> Weight;
208    fn set_const_on_chain_schema() -> Weight;
209    fn set_variable_on_chain_schema() -> Weight;
210    fn set_variable_meta_data() -> Weight;
206}211}
207212
213#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
214#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
215pub struct CreateNftData {
216    pub const_data: Vec<u8>,
217    pub variable_data: Vec<u8>,
218}
219
220#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
221#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
222pub struct CreateFungibleData {
223}
224
225#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
226#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
227pub struct CreateReFungibleData {
228    pub const_data: Vec<u8>,
229    pub variable_data: Vec<u8>,
230}
231
232#[derive(Encode, Decode, Debug, Clone, PartialEq)]
233#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
234pub enum CreateItemData {
235    NFT(CreateNftData),
236    Fungible(CreateFungibleData),
237    ReFungible(CreateReFungibleData)
238}
239
240impl CreateItemData {
241    pub fn len(&self) -> usize {
242        let len = match self {
243            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),
244            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),
245            _ => 0
246        };
247        
248        return len;
249    }
250}
251
208pub trait Trait: system::Trait + Sized  {252pub trait Trait: system::Trait + Sized  {
209    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;253    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
210254
361405
362            // Anyone can create a collection406            // Anyone can create a collection
363            let who = ensure_signed(origin)?;407            let who = ensure_signed(origin)?;
364            let custom_data_size = match mode {
365                CollectionMode::NFT(size) => {
366408
367                    // bound Custom data size
368                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");
369                    size
370                },
371                CollectionMode::ReFungible(size, _) => {
372
373                    // bound Custom data size
374                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");
375                    size
376                },
377                _ => 0
378            };
379
380            let decimal_points = match mode {409            let decimal_points = match mode {
381                CollectionMode::Fungible(points) => points,410                CollectionMode::Fungible(points) => points,
382                CollectionMode::ReFungible(_, points) => points,411                CollectionMode::ReFungible(points) => points,
383                _ => 0412                _ => 0
384            };413            };
385414
425                decimal_points: decimal_points,454                decimal_points: decimal_points,
426                token_prefix: prefix,455                token_prefix: prefix,
427                offchain_schema: Vec::new(),456                offchain_schema: Vec::new(),
428                custom_data_size: custom_data_size,
429                sponsor: T::AccountId::default(),457                sponsor: T::AccountId::default(),
430                unconfirmed_sponsor: T::AccountId::default(),458                unconfirmed_sponsor: T::AccountId::default(),
459                variable_on_chain_schema: Vec::new(),
460                const_on_chain_schema: Vec::new(),
431            };461            };
432462
433            // Add new collection to map463            // Add new collection to map
440        }470        }
441471
442        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.472        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.
443        /// 473        ///     
444        /// # Permissions474        /// # Permissions
445        /// 475        /// 
446        /// * Collection Owner.476        /// * Collection Owner.
770        /// 800        /// 
771        /// * collection_id: ID of the collection.801        /// * collection_id: ID of the collection.
772        /// 802        /// 
773        /// * properties: Array of bytes that contains NFT properties. Since NFT Module is agnostic of properties meaning, it is treated purely as an array of bytes.
774        /// 
775        /// * owner: Address, initial owner of the NFT.803        /// * owner: Address, initial owner of the NFT.
804        ///
805        /// * data: Token data to store on chain.
776        // #[weight =806        // #[weight =
777        // (130_000_000 as Weight)807        // (130_000_000 as Weight)
778        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))808        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))
779        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))809        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))
780        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]810        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]
781811
782        #[weight = T::WeightInfo::create_item(properties.len())]812        #[weight = T::WeightInfo::create_item(data.len())]
783        pub fn create_item(origin, collection_id: u64, properties: Vec<u8>, owner: T::AccountId) -> DispatchResult {813        pub fn create_item(origin, collection_id: u64, owner: T::AccountId, data: CreateItemData) -> DispatchResult {
784814
785            let sender = ensure_signed(origin)?;815            let sender = ensure_signed(origin)?;
786            Self::collection_exists(collection_id)?;816            Self::collection_exists(collection_id)?;
787            let target_collection = <Collection<T>>::get(collection_id);817            let target_collection = <Collection<T>>::get(collection_id);
788818
789            if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {819            if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {
790                ensure!(target_collection.mint_mode == true, "Public minting is not allowed for this collection");820                ensure!(target_collection.mint_mode == true, "Public minting is not allowed for this collection.");
791                Self::check_white_list(collection_id, &owner)?;821                Self::check_white_list(collection_id, &owner)?;
792                Self::check_white_list(collection_id, &sender)?;822                Self::check_white_list(collection_id, &sender)?;
793            }823            }
794824
795            match target_collection.mode825            match target_collection.mode
796            {826            {
797                CollectionMode::NFT(_) => {827                CollectionMode::NFT => {
798828                    if let CreateItemData::NFT(data) = data {
799                    // check size829                        // check sizes
800                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");830                        ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");
801831                        ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");
832    
802                    // Create nft item833                        // Create nft item
803                    let item = NftItemType {834                        let item = NftItemType {
804                        collection: collection_id,835                            collection: collection_id,
805                        owner: owner,836                            owner: owner,
806                        data: properties.clone(),837                            const_data: data.const_data.clone(),
807                    };838                            variable_data: data.variable_data.clone() 
808839                        };
840    
809                    Self::add_nft_item(item)?;841                        Self::add_nft_item(item)?;
810842                    
843                    } else {
844                        fail!("Not NFT item data used to mint in NFT collection.");
845                    }
811                },846                },
812                CollectionMode::Fungible(_) => {847                CollectionMode::Fungible(_) => {
813
814                    // check size848                    if let CreateItemData::Fungible(_) = data {
815                    ensure!(properties.len() as u32 == 0, "Size of item must be 0 with fungible type");849    
816
817                    let item = FungibleItemType {850                        let item = FungibleItemType {
818                        collection: collection_id,851                            collection: collection_id,
819                        owner: owner,852                            owner: owner,
820                        value: (10 as u128).pow(target_collection.decimal_points)853                            value: (10 as u128).pow(target_collection.decimal_points)
821                    };854                        };
822855    
823                    Self::add_fungible_item(item)?;856                        Self::add_fungible_item(item)?;
857                    } else {
858                        fail!("Not Fungible item data used to mint in Fungible collection.");
859                    }
824                },860                },
825                CollectionMode::ReFungible(_, _) => {861                CollectionMode::ReFungible(_) => {
826862                    if let CreateItemData::ReFungible(data) = data {
827                    // check size863    
864                        // check sizes
828                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");865                        ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");
829866                        ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");
867    
830                    let mut owner_list = Vec::new();868                        let mut owner_list = Vec::new();
831                    let value = (10 as u128).pow(target_collection.decimal_points);869                        let value = (10 as u128).pow(target_collection.decimal_points);
832                    owner_list.push(Ownership {owner: owner.clone(), fraction: value});870                        owner_list.push(Ownership {owner: owner.clone(), fraction: value});
833871    
834                    let item = ReFungibleItemType {872                        let item = ReFungibleItemType {
835                        collection: collection_id,873                            collection: collection_id,
836                        owner: owner_list,874                            owner: owner_list,
837                        data: properties.clone()875                            const_data: data.const_data.clone(),
876                            variable_data: data.variable_data.clone() 
838                    };877                        };
839878    
840                    Self::add_refungible_item(item)?;879                        Self::add_refungible_item(item)?;
880                    } else {
881                        fail!("Not Re Fungible item data used to mint in Re Fungible collection.");
882                    }
841                },883                },
842                _ => { ensure!(1 == 0,"just error"); }884                _ => { ensure!(1 == 0,"Unexpected collection type."); }
843
844            };885            };
845886
880921
881            match target_collection.mode922            match target_collection.mode
882            {923            {
883                CollectionMode::NFT(_) => Self::burn_nft_item(collection_id, item_id)?,924                CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,
884                CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,925                CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,
885                CollectionMode::ReFungible(_, _)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,926                CollectionMode::ReFungible(_)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,
886                _ => ()927                _ => ()
887            };928            };
888929
933974
934            match target_collection.mode975            match target_collection.mode
935            {976            {
936                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,977                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,
937                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,978                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,
938                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,979                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,
939                _ => ()980                _ => ()
940            };981            };
941982
10501091
1051            match target_collection.mode1092            match target_collection.mode
1052            {1093            {
1053                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, from, recipient)?,1094                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,
1054                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,1095                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,
1055                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1096                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,
1056                _ => ()1097                _ => ()
1057            };1098            };
10581099
10741115
1075            Ok(())1116            Ok(())
1076        }1117        }
1118        
1119        /// Set off-chain data schema.
1120        /// 
1121        /// # Permissions
1122        /// 
1123        /// * Collection Owner
1124        /// * Collection Admin
1125        /// 
1126        /// # Arguments
1127        /// 
1128        /// * collection_id.
1129        /// 
1130        /// * schema: String representing the offchain data schema.
1131        #[weight = T::WeightInfo::set_variable_meta_data()]
1132        pub fn set_variable_meta_data (
1133            origin,
1134            collection_id: u64,
1135            item_id: u64,
1136            data: Vec<u8>
1137        ) -> DispatchResult {
1138            let sender = ensure_signed(origin)?;
1139            
1140            Self::collection_exists(collection_id)?;
10771141
1142            // Modify permissions check
1143            let target_collection = <Collection<T>>::get(collection_id);
1144            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||
1145                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),
1146                "Only item owner, collection owner and admins can modify item");
1147
1148            Self::item_exists(collection_id, item_id, &target_collection.mode)?;
1149
1150            match target_collection.mode
1151            {
1152                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,
1153                CollectionMode::ReFungible(_)  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,
1154                _ => ()
1155            };
1156
1157            Ok(())
1158        }
1159        
1160
1078        /// Set off-chain data schema.1161        /// Set off-chain data schema.
1079        /// 1162        /// 
1080        /// # Permissions1163        /// # Permissions
1103            Ok(())1186            Ok(())
1104        }1187        }
11051188
1189        /// Set const on-chain data schema.
1190        /// 
1191        /// # Permissions
1192        /// 
1193        /// * Collection Owner
1194        /// * Collection Admin
1195        /// 
1196        /// # Arguments
1197        /// 
1198        /// * collection_id.
1199        /// 
1200        /// * schema: String representing the const on-chain data schema.
1201        #[weight = T::WeightInfo::set_const_on_chain_schema()]
1202        pub fn set_const_on_chain_schema (
1203            origin,
1204            collection_id: u64,
1205            schema: Vec<u8>
1206        ) -> DispatchResult {
1207            let sender = ensure_signed(origin)?;
1208            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;
1209
1210            let mut target_collection = <Collection<T>>::get(collection_id);
1211            target_collection.const_on_chain_schema = schema;
1212            <Collection<T>>::insert(collection_id, target_collection);
1213
1214            Ok(())
1215        }
1216
1217        /// Set variable on-chain data schema.
1218        /// 
1219        /// # Permissions
1220        /// 
1221        /// * Collection Owner
1222        /// * Collection Admin
1223        /// 
1224        /// # Arguments
1225        /// 
1226        /// * collection_id.
1227        /// 
1228        /// * schema: String representing the variable on-chain data schema.
1229        #[weight = T::WeightInfo::set_const_on_chain_schema()]
1230        pub fn set_variable_on_chain_schema (
1231            origin,
1232            collection_id: u64,
1233            schema: Vec<u8>
1234        ) -> DispatchResult {
1235            let sender = ensure_signed(origin)?;
1236            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;
1237
1238            let mut target_collection = <Collection<T>>::get(collection_id);
1239            target_collection.variable_on_chain_schema = schema;
1240            <Collection<T>>::insert(collection_id, target_collection);
1241
1242            Ok(())
1243        }
1244
1106        // Sudo permissions function1245        // Sudo permissions function
1107        #[weight = 0]1246        #[weight = 0]
1108        pub fn set_chain_limits(1247        pub fn set_chain_limits(
1322        let target_collection = <Collection<T>>::get(collection_id);1461        let target_collection = <Collection<T>>::get(collection_id);
13231462
1324        match target_collection.mode {1463        match target_collection.mode {
1325            CollectionMode::NFT(_) => {1464            CollectionMode::NFT => {
1326                <NftItemList<T>>::get(collection_id, item_id).owner == subject1465                <NftItemList<T>>::get(collection_id, item_id).owner == subject
1327            }1466            }
1328            CollectionMode::Fungible(_) => {1467            CollectionMode::Fungible(_) => {
1329                <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1468                <FungibleItemList<T>>::get(collection_id, item_id).owner == subject
1330            }1469            }
1331            CollectionMode::ReFungible(_, _) => {1470            CollectionMode::ReFungible(_) => {
1332                <ReFungibleItemList<T>>::get(collection_id, item_id)1471                <ReFungibleItemList<T>>::get(collection_id, item_id)
1333                    .owner1472                    .owner
1334                    .iter()1473                    .iter()
15611700
1562        // reset approved list1701        // reset approved list
1563        <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1702        <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));
1703        Ok(())
1704    }
1705    
1706    fn item_exists(
1707        collection_id: u64,
1708        item_id: u64,
1709        mode: &CollectionMode
1710    ) -> DispatchResult {
1711        match mode {
1712            CollectionMode::NFT => ensure!(<NftItemList<T>>::contains_key(collection_id, item_id), "Item does not exists"),
1713            CollectionMode::ReFungible(_) => ensure!(<ReFungibleItemList<T>>::contains_key(collection_id, item_id), "Item does not exists"),
1714            CollectionMode::Fungible(_) => ensure!(<FungibleItemList<T>>::contains_key(collection_id, item_id), "Item does not exists"),
1715            _ => ()
1716        };
1717        
1718        Ok(())
1719    }
1720
1721    fn set_re_fungible_variable_data(
1722        collection_id: u64,
1723        item_id: u64,
1724        data: Vec<u8>
1725    ) -> DispatchResult {
1726        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);
1727
1728        item.variable_data = data;
1729
1730        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);
1731
1732        Ok(())
1733    }
1734
1735    fn set_nft_variable_data(
1736        collection_id: u64,
1737        item_id: u64,
1738        data: Vec<u8>
1739    ) -> DispatchResult {
1740        let mut item = <NftItemList<T>>::get(collection_id, item_id);
1741        
1742        item.variable_data = data;
1743
1744        <NftItemList<T>>::insert(collection_id, item_id, item);
1745        
1564        Ok(())1746        Ok(())
1565    }1747    }
15661748
18041986
1805                // sponsor timeout1987                // sponsor timeout
1806                let sponsor_transfer = match _collection_mode {1988                let sponsor_transfer = match _collection_mode {
1807                    CollectionMode::NFT(_) => {1989                    CollectionMode::NFT => {
1808                        let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);1990                        let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);
1809                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;1991                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;
1810                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();1992                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();
1838                            true2020                            true
1839                        }2021                        }
1840                    }2022                    }
1841                    CollectionMode::ReFungible(_, _) => {2023                    CollectionMode::ReFungible(_) => {
1842                        let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);2024                        let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);
1843                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2025                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;
1844                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2026                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();

--- a/pallets/nft/src/tests.rs
+++ b/pallets/nft/src/tests.rs
@@ -1,21 +1,16 @@
 // Tests to be written here
 use crate::mock::*;
-use crate::{AccessMode, ApprovePermissions, CollectionMode, Ownership, ChainLimits};
+use crate::{AccessMode, ApprovePermissions, CollectionMode, Ownership, ChainLimits, CreateItemData, NftItemType, CreateNftData, CreateFungibleData, CreateReFungibleData};
 use frame_support::{assert_noop, assert_ok};
 use frame_system::{ RawOrigin };
 
-// Use cases tests region
-// #region
-#[test]
-fn create_nft_item() {
-    new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+fn default_collection_numbers_limit() -> u64 {
+    10
+}
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
+fn default_limits() {
+    assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: default_collection_numbers_limit(),
             account_token_ownership_limit: 10,
             collections_admins_limit: 5,
             custom_data_limit: 2048,
@@ -23,67 +18,86 @@
             fungible_sponsor_transfer_timeout: 15,
             refungible_sponsor_transfer_timeout: 15,          
         }));
+}
+
+fn default_nft_data() -> CreateItemData {
+    CreateItemData::NFT(CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] })
+}
+
+fn default_fungible_data () -> CreateItemData {
+    CreateItemData::Fungible(CreateFungibleData { })
+}
 
-        let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
+fn default_re_fungible_data () -> CreateItemData {
+    CreateItemData::ReFungible(CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] })
+}
+
+fn create_test_collection_for_owner(mode: &CollectionMode, owner: u64) -> u64 {
+    let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+    let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+    let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+
+    let collection_id = TemplateModule::nextCollectionID();
+    let origin1 = Origin::signed(owner);
+    assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
             col_desc1.clone(),
             token_prefix1.clone(),
             mode
         ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
+    assert_eq!(TemplateModule::collection(collection_id).owner, owner);
+    return collection_id;
+}
+
+fn create_test_collection(mode: &CollectionMode) -> u64 {
+    return create_test_collection_for_owner(&mode, 1);
+}
 
-        assert_ok!(TemplateModule::create_item(
+fn create_test_item(collection_id: u64, data: &CreateItemData) {
+    let origin1 = Origin::signed(1);
+    assert_ok!(TemplateModule::create_item(
             origin1.clone(),
+            collection_id,
             1,
-            [1, 2, 3].to_vec(),
-            1
+            data.clone()
         ));
-        assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
-    });
+
 }
 
+// Use cases tests region
+// #region
 #[test]
-fn create_refungible_item() {
+fn create_nft_item() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
+        default_limits();
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
+        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).const_data, data.const_data);
+        assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, data.variable_data);
+    });
+}
 
-        let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
+#[test]
+fn create_refungible_item() {
+    new_test_ext().execute_with(|| {
+        default_limits();
+        let collection_id = create_test_collection(&CollectionMode::ReFungible(3));
 
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
+        let data = default_re_fungible_data();
+        create_test_item(collection_id, &data);
+        assert_eq!(
+            TemplateModule::refungible_item_id(collection_id, 1).const_data,
+            data.const_data
+        );
         assert_eq!(
-            TemplateModule::refungible_item_id(1, 1).data,
-            [1, 2, 3].to_vec()
+            TemplateModule::refungible_item_id(collection_id, 1).variable_data,
+            data.variable_data
         );
         assert_eq!(
-            TemplateModule::refungible_item_id(1, 1).owner[0],
+            TemplateModule::refungible_item_id(collection_id, 1).owner[0],
             Ownership {
                 owner: 1,
                 fraction: 1000
@@ -95,38 +109,12 @@
 #[test]
 fn create_fungible_item() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::Fungible(3);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        let collection_id = create_test_collection(&CollectionMode::Fungible(3));
 
-        let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
+        let data = default_fungible_data();
+        create_test_item(collection_id, &data);
 
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [].to_vec(),
-            1
-        ));
-        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
+        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).owner, 1);
         assert_eq!(TemplateModule::balance_count(1, 1), 1000);
         assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
     });
@@ -135,38 +123,16 @@
 #[test]
 fn transfer_fungible_item() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::Fungible(3);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::Fungible(3));
 
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
 
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [].to_vec(),
-            1
-        ));
+        let data = default_fungible_data();
+        create_test_item(collection_id, &data);
+
         assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
         assert_eq!(TemplateModule::balance_count(1, 1), 1000);
         assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
@@ -203,44 +169,25 @@
 #[test]
 fn transfer_refungible_item() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::ReFungible(3));
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        let data = default_re_fungible_data();
+        create_test_item(collection_id, &data);
 
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
-
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
         assert_eq!(
-            TemplateModule::refungible_item_id(1, 1).data,
-            [1, 2, 3].to_vec()
+            TemplateModule::refungible_item_id(collection_id, 1).const_data,
+            data.const_data
+        );
+        assert_eq!(
+            TemplateModule::refungible_item_id(collection_id, 1).variable_data,
+            data.variable_data
         );
         assert_eq!(
-            TemplateModule::refungible_item_id(1, 1).owner[0],
+            TemplateModule::refungible_item_id(collection_id, 1).owner[0],
             Ownership {
                 owner: 1,
                 fraction: 1000
@@ -310,38 +257,12 @@
 #[test]
 fn transfer_nft_item() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
-        assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
         assert_eq!(TemplateModule::balance_count(1, 1), 1);
         assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
@@ -358,39 +279,16 @@
 #[test]
 fn nft_approve_and_transfer_from() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
 
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
 
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
-        assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
         assert_eq!(TemplateModule::balance_count(1, 1), 1);
         assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
@@ -436,49 +334,16 @@
 #[test]
 fn refungible_approve_and_transfer_from() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::ReFungible(3));
+        
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
 
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
-        assert_eq!(
-            TemplateModule::refungible_item_id(1, 1).data,
-            [1, 2, 3].to_vec()
-        );
-        assert_eq!(
-            TemplateModule::refungible_item_id(1, 1).owner[0],
-            Ownership {
-                owner: 1,
-                fraction: 1000
-            }
-        );
+        let data = default_re_fungible_data();
+        create_test_item(collection_id, &data);
+
         assert_eq!(TemplateModule::balance_count(1, 1), 1000);
         assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
@@ -536,39 +401,16 @@
 #[test]
 fn fungible_approve_and_transfer_from() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::Fungible(3);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::Fungible(3));
+        
+        let data = default_fungible_data();
+        create_test_item(collection_id, &data);
 
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
 
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [].to_vec(),
-            1
-        ));
-        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
         assert_eq!(TemplateModule::balance_count(1, 1), 1000);
         assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
@@ -642,104 +484,45 @@
 #[test]
 fn change_collection_owner() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
+        
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
         assert_ok!(TemplateModule::change_collection_owner(
             origin1.clone(),
-            1,
+            collection_id,
             2
         ));
-        assert_eq!(TemplateModule::collection(1).owner, 2);
+        assert_eq!(TemplateModule::collection(collection_id).owner, 2);
     });
 }
 
 #[test]
 fn destroy_collection() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
+        
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
+        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));
     });
 }
 
 #[test]
 fn burn_nft_item() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
+        
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
 
-        assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
-
         // check balance (collection with id = 1, user id = 1)
         assert_eq!(TemplateModule::balance_count(1, 1), 1);
 
@@ -757,36 +540,15 @@
 #[test]
 fn burn_fungible_item() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::Fungible(3);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::Fungible(3));
+        
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [].to_vec(),
-            1
-        ));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
+        
+        let data = default_fungible_data();
+        create_test_item(collection_id, &data);
 
         // check balance (collection with id = 1, user id = 1)
         assert_eq!(TemplateModule::balance_count(1, 1), 1000);
@@ -805,55 +567,28 @@
 #[test]
 fn burn_refungible_item() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::ReFungible(200, 3);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::ReFungible(3));
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
 
         assert_ok!(TemplateModule::set_mint_permission(
             origin1.clone(),
-            1,
+            collection_id,
             true
         ));
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
 
         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::create_item(
-            origin2.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
-
-        assert_eq!(
-            TemplateModule::refungible_item_id(1, 1).data,
-            [1, 2, 3].to_vec()
-        );
+        
+        let data = default_re_fungible_data();
+        create_test_item(collection_id, &data);
 
         // check balance (collection with id = 1, user id = 2)
         assert_eq!(TemplateModule::balance_count(1, 1), 1000);
@@ -872,110 +607,38 @@
 #[test]
 fn add_collection_admin() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
+        default_limits();
+        
+        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1);
+        create_test_collection_for_owner(&CollectionMode::NFT, 2);
+        create_test_collection_for_owner(&CollectionMode::NFT, 3);
+        
         let origin1 = Origin::signed(1);
-        let origin2 = Origin::signed(2);
-        let origin3 = Origin::signed(3);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode.clone()
-        ));
-        assert_ok!(TemplateModule::create_collection(
-            origin2.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode.clone()
-        ));
-        assert_ok!(TemplateModule::create_collection(
-            origin3.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode.clone()
-        ));
-
-        assert_eq!(TemplateModule::collection(1).owner, 1);
-        assert_eq!(TemplateModule::collection(2).owner, 2);
-        assert_eq!(TemplateModule::collection(3).owner, 3);
 
         // collection admin
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));
 
-        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);
-        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);
+        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);
+        assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);
     });
 }
 
 #[test]
 fn remove_collection_admin() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1);
+        create_test_collection_for_owner(&CollectionMode::NFT, 2);
+        create_test_collection_for_owner(&CollectionMode::NFT, 3);
 
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        let origin3 = Origin::signed(3);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode.clone()
-        ));
-        assert_ok!(TemplateModule::create_collection(
-            origin2.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode.clone()
-        ));
-        assert_ok!(TemplateModule::create_collection(
-            origin3.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode.clone()
-        ));
-
-        assert_eq!(TemplateModule::collection(1).owner, 1);
-        assert_eq!(TemplateModule::collection(2).owner, 2);
-        assert_eq!(TemplateModule::collection(3).owner, 3);
 
         // collection admin
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));
 
         assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);
         assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);
@@ -993,125 +656,50 @@
 #[test]
 fn balance_of() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let nft_mode: CollectionMode = CollectionMode::NFT(2000);
-        let furg_mode: CollectionMode = CollectionMode::Fungible(3);
-        let refung_mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
-
+        default_limits();
+        
+        let nft_collection_id = create_test_collection(&CollectionMode::NFT);
+        let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3));
+        let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3));
+        
         let origin1 = Origin::signed(1);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            nft_mode.clone()
-        ));
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            furg_mode.clone()
-        ));
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            refung_mode.clone()
-        ));
-
-        assert_eq!(TemplateModule::collection(1).owner, 1);
-        assert_eq!(TemplateModule::collection(2).owner, 1);
-        assert_eq!(TemplateModule::collection(3).owner, 1);
 
         // check balance before
-        assert_eq!(TemplateModule::balance_count(1, 1), 0);
-        assert_eq!(TemplateModule::balance_count(2, 1), 0);
-        assert_eq!(TemplateModule::balance_count(3, 1), 0);
+        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);
+        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);
+        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);
 
-        // create item
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 1, 1].to_vec(),
-            1
-        ));
-
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            2,
-            [].to_vec(),
-            1
-        ));
-
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            3,
-            [1, 1, 1].to_vec(),
-            1
-        ));
+        let nft_data = default_nft_data();
+        create_test_item(nft_collection_id, &nft_data);
+        
+        let fungible_data = default_fungible_data();
+        create_test_item(fungible_collection_id, &fungible_data);
+        
+        let re_fungible_data = default_re_fungible_data();
+        create_test_item(re_fungible_collection_id, &re_fungible_data);
 
         // check balance (collection with id = 1, user id = 1)
-        assert_eq!(TemplateModule::balance_count(1, 1), 1);
-        assert_eq!(TemplateModule::balance_count(2, 1), 1000);
-        assert_eq!(TemplateModule::balance_count(3, 1), 1000);
-        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 1);
-        assert_eq!(TemplateModule::fungible_item_id(2, 1).owner, 1);
-        assert_eq!(TemplateModule::refungible_item_id(3, 1).owner[0].owner, 1);
+        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);
+        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);
+        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);
+        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);
+        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);
+        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);
     });
 }
 
 #[test]
 fn approve() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let nft_mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
+        
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
+
         let origin1 = Origin::signed(1);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            nft_mode.clone()
-        ));
-
-        assert_eq!(TemplateModule::collection(1).owner, 1);
-
-        // create item
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 1, 1].to_vec(),
-            1
-        ));
-
+        
         // approve
         assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
         assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);
@@ -1121,40 +709,14 @@
 #[test]
 fn transfer_from() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
-        assert_eq!(TemplateModule::collection(1).owner, 1);
-
-        // create item
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 1, 1].to_vec(),
-            1
-        ));
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
 
         // approve
         assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
@@ -1197,99 +759,41 @@
 #[test]
 fn owner_can_add_address_to_white_list() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
+
         let origin1 = Origin::signed(1);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
-        assert_eq!(TemplateModule::white_list(1)[0], 2);
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
+        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);
     });
 }
 
 #[test]
 fn admin_can_add_address_to_white_list() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), 1, 3));
-        assert_eq!(TemplateModule::white_list(1)[0], 3);
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
+        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));
+        assert_eq!(TemplateModule::white_list(collection_id)[0], 3);
     });
 }
 
 #[test]
 fn nonprivileged_user_cannot_add_address_to_white_list() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-        let origin1 = Origin::signed(1);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
+
         let origin2 = Origin::signed(2);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
         assert_noop!(
-            TemplateModule::add_to_white_list(origin2.clone(), 1, 3),
+            TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),
             "You do not have permissions to modify this collection"
         );
     });
@@ -1298,17 +802,9 @@
 #[test]
 fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {
     new_test_ext().execute_with(|| {
+        default_limits();
+
         let origin1 = Origin::signed(1);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
 
         assert_noop!(
             TemplateModule::add_to_white_list(origin1.clone(), 1, 2),
@@ -1320,33 +816,13 @@
 #[test]
 fn nobody_can_add_address_to_white_list_of_deleted_collection() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-        let origin1 = Origin::signed(1);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
-        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
+        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));
         assert_noop!(
-            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),
+            TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),
             "This collection does not exist"
         );
     });
@@ -1356,165 +832,80 @@
 #[test]
 fn address_is_already_added_to_white_list() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
         let origin1 = Origin::signed(1);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
-        assert_eq!(TemplateModule::white_list(1)[0], 2);
-        assert_eq!(TemplateModule::white_list(1).len(), 1);
+        
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
+        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);
+        assert_eq!(TemplateModule::white_list(collection_id).len(), 1);
     });
 }
 
 #[test]
 fn owner_can_remove_address_from_white_list() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-        let origin1 = Origin::signed(1);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
         assert_ok!(TemplateModule::remove_from_white_list(
             origin1.clone(),
-            1,
+            collection_id,
             2
         ));
-        assert_eq!(TemplateModule::white_list(1).len(), 0);
+        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
     });
 }
 
 #[test]
 fn admin_can_remove_address_from_white_list() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
 
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));
         assert_ok!(TemplateModule::remove_from_white_list(
             origin2.clone(),
-            1,
+            collection_id,
             3
         ));
-        assert_eq!(TemplateModule::white_list(1).len(), 0);
+        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
     });
 }
 
 #[test]
 fn nonprivileged_user_cannot_remove_address_from_white_list() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
         assert_noop!(
-            TemplateModule::remove_from_white_list(origin2.clone(), 1, 2),
+            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),
             "You do not have permissions to modify this collection"
         );
-        assert_eq!(TemplateModule::white_list(1)[0], 2);
+        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);
     });
 }
 
 #[test]
 fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {
     new_test_ext().execute_with(|| {
+        default_limits();
         let origin1 = Origin::signed(1);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
 
         assert_noop!(
             TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),
@@ -1526,38 +917,19 @@
 #[test]
 fn nobody_can_remove_address_from_white_list_of_deleted_collection() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
+        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));
         assert_noop!(
-            TemplateModule::remove_from_white_list(origin2.clone(), 1, 2),
+            TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),
             "This collection does not exist"
         );
-        assert_eq!(TemplateModule::white_list(1).len(), 0);
+        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
     });
 }
 
@@ -1565,42 +937,23 @@
 #[test]
 fn address_is_already_removed_from_white_list() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
         let origin1 = Origin::signed(1);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
         assert_ok!(TemplateModule::remove_from_white_list(
             origin1.clone(),
-            1,
+            collection_id,
             2
         ));
         assert_ok!(TemplateModule::remove_from_white_list(
             origin1.clone(),
-            1,
+            collection_id,
             2
         ));
-        assert_eq!(TemplateModule::white_list(1).len(), 0);
+        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
     });
 }
 
@@ -1608,44 +961,21 @@
 #[test]
 fn white_list_test_1() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
-
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
+        
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
 
         assert_noop!(
             TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),
@@ -1657,41 +987,17 @@
 #[test]
 fn white_list_test_2() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
-
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
+        
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
@@ -1718,41 +1024,18 @@
 #[test]
 fn white_list_test_3() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
-
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
+        
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
@@ -1767,45 +1050,22 @@
 #[test]
 fn white_list_test_4() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
 
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
 
         // do approve
         assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));
@@ -1813,7 +1073,7 @@
 
         assert_ok!(TemplateModule::remove_from_white_list(
             origin1.clone(),
-            1,
+            collection_id,
             2
         ));
 
@@ -1828,41 +1088,18 @@
 #[test]
 fn white_list_test_5() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
 
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_noop!(
@@ -1876,32 +1113,14 @@
 #[test]
 fn white_list_test_6() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
 
@@ -1918,45 +1137,22 @@
 #[test]
 fn white_list_test_7() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
+        
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
-
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
 
         assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));
     });
@@ -1965,45 +1161,22 @@
 #[test]
 fn white_list_test_8() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
+        
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-        assert_eq!(TemplateModule::collection(1).owner, 1);
-
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
 
         // do approve
         assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));
@@ -2024,47 +1197,24 @@
 #[test]
 fn white_list_test_9() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_ok!(TemplateModule::set_mint_permission(
             origin1.clone(),
-            1,
+            collection_id,
             false
         ));
 
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
     });
 }
 
@@ -2072,49 +1222,31 @@
 #[test]
 fn white_list_test_10() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_ok!(TemplateModule::set_mint_permission(
             origin1.clone(),
-            1,
+            collection_id,
             false
         ));
 
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
 
         assert_ok!(TemplateModule::create_item(
             origin2.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            2
+            collection_id,
+            2,
+            default_nft_data()
         ));
     });
 }
@@ -2123,45 +1255,27 @@
 #[test]
 fn white_list_test_11() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_ok!(TemplateModule::set_mint_permission(
             origin1.clone(),
-            1,
+            collection_id,
             false
         ));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
 
         assert_noop!(
-            TemplateModule::create_item(origin2.clone(), 1, [1, 2, 3].to_vec(), 2),
+            TemplateModule::create_item(origin2.clone(), 1, vec![1, 2, 3], 2),
             "Public minting is not allowed for this collection"
         );
     });
@@ -2171,44 +1285,26 @@
 #[test]
 fn white_list_test_12() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_ok!(TemplateModule::set_mint_permission(
             origin1.clone(),
-            1,
+            collection_id,
             false
         ));
 
         assert_noop!(
-            TemplateModule::create_item(origin2.clone(), 1, [1, 2, 3].to_vec(), 2),
+            TemplateModule::create_item(origin2.clone(), 1, vec![1, 2, 3], 2),
             "Public minting is not allowed for this collection"
         );
     });
@@ -2218,47 +1314,25 @@
 #[test]
 fn white_list_test_13() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_ok!(TemplateModule::set_mint_permission(
             origin1.clone(),
-            1,
+            collection_id,
             true
         ));
 
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
     });
 }
 
@@ -2266,49 +1340,31 @@
 #[test]
 fn white_list_test_14() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_ok!(TemplateModule::set_mint_permission(
             origin1.clone(),
-            1,
+            collection_id,
             true
         ));
 
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
 
         assert_ok!(TemplateModule::create_item(
             origin2.clone(),
             1,
-            [1, 2, 3].to_vec(),
-            2
+            2,
+            default_nft_data()
         ));
     });
 }
@@ -2317,44 +1373,26 @@
 #[test]
 fn white_list_test_15() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_ok!(TemplateModule::set_mint_permission(
             origin1.clone(),
-            1,
+            collection_id,
             true
         ));
 
         assert_noop!(
-            TemplateModule::create_item(origin2.clone(), 1, [1, 2, 3].to_vec(), 2),
+            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data()),
             "Address is not in white list"
         );
     });
@@ -2364,48 +1402,30 @@
 #[test]
 fn white_list_test_16() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
 
         assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            1,
+            collection_id,
             AccessMode::WhiteList
         ));
         assert_ok!(TemplateModule::set_mint_permission(
             origin1.clone(),
-            1,
+            collection_id,
             true
         ));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
 
         assert_ok!(TemplateModule::create_item(
             origin2.clone(),
             1,
-            [1, 2, 3].to_vec(),
-            2
+            2,
+            default_nft_data()
         ));
     });
 }
@@ -2414,29 +1434,9 @@
 #[test]
 fn total_number_collections_bound() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
+        default_limits();
+        
+        create_test_collection(&CollectionMode::NFT);
     });
 }
 
@@ -2444,32 +1444,12 @@
 #[test]
 fn total_number_collections_bound_neg() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
+        default_limits();
 
         let origin1 = Origin::signed(1);
 
-        for _ in 0..10 {
-
-            assert_ok!(TemplateModule::create_collection(
-                origin1.clone(),
-                col_name1.clone(),
-                col_desc1.clone(),
-                token_prefix1.clone(),
-                mode.clone()
-            ));
+        for _ in 0..default_collection_numbers_limit() {
+            create_test_collection(&CollectionMode::NFT)
         }
 
         // 11-th collection in chain. Expects error
@@ -2487,43 +1467,13 @@
 #[test]
 fn owned_tokens_bound() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
-        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
-            collection_numbers_limit: 10,
-            account_token_ownership_limit: 10,
-            collections_admins_limit: 5,
-            custom_data_limit: 2048,
-            nft_sponsor_transfer_timeout: 15,
-            fungible_sponsor_transfer_timeout: 15,
-            refungible_sponsor_transfer_timeout: 15,          
-        }));
-
-        let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
-
-        assert_ok!(TemplateModule::create_item(
-            origin1.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
+        create_test_item(collection_id, &data);
     });
 }
 
@@ -2531,11 +1481,6 @@
 #[test]
 fn owned_tokens_bound_neg() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
         assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
             collection_numbers_limit: 10,
             account_token_ownership_limit: 1,
@@ -2545,28 +1490,18 @@
             fungible_sponsor_transfer_timeout: 15,
             refungible_sponsor_transfer_timeout: 15,          
         }));
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
+        let data = default_nft_data();
+        create_test_item(collection_id, &data);
 
-        assert_ok!(TemplateModule::create_item(
+        assert_noop!(TemplateModule::create_item(
             origin1.clone(),
             1,
-            [1, 2, 3].to_vec(),
-            1
-        ));
-
-        assert_noop!(TemplateModule::create_item(
-            origin1.clone(),
             1,
-            [1, 2, 3].to_vec(),
-            1
+            data
         ), "Owned tokens by a single address bound exceeded");
     });
 }
@@ -2575,11 +1510,6 @@
 #[test]
 fn collection_admins_bound() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
         assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
             collection_numbers_limit: 10,
             account_token_ownership_limit: 10,
@@ -2589,18 +1519,13 @@
             fungible_sponsor_transfer_timeout: 15,
             refungible_sponsor_transfer_timeout: 15,          
         }));
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
-
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
+        
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));
     });
 }
 
@@ -2608,11 +1533,6 @@
 #[test]
 fn collection_admins_bound_neg() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
-
         assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
             collection_numbers_limit: 10,
             account_token_ownership_limit: 1,
@@ -2622,78 +1542,167 @@
             fungible_sponsor_transfer_timeout: 15,
             refungible_sponsor_transfer_timeout: 15,          
         }));
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
 
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
-            origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
 
-        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3), "Number of collection admins bound exceeded");
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
+        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), "Number of collection admins bound exceeded");
     });
 }
 
-// Custom data size. Positive test
+// NFT custom data size. Negative test const_data.
 #[test]
-fn custom_data_size_bound() {
+fn custom_data_size_nft_const_data_bound_neg() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
+
+        let origin1 = Origin::signed(1);
+        let too_big_const_data = CreateItemData::NFT(CreateNftData{
+            const_data: vec![1, 2, 3, 4],
+            variable_data: vec![]
+        });
+
+        assert_noop!(TemplateModule::create_item(
+            origin1.clone(),
+            collection_id,
+            1,
+            too_big_const_data
+        ), "const_data exceeded data limit: 2.");
+    });
+}
 
+// NFT custom data size. Negative test variable_data.
+#[test]
+fn custom_data_size_nft_variable_data_bound_neg() {
+    new_test_ext().execute_with(|| {
         assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
             collection_numbers_limit: 10,
             account_token_ownership_limit: 10,
             collections_admins_limit: 5,
-            custom_data_limit: 2048,
+            custom_data_limit: 2,
             nft_sponsor_transfer_timeout: 15,
             fungible_sponsor_transfer_timeout: 15,
             refungible_sponsor_transfer_timeout: 15,          
         }));
 
+        let collection_id = create_test_collection(&CollectionMode::NFT);
+
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(
+        let too_big_const_data = CreateItemData::NFT(CreateNftData{
+            const_data: vec![],
+            variable_data: vec![1, 2, 3, 4]
+        });
+
+        assert_noop!(TemplateModule::create_item(
             origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ));
+            collection_id,
+            1,
+            too_big_const_data
+        ), "variable_data exceeded data limit: 2.");
     });
 }
 
-// Custom data size. Negotive test
+// Re fungible custom data size. Negative test const_data.
 #[test]
-fn custom_data_size_bound_neg() {
+fn custom_data_size_re_fungible_const_data_bound_neg() {
     new_test_ext().execute_with(|| {
-        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
-        let mode: CollectionMode = CollectionMode::NFT(2000);
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
+        let collection_id = create_test_collection(&CollectionMode::NFT);
+
+        let origin1 = Origin::signed(1);
+        let too_big_const_data = CreateItemData::NFT(CreateNftData{
+            const_data: vec![1, 2, 3, 4],
+            variable_data: vec![]
+        });
+
+        assert_noop!(TemplateModule::create_item(
+            origin1.clone(),
+            collection_id,
+            1,
+            too_big_const_data
+        ), "const_data exceeded data limit: 2.");
+    });
+}
 
+// Re fungible custom data size. Negative test variable_data.
+#[test]
+fn custom_data_size_re_fungible_variable_data_bound_neg() {
+    new_test_ext().execute_with(|| {
         assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
             collection_numbers_limit: 10,
             account_token_ownership_limit: 10,
             collections_admins_limit: 5,
-            custom_data_limit: 200,
+            custom_data_limit: 2,
             nft_sponsor_transfer_timeout: 15,
             fungible_sponsor_transfer_timeout: 15,
             refungible_sponsor_transfer_timeout: 15,          
         }));
 
+        let collection_id = create_test_collection(&CollectionMode::NFT);
+
         let origin1 = Origin::signed(1);
-        assert_noop!(TemplateModule::create_collection(
+        let too_big_const_data = CreateItemData::NFT(CreateNftData{
+            const_data: vec![],
+            variable_data: vec![1, 2, 3, 4]
+        });
+
+        assert_noop!(TemplateModule::create_item(
             origin1.clone(),
-            col_name1.clone(),
-            col_desc1.clone(),
-            token_prefix1.clone(),
-            mode
-        ), "Custom data size bound exceeded");
+            collection_id,
+            1,
+            too_big_const_data
+        ), "variable_data exceeded data limit: 2.");
     });
 }
 // #endregion
+
+#[test]
+fn set_const_on_chain_schema() {
+    new_test_ext().execute_with(|| {
+        default_limits();
+
+        let collection_id = create_test_collection(&CollectionMode::NFT);
+
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, "test const on chain schema".to_vec()));
+
+        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, "test const on chain schema".to_vec());
+        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, "".to_vec());
+    });
+}
+
+#[test]
+fn set_variable_on_chain_schema() {
+    new_test_ext().execute_with(|| {
+        default_limits();
+        
+        let collection_id = create_test_collection(&CollectionMode::NFT);
+
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, "test variable on chain schema".to_vec()));
+
+        assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, "".to_vec());
+        assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, "test variable on chain schema".to_vec());
+    });
+}
\ No newline at end of file

--- a/runtime/src/nft_weights.rs
+++ b/runtime/src/nft_weights.rs
@@ -93,4 +93,19 @@
             .saturating_add(DbWeight::get().reads(2 as Weight))
             .saturating_add(DbWeight::get().writes(1 as Weight))
     }
+    fn set_const_on_chain_schema() -> Weight {
+        (11_100_000 as Weight)
+            .saturating_add(DbWeight::get().reads(2 as Weight))
+            .saturating_add(DbWeight::get().writes(1 as Weight))
+    }
+    fn set_variable_on_chain_schema() -> Weight {
+        (11_100_000 as Weight)
+            .saturating_add(DbWeight::get().reads(2 as Weight))
+            .saturating_add(DbWeight::get().writes(1 as Weight))
+    }
+    fn set_variable_meta_data() -> Weight {
+        (17_500_000 as Weight)
+            .saturating_add(DbWeight::get().reads(2 as Weight))
+            .saturating_add(DbWeight::get().writes(1 as Weight))
+    }
 }