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

difftreelog

NFTPAR-142 Off-chain and on-chain data schema.

sotmorskiy2020-11-11parent: #3f1f974.patch.diff
in: master

6 files changed

modifiednode/src/chain_spec.rsdiffbeforeafterboth
--- 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![],
modifiedpallets/nft/src/benchmarking.rsdiffbeforeafterboth
--- 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
modifiedpallets/nft/src/default_weights.rsdiffbeforeafterboth
--- 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))
+    }
 }
modifiedpallets/nft/src/lib.rsdiffbeforeafterboth
--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -10,7 +10,7 @@
 pub use frame_support::{
     construct_runtime, decl_event, decl_module, decl_storage,
     dispatch::DispatchResult,
-    ensure, parameter_types,
+    ensure, parameter_types, fail,
     traits::{
         Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,
         Randomness, WithdrawReason,
@@ -53,21 +53,20 @@
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
 pub enum CollectionMode {
     Invalid,
-    // custom data size
-    NFT(u32),
+    NFT,
     // decimal points
     Fungible(u32),
-    // custom data size and decimal points
-    ReFungible(u32, u32),
+    // decimal points
+    ReFungible(u32),
 }
 
 impl Into<u8> for CollectionMode {
     fn into(self) -> u8 {
         match self {
             CollectionMode::Invalid => 0,
-            CollectionMode::NFT(_) => 1,
+            CollectionMode::NFT => 1,
             CollectionMode::Fungible(_) => 2,
-            CollectionMode::ReFungible(_, _) => 3,
+            CollectionMode::ReFungible(_) => 3,
         }
     }
 }
@@ -107,11 +106,12 @@
     pub name: Vec<u16>,        // 64 include null escape char
     pub description: Vec<u16>, // 256 include null escape char
     pub token_prefix: Vec<u8>, // 16 include null escape char
-    pub custom_data_size: u32,
     pub mint_mode: bool,
     pub offchain_schema: Vec<u8>,
     pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender
     pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship
+    pub variable_on_chain_schema: Vec<u8>, //
+    pub const_on_chain_schema: Vec<u8>, //
 }
 
 #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
@@ -126,7 +126,8 @@
 pub struct NftItemType<AccountId> {
     pub collection: u64,
     pub owner: AccountId,
-    pub data: Vec<u8>,
+    pub const_data: Vec<u8>,
+    pub variable_data: Vec<u8>,
 }
 
 #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
@@ -142,7 +143,8 @@
 pub struct ReFungibleItemType<AccountId> {
     pub collection: u64,
     pub owner: Vec<Ownership<AccountId>>,
-    pub data: Vec<u8>,
+    pub const_data: Vec<u8>,
+    pub variable_data: Vec<u8>,
 }
 
 #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
@@ -197,14 +199,56 @@
     fn set_collection_sponsor() -> Weight;
     fn confirm_sponsorship() -> Weight;
     fn remove_collection_sponsor() -> Weight;
-    fn create_item(s: usize, ) -> Weight;
+    fn create_item(s: usize) -> Weight;
     fn burn_item() -> Weight;
     fn transfer() -> Weight;
     fn approve() -> Weight;
     fn transfer_from() -> Weight;
     fn set_offchain_schema() -> Weight;
+    fn set_const_on_chain_schema() -> Weight;
+    fn set_variable_on_chain_schema() -> Weight;
+    fn set_variable_meta_data() -> Weight;
+}
+
+#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub struct CreateNftData {
+    pub const_data: Vec<u8>,
+    pub variable_data: Vec<u8>,
 }
 
+#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub struct CreateFungibleData {
+}
+
+#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub struct CreateReFungibleData {
+    pub const_data: Vec<u8>,
+    pub variable_data: Vec<u8>,
+}
+
+#[derive(Encode, Decode, Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub enum CreateItemData {
+    NFT(CreateNftData),
+    Fungible(CreateFungibleData),
+    ReFungible(CreateReFungibleData)
+}
+
+impl CreateItemData {
+    pub fn len(&self) -> usize {
+        let len = match self {
+            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),
+            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),
+            _ => 0
+        };
+        
+        return len;
+    }
+}
+
 pub trait Trait: system::Trait + Sized  {
     type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
 
@@ -361,25 +405,10 @@
 
             // Anyone can create a collection
             let who = ensure_signed(origin)?;
-            let custom_data_size = match mode {
-                CollectionMode::NFT(size) => {
-
-                    // bound Custom data size
-                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");
-                    size
-                },
-                CollectionMode::ReFungible(size, _) => {
-
-                    // bound Custom data size
-                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");
-                    size
-                },
-                _ => 0
-            };
 
             let decimal_points = match mode {
                 CollectionMode::Fungible(points) => points,
-                CollectionMode::ReFungible(_, points) => points,
+                CollectionMode::ReFungible(points) => points,
                 _ => 0
             };
 
@@ -425,9 +454,10 @@
                 decimal_points: decimal_points,
                 token_prefix: prefix,
                 offchain_schema: Vec::new(),
-                custom_data_size: custom_data_size,
                 sponsor: T::AccountId::default(),
                 unconfirmed_sponsor: T::AccountId::default(),
+                variable_on_chain_schema: Vec::new(),
+                const_on_chain_schema: Vec::new(),
             };
 
             // Add new collection to map
@@ -440,7 +470,7 @@
         }
 
         /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.
-        /// 
+        ///     
         /// # Permissions
         /// 
         /// * Collection Owner.
@@ -769,78 +799,89 @@
         /// # Arguments
         /// 
         /// * collection_id: ID of the collection.
-        /// 
-        /// * 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.
         /// 
         /// * owner: Address, initial owner of the NFT.
+        ///
+        /// * data: Token data to store on chain.
         // #[weight =
         // (130_000_000 as Weight)
         // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))
         // .saturating_add(RocksDbWeight::get().reads(10 as Weight))
         // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]
 
-        #[weight = T::WeightInfo::create_item(properties.len())]
-        pub fn create_item(origin, collection_id: u64, properties: Vec<u8>, owner: T::AccountId) -> DispatchResult {
+        #[weight = T::WeightInfo::create_item(data.len())]
+        pub fn create_item(origin, collection_id: u64, owner: T::AccountId, data: CreateItemData) -> DispatchResult {
 
             let sender = ensure_signed(origin)?;
             Self::collection_exists(collection_id)?;
             let target_collection = <Collection<T>>::get(collection_id);
 
             if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {
-                ensure!(target_collection.mint_mode == true, "Public minting is not allowed for this collection");
+                ensure!(target_collection.mint_mode == true, "Public minting is not allowed for this collection.");
                 Self::check_white_list(collection_id, &owner)?;
                 Self::check_white_list(collection_id, &sender)?;
             }
 
             match target_collection.mode
             {
-                CollectionMode::NFT(_) => {
-
-                    // check size
-                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");
-
-                    // Create nft item
-                    let item = NftItemType {
-                        collection: collection_id,
-                        owner: owner,
-                        data: properties.clone(),
-                    };
-
-                    Self::add_nft_item(item)?;
-
+                CollectionMode::NFT => {
+                    if let CreateItemData::NFT(data) = data {
+                        // check sizes
+                        ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");
+                        ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");
+    
+                        // Create nft item
+                        let item = NftItemType {
+                            collection: collection_id,
+                            owner: owner,
+                            const_data: data.const_data.clone(),
+                            variable_data: data.variable_data.clone() 
+                        };
+    
+                        Self::add_nft_item(item)?;
+                    
+                    } else {
+                        fail!("Not NFT item data used to mint in NFT collection.");
+                    }
                 },
                 CollectionMode::Fungible(_) => {
-
-                    // check size
-                    ensure!(properties.len() as u32 == 0, "Size of item must be 0 with fungible type");
-
-                    let item = FungibleItemType {
-                        collection: collection_id,
-                        owner: owner,
-                        value: (10 as u128).pow(target_collection.decimal_points)
-                    };
-
-                    Self::add_fungible_item(item)?;
+                    if let CreateItemData::Fungible(_) = data {
+    
+                        let item = FungibleItemType {
+                            collection: collection_id,
+                            owner: owner,
+                            value: (10 as u128).pow(target_collection.decimal_points)
+                        };
+    
+                        Self::add_fungible_item(item)?;
+                    } else {
+                        fail!("Not Fungible item data used to mint in Fungible collection.");
+                    }
                 },
-                CollectionMode::ReFungible(_, _) => {
-
-                    // check size
-                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");
-
-                    let mut owner_list = Vec::new();
-                    let value = (10 as u128).pow(target_collection.decimal_points);
-                    owner_list.push(Ownership {owner: owner.clone(), fraction: value});
-
-                    let item = ReFungibleItemType {
-                        collection: collection_id,
-                        owner: owner_list,
-                        data: properties.clone()
-                    };
-
-                    Self::add_refungible_item(item)?;
+                CollectionMode::ReFungible(_) => {
+                    if let CreateItemData::ReFungible(data) = data {
+    
+                        // check sizes
+                        ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");
+                        ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");
+    
+                        let mut owner_list = Vec::new();
+                        let value = (10 as u128).pow(target_collection.decimal_points);
+                        owner_list.push(Ownership {owner: owner.clone(), fraction: value});
+    
+                        let item = ReFungibleItemType {
+                            collection: collection_id,
+                            owner: owner_list,
+                            const_data: data.const_data.clone(),
+                            variable_data: data.variable_data.clone() 
+                        };
+    
+                        Self::add_refungible_item(item)?;
+                    } else {
+                        fail!("Not Re Fungible item data used to mint in Re Fungible collection.");
+                    }
                 },
-                _ => { ensure!(1 == 0,"just error"); }
-
+                _ => { ensure!(1 == 0,"Unexpected collection type."); }
             };
 
             // call event
@@ -880,9 +921,9 @@
 
             match target_collection.mode
             {
-                CollectionMode::NFT(_) => Self::burn_nft_item(collection_id, item_id)?,
+                CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,
                 CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,
-                CollectionMode::ReFungible(_, _)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,
+                CollectionMode::ReFungible(_)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,
                 _ => ()
             };
 
@@ -933,9 +974,9 @@
 
             match target_collection.mode
             {
-                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,
+                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,
                 CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,
-                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,
+                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,
                 _ => ()
             };
 
@@ -1050,9 +1091,9 @@
 
             match target_collection.mode
             {
-                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, from, recipient)?,
+                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,
                 CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,
-                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,
+                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,
                 _ => ()
             };
 
@@ -1074,7 +1115,49 @@
 
             Ok(())
         }
+        
+        /// Set off-chain data schema.
+        /// 
+        /// # Permissions
+        /// 
+        /// * Collection Owner
+        /// * Collection Admin
+        /// 
+        /// # Arguments
+        /// 
+        /// * collection_id.
+        /// 
+        /// * schema: String representing the offchain data schema.
+        #[weight = T::WeightInfo::set_variable_meta_data()]
+        pub fn set_variable_meta_data (
+            origin,
+            collection_id: u64,
+            item_id: u64,
+            data: Vec<u8>
+        ) -> DispatchResult {
+            let sender = ensure_signed(origin)?;
+            
+            Self::collection_exists(collection_id)?;
+
+            // Modify permissions check
+            let target_collection = <Collection<T>>::get(collection_id);
+            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||
+                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),
+                "Only item owner, collection owner and admins can modify item");
+
+            Self::item_exists(collection_id, item_id, &target_collection.mode)?;
+
+            match target_collection.mode
+            {
+                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,
+                CollectionMode::ReFungible(_)  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,
+                _ => ()
+            };
 
+            Ok(())
+        }
+        
+
         /// Set off-chain data schema.
         /// 
         /// # Permissions
@@ -1103,6 +1186,62 @@
             Ok(())
         }
 
+        /// Set const on-chain data schema.
+        /// 
+        /// # Permissions
+        /// 
+        /// * Collection Owner
+        /// * Collection Admin
+        /// 
+        /// # Arguments
+        /// 
+        /// * collection_id.
+        /// 
+        /// * schema: String representing the const on-chain data schema.
+        #[weight = T::WeightInfo::set_const_on_chain_schema()]
+        pub fn set_const_on_chain_schema (
+            origin,
+            collection_id: u64,
+            schema: Vec<u8>
+        ) -> DispatchResult {
+            let sender = ensure_signed(origin)?;
+            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;
+
+            let mut target_collection = <Collection<T>>::get(collection_id);
+            target_collection.const_on_chain_schema = schema;
+            <Collection<T>>::insert(collection_id, target_collection);
+
+            Ok(())
+        }
+
+        /// Set variable on-chain data schema.
+        /// 
+        /// # Permissions
+        /// 
+        /// * Collection Owner
+        /// * Collection Admin
+        /// 
+        /// # Arguments
+        /// 
+        /// * collection_id.
+        /// 
+        /// * schema: String representing the variable on-chain data schema.
+        #[weight = T::WeightInfo::set_const_on_chain_schema()]
+        pub fn set_variable_on_chain_schema (
+            origin,
+            collection_id: u64,
+            schema: Vec<u8>
+        ) -> DispatchResult {
+            let sender = ensure_signed(origin)?;
+            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;
+
+            let mut target_collection = <Collection<T>>::get(collection_id);
+            target_collection.variable_on_chain_schema = schema;
+            <Collection<T>>::insert(collection_id, target_collection);
+
+            Ok(())
+        }
+
         // Sudo permissions function
         #[weight = 0]
         pub fn set_chain_limits(
@@ -1322,13 +1461,13 @@
         let target_collection = <Collection<T>>::get(collection_id);
 
         match target_collection.mode {
-            CollectionMode::NFT(_) => {
+            CollectionMode::NFT => {
                 <NftItemList<T>>::get(collection_id, item_id).owner == subject
             }
             CollectionMode::Fungible(_) => {
                 <FungibleItemList<T>>::get(collection_id, item_id).owner == subject
             }
-            CollectionMode::ReFungible(_, _) => {
+            CollectionMode::ReFungible(_) => {
                 <ReFungibleItemList<T>>::get(collection_id, item_id)
                     .owner
                     .iter()
@@ -1563,7 +1702,50 @@
         <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));
         Ok(())
     }
+    
+    fn item_exists(
+        collection_id: u64,
+        item_id: u64,
+        mode: &CollectionMode
+    ) -> DispatchResult {
+        match mode {
+            CollectionMode::NFT => ensure!(<NftItemList<T>>::contains_key(collection_id, item_id), "Item does not exists"),
+            CollectionMode::ReFungible(_) => ensure!(<ReFungibleItemList<T>>::contains_key(collection_id, item_id), "Item does not exists"),
+            CollectionMode::Fungible(_) => ensure!(<FungibleItemList<T>>::contains_key(collection_id, item_id), "Item does not exists"),
+            _ => ()
+        };
+        
+        Ok(())
+    }
+
+    fn set_re_fungible_variable_data(
+        collection_id: u64,
+        item_id: u64,
+        data: Vec<u8>
+    ) -> DispatchResult {
+        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);
+
+        item.variable_data = data;
+
+        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);
+
+        Ok(())
+    }
+
+    fn set_nft_variable_data(
+        collection_id: u64,
+        item_id: u64,
+        data: Vec<u8>
+    ) -> DispatchResult {
+        let mut item = <NftItemList<T>>::get(collection_id, item_id);
+        
+        item.variable_data = data;
 
+        <NftItemList<T>>::insert(collection_id, item_id, item);
+        
+        Ok(())
+    }
+
     fn init_collection(item: &CollectionType<T::AccountId>) {
         // check params
         assert!(
@@ -1804,7 +1986,7 @@
 
                 // sponsor timeout
                 let sponsor_transfer = match _collection_mode {
-                    CollectionMode::NFT(_) => {
+                    CollectionMode::NFT => {
                         let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);
                         let block_number = <system::Module<T>>::block_number() as T::BlockNumber;
                         let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();
@@ -1838,7 +2020,7 @@
                             true
                         }
                     }
-                    CollectionMode::ReFungible(_, _) => {
+                    CollectionMode::ReFungible(_) => {
                         let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);
                         let block_number = <system::Module<T>>::block_number() as T::BlockNumber;
                         let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();
modifiedpallets/nft/src/tests.rsdiffbeforeafterboth
1// Tests to be written here1// Tests to be written here
2use crate::mock::*;2use crate::mock::*;
3use crate::{AccessMode, ApprovePermissions, CollectionMode, Ownership, ChainLimits};3use crate::{AccessMode, ApprovePermissions, CollectionMode, Ownership, ChainLimits, CreateItemData, NftItemType, CreateNftData, CreateFungibleData, CreateReFungibleData};
4use frame_support::{assert_noop, assert_ok};4use frame_support::{assert_noop, assert_ok};
5use frame_system::{ RawOrigin };5use frame_system::{ RawOrigin };
66
7// Use cases tests region
8// #region
9#[test]
10fn create_nft_item() {7fn default_collection_numbers_limit() -> u64 {
11 new_test_ext().execute_with(|| {
12 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();8 10
13 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();9}
14 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
15 let mode: CollectionMode = CollectionMode::NFT(2000);
1610
17 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 11fn default_limits() {
12 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
18 collection_numbers_limit: 10,13 collection_numbers_limit: default_collection_numbers_limit(),
19 account_token_ownership_limit: 10,14 account_token_ownership_limit: 10,
20 collections_admins_limit: 5,15 collections_admins_limit: 5,
21 custom_data_limit: 2048,16 custom_data_limit: 2048,
22 nft_sponsor_transfer_timeout: 15,17 nft_sponsor_transfer_timeout: 15,
23 fungible_sponsor_transfer_timeout: 15,18 fungible_sponsor_transfer_timeout: 15,
24 refungible_sponsor_transfer_timeout: 15, 19 refungible_sponsor_transfer_timeout: 15,
25 }));20 }));
21}
2622
27 let origin1 = Origin::signed(1);23fn default_nft_data() -> CreateItemData {
24 CreateItemData::NFT(CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] })
25}
26
27fn default_fungible_data () -> CreateItemData {
28 CreateItemData::Fungible(CreateFungibleData { })
29}
30
31fn default_re_fungible_data () -> CreateItemData {
32 CreateItemData::ReFungible(CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] })
33}
34
35fn create_test_collection_for_owner(mode: &CollectionMode, owner: u64) -> u64 {
36 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
28 assert_ok!(TemplateModule::create_collection(37 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
38 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
39
40 let collection_id = TemplateModule::nextCollectionID();
41 let origin1 = Origin::signed(owner);
42 assert_ok!(TemplateModule::create_collection(
29 origin1.clone(),43 origin1.clone(),
30 col_name1.clone(),44 col_name1.clone(),
31 col_desc1.clone(),45 col_desc1.clone(),
32 token_prefix1.clone(),46 token_prefix1.clone(),
33 mode47 mode
34 ));48 ));
35 assert_eq!(TemplateModule::collection(1).owner, 1);49 assert_eq!(TemplateModule::collection(collection_id).owner, owner);
50 return collection_id;
51}
3652
37 assert_ok!(TemplateModule::create_item(53fn create_test_collection(mode: &CollectionMode) -> u64 {
54 return create_test_collection_for_owner(&mode, 1);
55}
56
57fn create_test_item(collection_id: u64, data: &CreateItemData) {
58 let origin1 = Origin::signed(1);
59 assert_ok!(TemplateModule::create_item(
38 origin1.clone(),60 origin1.clone(),
61 collection_id,
39 1,62 1,
40 [1, 2, 3].to_vec(),63 data.clone()
41 1
42 ));64 ));
65
66}
67
43 assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());68// Use cases tests region
69// #region
70#[test]
71fn create_nft_item() {
72 new_test_ext().execute_with(|| {
73 default_limits();
74 let collection_id = create_test_collection(&CollectionMode::NFT);
75
76 let data = default_nft_data();
77 create_test_item(collection_id, &data);
78 assert_eq!(TemplateModule::nft_item_id(collection_id, 1).const_data, data.const_data);
79 assert_eq!(TemplateModule::nft_item_id(collection_id, 1).variable_data, data.variable_data);
44 });80 });
45}81}
4682
47#[test]83#[test]
48fn create_refungible_item() {84fn create_refungible_item() {
49 new_test_ext().execute_with(|| {85 new_test_ext().execute_with(|| {
50 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();86 default_limits();
51 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();87 let collection_id = create_test_collection(&CollectionMode::ReFungible(3));
52 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
53 let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
5488
55 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 89 let data = default_re_fungible_data();
56 collection_numbers_limit: 10,
57 account_token_ownership_limit: 10,
58 collections_admins_limit: 5,
59 custom_data_limit: 2048,
60 nft_sponsor_transfer_timeout: 15,
61 fungible_sponsor_transfer_timeout: 15,
62 refungible_sponsor_transfer_timeout: 15,
63 }));
64
65 let origin1 = Origin::signed(1);
66 assert_ok!(TemplateModule::create_collection(90 create_test_item(collection_id, &data);
67 origin1.clone(),
68 col_name1.clone(),
69 col_desc1.clone(),
70 token_prefix1.clone(),
71 mode
72 ));
73 assert_eq!(TemplateModule::collection(1).owner, 1);
74
75 assert_ok!(TemplateModule::create_item(
76 origin1.clone(),
77 1,
78 [1, 2, 3].to_vec(),
79 1
80 ));
81 assert_eq!(91 assert_eq!(
82 TemplateModule::refungible_item_id(1, 1).data,92 TemplateModule::refungible_item_id(collection_id, 1).const_data,
83 [1, 2, 3].to_vec()93 data.const_data
84 );94 );
85 assert_eq!(95 assert_eq!(
86 TemplateModule::refungible_item_id(1, 1).owner[0],96 TemplateModule::refungible_item_id(collection_id, 1).variable_data,
97 data.variable_data
98 );
99 assert_eq!(
100 TemplateModule::refungible_item_id(collection_id, 1).owner[0],
87 Ownership {101 Ownership {
88 owner: 1,102 owner: 1,
89 fraction: 1000103 fraction: 1000
95#[test]109#[test]
96fn create_fungible_item() {110fn create_fungible_item() {
97 new_test_ext().execute_with(|| {111 new_test_ext().execute_with(|| {
98 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();112 let collection_id = create_test_collection(&CollectionMode::Fungible(3));
99 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
100 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
101 let mode: CollectionMode = CollectionMode::Fungible(3);
102113
103 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 114 let data = default_fungible_data();
104 collection_numbers_limit: 10,115 create_test_item(collection_id, &data);
105 account_token_ownership_limit: 10,
106 collections_admins_limit: 5,
107 custom_data_limit: 2048,
108 nft_sponsor_transfer_timeout: 15,
109 fungible_sponsor_transfer_timeout: 15,
110 refungible_sponsor_transfer_timeout: 15,
111 }));
112116
113 let origin1 = Origin::signed(1);117 assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).owner, 1);
114 assert_ok!(TemplateModule::create_collection(
115 origin1.clone(),
116 col_name1.clone(),
117 col_desc1.clone(),
118 token_prefix1.clone(),
119 mode
120 ));
121 assert_eq!(TemplateModule::collection(1).owner, 1);
122
123 assert_ok!(TemplateModule::create_item(
124 origin1.clone(),
125 1,
126 [].to_vec(),
127 1
128 ));
129 assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
130 assert_eq!(TemplateModule::balance_count(1, 1), 1000);118 assert_eq!(TemplateModule::balance_count(1, 1), 1000);
131 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);119 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
132 });120 });
135#[test]123#[test]
136fn transfer_fungible_item() {124fn transfer_fungible_item() {
137 new_test_ext().execute_with(|| {125 new_test_ext().execute_with(|| {
138 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();126 default_limits();
139 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();127
140 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();128 let collection_id = create_test_collection(&CollectionMode::Fungible(3));
141 let mode: CollectionMode = CollectionMode::Fungible(3);
142129
143 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
144 collection_numbers_limit: 10,
145 account_token_ownership_limit: 10,
146 collections_admins_limit: 5,
147 custom_data_limit: 2048,
148 nft_sponsor_transfer_timeout: 15,
149 fungible_sponsor_transfer_timeout: 15,
150 refungible_sponsor_transfer_timeout: 15,
151 }));
152
153 let origin1 = Origin::signed(1);130 let origin1 = Origin::signed(1);
154 let origin2 = Origin::signed(2);131 let origin2 = Origin::signed(2);
155 assert_ok!(TemplateModule::create_collection(
156 origin1.clone(),
157 col_name1.clone(),
158 col_desc1.clone(),
159 token_prefix1.clone(),
160 mode
161 ));
162 assert_eq!(TemplateModule::collection(1).owner, 1);
163132
164 assert_ok!(TemplateModule::create_item(133 let data = default_fungible_data();
165 origin1.clone(),
166 1,134 create_test_item(collection_id, &data);
167 [].to_vec(),135
168 1
169 ));
170 assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);136 assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
171 assert_eq!(TemplateModule::balance_count(1, 1), 1000);137 assert_eq!(TemplateModule::balance_count(1, 1), 1000);
172 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);138 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
203#[test]169#[test]
204fn transfer_refungible_item() {170fn transfer_refungible_item() {
205 new_test_ext().execute_with(|| {171 new_test_ext().execute_with(|| {
206 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();172 default_limits();
207 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();173
208 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();174 let collection_id = create_test_collection(&CollectionMode::ReFungible(3));
209 let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
210175
211 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 176 let data = default_re_fungible_data();
212 collection_numbers_limit: 10,177 create_test_item(collection_id, &data);
213 account_token_ownership_limit: 10,
214 collections_admins_limit: 5,
215 custom_data_limit: 2048,
216 nft_sponsor_transfer_timeout: 15,
217 fungible_sponsor_transfer_timeout: 15,
218 refungible_sponsor_transfer_timeout: 15,
219 }));
220178
221 let origin1 = Origin::signed(1);179 let origin1 = Origin::signed(1);
222 let origin2 = Origin::signed(2);180 let origin2 = Origin::signed(2);
223 assert_ok!(TemplateModule::create_collection(
224 origin1.clone(),
225 col_name1.clone(),
226 col_desc1.clone(),
227 token_prefix1.clone(),
228 mode
229 ));
230 assert_eq!(TemplateModule::collection(1).owner, 1);
231
232 assert_ok!(TemplateModule::create_item(
233 origin1.clone(),
234 1,
235 [1, 2, 3].to_vec(),
236 1
237 ));
238 assert_eq!(181 assert_eq!(
239 TemplateModule::refungible_item_id(1, 1).data,182 TemplateModule::refungible_item_id(collection_id, 1).const_data,
240 [1, 2, 3].to_vec()183 data.const_data
241 );184 );
242 assert_eq!(185 assert_eq!(
243 TemplateModule::refungible_item_id(1, 1).owner[0],186 TemplateModule::refungible_item_id(collection_id, 1).variable_data,
187 data.variable_data
188 );
189 assert_eq!(
190 TemplateModule::refungible_item_id(collection_id, 1).owner[0],
244 Ownership {191 Ownership {
245 owner: 1,192 owner: 1,
246 fraction: 1000193 fraction: 1000
310#[test]257#[test]
311fn transfer_nft_item() {258fn transfer_nft_item() {
312 new_test_ext().execute_with(|| {259 new_test_ext().execute_with(|| {
313 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();260 default_limits();
314 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();261
315 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();262 let collection_id = create_test_collection(&CollectionMode::NFT);
316 let mode: CollectionMode = CollectionMode::NFT(2000);
317263
318 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 264 let data = default_nft_data();
319 collection_numbers_limit: 10,
320 account_token_ownership_limit: 10,
321 collections_admins_limit: 5,
322 custom_data_limit: 2048,
323 nft_sponsor_transfer_timeout: 15,
324 fungible_sponsor_transfer_timeout: 15,
325 refungible_sponsor_transfer_timeout: 15,
326 }));
327
328 let origin1 = Origin::signed(1);
329 assert_ok!(TemplateModule::create_collection(265 create_test_item(collection_id, &data);
330 origin1.clone(),
331 col_name1.clone(),
332 col_desc1.clone(),
333 token_prefix1.clone(),
334 mode
335 ));
336 assert_eq!(TemplateModule::collection(1).owner, 1);
337
338 assert_ok!(TemplateModule::create_item(
339 origin1.clone(),
340 1,
341 [1, 2, 3].to_vec(),
342 1
343 ));
344 assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
345 assert_eq!(TemplateModule::balance_count(1, 1), 1);266 assert_eq!(TemplateModule::balance_count(1, 1), 1);
346 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);267 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
347268
358#[test]279#[test]
359fn nft_approve_and_transfer_from() {280fn nft_approve_and_transfer_from() {
360 new_test_ext().execute_with(|| {281 new_test_ext().execute_with(|| {
361 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();282 default_limits();
362 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();283
363 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();284 let collection_id = create_test_collection(&CollectionMode::NFT);
364 let mode: CollectionMode = CollectionMode::NFT(2000);
365285
366 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 286 let data = default_nft_data();
367 collection_numbers_limit: 10,287 create_test_item(collection_id, &data);
368 account_token_ownership_limit: 10,
369 collections_admins_limit: 5,
370 custom_data_limit: 2048,
371 nft_sponsor_transfer_timeout: 15,
372 fungible_sponsor_transfer_timeout: 15,
373 refungible_sponsor_transfer_timeout: 15,
374 }));
375288
376 let origin1 = Origin::signed(1);289 let origin1 = Origin::signed(1);
377 let origin2 = Origin::signed(2);290 let origin2 = Origin::signed(2);
378 assert_ok!(TemplateModule::create_collection(
379 origin1.clone(),
380 col_name1.clone(),
381 col_desc1.clone(),
382 token_prefix1.clone(),
383 mode
384 ));
385 assert_eq!(TemplateModule::collection(1).owner, 1);
386291
387 assert_ok!(TemplateModule::create_item(
388 origin1.clone(),
389 1,
390 [1, 2, 3].to_vec(),
391 1
392 ));
393 assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
394 assert_eq!(TemplateModule::balance_count(1, 1), 1);292 assert_eq!(TemplateModule::balance_count(1, 1), 1);
395 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);293 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
396294
436#[test]334#[test]
437fn refungible_approve_and_transfer_from() {335fn refungible_approve_and_transfer_from() {
438 new_test_ext().execute_with(|| {336 new_test_ext().execute_with(|| {
439 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();337 default_limits();
440 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();338
441 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();339 let collection_id = create_test_collection(&CollectionMode::ReFungible(3));
442 let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
443
444 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 340
445 collection_numbers_limit: 10,
446 account_token_ownership_limit: 10,
447 collections_admins_limit: 5,
448 custom_data_limit: 2048,
449 nft_sponsor_transfer_timeout: 15,
450 fungible_sponsor_transfer_timeout: 15,
451 refungible_sponsor_transfer_timeout: 15,
452 }));
453
454 let origin1 = Origin::signed(1);341 let origin1 = Origin::signed(1);
455 let origin2 = Origin::signed(2);342 let origin2 = Origin::signed(2);
456 assert_ok!(TemplateModule::create_collection(
457 origin1.clone(),
458 col_name1.clone(),
459 col_desc1.clone(),
460 token_prefix1.clone(),
461 mode
462 ));
463 assert_eq!(TemplateModule::collection(1).owner, 1);
464343
465 assert_ok!(TemplateModule::create_item(344 let data = default_re_fungible_data();
466 origin1.clone(),
467 1,
468 [1, 2, 3].to_vec(),
469 1
470 ));
471 assert_eq!(345 create_test_item(collection_id, &data);
472 TemplateModule::refungible_item_id(1, 1).data,346
473 [1, 2, 3].to_vec()
474 );
475 assert_eq!(
476 TemplateModule::refungible_item_id(1, 1).owner[0],
477 Ownership {
478 owner: 1,
479 fraction: 1000
480 }
481 );
482 assert_eq!(TemplateModule::balance_count(1, 1), 1000);347 assert_eq!(TemplateModule::balance_count(1, 1), 1000);
483 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);348 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
484349
536#[test]401#[test]
537fn fungible_approve_and_transfer_from() {402fn fungible_approve_and_transfer_from() {
538 new_test_ext().execute_with(|| {403 new_test_ext().execute_with(|| {
539 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();404 default_limits();
405
540 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();406 let collection_id = create_test_collection(&CollectionMode::Fungible(3));
541 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();407
408 let data = default_fungible_data();
542 let mode: CollectionMode = CollectionMode::Fungible(3);409 create_test_item(collection_id, &data);
543410
544 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
545 collection_numbers_limit: 10,
546 account_token_ownership_limit: 10,
547 collections_admins_limit: 5,
548 custom_data_limit: 2048,
549 nft_sponsor_transfer_timeout: 15,
550 fungible_sponsor_transfer_timeout: 15,
551 refungible_sponsor_transfer_timeout: 15,
552 }));
553
554 let origin1 = Origin::signed(1);411 let origin1 = Origin::signed(1);
555 let origin2 = Origin::signed(2);412 let origin2 = Origin::signed(2);
556 assert_ok!(TemplateModule::create_collection(
557 origin1.clone(),
558 col_name1.clone(),
559 col_desc1.clone(),
560 token_prefix1.clone(),
561 mode
562 ));
563 assert_eq!(TemplateModule::collection(1).owner, 1);
564413
565 assert_ok!(TemplateModule::create_item(
566 origin1.clone(),
567 1,
568 [].to_vec(),
569 1
570 ));
571 assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
572 assert_eq!(TemplateModule::balance_count(1, 1), 1000);414 assert_eq!(TemplateModule::balance_count(1, 1), 1000);
573 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);415 assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
574416
642#[test]484#[test]
643fn change_collection_owner() {485fn change_collection_owner() {
644 new_test_ext().execute_with(|| {486 new_test_ext().execute_with(|| {
645 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();487 default_limits();
646 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();488
647 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();489 let collection_id = create_test_collection(&CollectionMode::NFT);
648 let mode: CollectionMode = CollectionMode::NFT(2000);
649
650 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 490
651 collection_numbers_limit: 10,
652 account_token_ownership_limit: 10,
653 collections_admins_limit: 5,
654 custom_data_limit: 2048,
655 nft_sponsor_transfer_timeout: 15,
656 fungible_sponsor_transfer_timeout: 15,
657 refungible_sponsor_transfer_timeout: 15,
658 }));
659
660 let origin1 = Origin::signed(1);491 let origin1 = Origin::signed(1);
661 assert_ok!(TemplateModule::create_collection(
662 origin1.clone(),
663 col_name1.clone(),
664 col_desc1.clone(),
665 token_prefix1.clone(),
666 mode
667 ));
668 assert_ok!(TemplateModule::change_collection_owner(492 assert_ok!(TemplateModule::change_collection_owner(
669 origin1.clone(),493 origin1.clone(),
670 1,494 collection_id,
671 2495 2
672 ));496 ));
673 assert_eq!(TemplateModule::collection(1).owner, 2);497 assert_eq!(TemplateModule::collection(collection_id).owner, 2);
674 });498 });
675}499}
676500
677#[test]501#[test]
678fn destroy_collection() {502fn destroy_collection() {
679 new_test_ext().execute_with(|| {503 new_test_ext().execute_with(|| {
680 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();504 default_limits();
681 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();505
682 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();506 let collection_id = create_test_collection(&CollectionMode::NFT);
683 let mode: CollectionMode = CollectionMode::NFT(2000);
684
685 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 507
686 collection_numbers_limit: 10,
687 account_token_ownership_limit: 10,
688 collections_admins_limit: 5,
689 custom_data_limit: 2048,
690 nft_sponsor_transfer_timeout: 15,
691 fungible_sponsor_transfer_timeout: 15,
692 refungible_sponsor_transfer_timeout: 15,
693 }));
694
695 let origin1 = Origin::signed(1);508 let origin1 = Origin::signed(1);
696 assert_ok!(TemplateModule::create_collection(509 assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));
697 origin1.clone(),
698 col_name1.clone(),
699 col_desc1.clone(),
700 token_prefix1.clone(),
701 mode
702 ));
703 assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
704 });510 });
705}511}
706512
707#[test]513#[test]
708fn burn_nft_item() {514fn burn_nft_item() {
709 new_test_ext().execute_with(|| {515 new_test_ext().execute_with(|| {
710 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();516 default_limits();
711 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();517
712 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();518 let collection_id = create_test_collection(&CollectionMode::NFT);
713 let mode: CollectionMode = CollectionMode::NFT(2000);
714519
715 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
716 collection_numbers_limit: 10,
717 account_token_ownership_limit: 10,
718 collections_admins_limit: 5,
719 custom_data_limit: 2048,
720 nft_sponsor_transfer_timeout: 15,
721 fungible_sponsor_transfer_timeout: 15,
722 refungible_sponsor_transfer_timeout: 15,
723 }));
724
725 let origin1 = Origin::signed(1);520 let origin1 = Origin::signed(1);
726 assert_ok!(TemplateModule::create_collection(521 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
727 origin1.clone(),
728 col_name1.clone(),
729 col_desc1.clone(),
730 token_prefix1.clone(),
731 mode
732 ));
733 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
734 assert_ok!(TemplateModule::create_item(522
735 origin1.clone(),523 let data = default_nft_data();
736 1,524 create_test_item(collection_id, &data);
737 [1, 2, 3].to_vec(),
738 1
739 ));
740525
741 assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
742
743 // check balance (collection with id = 1, user id = 1)526 // check balance (collection with id = 1, user id = 1)
744 assert_eq!(TemplateModule::balance_count(1, 1), 1);527 assert_eq!(TemplateModule::balance_count(1, 1), 1);
745528
757#[test]540#[test]
758fn burn_fungible_item() {541fn burn_fungible_item() {
759 new_test_ext().execute_with(|| {542 new_test_ext().execute_with(|| {
760 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();543 default_limits();
761 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();544
762 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();545 let collection_id = create_test_collection(&CollectionMode::Fungible(3));
763 let mode: CollectionMode = CollectionMode::Fungible(3);
764
765 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 546
766 collection_numbers_limit: 10,
767 account_token_ownership_limit: 10,
768 collections_admins_limit: 5,
769 custom_data_limit: 2048,
770 nft_sponsor_transfer_timeout: 15,
771 fungible_sponsor_transfer_timeout: 15,
772 refungible_sponsor_transfer_timeout: 15,
773 }));
774
775 let origin1 = Origin::signed(1);547 let origin1 = Origin::signed(1);
776 assert_ok!(TemplateModule::create_collection(548 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
777 origin1.clone(),
778 col_name1.clone(),
779 col_desc1.clone(),
780 token_prefix1.clone(),
781 mode
782 ));
783 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
784 assert_ok!(TemplateModule::create_item(549
785 origin1.clone(),550 let data = default_fungible_data();
786 1,551 create_test_item(collection_id, &data);
787 [].to_vec(),
788 1
789 ));
790552
791 // check balance (collection with id = 1, user id = 1)553 // check balance (collection with id = 1, user id = 1)
792 assert_eq!(TemplateModule::balance_count(1, 1), 1000);554 assert_eq!(TemplateModule::balance_count(1, 1), 1000);
805#[test]567#[test]
806fn burn_refungible_item() {568fn burn_refungible_item() {
807 new_test_ext().execute_with(|| {569 new_test_ext().execute_with(|| {
808 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();570 default_limits();
809 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();571
810 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();572 let collection_id = create_test_collection(&CollectionMode::ReFungible(3));
811 let mode: CollectionMode = CollectionMode::ReFungible(200, 3);
812
813 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
814 collection_numbers_limit: 10,
815 account_token_ownership_limit: 10,
816 collections_admins_limit: 5,
817 custom_data_limit: 2048,
818 nft_sponsor_transfer_timeout: 15,
819 fungible_sponsor_transfer_timeout: 15,
820 refungible_sponsor_transfer_timeout: 15,
821 }));
822
823 let origin1 = Origin::signed(1);573 let origin1 = Origin::signed(1);
824 let origin2 = Origin::signed(2);574 let origin2 = Origin::signed(2);
825 assert_ok!(TemplateModule::create_collection(
826 origin1.clone(),
827 col_name1.clone(),
828 col_desc1.clone(),
829 token_prefix1.clone(),
830 mode
831 ));
832575
833 assert_ok!(TemplateModule::set_mint_permission(576 assert_ok!(TemplateModule::set_mint_permission(
834 origin1.clone(),577 origin1.clone(),
835 1,578 collection_id,
836 true579 true
837 ));580 ));
838 assert_ok!(TemplateModule::set_public_access_mode(581 assert_ok!(TemplateModule::set_public_access_mode(
839 origin1.clone(),582 origin1.clone(),
840 1,583 collection_id,
841 AccessMode::WhiteList584 AccessMode::WhiteList
842 ));585 ));
843 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));586 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
844587
845 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));588 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
846 assert_ok!(TemplateModule::create_item(589
847 origin2.clone(),590 let data = default_re_fungible_data();
848 1,591 create_test_item(collection_id, &data);
849 [1, 2, 3].to_vec(),
850 1
851 ));
852592
853 assert_eq!(
854 TemplateModule::refungible_item_id(1, 1).data,
855 [1, 2, 3].to_vec()
856 );
857
858 // check balance (collection with id = 1, user id = 2)593 // check balance (collection with id = 1, user id = 2)
859 assert_eq!(TemplateModule::balance_count(1, 1), 1000);594 assert_eq!(TemplateModule::balance_count(1, 1), 1000);
860595
872#[test]607#[test]
873fn add_collection_admin() {608fn add_collection_admin() {
874 new_test_ext().execute_with(|| {609 new_test_ext().execute_with(|| {
875 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();610 default_limits();
876 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();611
877 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();612 let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1);
878 let mode: CollectionMode = CollectionMode::NFT(2000);
879
880 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 613 create_test_collection_for_owner(&CollectionMode::NFT, 2);
881 collection_numbers_limit: 10,614 create_test_collection_for_owner(&CollectionMode::NFT, 3);
882 account_token_ownership_limit: 10,
883 collections_admins_limit: 5,
884 custom_data_limit: 2048,615
885 nft_sponsor_transfer_timeout: 15,
886 fungible_sponsor_transfer_timeout: 15,
887 refungible_sponsor_transfer_timeout: 15,
888 }));
889
890 let origin1 = Origin::signed(1);616 let origin1 = Origin::signed(1);
891 let origin2 = Origin::signed(2);
892 let origin3 = Origin::signed(3);
893 assert_ok!(TemplateModule::create_collection(
894 origin1.clone(),
895 col_name1.clone(),
896 col_desc1.clone(),
897 token_prefix1.clone(),
898 mode.clone()
899 ));
900 assert_ok!(TemplateModule::create_collection(
901 origin2.clone(),
902 col_name1.clone(),
903 col_desc1.clone(),
904 token_prefix1.clone(),
905 mode.clone()
906 ));
907 assert_ok!(TemplateModule::create_collection(
908 origin3.clone(),
909 col_name1.clone(),
910 col_desc1.clone(),
911 token_prefix1.clone(),
912 mode.clone()
913 ));
914617
915 assert_eq!(TemplateModule::collection(1).owner, 1);
916 assert_eq!(TemplateModule::collection(2).owner, 2);
917 assert_eq!(TemplateModule::collection(3).owner, 3);
918
919 // collection admin618 // collection admin
920 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));619 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));
921 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));620 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));
922621
923 assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);622 assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&2), true);
924 assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);623 assert_eq!(TemplateModule::admin_list_collection(collection1_id).contains(&3), true);
925 });624 });
926}625}
927626
928#[test]627#[test]
929fn remove_collection_admin() {628fn remove_collection_admin() {
930 new_test_ext().execute_with(|| {629 new_test_ext().execute_with(|| {
931 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();630 default_limits();
631
932 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();632 let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1);
933 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();633 create_test_collection_for_owner(&CollectionMode::NFT, 2);
934 let mode: CollectionMode = CollectionMode::NFT(2000);634 create_test_collection_for_owner(&CollectionMode::NFT, 3);
935635
936 let origin1 = Origin::signed(1);636 let origin1 = Origin::signed(1);
937 let origin2 = Origin::signed(2);637 let origin2 = Origin::signed(2);
938 let origin3 = Origin::signed(3);
939638
940 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
941 collection_numbers_limit: 10,
942 account_token_ownership_limit: 10,
943 collections_admins_limit: 5,
944 custom_data_limit: 2048,
945 nft_sponsor_transfer_timeout: 15,
946 fungible_sponsor_transfer_timeout: 15,
947 refungible_sponsor_transfer_timeout: 15,
948 }));
949
950 assert_ok!(TemplateModule::create_collection(
951 origin1.clone(),
952 col_name1.clone(),
953 col_desc1.clone(),
954 token_prefix1.clone(),
955 mode.clone()
956 ));
957 assert_ok!(TemplateModule::create_collection(
958 origin2.clone(),
959 col_name1.clone(),
960 col_desc1.clone(),
961 token_prefix1.clone(),
962 mode.clone()
963 ));
964 assert_ok!(TemplateModule::create_collection(
965 origin3.clone(),
966 col_name1.clone(),
967 col_desc1.clone(),
968 token_prefix1.clone(),
969 mode.clone()
970 ));
971
972 assert_eq!(TemplateModule::collection(1).owner, 1);
973 assert_eq!(TemplateModule::collection(2).owner, 2);
974 assert_eq!(TemplateModule::collection(3).owner, 3);
975
976 // collection admin639 // collection admin
977 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));640 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 2));
978 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));641 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection1_id, 3));
979642
980 assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);643 assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);
981 assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);644 assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);
993#[test]656#[test]
994fn balance_of() {657fn balance_of() {
995 new_test_ext().execute_with(|| {658 new_test_ext().execute_with(|| {
996 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();659 default_limits();
997 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();660
998 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();661 let nft_collection_id = create_test_collection(&CollectionMode::NFT);
999 let nft_mode: CollectionMode = CollectionMode::NFT(2000);662 let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3));
1000 let furg_mode: CollectionMode = CollectionMode::Fungible(3);663 let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible(3));
1001 let refung_mode: CollectionMode = CollectionMode::ReFungible(2000, 3);664
1002
1003 let origin1 = Origin::signed(1);665 let origin1 = Origin::signed(1);
1004666
1005 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
1006 collection_numbers_limit: 10,
1007 account_token_ownership_limit: 10,
1008 collections_admins_limit: 5,
1009 custom_data_limit: 2048,
1010 nft_sponsor_transfer_timeout: 15,
1011 fungible_sponsor_transfer_timeout: 15,
1012 refungible_sponsor_transfer_timeout: 15,
1013 }));
1014
1015 assert_ok!(TemplateModule::create_collection(
1016 origin1.clone(),
1017 col_name1.clone(),
1018 col_desc1.clone(),
1019 token_prefix1.clone(),
1020 nft_mode.clone()
1021 ));
1022 assert_ok!(TemplateModule::create_collection(
1023 origin1.clone(),
1024 col_name1.clone(),
1025 col_desc1.clone(),
1026 token_prefix1.clone(),
1027 furg_mode.clone()
1028 ));
1029 assert_ok!(TemplateModule::create_collection(
1030 origin1.clone(),
1031 col_name1.clone(),
1032 col_desc1.clone(),
1033 token_prefix1.clone(),
1034 refung_mode.clone()
1035 ));
1036
1037 assert_eq!(TemplateModule::collection(1).owner, 1);
1038 assert_eq!(TemplateModule::collection(2).owner, 1);
1039 assert_eq!(TemplateModule::collection(3).owner, 1);
1040
1041 // check balance before667 // check balance before
1042 assert_eq!(TemplateModule::balance_count(1, 1), 0);668 assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 0);
1043 assert_eq!(TemplateModule::balance_count(2, 1), 0);669 assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 0);
1044 assert_eq!(TemplateModule::balance_count(3, 1), 0);670 assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 0);
1045671
1046 // create item672 let nft_data = default_nft_data();
1047 assert_ok!(TemplateModule::create_item(673 create_test_item(nft_collection_id, &nft_data);
1048 origin1.clone(),674
1049 1,675 let fungible_data = default_fungible_data();
1050 [1, 1, 1].to_vec(),676 create_test_item(fungible_collection_id, &fungible_data);
677
1051 1678 let re_fungible_data = default_re_fungible_data();
1052 ));679 create_test_item(re_fungible_collection_id, &re_fungible_data);
1053680
1054 assert_ok!(TemplateModule::create_item(
1055 origin1.clone(),
1056 2,
1057 [].to_vec(),
1058 1
1059 ));
1060
1061 assert_ok!(TemplateModule::create_item(
1062 origin1.clone(),
1063 3,
1064 [1, 1, 1].to_vec(),
1065 1
1066 ));
1067
1068 // check balance (collection with id = 1, user id = 1)681 // check balance (collection with id = 1, user id = 1)
1069 assert_eq!(TemplateModule::balance_count(1, 1), 1);682 assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);
1070 assert_eq!(TemplateModule::balance_count(2, 1), 1000);683 assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);
1071 assert_eq!(TemplateModule::balance_count(3, 1), 1000);684 assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);
1072 assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 1);685 assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);
1073 assert_eq!(TemplateModule::fungible_item_id(2, 1).owner, 1);686 assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);
1074 assert_eq!(TemplateModule::refungible_item_id(3, 1).owner[0].owner, 1);687 assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);
1075 });688 });
1076}689}
1077690
1078#[test]691#[test]
1079fn approve() {692fn approve() {
1080 new_test_ext().execute_with(|| {693 new_test_ext().execute_with(|| {
1081 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();694 default_limits();
695
1082 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();696 let collection_id = create_test_collection(&CollectionMode::NFT);
1083 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();697
1084 let nft_mode: CollectionMode = CollectionMode::NFT(2000);698 let data = default_nft_data();
1085 let origin1 = Origin::signed(1);699 create_test_item(collection_id, &data);
1086700
1087 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 701 let origin1 = Origin::signed(1);
1088 collection_numbers_limit: 10,
1089 account_token_ownership_limit: 10,
1090 collections_admins_limit: 5,
1091 custom_data_limit: 2048,
1092 nft_sponsor_transfer_timeout: 15,
1093 fungible_sponsor_transfer_timeout: 15,
1094 refungible_sponsor_transfer_timeout: 15,
1095 }));
1096
1097 assert_ok!(TemplateModule::create_collection(
1098 origin1.clone(),
1099 col_name1.clone(),
1100 col_desc1.clone(),
1101 token_prefix1.clone(),
1102 nft_mode.clone()
1103 ));
1104
1105 assert_eq!(TemplateModule::collection(1).owner, 1);
1106
1107 // create item702
1108 assert_ok!(TemplateModule::create_item(
1109 origin1.clone(),
1110 1,
1111 [1, 1, 1].to_vec(),
1112 1
1113 ));
1114
1115 // approve703 // approve
1116 assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));704 assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
1121#[test]709#[test]
1122fn transfer_from() {710fn transfer_from() {
1123 new_test_ext().execute_with(|| {711 new_test_ext().execute_with(|| {
1124 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();712 default_limits();
1125 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();713
1126 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();714 let collection_id = create_test_collection(&CollectionMode::NFT);
1127 let mode: CollectionMode = CollectionMode::NFT(2000);
1128 let origin1 = Origin::signed(1);715 let origin1 = Origin::signed(1);
1129 let origin2 = Origin::signed(2);716 let origin2 = Origin::signed(2);
1130717
1131 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 718 let data = default_nft_data();
1132 collection_numbers_limit: 10,719 create_test_item(collection_id, &data);
1133 account_token_ownership_limit: 10,
1134 collections_admins_limit: 5,
1135 custom_data_limit: 2048,
1136 nft_sponsor_transfer_timeout: 15,
1137 fungible_sponsor_transfer_timeout: 15,
1138 refungible_sponsor_transfer_timeout: 15,
1139 }));
1140720
1141 assert_ok!(TemplateModule::create_collection(
1142 origin1.clone(),
1143 col_name1.clone(),
1144 col_desc1.clone(),
1145 token_prefix1.clone(),
1146 mode
1147 ));
1148
1149 assert_eq!(TemplateModule::collection(1).owner, 1);
1150
1151 // create item
1152 assert_ok!(TemplateModule::create_item(
1153 origin1.clone(),
1154 1,
1155 [1, 1, 1].to_vec(),
1156 1
1157 ));
1158
1159 // approve721 // approve
1160 assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));722 assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
1161 assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);723 assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);
1197#[test]759#[test]
1198fn owner_can_add_address_to_white_list() {760fn owner_can_add_address_to_white_list() {
1199 new_test_ext().execute_with(|| {761 new_test_ext().execute_with(|| {
1200 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();762 default_limits();
1201 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();763
1202 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();764 let collection_id = create_test_collection(&CollectionMode::NFT);
1203 let mode: CollectionMode = CollectionMode::NFT(2000);
1204 let origin1 = Origin::signed(1);
1205765
1206 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 766 let origin1 = Origin::signed(1);
1207 collection_numbers_limit: 10,
1208 account_token_ownership_limit: 10,
1209 collections_admins_limit: 5,
1210 custom_data_limit: 2048,
1211 nft_sponsor_transfer_timeout: 15,
1212 fungible_sponsor_transfer_timeout: 15,
1213 refungible_sponsor_transfer_timeout: 15,
1214 }));
1215
1216 assert_ok!(TemplateModule::create_collection(
1217 origin1.clone(),
1218 col_name1.clone(),
1219 col_desc1.clone(),
1220 token_prefix1.clone(),
1221 mode
1222 ));
1223
1224 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));767 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
1225 assert_eq!(TemplateModule::white_list(1)[0], 2);768 assert_eq!(TemplateModule::white_list(collection_id)[0], 2);
1226 });769 });
1227}770}
1228771
1229#[test]772#[test]
1230fn admin_can_add_address_to_white_list() {773fn admin_can_add_address_to_white_list() {
1231 new_test_ext().execute_with(|| {774 new_test_ext().execute_with(|| {
1232 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();775 default_limits();
1233 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();776
1234 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();777 let collection_id = create_test_collection(&CollectionMode::NFT);
1235 let mode: CollectionMode = CollectionMode::NFT(2000);
1236 let origin1 = Origin::signed(1);778 let origin1 = Origin::signed(1);
1237 let origin2 = Origin::signed(2);779 let origin2 = Origin::signed(2);
1238780
1239 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 781 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
1240 collection_numbers_limit: 10,
1241 account_token_ownership_limit: 10,
1242 collections_admins_limit: 5,
1243 custom_data_limit: 2048,
1244 nft_sponsor_transfer_timeout: 15,
1245 fungible_sponsor_transfer_timeout: 15,
1246 refungible_sponsor_transfer_timeout: 15,
1247 }));
1248
1249 assert_ok!(TemplateModule::create_collection(
1250 origin1.clone(),
1251 col_name1.clone(),
1252 col_desc1.clone(),
1253 token_prefix1.clone(),
1254 mode
1255 ));
1256
1257 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
1258 assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), 1, 3));782 assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));
1259 assert_eq!(TemplateModule::white_list(1)[0], 3);783 assert_eq!(TemplateModule::white_list(collection_id)[0], 3);
1260 });784 });
1261}785}
1262786
1263#[test]787#[test]
1264fn nonprivileged_user_cannot_add_address_to_white_list() {788fn nonprivileged_user_cannot_add_address_to_white_list() {
1265 new_test_ext().execute_with(|| {789 new_test_ext().execute_with(|| {
1266 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();790 default_limits();
1267 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();791
1268 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();792 let collection_id = create_test_collection(&CollectionMode::NFT);
1269 let mode: CollectionMode = CollectionMode::NFT(2000);
1270 let origin1 = Origin::signed(1);
1271 let origin2 = Origin::signed(2);
1272793
1273 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 794 let origin2 = Origin::signed(2);
1274 collection_numbers_limit: 10,
1275 account_token_ownership_limit: 10,
1276 collections_admins_limit: 5,
1277 custom_data_limit: 2048,
1278 nft_sponsor_transfer_timeout: 15,
1279 fungible_sponsor_transfer_timeout: 15,
1280 refungible_sponsor_transfer_timeout: 15,
1281 }));
1282
1283 assert_ok!(TemplateModule::create_collection(
1284 origin1.clone(),
1285 col_name1.clone(),
1286 col_desc1.clone(),
1287 token_prefix1.clone(),
1288 mode
1289 ));
1290
1291 assert_noop!(795 assert_noop!(
1292 TemplateModule::add_to_white_list(origin2.clone(), 1, 3),796 TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3),
1293 "You do not have permissions to modify this collection"797 "You do not have permissions to modify this collection"
1294 );798 );
1295 });799 });
1298#[test]802#[test]
1299fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {803fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {
1300 new_test_ext().execute_with(|| {804 new_test_ext().execute_with(|| {
805 default_limits();
806
1301 let origin1 = Origin::signed(1);807 let origin1 = Origin::signed(1);
1302808
1303 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
1304 collection_numbers_limit: 10,
1305 account_token_ownership_limit: 10,
1306 collections_admins_limit: 5,
1307 custom_data_limit: 2048,
1308 nft_sponsor_transfer_timeout: 15,
1309 fungible_sponsor_transfer_timeout: 15,
1310 refungible_sponsor_transfer_timeout: 15,
1311 }));
1312
1313 assert_noop!(809 assert_noop!(
1314 TemplateModule::add_to_white_list(origin1.clone(), 1, 2),810 TemplateModule::add_to_white_list(origin1.clone(), 1, 2),
1315 "This collection does not exist"811 "This collection does not exist"
1320#[test]816#[test]
1321fn nobody_can_add_address_to_white_list_of_deleted_collection() {817fn nobody_can_add_address_to_white_list_of_deleted_collection() {
1322 new_test_ext().execute_with(|| {818 new_test_ext().execute_with(|| {
1323 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();819 default_limits();
1324 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();820
1325 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();821 let collection_id = create_test_collection(&CollectionMode::NFT);
1326 let mode: CollectionMode = CollectionMode::NFT(2000);
1327 let origin1 = Origin::signed(1);
1328822
1329 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 823 assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));
1330 collection_numbers_limit: 10,
1331 account_token_ownership_limit: 10,
1332 collections_admins_limit: 5,
1333 custom_data_limit: 2048,
1334 nft_sponsor_transfer_timeout: 15,
1335 fungible_sponsor_transfer_timeout: 15,
1336 refungible_sponsor_transfer_timeout: 15,
1337 }));
1338
1339 assert_ok!(TemplateModule::create_collection(
1340 origin1.clone(),
1341 col_name1.clone(),
1342 col_desc1.clone(),
1343 token_prefix1.clone(),
1344 mode
1345 ));
1346
1347 assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
1348 assert_noop!(824 assert_noop!(
1349 TemplateModule::add_to_white_list(origin1.clone(), 1, 2),825 TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2),
1350 "This collection does not exist"826 "This collection does not exist"
1351 );827 );
1352 });828 });
1356#[test]832#[test]
1357fn address_is_already_added_to_white_list() {833fn address_is_already_added_to_white_list() {
1358 new_test_ext().execute_with(|| {834 new_test_ext().execute_with(|| {
1359 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();835 default_limits();
1360 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();836
1361 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();837 let collection_id = create_test_collection(&CollectionMode::NFT);
1362 let mode: CollectionMode = CollectionMode::NFT(2000);
1363 let origin1 = Origin::signed(1);838 let origin1 = Origin::signed(1);
1364
1365 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 839
1366 collection_numbers_limit: 10,840 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
1367 account_token_ownership_limit: 10,
1368 collections_admins_limit: 5,
1369 custom_data_limit: 2048,
1370 nft_sponsor_transfer_timeout: 15,
1371 fungible_sponsor_transfer_timeout: 15,
1372 refungible_sponsor_transfer_timeout: 15,
1373 }));
1374
1375 assert_ok!(TemplateModule::create_collection(
1376 origin1.clone(),
1377 col_name1.clone(),
1378 col_desc1.clone(),
1379 token_prefix1.clone(),
1380 mode
1381 ));
1382
1383 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1384 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));841 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
1385 assert_eq!(TemplateModule::white_list(1)[0], 2);842 assert_eq!(TemplateModule::white_list(collection_id)[0], 2);
1386 assert_eq!(TemplateModule::white_list(1).len(), 1);843 assert_eq!(TemplateModule::white_list(collection_id).len(), 1);
1387 });844 });
1388}845}
1389846
1390#[test]847#[test]
1391fn owner_can_remove_address_from_white_list() {848fn owner_can_remove_address_from_white_list() {
1392 new_test_ext().execute_with(|| {849 new_test_ext().execute_with(|| {
1393 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();850 default_limits();
1394 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();851
1395 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();852 let collection_id = create_test_collection(&CollectionMode::NFT);
1396 let mode: CollectionMode = CollectionMode::NFT(2000);
1397 let origin1 = Origin::signed(1);
1398853
1399 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 854 let origin1 = Origin::signed(1);
1400 collection_numbers_limit: 10,
1401 account_token_ownership_limit: 10,
1402 collections_admins_limit: 5,
1403 custom_data_limit: 2048,
1404 nft_sponsor_transfer_timeout: 15,
1405 fungible_sponsor_transfer_timeout: 15,
1406 refungible_sponsor_transfer_timeout: 15,
1407 }));
1408
1409 assert_ok!(TemplateModule::create_collection(
1410 origin1.clone(),
1411 col_name1.clone(),
1412 col_desc1.clone(),
1413 token_prefix1.clone(),
1414 mode
1415 ));
1416
1417 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));855 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
1418 assert_ok!(TemplateModule::remove_from_white_list(856 assert_ok!(TemplateModule::remove_from_white_list(
1419 origin1.clone(),857 origin1.clone(),
1420 1,858 collection_id,
1421 2859 2
1422 ));860 ));
1423 assert_eq!(TemplateModule::white_list(1).len(), 0);861 assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
1424 });862 });
1425}863}
1426864
1427#[test]865#[test]
1428fn admin_can_remove_address_from_white_list() {866fn admin_can_remove_address_from_white_list() {
1429 new_test_ext().execute_with(|| {867 new_test_ext().execute_with(|| {
1430 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();868 default_limits();
1431 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();869
1432 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();870 let collection_id = create_test_collection(&CollectionMode::NFT);
1433 let mode: CollectionMode = CollectionMode::NFT(2000);
1434 let origin1 = Origin::signed(1);871 let origin1 = Origin::signed(1);
1435 let origin2 = Origin::signed(2);872 let origin2 = Origin::signed(2);
1436873
1437 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 874 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
1438 collection_numbers_limit: 10,
1439 account_token_ownership_limit: 10,
1440 collections_admins_limit: 5,
1441 custom_data_limit: 2048,
1442 nft_sponsor_transfer_timeout: 15,
1443 fungible_sponsor_transfer_timeout: 15,
1444 refungible_sponsor_transfer_timeout: 15,
1445 }));
1446875
1447 assert_ok!(TemplateModule::create_collection(876 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 3));
1448 origin1.clone(),
1449 col_name1.clone(),
1450 col_desc1.clone(),
1451 token_prefix1.clone(),
1452 mode
1453 ));
1454
1455 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
1456
1457 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
1458 assert_ok!(TemplateModule::remove_from_white_list(877 assert_ok!(TemplateModule::remove_from_white_list(
1459 origin2.clone(),878 origin2.clone(),
1460 1,879 collection_id,
1461 3880 3
1462 ));881 ));
1463 assert_eq!(TemplateModule::white_list(1).len(), 0);882 assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
1464 });883 });
1465}884}
1466885
1467#[test]886#[test]
1468fn nonprivileged_user_cannot_remove_address_from_white_list() {887fn nonprivileged_user_cannot_remove_address_from_white_list() {
1469 new_test_ext().execute_with(|| {888 new_test_ext().execute_with(|| {
1470 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();889 default_limits();
1471 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();890
1472 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();891 let collection_id = create_test_collection(&CollectionMode::NFT);
1473 let mode: CollectionMode = CollectionMode::NFT(2000);
1474 let origin1 = Origin::signed(1);892 let origin1 = Origin::signed(1);
1475 let origin2 = Origin::signed(2);893 let origin2 = Origin::signed(2);
1476894
1477 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 895 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
1478 collection_numbers_limit: 10,
1479 account_token_ownership_limit: 10,
1480 collections_admins_limit: 5,
1481 custom_data_limit: 2048,
1482 nft_sponsor_transfer_timeout: 15,
1483 fungible_sponsor_transfer_timeout: 15,
1484 refungible_sponsor_transfer_timeout: 15,
1485 }));
1486
1487 assert_ok!(TemplateModule::create_collection(
1488 origin1.clone(),
1489 col_name1.clone(),
1490 col_desc1.clone(),
1491 token_prefix1.clone(),
1492 mode
1493 ));
1494
1495 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1496 assert_noop!(896 assert_noop!(
1497 TemplateModule::remove_from_white_list(origin2.clone(), 1, 2),897 TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),
1498 "You do not have permissions to modify this collection"898 "You do not have permissions to modify this collection"
1499 );899 );
1500 assert_eq!(TemplateModule::white_list(1)[0], 2);900 assert_eq!(TemplateModule::white_list(collection_id)[0], 2);
1501 });901 });
1502}902}
1503903
1504#[test]904#[test]
1505fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {905fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {
1506 new_test_ext().execute_with(|| {906 new_test_ext().execute_with(|| {
907 default_limits();
1507 let origin1 = Origin::signed(1);908 let origin1 = Origin::signed(1);
1508909
1509 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
1510 collection_numbers_limit: 10,
1511 account_token_ownership_limit: 10,
1512 collections_admins_limit: 5,
1513 custom_data_limit: 2048,
1514 nft_sponsor_transfer_timeout: 15,
1515 fungible_sponsor_transfer_timeout: 15,
1516 refungible_sponsor_transfer_timeout: 15,
1517 }));
1518
1519 assert_noop!(910 assert_noop!(
1520 TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),911 TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),
1521 "This collection does not exist"912 "This collection does not exist"
1526#[test]917#[test]
1527fn nobody_can_remove_address_from_white_list_of_deleted_collection() {918fn nobody_can_remove_address_from_white_list_of_deleted_collection() {
1528 new_test_ext().execute_with(|| {919 new_test_ext().execute_with(|| {
1529 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();920 default_limits();
1530 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();921
1531 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();922 let collection_id = create_test_collection(&CollectionMode::NFT);
1532 let mode: CollectionMode = CollectionMode::NFT(2000);
1533 let origin1 = Origin::signed(1);923 let origin1 = Origin::signed(1);
1534 let origin2 = Origin::signed(2);924 let origin2 = Origin::signed(2);
1535925
1536 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 926 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
1537 collection_numbers_limit: 10,
1538 account_token_ownership_limit: 10,
1539 collections_admins_limit: 5,
1540 custom_data_limit: 2048,
1541 nft_sponsor_transfer_timeout: 15,
1542 fungible_sponsor_transfer_timeout: 15,
1543 refungible_sponsor_transfer_timeout: 15,
1544 }));
1545
1546 assert_ok!(TemplateModule::create_collection(
1547 origin1.clone(),
1548 col_name1.clone(),
1549 col_desc1.clone(),
1550 token_prefix1.clone(),
1551 mode
1552 ));
1553
1554 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1555 assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));927 assert_ok!(TemplateModule::destroy_collection(origin1.clone(), collection_id));
1556 assert_noop!(928 assert_noop!(
1557 TemplateModule::remove_from_white_list(origin2.clone(), 1, 2),929 TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),
1558 "This collection does not exist"930 "This collection does not exist"
1559 );931 );
1560 assert_eq!(TemplateModule::white_list(1).len(), 0);932 assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
1561 });933 });
1562}934}
1563935
1564// If address is already removed from white list, nothing happens936// If address is already removed from white list, nothing happens
1565#[test]937#[test]
1566fn address_is_already_removed_from_white_list() {938fn address_is_already_removed_from_white_list() {
1567 new_test_ext().execute_with(|| {939 new_test_ext().execute_with(|| {
1568 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();940 default_limits();
1569 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();941
1570 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();942 let collection_id = create_test_collection(&CollectionMode::NFT);
1571 let mode: CollectionMode = CollectionMode::NFT(2000);
1572 let origin1 = Origin::signed(1);943 let origin1 = Origin::signed(1);
1573944
1574 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 945 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
1575 collection_numbers_limit: 10,
1576 account_token_ownership_limit: 10,
1577 collections_admins_limit: 5,
1578 custom_data_limit: 2048,
1579 nft_sponsor_transfer_timeout: 15,
1580 fungible_sponsor_transfer_timeout: 15,
1581 refungible_sponsor_transfer_timeout: 15,
1582 }));
1583
1584 assert_ok!(TemplateModule::create_collection(
1585 origin1.clone(),
1586 col_name1.clone(),
1587 col_desc1.clone(),
1588 token_prefix1.clone(),
1589 mode
1590 ));
1591
1592 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1593 assert_ok!(TemplateModule::remove_from_white_list(946 assert_ok!(TemplateModule::remove_from_white_list(
1594 origin1.clone(),947 origin1.clone(),
1595 1,948 collection_id,
1596 2949 2
1597 ));950 ));
1598 assert_ok!(TemplateModule::remove_from_white_list(951 assert_ok!(TemplateModule::remove_from_white_list(
1599 origin1.clone(),952 origin1.clone(),
1600 1,953 collection_id,
1601 2954 2
1602 ));955 ));
1603 assert_eq!(TemplateModule::white_list(1).len(), 0);956 assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
1604 });957 });
1605}958}
1606959
1607// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)960// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)
1608#[test]961#[test]
1609fn white_list_test_1() {962fn white_list_test_1() {
1610 new_test_ext().execute_with(|| {963 new_test_ext().execute_with(|| {
1611 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();964 default_limits();
1612 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();965
1613 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();966 let collection_id = create_test_collection(&CollectionMode::NFT);
1614 let mode: CollectionMode = CollectionMode::NFT(2000);
1615967
1616 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
1617 collection_numbers_limit: 10,
1618 account_token_ownership_limit: 10,
1619 collections_admins_limit: 5,
1620 custom_data_limit: 2048,
1621 nft_sponsor_transfer_timeout: 15,
1622 fungible_sponsor_transfer_timeout: 15,
1623 refungible_sponsor_transfer_timeout: 15,
1624 }));
1625
1626 let origin1 = Origin::signed(1);968 let origin1 = Origin::signed(1);
1627 assert_ok!(TemplateModule::create_collection(969
1628 origin1.clone(),970 let data = default_nft_data();
1629 col_name1.clone(),
1630 col_desc1.clone(),
1631 token_prefix1.clone(),
1632 mode
1633 ));
1634 assert_eq!(TemplateModule::collection(1).owner, 1);971 create_test_item(collection_id, &data);
1635972
1636 assert_ok!(TemplateModule::create_item(
1637 origin1.clone(),
1638 1,
1639 [1, 2, 3].to_vec(),
1640 1
1641 ));
1642
1643 assert_ok!(TemplateModule::set_public_access_mode(973 assert_ok!(TemplateModule::set_public_access_mode(
1644 origin1.clone(),974 origin1.clone(),
1645 1,975 collection_id,
1646 AccessMode::WhiteList976 AccessMode::WhiteList
1647 ));977 ));
1648 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));978 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
1649979
1650 assert_noop!(980 assert_noop!(
1651 TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),981 TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),
1657#[test]987#[test]
1658fn white_list_test_2() {988fn white_list_test_2() {
1659 new_test_ext().execute_with(|| {989 new_test_ext().execute_with(|| {
1660 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();990 default_limits();
1661 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();991
1662 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();992 let collection_id = create_test_collection(&CollectionMode::NFT);
1663 let mode: CollectionMode = CollectionMode::NFT(2000);
1664
1665 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
1666 collection_numbers_limit: 10,
1667 account_token_ownership_limit: 10,
1668 collections_admins_limit: 5,
1669 custom_data_limit: 2048,
1670 nft_sponsor_transfer_timeout: 15,
1671 fungible_sponsor_transfer_timeout: 15,
1672 refungible_sponsor_transfer_timeout: 15,
1673 }));
1674
1675 let origin1 = Origin::signed(1);993 let origin1 = Origin::signed(1);
1676 assert_ok!(TemplateModule::create_collection(994
1677 origin1.clone(),995 let data = default_nft_data();
1678 col_name1.clone(),
1679 col_desc1.clone(),
1680 token_prefix1.clone(),
1681 mode
1682 ));
1683 assert_eq!(TemplateModule::collection(1).owner, 1);996 create_test_item(collection_id, &data);
1684997
1685 assert_ok!(TemplateModule::create_item(
1686 origin1.clone(),
1687 1,
1688 [1, 2, 3].to_vec(),
1689 1
1690 ));
1691
1692 assert_ok!(TemplateModule::set_public_access_mode(998 assert_ok!(TemplateModule::set_public_access_mode(
1693 origin1.clone(),999 origin1.clone(),
1694 1,1000 collection_id,
1695 AccessMode::WhiteList1001 AccessMode::WhiteList
1696 ));1002 ));
1697 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1003 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
1718#[test]1024#[test]
1719fn white_list_test_3() {1025fn white_list_test_3() {
1720 new_test_ext().execute_with(|| {1026 new_test_ext().execute_with(|| {
1721 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1027 default_limits();
1722 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1028
1723 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1029 let collection_id = create_test_collection(&CollectionMode::NFT);
1724 let mode: CollectionMode = CollectionMode::NFT(2000);
17251030
1726 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
1727 collection_numbers_limit: 10,
1728 account_token_ownership_limit: 10,
1729 collections_admins_limit: 5,
1730 custom_data_limit: 2048,
1731 nft_sponsor_transfer_timeout: 15,
1732 fungible_sponsor_transfer_timeout: 15,
1733 refungible_sponsor_transfer_timeout: 15,
1734 }));
1735
1736 let origin1 = Origin::signed(1);1031 let origin1 = Origin::signed(1);
1737 assert_ok!(TemplateModule::create_collection(1032
1738 origin1.clone(),1033 let data = default_nft_data();
1739 col_name1.clone(),
1740 col_desc1.clone(),
1741 token_prefix1.clone(),
1742 mode
1743 ));
1744 assert_eq!(TemplateModule::collection(1).owner, 1);1034 create_test_item(collection_id, &data);
17451035
1746 assert_ok!(TemplateModule::create_item(
1747 origin1.clone(),
1748 1,
1749 [1, 2, 3].to_vec(),
1750 1
1751 ));
1752
1753 assert_ok!(TemplateModule::set_public_access_mode(1036 assert_ok!(TemplateModule::set_public_access_mode(
1754 origin1.clone(),1037 origin1.clone(),
1755 1,1038 collection_id,
1756 AccessMode::WhiteList1039 AccessMode::WhiteList
1757 ));1040 ));
1758 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1041 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
1767#[test]1050#[test]
1768fn white_list_test_4() {1051fn white_list_test_4() {
1769 new_test_ext().execute_with(|| {1052 new_test_ext().execute_with(|| {
1770 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1053 default_limits();
1771 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1054
1772 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1055 let collection_id = create_test_collection(&CollectionMode::NFT);
1773 let mode: CollectionMode = CollectionMode::NFT(2000);
17741056
1775 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
1776 collection_numbers_limit: 10,
1777 account_token_ownership_limit: 10,
1778 collections_admins_limit: 5,
1779 custom_data_limit: 2048,
1780 nft_sponsor_transfer_timeout: 15,
1781 fungible_sponsor_transfer_timeout: 15,
1782 refungible_sponsor_transfer_timeout: 15,
1783 }));
1784
1785 let origin1 = Origin::signed(1);1057 let origin1 = Origin::signed(1);
1786 assert_ok!(TemplateModule::create_collection(
1787 origin1.clone(),
1788 col_name1.clone(),
1789 col_desc1.clone(),
1790 token_prefix1.clone(),
1791 mode
1792 ));
1793 assert_eq!(TemplateModule::collection(1).owner, 1);
17941058
1795 assert_ok!(TemplateModule::create_item(1059 let data = default_nft_data();
1796 origin1.clone(),
1797 1,1060 create_test_item(collection_id, &data);
1798 [1, 2, 3].to_vec(),
1799 1
1800 ));
18011061
1802 assert_ok!(TemplateModule::set_public_access_mode(1062 assert_ok!(TemplateModule::set_public_access_mode(
1803 origin1.clone(),1063 origin1.clone(),
1804 1,1064 collection_id,
1805 AccessMode::WhiteList1065 AccessMode::WhiteList
1806 ));1066 ));
1807 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1067 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));
1808 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));1068 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
18091069
1810 // do approve1070 // do approve
1811 assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1071 assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));
1812 assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);1072 assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
18131073
1814 assert_ok!(TemplateModule::remove_from_white_list(1074 assert_ok!(TemplateModule::remove_from_white_list(
1815 origin1.clone(),1075 origin1.clone(),
1816 1,1076 collection_id,
1817 21077 2
1818 ));1078 ));
18191079
1828#[test]1088#[test]
1829fn white_list_test_5() {1089fn white_list_test_5() {
1830 new_test_ext().execute_with(|| {1090 new_test_ext().execute_with(|| {
1831 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1091 default_limits();
1832 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1092
1833 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1093 let collection_id = create_test_collection(&CollectionMode::NFT);
1834 let mode: CollectionMode = CollectionMode::NFT(2000);
18351094
1836 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
1837 collection_numbers_limit: 10,
1838 account_token_ownership_limit: 10,
1839 collections_admins_limit: 5,
1840 custom_data_limit: 2048,
1841 nft_sponsor_transfer_timeout: 15,
1842 fungible_sponsor_transfer_timeout: 15,
1843 refungible_sponsor_transfer_timeout: 15,
1844 }));
1845
1846 let origin1 = Origin::signed(1);1095 let origin1 = Origin::signed(1);
1847 assert_ok!(TemplateModule::create_collection(
1848 origin1.clone(),
1849 col_name1.clone(),
1850 col_desc1.clone(),
1851 token_prefix1.clone(),
1852 mode
1853 ));
1854 assert_eq!(TemplateModule::collection(1).owner, 1);
18551096
1856 assert_ok!(TemplateModule::create_item(1097 let data = default_nft_data();
1857 origin1.clone(),
1858 1,1098 create_test_item(collection_id, &data);
1859 [1, 2, 3].to_vec(),
1860 1
1861 ));
18621099
1863 assert_ok!(TemplateModule::set_public_access_mode(1100 assert_ok!(TemplateModule::set_public_access_mode(
1864 origin1.clone(),1101 origin1.clone(),
1865 1,1102 collection_id,
1866 AccessMode::WhiteList1103 AccessMode::WhiteList
1867 ));1104 ));
1868 assert_noop!(1105 assert_noop!(
1876#[test]1113#[test]
1877fn white_list_test_6() {1114fn white_list_test_6() {
1878 new_test_ext().execute_with(|| {1115 new_test_ext().execute_with(|| {
1879 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1116 default_limits();
1880 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1117
1881 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1118 let collection_id = create_test_collection(&CollectionMode::NFT);
1882 let mode: CollectionMode = CollectionMode::NFT(2000);
18831119
1884 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
1885 collection_numbers_limit: 10,
1886 account_token_ownership_limit: 10,
1887 collections_admins_limit: 5,
1888 custom_data_limit: 2048,
1889 nft_sponsor_transfer_timeout: 15,
1890 fungible_sponsor_transfer_timeout: 15,
1891 refungible_sponsor_transfer_timeout: 15,
1892 }));
1893
1894 let origin1 = Origin::signed(1);1120 let origin1 = Origin::signed(1);
1895 assert_ok!(TemplateModule::create_collection(
1896 origin1.clone(),
1897 col_name1.clone(),
1898 col_desc1.clone(),
1899 token_prefix1.clone(),
1900 mode
1901 ));
1902 assert_ok!(TemplateModule::set_public_access_mode(1121 assert_ok!(TemplateModule::set_public_access_mode(
1903 origin1.clone(),1122 origin1.clone(),
1904 1,1123 collection_id,
1905 AccessMode::WhiteList1124 AccessMode::WhiteList
1906 ));1125 ));
19071126
1918#[test]1137#[test]
1919fn white_list_test_7() {1138fn white_list_test_7() {
1920 new_test_ext().execute_with(|| {1139 new_test_ext().execute_with(|| {
1921 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1140 default_limits();
1922 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1141
1923 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1142 let collection_id = create_test_collection(&CollectionMode::NFT);
1924 let mode: CollectionMode = CollectionMode::NFT(2000);
19251143
1926 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1144 let data = default_nft_data();
1927 collection_numbers_limit: 10,1145 create_test_item(collection_id, &data);
1928 account_token_ownership_limit: 10,
1929 collections_admins_limit: 5,1146
1930 custom_data_limit: 2048,
1931 nft_sponsor_transfer_timeout: 15,
1932 fungible_sponsor_transfer_timeout: 15,
1933 refungible_sponsor_transfer_timeout: 15,
1934 }));
1935
1936 let origin1 = Origin::signed(1);1147 let origin1 = Origin::signed(1);
1937 assert_ok!(TemplateModule::create_collection(
1938 origin1.clone(),
1939 col_name1.clone(),
1940 col_desc1.clone(),
1941 token_prefix1.clone(),
1942 mode
1943 ));
1944 assert_eq!(TemplateModule::collection(1).owner, 1);
19451148
1946 assert_ok!(TemplateModule::create_item(
1947 origin1.clone(),
1948 1,
1949 [1, 2, 3].to_vec(),
1950 1
1951 ));
1952
1953 assert_ok!(TemplateModule::set_public_access_mode(1149 assert_ok!(TemplateModule::set_public_access_mode(
1954 origin1.clone(),1150 origin1.clone(),
1955 1,1151 collection_id,
1956 AccessMode::WhiteList1152 AccessMode::WhiteList
1957 ));1153 ));
1958 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1154 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));
1959 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));1155 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
19601156
1961 assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));1157 assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));
1962 });1158 });
1965#[test]1161#[test]
1966fn white_list_test_8() {1162fn white_list_test_8() {
1967 new_test_ext().execute_with(|| {1163 new_test_ext().execute_with(|| {
1968 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1164 default_limits();
1969 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1165
1970 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1166 let collection_id = create_test_collection(&CollectionMode::NFT);
1971 let mode: CollectionMode = CollectionMode::NFT(2000);
19721167
1973 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1168 let data = default_nft_data();
1974 collection_numbers_limit: 10,1169 create_test_item(collection_id, &data);
1975 account_token_ownership_limit: 10,
1976 collections_admins_limit: 5,1170
1977 custom_data_limit: 2048,
1978 nft_sponsor_transfer_timeout: 15,
1979 fungible_sponsor_transfer_timeout: 15,
1980 refungible_sponsor_transfer_timeout: 15,
1981 }));
1982
1983 let origin1 = Origin::signed(1);1171 let origin1 = Origin::signed(1);
1984 assert_ok!(TemplateModule::create_collection(
1985 origin1.clone(),
1986 col_name1.clone(),
1987 col_desc1.clone(),
1988 token_prefix1.clone(),
1989 mode
1990 ));
1991 assert_eq!(TemplateModule::collection(1).owner, 1);
19921172
1993 assert_ok!(TemplateModule::create_item(
1994 origin1.clone(),
1995 1,
1996 [1, 2, 3].to_vec(),
1997 1
1998 ));
1999
2000 assert_ok!(TemplateModule::set_public_access_mode(1173 assert_ok!(TemplateModule::set_public_access_mode(
2001 origin1.clone(),1174 origin1.clone(),
2002 1,1175 collection_id,
2003 AccessMode::WhiteList1176 AccessMode::WhiteList
2004 ));1177 ));
2005 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));1178 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 1));
2006 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));1179 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
20071180
2008 // do approve1181 // do approve
2009 assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1182 assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));
2024#[test]1197#[test]
2025fn white_list_test_9() {1198fn white_list_test_9() {
2026 new_test_ext().execute_with(|| {1199 new_test_ext().execute_with(|| {
2027 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1200 default_limits();
2028 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1201
2029 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1202 let collection_id = create_test_collection(&CollectionMode::NFT);
2030 let mode: CollectionMode = CollectionMode::NFT(2000);
2031
2032 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2033 collection_numbers_limit: 10,
2034 account_token_ownership_limit: 10,
2035 collections_admins_limit: 5,
2036 custom_data_limit: 2048,
2037 nft_sponsor_transfer_timeout: 15,
2038 fungible_sponsor_transfer_timeout: 15,
2039 refungible_sponsor_transfer_timeout: 15,
2040 }));
2041
2042 let origin1 = Origin::signed(1);1203 let origin1 = Origin::signed(1);
2043 assert_ok!(TemplateModule::create_collection(
2044 origin1.clone(),
2045 col_name1.clone(),
2046 col_desc1.clone(),
2047 token_prefix1.clone(),
2048 mode
2049 ));
20501204
2051 assert_ok!(TemplateModule::set_public_access_mode(1205 assert_ok!(TemplateModule::set_public_access_mode(
2052 origin1.clone(),1206 origin1.clone(),
2053 1,1207 collection_id,
2054 AccessMode::WhiteList1208 AccessMode::WhiteList
2055 ));1209 ));
2056 assert_ok!(TemplateModule::set_mint_permission(1210 assert_ok!(TemplateModule::set_mint_permission(
2057 origin1.clone(),1211 origin1.clone(),
2058 1,1212 collection_id,
2059 false1213 false
2060 ));1214 ));
20611215
2062 assert_ok!(TemplateModule::create_item(1216 let data = default_nft_data();
2063 origin1.clone(),
2064 1,1217 create_test_item(collection_id, &data);
2065 [1, 2, 3].to_vec(),
2066 1
2067 ));
2068 });1218 });
2069}1219}
20701220
2071// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1221// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.
2072#[test]1222#[test]
2073fn white_list_test_10() {1223fn white_list_test_10() {
2074 new_test_ext().execute_with(|| {1224 new_test_ext().execute_with(|| {
2075 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1225 default_limits();
2076 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1226
2077 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1227 let collection_id = create_test_collection(&CollectionMode::NFT);
2078 let mode: CollectionMode = CollectionMode::NFT(2000);
20791228
2080 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2081 collection_numbers_limit: 10,
2082 account_token_ownership_limit: 10,
2083 collections_admins_limit: 5,
2084 custom_data_limit: 2048,
2085 nft_sponsor_transfer_timeout: 15,
2086 fungible_sponsor_transfer_timeout: 15,
2087 refungible_sponsor_transfer_timeout: 15,
2088 }));
2089
2090 let origin1 = Origin::signed(1);1229 let origin1 = Origin::signed(1);
2091 let origin2 = Origin::signed(2);1230 let origin2 = Origin::signed(2);
2092 assert_ok!(TemplateModule::create_collection(
2093 origin1.clone(),
2094 col_name1.clone(),
2095 col_desc1.clone(),
2096 token_prefix1.clone(),
2097 mode
2098 ));
20991231
2100 assert_ok!(TemplateModule::set_public_access_mode(1232 assert_ok!(TemplateModule::set_public_access_mode(
2101 origin1.clone(),1233 origin1.clone(),
2102 1,1234 collection_id,
2103 AccessMode::WhiteList1235 AccessMode::WhiteList
2104 ));1236 ));
2105 assert_ok!(TemplateModule::set_mint_permission(1237 assert_ok!(TemplateModule::set_mint_permission(
2106 origin1.clone(),1238 origin1.clone(),
2107 1,1239 collection_id,
2108 false1240 false
2109 ));1241 ));
21101242
2111 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));1243 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
21121244
2113 assert_ok!(TemplateModule::create_item(1245 assert_ok!(TemplateModule::create_item(
2114 origin2.clone(),1246 origin2.clone(),
2115 1,1247 collection_id,
2116 [1, 2, 3].to_vec(),1248 2,
2117 21249 default_nft_data()
2118 ));1250 ));
2119 });1251 });
2120}1252}
2123#[test]1255#[test]
2124fn white_list_test_11() {1256fn white_list_test_11() {
2125 new_test_ext().execute_with(|| {1257 new_test_ext().execute_with(|| {
2126 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1258 default_limits();
2127 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1259
2128 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1260 let collection_id = create_test_collection(&CollectionMode::NFT);
2129 let mode: CollectionMode = CollectionMode::NFT(2000);
21301261
2131 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2132 collection_numbers_limit: 10,
2133 account_token_ownership_limit: 10,
2134 collections_admins_limit: 5,
2135 custom_data_limit: 2048,
2136 nft_sponsor_transfer_timeout: 15,
2137 fungible_sponsor_transfer_timeout: 15,
2138 refungible_sponsor_transfer_timeout: 15,
2139 }));
2140
2141 let origin1 = Origin::signed(1);1262 let origin1 = Origin::signed(1);
2142 let origin2 = Origin::signed(2);1263 let origin2 = Origin::signed(2);
2143 assert_ok!(TemplateModule::create_collection(
2144 origin1.clone(),
2145 col_name1.clone(),
2146 col_desc1.clone(),
2147 token_prefix1.clone(),
2148 mode
2149 ));
21501264
2151 assert_ok!(TemplateModule::set_public_access_mode(1265 assert_ok!(TemplateModule::set_public_access_mode(
2152 origin1.clone(),1266 origin1.clone(),
2153 1,1267 collection_id,
2154 AccessMode::WhiteList1268 AccessMode::WhiteList
2155 ));1269 ));
2156 assert_ok!(TemplateModule::set_mint_permission(1270 assert_ok!(TemplateModule::set_mint_permission(
2157 origin1.clone(),1271 origin1.clone(),
2158 1,1272 collection_id,
2159 false1273 false
2160 ));1274 ));
2161 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));1275 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
21621276
2163 assert_noop!(1277 assert_noop!(
2164 TemplateModule::create_item(origin2.clone(), 1, [1, 2, 3].to_vec(), 2),1278 TemplateModule::create_item(origin2.clone(), 1, vec![1, 2, 3], 2),
2165 "Public minting is not allowed for this collection"1279 "Public minting is not allowed for this collection"
2166 );1280 );
2167 });1281 });
2171#[test]1285#[test]
2172fn white_list_test_12() {1286fn white_list_test_12() {
2173 new_test_ext().execute_with(|| {1287 new_test_ext().execute_with(|| {
2174 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1288 default_limits();
2175 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1289
2176 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1290 let collection_id = create_test_collection(&CollectionMode::NFT);
2177 let mode: CollectionMode = CollectionMode::NFT(2000);
21781291
2179 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2180 collection_numbers_limit: 10,
2181 account_token_ownership_limit: 10,
2182 collections_admins_limit: 5,
2183 custom_data_limit: 2048,
2184 nft_sponsor_transfer_timeout: 15,
2185 fungible_sponsor_transfer_timeout: 15,
2186 refungible_sponsor_transfer_timeout: 15,
2187 }));
2188
2189 let origin1 = Origin::signed(1);1292 let origin1 = Origin::signed(1);
2190 let origin2 = Origin::signed(2);1293 let origin2 = Origin::signed(2);
2191 assert_ok!(TemplateModule::create_collection(
2192 origin1.clone(),
2193 col_name1.clone(),
2194 col_desc1.clone(),
2195 token_prefix1.clone(),
2196 mode
2197 ));
21981294
2199 assert_ok!(TemplateModule::set_public_access_mode(1295 assert_ok!(TemplateModule::set_public_access_mode(
2200 origin1.clone(),1296 origin1.clone(),
2201 1,1297 collection_id,
2202 AccessMode::WhiteList1298 AccessMode::WhiteList
2203 ));1299 ));
2204 assert_ok!(TemplateModule::set_mint_permission(1300 assert_ok!(TemplateModule::set_mint_permission(
2205 origin1.clone(),1301 origin1.clone(),
2206 1,1302 collection_id,
2207 false1303 false
2208 ));1304 ));
22091305
2210 assert_noop!(1306 assert_noop!(
2211 TemplateModule::create_item(origin2.clone(), 1, [1, 2, 3].to_vec(), 2),1307 TemplateModule::create_item(origin2.clone(), 1, vec![1, 2, 3], 2),
2212 "Public minting is not allowed for this collection"1308 "Public minting is not allowed for this collection"
2213 );1309 );
2214 });1310 });
2218#[test]1314#[test]
2219fn white_list_test_13() {1315fn white_list_test_13() {
2220 new_test_ext().execute_with(|| {1316 new_test_ext().execute_with(|| {
2221 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1317 default_limits();
2222 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1318
2223 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1319 let collection_id = create_test_collection(&CollectionMode::NFT);
2224 let mode: CollectionMode = CollectionMode::NFT(2000);
22251320
2226 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2227 collection_numbers_limit: 10,
2228 account_token_ownership_limit: 10,
2229 collections_admins_limit: 5,
2230 custom_data_limit: 2048,
2231 nft_sponsor_transfer_timeout: 15,
2232 fungible_sponsor_transfer_timeout: 15,
2233 refungible_sponsor_transfer_timeout: 15,
2234 }));
2235
2236 let origin1 = Origin::signed(1);1321 let origin1 = Origin::signed(1);
2237 assert_ok!(TemplateModule::create_collection(
2238 origin1.clone(),
2239 col_name1.clone(),
2240 col_desc1.clone(),
2241 token_prefix1.clone(),
2242 mode
2243 ));
22441322
2245 assert_ok!(TemplateModule::set_public_access_mode(1323 assert_ok!(TemplateModule::set_public_access_mode(
2246 origin1.clone(),1324 origin1.clone(),
2247 1,1325 collection_id,
2248 AccessMode::WhiteList1326 AccessMode::WhiteList
2249 ));1327 ));
2250 assert_ok!(TemplateModule::set_mint_permission(1328 assert_ok!(TemplateModule::set_mint_permission(
2251 origin1.clone(),1329 origin1.clone(),
2252 1,1330 collection_id,
2253 true1331 true
2254 ));1332 ));
22551333
2256 assert_ok!(TemplateModule::create_item(1334 let data = default_nft_data();
2257 origin1.clone(),
2258 1,1335 create_test_item(collection_id, &data);
2259 [1, 2, 3].to_vec(),
2260 1
2261 ));
2262 });1336 });
2263}1337}
22641338
2265// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1339// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.
2266#[test]1340#[test]
2267fn white_list_test_14() {1341fn white_list_test_14() {
2268 new_test_ext().execute_with(|| {1342 new_test_ext().execute_with(|| {
2269 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1343 default_limits();
2270 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1344
2271 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1345 let collection_id = create_test_collection(&CollectionMode::NFT);
2272 let mode: CollectionMode = CollectionMode::NFT(2000);
22731346
2274 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2275 collection_numbers_limit: 10,
2276 account_token_ownership_limit: 10,
2277 collections_admins_limit: 5,
2278 custom_data_limit: 2048,
2279 nft_sponsor_transfer_timeout: 15,
2280 fungible_sponsor_transfer_timeout: 15,
2281 refungible_sponsor_transfer_timeout: 15,
2282 }));
2283
2284 let origin1 = Origin::signed(1);1347 let origin1 = Origin::signed(1);
2285 let origin2 = Origin::signed(2);1348 let origin2 = Origin::signed(2);
2286 assert_ok!(TemplateModule::create_collection(
2287 origin1.clone(),
2288 col_name1.clone(),
2289 col_desc1.clone(),
2290 token_prefix1.clone(),
2291 mode
2292 ));
22931349
2294 assert_ok!(TemplateModule::set_public_access_mode(1350 assert_ok!(TemplateModule::set_public_access_mode(
2295 origin1.clone(),1351 origin1.clone(),
2296 1,1352 collection_id,
2297 AccessMode::WhiteList1353 AccessMode::WhiteList
2298 ));1354 ));
2299 assert_ok!(TemplateModule::set_mint_permission(1355 assert_ok!(TemplateModule::set_mint_permission(
2300 origin1.clone(),1356 origin1.clone(),
2301 1,1357 collection_id,
2302 true1358 true
2303 ));1359 ));
23041360
2305 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));1361 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
23061362
2307 assert_ok!(TemplateModule::create_item(1363 assert_ok!(TemplateModule::create_item(
2308 origin2.clone(),1364 origin2.clone(),
2309 1,1365 1,
2310 [1, 2, 3].to_vec(),1366 2,
2311 21367 default_nft_data()
2312 ));1368 ));
2313 });1369 });
2314}1370}
2317#[test]1373#[test]
2318fn white_list_test_15() {1374fn white_list_test_15() {
2319 new_test_ext().execute_with(|| {1375 new_test_ext().execute_with(|| {
2320 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1376 default_limits();
2321 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1377
2322 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1378 let collection_id = create_test_collection(&CollectionMode::NFT);
2323 let mode: CollectionMode = CollectionMode::NFT(2000);
23241379
2325 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2326 collection_numbers_limit: 10,
2327 account_token_ownership_limit: 10,
2328 collections_admins_limit: 5,
2329 custom_data_limit: 2048,
2330 nft_sponsor_transfer_timeout: 15,
2331 fungible_sponsor_transfer_timeout: 15,
2332 refungible_sponsor_transfer_timeout: 15,
2333 }));
2334
2335 let origin1 = Origin::signed(1);1380 let origin1 = Origin::signed(1);
2336 let origin2 = Origin::signed(2);1381 let origin2 = Origin::signed(2);
2337 assert_ok!(TemplateModule::create_collection(
2338 origin1.clone(),
2339 col_name1.clone(),
2340 col_desc1.clone(),
2341 token_prefix1.clone(),
2342 mode
2343 ));
23441382
2345 assert_ok!(TemplateModule::set_public_access_mode(1383 assert_ok!(TemplateModule::set_public_access_mode(
2346 origin1.clone(),1384 origin1.clone(),
2347 1,1385 collection_id,
2348 AccessMode::WhiteList1386 AccessMode::WhiteList
2349 ));1387 ));
2350 assert_ok!(TemplateModule::set_mint_permission(1388 assert_ok!(TemplateModule::set_mint_permission(
2351 origin1.clone(),1389 origin1.clone(),
2352 1,1390 collection_id,
2353 true1391 true
2354 ));1392 ));
23551393
2356 assert_noop!(1394 assert_noop!(
2357 TemplateModule::create_item(origin2.clone(), 1, [1, 2, 3].to_vec(), 2),1395 TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data()),
2358 "Address is not in white list"1396 "Address is not in white list"
2359 );1397 );
2360 });1398 });
2364#[test]1402#[test]
2365fn white_list_test_16() {1403fn white_list_test_16() {
2366 new_test_ext().execute_with(|| {1404 new_test_ext().execute_with(|| {
2367 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1405 default_limits();
2368 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1406
2369 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1407 let collection_id = create_test_collection(&CollectionMode::NFT);
2370 let mode: CollectionMode = CollectionMode::NFT(2000);
23711408
2372 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2373 collection_numbers_limit: 10,
2374 account_token_ownership_limit: 10,
2375 collections_admins_limit: 5,
2376 custom_data_limit: 2048,
2377 nft_sponsor_transfer_timeout: 15,
2378 fungible_sponsor_transfer_timeout: 15,
2379 refungible_sponsor_transfer_timeout: 15,
2380 }));
2381
2382 let origin1 = Origin::signed(1);1409 let origin1 = Origin::signed(1);
2383 let origin2 = Origin::signed(2);1410 let origin2 = Origin::signed(2);
2384 assert_ok!(TemplateModule::create_collection(
2385 origin1.clone(),
2386 col_name1.clone(),
2387 col_desc1.clone(),
2388 token_prefix1.clone(),
2389 mode
2390 ));
23911411
2392 assert_ok!(TemplateModule::set_public_access_mode(1412 assert_ok!(TemplateModule::set_public_access_mode(
2393 origin1.clone(),1413 origin1.clone(),
2394 1,1414 collection_id,
2395 AccessMode::WhiteList1415 AccessMode::WhiteList
2396 ));1416 ));
2397 assert_ok!(TemplateModule::set_mint_permission(1417 assert_ok!(TemplateModule::set_mint_permission(
2398 origin1.clone(),1418 origin1.clone(),
2399 1,1419 collection_id,
2400 true1420 true
2401 ));1421 ));
2402 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));1422 assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
24031423
2404 assert_ok!(TemplateModule::create_item(1424 assert_ok!(TemplateModule::create_item(
2405 origin2.clone(),1425 origin2.clone(),
2406 1,1426 1,
2407 [1, 2, 3].to_vec(),1427 2,
2408 21428 default_nft_data()
2409 ));1429 ));
2410 });1430 });
2411}1431}
2414#[test]1434#[test]
2415fn total_number_collections_bound() {1435fn total_number_collections_bound() {
2416 new_test_ext().execute_with(|| {1436 new_test_ext().execute_with(|| {
2417 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1437 default_limits();
2418 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1438
2419 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1439 create_test_collection(&CollectionMode::NFT);
2420 let mode: CollectionMode = CollectionMode::NFT(2000);
2421
2422 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2423 collection_numbers_limit: 10,
2424 account_token_ownership_limit: 10,
2425 collections_admins_limit: 5,
2426 custom_data_limit: 2048,
2427 nft_sponsor_transfer_timeout: 15,
2428 fungible_sponsor_transfer_timeout: 15,
2429 refungible_sponsor_transfer_timeout: 15,
2430 }));
2431
2432 let origin1 = Origin::signed(1);
2433 assert_ok!(TemplateModule::create_collection(
2434 origin1.clone(),
2435 col_name1.clone(),
2436 col_desc1.clone(),
2437 token_prefix1.clone(),
2438 mode
2439 ));
2440 });1440 });
2441}1441}
24421442
2443// Total number of collections. Negotive test1443// Total number of collections. Negotive test
2444#[test]1444#[test]
2445fn total_number_collections_bound_neg() {1445fn total_number_collections_bound_neg() {
2446 new_test_ext().execute_with(|| {1446 new_test_ext().execute_with(|| {
2447 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1447 default_limits();
2448 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
2449 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
2450 let mode: CollectionMode = CollectionMode::NFT(2000);
24511448
2452 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2453 collection_numbers_limit: 10,
2454 account_token_ownership_limit: 10,
2455 collections_admins_limit: 5,
2456 custom_data_limit: 2048,
2457 nft_sponsor_transfer_timeout: 15,
2458 fungible_sponsor_transfer_timeout: 15,
2459 refungible_sponsor_transfer_timeout: 15,
2460 }));
2461
2462 let origin1 = Origin::signed(1);1449 let origin1 = Origin::signed(1);
24631450
2464 for _ in 0..10 {1451 for _ in 0..default_collection_numbers_limit() {
2465
2466 assert_ok!(TemplateModule::create_collection(1452 create_test_collection(&CollectionMode::NFT)
2467 origin1.clone(),
2468 col_name1.clone(),
2469 col_desc1.clone(),
2470 token_prefix1.clone(),
2471 mode.clone()
2472 ));
2473 }1453 }
24741454
2475 // 11-th collection in chain. Expects error1455 // 11-th collection in chain. Expects error
2487#[test]1467#[test]
2488fn owned_tokens_bound() {1468fn owned_tokens_bound() {
2489 new_test_ext().execute_with(|| {1469 new_test_ext().execute_with(|| {
2490 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1470 default_limits();
2491 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1471
2492 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1472 let collection_id = create_test_collection(&CollectionMode::NFT);
2493 let mode: CollectionMode = CollectionMode::NFT(2000);
24941473
2495 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1474 let data = default_nft_data();
2496 collection_numbers_limit: 10,
2497 account_token_ownership_limit: 10,
2498 collections_admins_limit: 5,
2499 custom_data_limit: 2048,
2500 nft_sponsor_transfer_timeout: 15,
2501 fungible_sponsor_transfer_timeout: 15,
2502 refungible_sponsor_transfer_timeout: 15,
2503 }));
2504
2505 let origin1 = Origin::signed(1);
2506 assert_ok!(TemplateModule::create_collection(1475 create_test_item(collection_id, &data);
2507 origin1.clone(),
2508 col_name1.clone(),
2509 col_desc1.clone(),
2510 token_prefix1.clone(),
2511 mode
2512 ));
2513
2514 assert_ok!(TemplateModule::create_item(1476 create_test_item(collection_id, &data);
2515 origin1.clone(),
2516 1,
2517 [1, 2, 3].to_vec(),
2518 1
2519 ));
2520
2521 assert_ok!(TemplateModule::create_item(
2522 origin1.clone(),
2523 1,
2524 [1, 2, 3].to_vec(),
2525 1
2526 ));
2527 });1477 });
2528}1478}
25291479
2530// Owned tokens by a single address. Negotive test1480// Owned tokens by a single address. Negotive test
2531#[test]1481#[test]
2532fn owned_tokens_bound_neg() {1482fn owned_tokens_bound_neg() {
2533 new_test_ext().execute_with(|| {1483 new_test_ext().execute_with(|| {
2534 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
2535 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
2536 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
2537 let mode: CollectionMode = CollectionMode::NFT(2000);
2538
2539 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1484 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2540 collection_numbers_limit: 10,1485 collection_numbers_limit: 10,
2541 account_token_ownership_limit: 1,1486 account_token_ownership_limit: 1,
2545 fungible_sponsor_transfer_timeout: 15,1490 fungible_sponsor_transfer_timeout: 15,
2546 refungible_sponsor_transfer_timeout: 15, 1491 refungible_sponsor_transfer_timeout: 15,
2547 }));1492 }));
1493
1494 let collection_id = create_test_collection(&CollectionMode::NFT);
25481495
2549 let origin1 = Origin::signed(1);1496 let origin1 = Origin::signed(1);
2550 assert_ok!(TemplateModule::create_collection(1497 let data = default_nft_data();
2551 origin1.clone(),
2552 col_name1.clone(),1498 create_test_item(collection_id, &data);
2553 col_desc1.clone(),
2554 token_prefix1.clone(),
2555 mode
2556 ));
25571499
2558 assert_ok!(TemplateModule::create_item(
2559 origin1.clone(),
2560 1,
2561 [1, 2, 3].to_vec(),
2562 1
2563 ));
2564
2565 assert_noop!(TemplateModule::create_item(1500 assert_noop!(TemplateModule::create_item(
2566 origin1.clone(),1501 origin1.clone(),
2567 1,1502 1,
2568 [1, 2, 3].to_vec(),1503 1,
2569 11504 data
2570 ), "Owned tokens by a single address bound exceeded");1505 ), "Owned tokens by a single address bound exceeded");
2571 });1506 });
2572}1507}
2575#[test]1510#[test]
2576fn collection_admins_bound() {1511fn collection_admins_bound() {
2577 new_test_ext().execute_with(|| {1512 new_test_ext().execute_with(|| {
2578 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
2579 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
2580 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
2581 let mode: CollectionMode = CollectionMode::NFT(2000);
2582
2583 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1513 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2584 collection_numbers_limit: 10,1514 collection_numbers_limit: 10,
2585 account_token_ownership_limit: 10,1515 account_token_ownership_limit: 10,
2589 fungible_sponsor_transfer_timeout: 15,1519 fungible_sponsor_transfer_timeout: 15,
2590 refungible_sponsor_transfer_timeout: 15, 1520 refungible_sponsor_transfer_timeout: 15,
2591 }));1521 }));
1522
1523 let collection_id = create_test_collection(&CollectionMode::NFT);
25921524
2593 let origin1 = Origin::signed(1);1525 let origin1 = Origin::signed(1);
2594 assert_ok!(TemplateModule::create_collection(1526
2595 origin1.clone(),
2596 col_name1.clone(),
2597 col_desc1.clone(),
2598 token_prefix1.clone(),
2599 mode
2600 ));
2601
2602 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));1527 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
2603 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));1528 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3));
2604 });1529 });
2605}1530}
26061531
2607// Number of collection admins. Negotive test1532// Number of collection admins. Negotive test
2608#[test]1533#[test]
2609fn collection_admins_bound_neg() {1534fn collection_admins_bound_neg() {
2610 new_test_ext().execute_with(|| {1535 new_test_ext().execute_with(|| {
2611 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
2612 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
2613 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
2614 let mode: CollectionMode = CollectionMode::NFT(2000);
2615
2616 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1536 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2617 collection_numbers_limit: 10,1537 collection_numbers_limit: 10,
2618 account_token_ownership_limit: 1,1538 account_token_ownership_limit: 1,
2622 fungible_sponsor_transfer_timeout: 15,1542 fungible_sponsor_transfer_timeout: 15,
2623 refungible_sponsor_transfer_timeout: 15, 1543 refungible_sponsor_transfer_timeout: 15,
2624 }));1544 }));
1545
1546 let collection_id = create_test_collection(&CollectionMode::NFT);
26251547
2626 let origin1 = Origin::signed(1);1548 let origin1 = Origin::signed(1);
2627 assert_ok!(TemplateModule::create_collection(
2628 origin1.clone(),
2629 col_name1.clone(),
2630 col_desc1.clone(),
2631 token_prefix1.clone(),
2632 mode
2633 ));
26341549
2635 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));1550 assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
2636 assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3), "Number of collection admins bound exceeded");1551 assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 3), "Number of collection admins bound exceeded");
2637 });1552 });
2638}1553}
26391554
2640// Custom data size. Positive test1555// NFT custom data size. Negative test const_data.
2641#[test]1556#[test]
2642fn custom_data_size_bound() {1557fn custom_data_size_nft_const_data_bound_neg() {
2643 new_test_ext().execute_with(|| {1558 new_test_ext().execute_with(|| {
2644 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1559 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
1560 collection_numbers_limit: 10,
1561 account_token_ownership_limit: 10,
1562 collections_admins_limit: 5,
2645 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1563 custom_data_limit: 2,
1564 nft_sponsor_transfer_timeout: 15,
1565 fungible_sponsor_transfer_timeout: 15,
2646 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1566 refungible_sponsor_transfer_timeout: 15,
1567 }));
2647 let mode: CollectionMode = CollectionMode::NFT(2000);1568
1569 let collection_id = create_test_collection(&CollectionMode::NFT);
26481570
1571 let origin1 = Origin::signed(1);
1572 let too_big_const_data = CreateItemData::NFT(CreateNftData{
1573 const_data: vec![1, 2, 3, 4],
1574 variable_data: vec![]
1575 });
1576
1577 assert_noop!(TemplateModule::create_item(
1578 origin1.clone(),
1579 collection_id,
1580 1,
1581 too_big_const_data
1582 ), "const_data exceeded data limit: 2.");
1583 });
1584}
1585
1586// NFT custom data size. Negative test variable_data.
1587#[test]
1588fn custom_data_size_nft_variable_data_bound_neg() {
1589 new_test_ext().execute_with(|| {
2649 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1590 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2650 collection_numbers_limit: 10,1591 collection_numbers_limit: 10,
2651 account_token_ownership_limit: 10,1592 account_token_ownership_limit: 10,
2652 collections_admins_limit: 5,1593 collections_admins_limit: 5,
2653 custom_data_limit: 2048,1594 custom_data_limit: 2,
2654 nft_sponsor_transfer_timeout: 15,1595 nft_sponsor_transfer_timeout: 15,
2655 fungible_sponsor_transfer_timeout: 15,1596 fungible_sponsor_transfer_timeout: 15,
2656 refungible_sponsor_transfer_timeout: 15, 1597 refungible_sponsor_transfer_timeout: 15,
2657 }));1598 }));
26581599
1600 let collection_id = create_test_collection(&CollectionMode::NFT);
1601
2659 let origin1 = Origin::signed(1);1602 let origin1 = Origin::signed(1);
2660 assert_ok!(TemplateModule::create_collection(1603 let too_big_const_data = CreateItemData::NFT(CreateNftData{
1604 const_data: vec![],
1605 variable_data: vec![1, 2, 3, 4]
1606 });
1607
1608 assert_noop!(TemplateModule::create_item(
2661 origin1.clone(),1609 origin1.clone(),
2662 col_name1.clone(),1610 collection_id,
2663 col_desc1.clone(),1611 1,
2664 token_prefix1.clone(),1612 too_big_const_data
2665 mode1613 ), "variable_data exceeded data limit: 2.");
2666 ));
2667 });1614 });
2668}1615}
26691616
2670// Custom data size. Negotive test1617// Re fungible custom data size. Negative test const_data.
2671#[test]1618#[test]
2672fn custom_data_size_bound_neg() {1619fn custom_data_size_re_fungible_const_data_bound_neg() {
2673 new_test_ext().execute_with(|| {1620 new_test_ext().execute_with(|| {
2674 let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();1621 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2675 let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();1622 collection_numbers_limit: 10,
1623 account_token_ownership_limit: 10,
1624 collections_admins_limit: 5,
2676 let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();1625 custom_data_limit: 2,
1626 nft_sponsor_transfer_timeout: 15,
2677 let mode: CollectionMode = CollectionMode::NFT(2000);1627 fungible_sponsor_transfer_timeout: 15,
1628 refungible_sponsor_transfer_timeout: 15,
1629 }));
26781630
1631 let collection_id = create_test_collection(&CollectionMode::NFT);
1632
1633 let origin1 = Origin::signed(1);
1634 let too_big_const_data = CreateItemData::NFT(CreateNftData{
1635 const_data: vec![1, 2, 3, 4],
1636 variable_data: vec![]
1637 });
1638
1639 assert_noop!(TemplateModule::create_item(
1640 origin1.clone(),
1641 collection_id,
1642 1,
1643 too_big_const_data
1644 ), "const_data exceeded data limit: 2.");
1645 });
1646}
1647
1648// Re fungible custom data size. Negative test variable_data.
1649#[test]
1650fn custom_data_size_re_fungible_variable_data_bound_neg() {
1651 new_test_ext().execute_with(|| {
2679 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 1652 assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits {
2680 collection_numbers_limit: 10,1653 collection_numbers_limit: 10,
2681 account_token_ownership_limit: 10,1654 account_token_ownership_limit: 10,
2682 collections_admins_limit: 5,1655 collections_admins_limit: 5,
2683 custom_data_limit: 200,1656 custom_data_limit: 2,
2684 nft_sponsor_transfer_timeout: 15,1657 nft_sponsor_transfer_timeout: 15,
2685 fungible_sponsor_transfer_timeout: 15,1658 fungible_sponsor_transfer_timeout: 15,
2686 refungible_sponsor_transfer_timeout: 15, 1659 refungible_sponsor_transfer_timeout: 15,
2687 }));1660 }));
26881661
1662 let collection_id = create_test_collection(&CollectionMode::NFT);
1663
2689 let origin1 = Origin::signed(1);1664 let origin1 = Origin::signed(1);
2690 assert_noop!(TemplateModule::create_collection(1665 let too_big_const_data = CreateItemData::NFT(CreateNftData{
1666 const_data: vec![],
1667 variable_data: vec![1, 2, 3, 4]
1668 });
1669
1670 assert_noop!(TemplateModule::create_item(
2691 origin1.clone(),1671 origin1.clone(),
2692 col_name1.clone(),1672 collection_id,
2693 col_desc1.clone(),1673 1,
2694 token_prefix1.clone(),1674 too_big_const_data
2695 mode1675 ), "variable_data exceeded data limit: 2.");
2696 ), "Custom data size bound exceeded");
2697 });1676 });
2698}1677}
2699// #endregion1678// #endregion
27001679
1680#[test]
1681fn set_const_on_chain_schema() {
1682 new_test_ext().execute_with(|| {
1683 default_limits();
1684
1685 let collection_id = create_test_collection(&CollectionMode::NFT);
1686
1687 let origin1 = Origin::signed(1);
1688 assert_ok!(TemplateModule::set_const_on_chain_schema(origin1, collection_id, "test const on chain schema".to_vec()));
1689
1690 assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, "test const on chain schema".to_vec());
1691 assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, "".to_vec());
1692 });
1693}
1694
1695#[test]
1696fn set_variable_on_chain_schema() {
1697 new_test_ext().execute_with(|| {
1698 default_limits();
1699
1700 let collection_id = create_test_collection(&CollectionMode::NFT);
1701
1702 let origin1 = Origin::signed(1);
1703 assert_ok!(TemplateModule::set_variable_on_chain_schema(origin1, collection_id, "test variable on chain schema".to_vec()));
1704
1705 assert_eq!(TemplateModule::collection(collection_id).const_on_chain_schema, "".to_vec());
1706 assert_eq!(TemplateModule::collection(collection_id).variable_on_chain_schema, "test variable on chain schema".to_vec());
1707 });
1708}
modifiedruntime/src/nft_weights.rsdiffbeforeafterboth
--- 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))
+    }
 }