git.delta.rocks / unique-network / refs/commits / 5a0b0e30f20b

difftreelog

Transfer rate limit + chain bounds

str-mv2020-10-08parent: #29e7096.patch.diff
in: master

4 files changed

modifiednode/src/chain_spec.rsdiffbeforeafterboth
--- a/node/src/chain_spec.rs
+++ b/node/src/chain_spec.rs
@@ -130,23 +130,35 @@
         }),
         sudo: Some(SudoConfig { key: root_key }),
         nft: Some(NftConfig {
-            collection: vec![(1, CollectionType { 
-                owner: get_account_id_from_seed::<sr25519::Public>("Alice"),
-                mode: CollectionMode::NFT(50),
-                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"),
-            })],
-            nft_item_id: vec!(),
-            fungible_item_id: vec!(),
-            refungible_item_id: vec!(),
+            collection: vec![(
+                1,
+                CollectionType {
+                    owner: get_account_id_from_seed::<sr25519::Public>("Alice"),
+                    mode: CollectionMode::NFT(50),
+                    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"),
+                },
+            )],
+            nft_item_id: vec![],
+            fungible_item_id: vec![],
+            refungible_item_id: vec![],
+            chain_limit: ChainLimits {
+                collection_numbers_limit: 10,
+                account_token_ownership_limit: 10,
+                collections_admins_limit: 5,
+                custom_data_limit: 2048,
+                nft_sponsor_transfer_timeout: 15,
+                fungible_sponsor_transfer_timeout: 15,
+                refungible_sponsor_transfer_timeout: 15,
+            },
         }),
         contracts: Some(ContractsConfig {
             current_schedule: ContractsSchedule {
modifiedpallets/nft/src/lib.rsdiffbeforeafterboth
1#![cfg_attr(not(feature = "std"), no_std)]1#![cfg_attr(not(feature = "std"), no_std)]
22
3#[cfg(feature = "std")]3#[cfg(feature = "std")]
4pub use std::*;
5
6#[cfg(feature = "std")]
4pub use serde::*;7pub use serde::*;
58
6use codec::{Decode, Encode};9use codec::{Decode, Encode};
20    IsSubType, StorageValue,23    IsSubType, StorageValue,
21};24};
2225
23use frame_system::{self as system, ensure_signed};26use frame_system::{self as system, ensure_signed, ensure_root};
24use sp_runtime::sp_std::prelude::Vec;27use sp_runtime::sp_std::prelude::Vec;
25use sp_runtime::{28use sp_runtime::{
26    traits::{29    traits::{
157    pub vesting_date: Moment,160    pub vesting_date: Moment,
158}161}
159162
163#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
164#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
165pub struct BasketItem<AccountId, BlockNumber> {
166    pub address: AccountId,
167    pub start_block: BlockNumber,
168}
169
170#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
171#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
172pub struct ChainLimits {
173    pub collection_numbers_limit: u64,
174    pub account_token_ownership_limit: u64,
175    pub collections_admins_limit: u64,
176    pub custom_data_limit: u32,
177
178    // Timeouts for item types in passed blocks
179    pub nft_sponsor_transfer_timeout: u32,
180    pub fungible_sponsor_transfer_timeout: u32,
181    pub refungible_sponsor_transfer_timeout: u32,
182}
183
160pub trait Trait: system::Trait {184pub trait Trait: system::Trait {
161    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;185    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
162}186}
172        ChainVersion: u64;196        ChainVersion: u64;
173        ItemListIndex: map hasher(blake2_128_concat) u64 => u64;197        ItemListIndex: map hasher(blake2_128_concat) u64 => u64;
174198
199        // Chain limits struct
200        pub ChainLimit get(fn chain_limit) config(): ChainLimits;
201
202        // Bound counters
203        CollectionCount: u64;
204        pub AccountItemCount get(fn account_item_count): map hasher(identity) T::AccountId => u64;
205
206        // Basic collections
175        pub Collection get(fn collection) config(): map hasher(identity) u64 => CollectionType<T::AccountId>;207        pub Collection get(fn collection) config(): map hasher(identity) u64 => CollectionType<T::AccountId>;
176        pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;208        pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;
177        pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;209        pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;
190        /// Index list222        /// Index list
191        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;223        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;
192224
225        /// Tokens transfer baskets
226        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;
227        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => Vec<BasketItem<T::AccountId, T::BlockNumber>>;
228        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;
229
193        // Sponsorship230        // Sponsorship
194        pub ContractSponsor get(fn contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;231        pub ContractSponsor get(fn contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;
195        pub UnconfirmedContractSponsor get(fn unconfirmed_contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;232        pub UnconfirmedContractSponsor get(fn unconfirmed_contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;
196    }233    }
197    add_extra_genesis {234    add_extra_genesis {
198        build(|config: &GenesisConfig<T>| {235        build(|config: &GenesisConfig<T>| {
199			// Modification of storage236            // Modification of storage
200            for (_num, _c) in &config.collection {237            for (_num, _c) in &config.collection {
201                <Module<T>>::init_collection(_c);238                <Module<T>>::init_collection(_c);
202            }239            }
212            for (_num, _q, _i) in &config.refungible_item_id {249            for (_num, _q, _i) in &config.refungible_item_id {
213                <Module<T>>::init_refungible_token(_i);250                <Module<T>>::init_refungible_token(_i);
214            }251            }
215		})252        })
216    }253    }
217}254}
218255
258            // Anyone can create a collection295            // Anyone can create a collection
259            let who = ensure_signed(origin)?;296            let who = ensure_signed(origin)?;
260            let custom_data_size = match mode {297            let custom_data_size = match mode {
261                CollectionMode::NFT(size) => size,298                CollectionMode::NFT(size) => {
299
300                    // bound Custom data size
301                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");
262                CollectionMode::ReFungible(size, _) => size,302                    size
303                },
304                CollectionMode::ReFungible(size, _) => {
305
306                    // bound Custom data size
307                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");
308                    size
309                },
263                _ => 0310                _ => 0
264            };311            };
265312
269                _ => 0316                _ => 0
270            };317            };
271318
319            // bound Total number of collections
320            ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, "Total collections bound exceeded");
321
272            // check params322            // check params
273            ensure!(decimal_points <= 4, "decimal_points parameter must be lower than 4");323            ensure!(decimal_points <= 4, "decimal_points parameter must be lower than 4");
274324
289                .checked_add(1)339                .checked_add(1)
290                .expect("collection id error");340                .expect("collection id error");
291341
342            // bound counter
343            let total = CollectionCount::get()
344                .checked_add(1)
345                .expect("collection counter error");
346
292            CreatedCollectionCount::put(next_id);347            CreatedCollectionCount::put(next_id);
348            CollectionCount::put(total);
293349
294            // Create new collection350            // Create new collection
295            let new_collection = CollectionType {351            let new_collection = CollectionType {
322            let sender = ensure_signed(origin)?;378            let sender = ensure_signed(origin)?;
323            Self::check_owner_permissions(collection_id, sender)?;379            Self::check_owner_permissions(collection_id, sender)?;
324380
325            // TODO Items remove
326            <AddressTokens<T>>::remove_prefix(collection_id);381            <AddressTokens<T>>::remove_prefix(collection_id);
327            <ApprovedList<T>>::remove_prefix(collection_id);382            <ApprovedList<T>>::remove_prefix(collection_id);
328            <Balance<T>>::remove_prefix(collection_id);383            <Balance<T>>::remove_prefix(collection_id);
331            <Collection<T>>::remove(collection_id);386            <Collection<T>>::remove(collection_id);
332            <WhiteList<T>>::remove(collection_id);387            <WhiteList<T>>::remove(collection_id);
333388
389            <NftItemList<T>>::remove_prefix(collection_id);
390            <FungibleItemList<T>>::remove_prefix(collection_id);
391            <ReFungibleItemList<T>>::remove_prefix(collection_id);
392
393            <NftTransferBasket<T>>::remove_prefix(collection_id);
394            <FungibleTransferBasket<T>>::remove_prefix(collection_id);
395            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);
396
397            if CollectionCount::get() > 0
398            {
399                // bound couter
400                let total = CollectionCount::get()
401                    .checked_sub(1)
402                    .expect("collection counter error");
403
404                CollectionCount::put(total);
405            }
406
334            Ok(())407            Ok(())
335        }408        }
336409
426                ensure!(!admin_arr.contains(&new_admin_id), "Account already has admin role");499                ensure!(!admin_arr.contains(&new_admin_id), "Account already has admin role");
427            }500            }
428501
502            // Number of collection admins
503            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, "Number of collection admins bound exceeded");
504
429            admin_arr.push(new_admin_id);505            admin_arr.push(new_admin_id);
430            <AdminList<T>>::insert(collection_id, admin_arr);506            <AdminList<T>>::insert(collection_id, admin_arr);
431507
570646
571            // Transfer permissions check647            // Transfer permissions check
572            let target_collection = <Collection<T>>::get(collection_id);648            let target_collection = <Collection<T>>::get(collection_id);
573            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) || 649            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||
574                Self::is_owner_or_admin_permissions(collection_id, sender.clone()), 650                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),
575                "Only item owner, collection owner and admins can modify item");651                "Only item owner, collection owner and admins can modify item");
576652
577            if target_collection.access == AccessMode::WhiteList {653            if target_collection.access == AccessMode::WhiteList {
599675
600            // Transfer permissions check676            // Transfer permissions check
601            let target_collection = <Collection<T>>::get(collection_id);677            let target_collection = <Collection<T>>::get(collection_id);
602            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) || 678            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||
603                Self::is_owner_or_admin_permissions(collection_id, sender.clone()), 679                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),
604                "Only item owner, collection owner and admins can modify item");680                "Only item owner, collection owner and admins can modify item");
605681
606            if target_collection.access == AccessMode::WhiteList {682            if target_collection.access == AccessMode::WhiteList {
626702
627            // Transfer permissions check703            // Transfer permissions check
628            let target_collection = <Collection<T>>::get(collection_id);704            let target_collection = <Collection<T>>::get(collection_id);
629            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) || 705            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||
630                Self::is_owner_or_admin_permissions(collection_id, sender.clone()), 706                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),
631                "Only item owner, collection owner and admins can approve");707                "Only item owner, collection owner and admins can approve");
632708
633            if target_collection.access == AccessMode::WhiteList {709            if target_collection.access == AccessMode::WhiteList {
674750
675            // Transfer permissions check751            // Transfer permissions check
676            let target_collection = <Collection<T>>::get(collection_id);752            let target_collection = <Collection<T>>::get(collection_id);
677            ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()), 753            ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),
678                "Only item owner, collection owner and admins can modify items");754                "Only item owner, collection owner and admins can modify items");
679755
680            if target_collection.access == AccessMode::WhiteList {756            if target_collection.access == AccessMode::WhiteList {
729805
730            Ok(())806            Ok(())
731        }807        }
808
809        // Sudo permissions function
810        #[weight = 0]
811        pub fn set_chain_limits(
812            origin,
813            limits: ChainLimits
814        ) -> DispatchResult {
815            ensure_root(origin)?;
816            <ChainLimit>::put(limits);
817            Ok(())
818        }        
732    }819    }
733}820}
734821
799        Ok(())886        Ok(())
800    }887    }
801888
802    fn burn_refungible_item(collection_id: u64, item_id: u64, owner: T::AccountId) -> DispatchResult {889    fn burn_refungible_item(
890        collection_id: u64,
891        item_id: u64,
892        owner: T::AccountId,
893    ) -> DispatchResult {
803        ensure!(894        ensure!(
804            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),895            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),
805            "Item does not exists"896            "Item does not exists"
891    }982    }
892983
893    fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {984    fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {
894
895        let target_collection = <Collection<T>>::get(collection_id);985        let target_collection = <Collection<T>>::get(collection_id);
896        let mut result: bool = subject == target_collection.owner;986        let mut result: bool = subject == target_collection.owner;
897        let exists = <AdminList<T>>::contains_key(collection_id);987        let exists = <AdminList<T>>::contains_key(collection_id);
905        result995        result
906    }996    }
907997
908    fn check_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {998    fn check_owner_or_admin_permissions(
909        999        collection_id: u64,
1000        subject: T::AccountId,
1001    ) -> DispatchResult {
910        Self::collection_exists(collection_id)?;1002        Self::collection_exists(collection_id)?;
911        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());1003        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());
9121004
913        ensure!(result, "You do not have permissions to modify this collection");1005        ensure!(
1006            result,
1007            "You do not have permissions to modify this collection"
1008        );
914        Ok(())1009        Ok(())
915    }1010    }
9161011
935    }1030    }
9361031
937    fn check_white_list(collection_id: u64, address: T::AccountId) -> DispatchResult {1032    fn check_white_list(collection_id: u64, address: T::AccountId) -> DispatchResult {
938
939        let mes = "Address is not in white list";1033        let mes = "Address is not in white list";
940        ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1034        ensure!(<WhiteList<T>>::contains_key(collection_id), mes);
941        let wl = <WhiteList<T>>::get(collection_id);1035        let wl = <WhiteList<T>>::get(collection_id);
951        owner: T::AccountId,1045        owner: T::AccountId,
952        new_owner: T::AccountId,1046        new_owner: T::AccountId,
953    ) -> DispatchResult {1047    ) -> DispatchResult {
954
955        ensure!(1048        ensure!(
956            <FungibleItemList<T>>::contains_key(collection_id, item_id),1049            <FungibleItemList<T>>::contains_key(collection_id, item_id),
957            "Item not exists"1050            "Item not exists"
1041        owner: T::AccountId,1134        owner: T::AccountId,
1042        new_owner: T::AccountId,1135        new_owner: T::AccountId,
1043    ) -> DispatchResult {1136    ) -> DispatchResult {
1044
1045        ensure!(1137        ensure!(
1046            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1138            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),
1047            "Item not exists"1139            "Item not exists"
1127        sender: T::AccountId,1219        sender: T::AccountId,
1128        new_owner: T::AccountId,1220        new_owner: T::AccountId,
1129    ) -> DispatchResult {1221    ) -> DispatchResult {
1130    
1131        ensure!(1222        ensure!(
1132            <NftItemList<T>>::contains_key(collection_id, item_id),1223            <NftItemList<T>>::contains_key(collection_id, item_id),
1133            "Item not exists"1224            "Item not exists"
1164        Ok(())1255        Ok(())
1165    }1256    }
11661257
1167    fn init_collection(item: &CollectionType<T::AccountId>){1258    fn init_collection(item: &CollectionType<T::AccountId>) {
1259        // check params
1260        assert!(
1261            item.decimal_points <= 4,
1262            "decimal_points parameter must be lower than 4"
1263        );
1264        assert!(
1265            item.name.len() <= 64,
1266            "Collection name can not be longer than 63 char"
1267        );
1268        assert!(
1269            item.name.len() <= 256,
1270            "Collection description can not be longer than 255 char"
1271        );
1272        assert!(
1273            item.token_prefix.len() <= 16,
1274            "Token prefix can not be longer than 15 char"
1275        );
11681276
1169                // check params1277        // Generate next collection ID
1170                assert!(item.decimal_points <= 4, "decimal_points parameter must be lower than 4");
1171                assert!(item.name.len() <= 64, "Collection name can not be longer than 63 char");
1172                assert!(item.name.len() <= 256, "Collection description can not be longer than 255 char");
1173                assert!(item.token_prefix.len() <= 16, "Token prefix can not be longer than 15 char");
1174    
1175                // Generate next collection ID
1176                let next_id = CreatedCollectionCount::get()1278        let next_id = CreatedCollectionCount::get()
1177                    .checked_add(1)1279            .checked_add(1)
1178                    .expect("collection id error");1280            .expect("collection id error");
1179    1281
1180                CreatedCollectionCount::put(next_id);  1282        CreatedCollectionCount::put(next_id);
1181    }1283    }
11821284
1183    fn init_nft_token(item: &NftItemType<T::AccountId>){1285    fn init_nft_token(item: &NftItemType<T::AccountId>) {
1184
1185        let current_index = <ItemListIndex>::get(item.collection)1286        let current_index = <ItemListIndex>::get(item.collection)
1186            .checked_add(1)1287            .checked_add(1)
1199        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);1300        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);
1200    }1301    }
12011302
1202    fn init_fungible_token(item: &FungibleItemType<T::AccountId>){1303    fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {
1203
1204        let current_index = <ItemListIndex>::get(item.collection)1304        let current_index = <ItemListIndex>::get(item.collection)
1205            .checked_add(1)1305            .checked_add(1)
1218        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1318        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);
1219    }1319    }
12201320
1221    fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>){1321    fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {
1222
1223        let current_index = <ItemListIndex>::get(item.collection)1322        let current_index = <ItemListIndex>::get(item.collection)
1224            .checked_add(1)1323            .checked_add(1)
1239    }1338    }
12401339
1241    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {1340    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {
1341
1342        // add to account limit
1343        if <AccountItemCount<T>>::contains_key(owner.clone()) {
1344
1345            // bound Owned tokens by a single address
1346            let count = <AccountItemCount<T>>::get(owner.clone());
1347            ensure!(count < ChainLimit::get().account_token_ownership_limit, "Owned tokens by a single address bound exceeded");
1348
1349            <AccountItemCount<T>>::insert(owner.clone(), 
1350                count.checked_add(1).unwrap());
1351        }
1352        else {
1353            <AccountItemCount<T>>::insert(owner.clone(), 1);
1354        }
1355
1242        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1356        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());
1243        if list_exists {1357        if list_exists {
1244            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1358            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());
1253            let mut itm = Vec::new();1367            let mut itm = Vec::new();
1254            itm.push(item_index.clone());1368            itm.push(item_index.clone());
1255            <AddressTokens<T>>::insert(collection_id, owner, itm);1369            <AddressTokens<T>>::insert(collection_id, owner, itm);
1370            
1256        }1371        }
12571372
1258        Ok(())1373        Ok(())
1263        item_index: u64,1378        item_index: u64,
1264        owner: T::AccountId,1379        owner: T::AccountId,
1265    ) -> DispatchResult {1380    ) -> DispatchResult {
1381
1382        // update counter
1383        <AccountItemCount<T>>::insert(owner.clone(), 
1384            <AccountItemCount<T>>::get(owner.clone()).checked_sub(1).unwrap());
1385
1386
1266        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1387        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());
1267        if list_exists {1388        if list_exists {
1268            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1389            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());
1370                <Collection<T>>::get(collection_id).sponsor1491                <Collection<T>>::get(collection_id).sponsor
1371            }1492            }
1372            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {1493            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {
1373                <Collection<T>>::get(collection_id).sponsor1494                let _collection_mode = <Collection<T>>::get(collection_id).mode;
1495
1496                // sponsor timeout
1497                let sponsor_timeout = match _collection_mode {
1498                    CollectionMode::NFT(_) => {
1499                        let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);
1500                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;
1501                        let time = basket - ChainLimit::get().nft_sponsor_transfer_timeout.into() - block_number;
1502                        if time <= 0.into() {
1503                            <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);
1504                        }
1505                        time
1506                    }
1507                    CollectionMode::Fungible(_) => {
1508                        let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);
1509                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;
1510                        let time: T::BlockNumber;
1511                        if basket.iter().any(|i| i.address == _new_owner.clone())
1512                        {
1513                            let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();
1514                            time = block_number - ChainLimit::get().fungible_sponsor_transfer_timeout.into() - item.start_block;
1515                            if time <= 0.into() {
1516                                basket.retain(|x| x.address == item.address);
1517                                basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });
1518                                <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);
1519                            }
1520                        }
1521                        else {
1522                            time = block_number;
1523                            basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});
1524                        }
1525
1526                        time
1527                    }
1528                    CollectionMode::ReFungible(_, _) => {
1529                        let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);
1530                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;
1531                        let time = basket - ChainLimit::get().refungible_sponsor_transfer_timeout.into() - block_number;
1532                        if time <= 0.into() {
1533                            <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);
1534                        }
1535                        time
1536                    }
1537                    _ => {
1538                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;
1539                        block_number
1540                    },
1541                };
1542
1543                if sponsor_timeout > 0.into() {
1544                    T::AccountId::default()
1545                } else {
1546                    <Collection<T>>::get(collection_id).sponsor
1547                }
1374            }1548            }
13751549
1376            _ => T::AccountId::default(),1550            _ => T::AccountId::default(),
1487        Ok(())1661        Ok(())
1488    }1662    }
1489}1663}
1490// #endregion1664// #endregion
1665
modifiedpallets/nft/src/mock.rsdiffbeforeafterboth
--- a/pallets/nft/src/mock.rs
+++ b/pallets/nft/src/mock.rs
@@ -65,6 +65,7 @@
 }
 pub type TemplateModule = Module<Test>;
 
+
 // This function basically just builds a genesis storage key/value store according to
 // our desired mockup.
 pub fn new_test_ext() -> sp_io::TestExternalities {
modifiedpallets/nft/src/tests.rsdiffbeforeafterboth
--- a/pallets/nft/src/tests.rs
+++ b/pallets/nft/src/tests.rs
@@ -1,7 +1,8 @@
 // Tests to be written here
 use crate::mock::*;
-use crate::{ApprovePermissions, CollectionMode, AccessMode, Ownership};
+use crate::{AccessMode, ApprovePermissions, CollectionMode, Ownership, ChainLimits};
 use frame_support::{assert_noop, assert_ok};
+use frame_system::{ RawOrigin };
 
 // Use cases tests region
 // #region
@@ -13,6 +14,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -41,6 +52,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -79,6 +100,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::Fungible(3);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -109,6 +140,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::Fungible(3);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -167,6 +208,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -264,6 +315,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -302,6 +363,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -323,8 +394,16 @@
         assert_eq!(TemplateModule::balance_count(1, 1), 1);
         assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            true
+        ));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
@@ -362,6 +441,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -393,8 +482,16 @@
         assert_eq!(TemplateModule::balance_count(1, 1), 1000);
         assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            true
+        ));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
@@ -444,6 +541,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::Fungible(3);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -465,8 +572,16 @@
         assert_eq!(TemplateModule::balance_count(1, 1), 1000);
         assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            true
+        ));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
@@ -532,6 +647,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -557,6 +682,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -577,6 +712,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -617,6 +762,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::Fungible(3);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -655,6 +810,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::ReFungible(200, 3);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -664,9 +829,17 @@
             token_prefix1.clone(),
             mode
         ));
-        
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
+
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            true
+        ));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
 
         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
@@ -704,6 +877,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         let origin3 = Origin::signed(3);
@@ -754,6 +937,16 @@
         let origin2 = Origin::signed(2);
         let origin3 = Origin::signed(3);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -809,6 +1002,16 @@
 
         let origin1 = Origin::signed(1);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -881,6 +1084,16 @@
         let nft_mode: CollectionMode = CollectionMode::NFT(2000);
         let origin1 = Origin::signed(1);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -915,6 +1128,16 @@
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -937,8 +1160,16 @@
         assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
         assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);
 
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            true
+        ));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
@@ -972,6 +1203,16 @@
         let mode: CollectionMode = CollectionMode::NFT(2000);
         let origin1 = Origin::signed(1);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -995,6 +1236,16 @@
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -1019,6 +1270,16 @@
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -1027,16 +1288,32 @@
             mode
         ));
 
-        assert_noop!(TemplateModule::add_to_white_list(origin2.clone(), 1, 3), "You do not have permissions to modify this collection");
+        assert_noop!(
+            TemplateModule::add_to_white_list(origin2.clone(), 1, 3),
+            "You do not have permissions to modify this collection"
+        );
     });
 }
 
 #[test]
 fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {
     new_test_ext().execute_with(|| {
+        let origin1 = Origin::signed(1);
+
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
 
-        let origin1 = Origin::signed(1);
-        assert_noop!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2), "This collection does not exist");
+        assert_noop!(
+            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),
+            "This collection does not exist"
+        );
     });
 }
 
@@ -1049,6 +1326,16 @@
         let mode: CollectionMode = CollectionMode::NFT(2000);
         let origin1 = Origin::signed(1);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -1058,7 +1345,10 @@
         ));
 
         assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
-        assert_noop!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2), "This collection does not exist");
+        assert_noop!(
+            TemplateModule::add_to_white_list(origin1.clone(), 1, 2),
+            "This collection does not exist"
+        );
     });
 }
 
@@ -1066,13 +1356,22 @@
 #[test]
 fn address_is_already_added_to_white_list() {
     new_test_ext().execute_with(|| {
-
         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
         let origin1 = Origin::signed(1);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -1091,13 +1390,22 @@
 #[test]
 fn owner_can_remove_address_from_white_list() {
     new_test_ext().execute_with(|| {
-        
         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
         let origin1 = Origin::signed(1);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -1107,7 +1415,11 @@
         ));
 
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::remove_from_white_list(
+            origin1.clone(),
+            1,
+            2
+        ));
         assert_eq!(TemplateModule::white_list(1).len(), 0);
     });
 }
@@ -1115,7 +1427,6 @@
 #[test]
 fn admin_can_remove_address_from_white_list() {
     new_test_ext().execute_with(|| {
-
         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
@@ -1123,6 +1434,16 @@
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -1134,7 +1455,11 @@
         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
 
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
-        assert_ok!(TemplateModule::remove_from_white_list(origin2.clone(), 1, 3));
+        assert_ok!(TemplateModule::remove_from_white_list(
+            origin2.clone(),
+            1,
+            3
+        ));
         assert_eq!(TemplateModule::white_list(1).len(), 0);
     });
 }
@@ -1142,7 +1467,6 @@
 #[test]
 fn nonprivileged_user_cannot_remove_address_from_white_list() {
     new_test_ext().execute_with(|| {
-
         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
@@ -1150,6 +1474,16 @@
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -1159,7 +1493,10 @@
         ));
 
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
-        assert_noop!(TemplateModule::remove_from_white_list(origin2.clone(), 1, 2), "You do not have permissions to modify this collection");
+        assert_noop!(
+            TemplateModule::remove_from_white_list(origin2.clone(), 1, 2),
+            "You do not have permissions to modify this collection"
+        );
         assert_eq!(TemplateModule::white_list(1)[0], 2);
     });
 }
@@ -1167,16 +1504,28 @@
 #[test]
 fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {
     new_test_ext().execute_with(|| {
+        let origin1 = Origin::signed(1);
+
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
 
-        let origin1 = Origin::signed(1);
-        assert_noop!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 2), "This collection does not exist");
+        assert_noop!(
+            TemplateModule::remove_from_white_list(origin1.clone(), 1, 2),
+            "This collection does not exist"
+        );
     });
 }
 
 #[test]
 fn nobody_can_remove_address_from_white_list_of_deleted_collection() {
     new_test_ext().execute_with(|| {
-
         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
@@ -1184,6 +1533,16 @@
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -1194,7 +1553,10 @@
 
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
         assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
-        assert_noop!(TemplateModule::remove_from_white_list(origin2.clone(), 1, 2), "This collection does not exist");
+        assert_noop!(
+            TemplateModule::remove_from_white_list(origin2.clone(), 1, 2),
+            "This collection does not exist"
+        );
         assert_eq!(TemplateModule::white_list(1).len(), 0);
     });
 }
@@ -1209,6 +1571,16 @@
         let mode: CollectionMode = CollectionMode::NFT(2000);
         let origin1 = Origin::signed(1);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
             col_name1.clone(),
@@ -1218,8 +1590,16 @@
         ));
 
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 2));
-        assert_ok!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::remove_from_white_list(
+            origin1.clone(),
+            1,
+            2
+        ));
+        assert_ok!(TemplateModule::remove_from_white_list(
+            origin1.clone(),
+            1,
+            2
+        ));
         assert_eq!(TemplateModule::white_list(1).len(), 0);
     });
 }
@@ -1233,6 +1613,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -1250,16 +1640,17 @@
             1
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
-
-        assert_noop!(TemplateModule::transfer(
+        assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            3,
             1,
-            1,
-            1
-        ), "Address is not in white list");
+            AccessMode::WhiteList
+        ));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
+
+        assert_noop!(
+            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),
+            "Address is not in white list"
+        );
     });
 }
 
@@ -1271,6 +1662,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -1288,24 +1689,28 @@
             1
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
 
         // do approve
         assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));
         assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
-
-        assert_ok!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 1));
 
-        assert_noop!(TemplateModule::transfer_from(
+        assert_ok!(TemplateModule::remove_from_white_list(
             origin1.clone(),
-            1,
-            3,
             1,
-            1,
             1
-        ), "Address is not in white list");
+        ));
+
+        assert_noop!(
+            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),
+            "Address is not in white list"
+        );
     });
 }
 
@@ -1318,6 +1723,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -1335,16 +1750,17 @@
             1
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
-        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
-
-        assert_noop!(TemplateModule::transfer(
+        assert_ok!(TemplateModule::set_public_access_mode(
             origin1.clone(),
-            3,
             1,
-            1,
-            1
-        ), "Address is not in white list");
+            AccessMode::WhiteList
+        ));
+        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
+
+        assert_noop!(
+            TemplateModule::transfer(origin1.clone(), 3, 1, 1, 1),
+            "Address is not in white list"
+        );
     });
 }
 
@@ -1356,6 +1772,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -1373,7 +1799,11 @@
             1
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
 
@@ -1381,16 +1811,16 @@
         assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));
         assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
 
-        assert_ok!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 2));
-
-        assert_noop!(TemplateModule::transfer_from(
+        assert_ok!(TemplateModule::remove_from_white_list(
             origin1.clone(),
-            1,
-            3,
             1,
-            1,
-            1
-        ), "Address is not in white list");
+            2
+        ));
+
+        assert_noop!(
+            TemplateModule::transfer_from(origin1.clone(), 1, 3, 1, 1, 1),
+            "Address is not in white list"
+        );
     });
 }
 
@@ -1403,6 +1833,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -1420,8 +1860,15 @@
             1
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
-        assert_noop!(TemplateModule::burn_item(origin1.clone(), 1, 1), "Address is not in white list");
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
+        assert_noop!(
+            TemplateModule::burn_item(origin1.clone(), 1, 1),
+            "Address is not in white list"
+        );
     });
 }
 
@@ -1434,6 +1881,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -1442,10 +1899,17 @@
             token_prefix1.clone(),
             mode
         ));
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
 
         // do approve
-        assert_noop!(TemplateModule::approve(origin1.clone(), 1, 1, 1), "Address is not in white list");
+        assert_noop!(
+            TemplateModule::approve(origin1.clone(), 1, 1, 1),
+            "Address is not in white list"
+        );
     });
 }
 
@@ -1459,6 +1923,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -1476,17 +1950,15 @@
             1
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
 
-        assert_ok!(TemplateModule::transfer(
-            origin1.clone(),
-            2,
-            1,
-            1,
-            1
-        ));
+        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1));
     });
 }
 
@@ -1498,6 +1970,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -1515,7 +1997,11 @@
             1
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
 
@@ -1543,6 +2029,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -1552,8 +2048,16 @@
             mode
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, false));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            false
+        ));
 
         assert_ok!(TemplateModule::create_item(
             origin1.clone(),
@@ -1573,6 +2077,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -1583,8 +2097,16 @@
             mode
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, false));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            false
+        ));
 
         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
 
@@ -1606,6 +2128,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -1616,16 +2148,22 @@
             mode
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, false));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            false
+        ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
 
-        assert_noop!(TemplateModule::create_item(
-            origin2.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            2
-        ), "Collection is not in mint mode");
+        assert_noop!(
+            TemplateModule::create_item(origin2.clone(), 1, [1, 2, 3].to_vec(), 2),
+            "Collection is not in mint mode"
+        );
     });
 }
 
@@ -1638,6 +2176,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -1648,15 +2196,21 @@
             mode
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, false));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            false
+        ));
 
-        assert_noop!(TemplateModule::create_item(
-            origin2.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            2
-        ), "Collection is not in mint mode");
+        assert_noop!(
+            TemplateModule::create_item(origin2.clone(), 1, [1, 2, 3].to_vec(), 2),
+            "Collection is not in mint mode"
+        );
     });
 }
 
@@ -1669,6 +2223,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::create_collection(
             origin1.clone(),
@@ -1678,8 +2242,16 @@
             mode
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            true
+        ));
 
         assert_ok!(TemplateModule::create_item(
             origin1.clone(),
@@ -1699,6 +2271,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -1709,8 +2291,16 @@
             mode
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            true
+        ));
 
         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
 
@@ -1732,6 +2322,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -1742,15 +2342,21 @@
             mode
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            true
+        ));
 
-        assert_noop!(TemplateModule::create_item(
-            origin2.clone(),
-            1,
-            [1, 2, 3].to_vec(),
-            2
-        ), "Address is not in white list");
+        assert_noop!(
+            TemplateModule::create_item(origin2.clone(), 1, [1, 2, 3].to_vec(), 2),
+            "Address is not in white list"
+        );
     });
 }
 
@@ -1763,6 +2369,16 @@
         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
         let mode: CollectionMode = CollectionMode::NFT(2000);
 
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         assert_ok!(TemplateModule::create_collection(
@@ -1773,8 +2389,16 @@
             mode
         ));
 
-        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
-        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
+        assert_ok!(TemplateModule::set_public_access_mode(
+            origin1.clone(),
+            1,
+            AccessMode::WhiteList
+        ));
+        assert_ok!(TemplateModule::set_mint_permission(
+            origin1.clone(),
+            1,
+            true
+        ));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
 
         assert_ok!(TemplateModule::create_item(
@@ -1786,4 +2410,290 @@
     });
 }
 
-// #endregion
\ No newline at end of file
+// Total number of collections. Positive test
+#[test]
+fn total_number_collections_bound() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
+
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+    });
+}
+
+// Total number of collections. Negotive test
+#[test]
+fn total_number_collections_bound_neg() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
+
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
+        let origin1 = Origin::signed(1);
+
+        for _ in 0..10 {
+
+            assert_ok!(TemplateModule::create_collection(
+                origin1.clone(),
+                col_name1.clone(),
+                col_desc1.clone(),
+                token_prefix1.clone(),
+                mode.clone()
+            ));
+        }
+
+        // 11-th collection in chain. Expects error
+        assert_noop!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode.clone()
+        ), "Total collections bound exceeded");
+    });
+}
+
+// Owned tokens by a single address. Positive test
+#[test]
+fn owned_tokens_bound() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
+
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ));
+
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ));
+    });
+}
+
+// Owned tokens by a single address. Negotive test
+#[test]
+fn owned_tokens_bound_neg() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
+
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 1,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ));
+
+        assert_noop!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ), "Owned tokens by a single address bound exceeded");
+    });
+}
+
+// Number of collection admins. Positive test
+#[test]
+fn collection_admins_bound() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
+
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 2,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
+    });
+}
+
+// Number of collection admins. Negotive test
+#[test]
+fn collection_admins_bound_neg() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
+
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 1,
+            collections_admins_limit: 1,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
+        assert_noop!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3), "Number of collection admins bound exceeded");
+    });
+}
+
+// Custom data size. Positive test
+#[test]
+fn custom_data_size_bound() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
+
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 2048,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+    });
+}
+
+// Custom data size. Negotive test
+#[test]
+fn custom_data_size_bound_neg() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
+
+        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
+            collection_numbers_limit: 10,
+            account_token_ownership_limit: 10,
+            collections_admins_limit: 5,
+            custom_data_limit: 200,
+            nft_sponsor_transfer_timeout: 15,
+            fungible_sponsor_transfer_timeout: 15,
+            refungible_sponsor_transfer_timeout: 15,          
+        }));
+
+        let origin1 = Origin::signed(1);
+        assert_noop!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ), "Custom data size bound exceeded");
+    });
+}
+// #endregion