git.delta.rocks / unique-network / refs/commits / 0b7086fb4c87

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4935,12 +4935,15 @@
 name = "nft-data-structs"
 version = "0.9.0"
 dependencies = [
+ "derivative",
  "frame-support",
  "frame-system",
+ "max-encoded-len",
  "parity-scale-codec",
  "serde",
  "sp-core",
  "sp-runtime",
+ "sp-std",
 ]
 
 [[package]]
@@ -4999,6 +5002,7 @@
  "cumulus-primitives-core",
  "cumulus-primitives-timestamp",
  "cumulus-primitives-utility",
+ "derivative",
  "fp-rpc",
  "frame-benchmarking",
  "frame-executive",
@@ -5007,6 +5011,7 @@
  "frame-system-benchmarking",
  "frame-system-rpc-runtime-api",
  "hex-literal",
+ "max-encoded-len",
  "nft-data-structs",
  "pallet-aura",
  "pallet-balances",

--- a/node/cli/src/chain_spec.rs
+++ b/node/cli/src/chain_spec.rs
@@ -202,18 +202,6 @@
 			nft_item_id: vec![],
 			fungible_item_id: vec![],
 			refungible_item_id: vec![],
-			chain_limit: ChainLimits {
-				collection_numbers_limit: 100000,
-				account_token_ownership_limit: 1000000,
-				collections_admins_limit: 5,
-				custom_data_limit: 2048,
-				nft_sponsor_transfer_timeout: 15,
-				fungible_sponsor_transfer_timeout: 15,
-				refungible_sponsor_transfer_timeout: 15,
-				offchain_schema_limit: 1024,
-				variable_on_chain_schema_limit: 1024,
-				const_on_chain_schema_limit: 1024,
-			},
 		},
 		parachain_info: nft_runtime::ParachainInfoConfig { parachain_id: id },
 		aura: nft_runtime::AuraConfig {

--- a/pallets/nft/Cargo.toml
+++ b/pallets/nft/Cargo.toml
@@ -41,6 +41,7 @@
     'evm-coder/std',
     'pallet-evm-coder-substrate/std',
 ]
+limit-testing = ["nft-data-structs/limit-testing"]
 
 ################################################################################
 # Substrate Dependencies

--- a/pallets/nft/src/default_weights.rs
+++ b/pallets/nft/src/default_weights.rs
@@ -117,11 +117,6 @@
 			.saturating_add(DbWeight::get().reads(2_u64))
 			.saturating_add(DbWeight::get().writes(1_u64))
 	}
-	fn set_chain_limits() -> Weight {
-		1_300_000_u64
-			.saturating_add(DbWeight::get().reads(0_u64))
-			.saturating_add(DbWeight::get().writes(1_u64))
-	}
 	fn set_contract_sponsoring_rate_limit() -> Weight {
 		3_500_000_u64
 			.saturating_add(DbWeight::get().reads(0_u64))

--- a/pallets/nft/src/eth/sponsoring.rs
+++ b/pallets/nft/src/eth/sponsoring.rs
@@ -1,12 +1,12 @@
 //! Implements EVM sponsoring logic via OnChargeEVMTransaction
 
 use crate::{
-	ChainLimit, Collection, CollectionById, Config, FungibleTransferBasket, NftTransferBasket,
+	Collection, CollectionById, Config, FungibleTransferBasket, NftTransferBasket,
 	eth::{account::EvmBackwardsAddressMapping, map_eth_to_id},
 };
 use evm_coder::{Call, abi::AbiReader};
 use frame_support::{
-	storage::{StorageMap, StorageDoubleMap, StorageValue},
+	storage::{StorageMap, StorageDoubleMap},
 };
 use sp_core::H160;
 use sp_std::prelude::*;
@@ -17,6 +17,7 @@
 };
 use core::convert::TryInto;
 use core::marker::PhantomData;
+use nft_data_structs::{NFT_SPONSOR_TRANSFER_TIMEOUT, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT};
 
 struct AnyError;
 
@@ -43,7 +44,7 @@
 					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
 						collection_limits.sponsor_transfer_timeout
 					} else {
-						ChainLimit::get().nft_sponsor_transfer_timeout
+						NFT_SPONSOR_TRANSFER_TIMEOUT
 					};
 
 					let mut sponsor = true;
@@ -74,7 +75,7 @@
 					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
 						collection_limits.sponsor_transfer_timeout
 					} else {
-						ChainLimit::get().fungible_sponsor_transfer_timeout
+						FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
 					};
 
 					let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;

--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -31,14 +31,16 @@
 	StorageValue, transactional,
 };
 
-use frame_system::{self as system, ensure_signed, ensure_root};
+use frame_system::{self as system, ensure_signed};
 use sp_core::H160;
 use sp_std::vec;
 use sp_runtime::sp_std::prelude::Vec;
 use core::ops::{Deref, DerefMut};
 use nft_data_structs::{
 	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,
-	AccessMode, ChainLimits, Collection, CreateItemData, CollectionLimits, CollectionId,
+	CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
+	VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,
+	OFFCHAIN_SCHEMA_LIMIT, AccessMode, Collection, CreateItemData, CollectionLimits, CollectionId,
 	CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,
 	FungibleItemType, ReFungibleItemType,
 };
@@ -86,7 +88,6 @@
 	fn set_variable_meta_data() -> Weight;
 	fn enable_contract_sponsoring() -> Weight;
 	fn set_schema_version() -> Weight;
-	fn set_chain_limits() -> Weight;
 	fn set_contract_sponsoring_rate_limit() -> Weight;
 	fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;
 	fn toggle_contract_white_list() -> Weight;
@@ -278,10 +279,6 @@
 		/// Id of last collection token
 		/// Collection id (controlled?1)
 		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;
-		//#endregion
-
-		//#region Chain limits struct
-		pub ChainLimit get(fn chain_limit) config(): ChainLimits;
 		//#endregion
 
 		//#region Bound counters
@@ -435,6 +432,7 @@
 		origin: T::Origin
 	{
 		fn deposit_event() = default;
+		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;
 		type Error = Error<T>;
 
 		fn on_initialize(_now: T::BlockNumber) -> Weight {
@@ -485,14 +483,12 @@
 				CollectionMode::Fungible(points) => points,
 				_ => 0
 			};
-
-			let chain_limit = ChainLimit::get();
 
 			let created_count = CreatedCollectionCount::get();
 			let destroyed_count = DestroyedCollectionCount::get();
 
 			// bound Total number of collections
-			ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);
+			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);
 
 			// check params
 			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);
@@ -508,7 +504,7 @@
 			CreatedCollectionCount::put(next_id);
 
 			let limits = CollectionLimits {
-				sponsored_data_size: chain_limit.custom_data_limit,
+				sponsored_data_size: CUSTOM_DATA_LIMIT,
 				..Default::default()
 			};
 
@@ -737,8 +733,7 @@
 			match admin_arr.binary_search(&new_admin_id) {
 				Ok(_) => {},
 				Err(idx) => {
-					let limits = ChainLimit::get();
-					ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);
+					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);
 					admin_arr.insert(idx, new_admin_id);
 					<AdminList<T>>::insert(collection_id, admin_arr);
 				}
@@ -1138,7 +1133,7 @@
 			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
 
 			// check schema limit
-			ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");
+			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");
 
 			target_collection.offchain_schema = schema;
 			target_collection.save()
@@ -1168,7 +1163,7 @@
 			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
 
 			// check schema limit
-			ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");
+			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");
 
 			target_collection.const_on_chain_schema = schema;
 			target_collection.save()
@@ -1198,25 +1193,10 @@
 			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
 
 			// check schema limit
-			ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");
+			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");
 
 			target_collection.variable_on_chain_schema = schema;
 			target_collection.save()
-		}
-
-		// Sudo permissions function
-		#[weight = <T as Config>::WeightInfo::set_chain_limits()]
-		#[transactional]
-		pub fn set_chain_limits(
-			origin,
-			limits: ChainLimits
-		) -> DispatchResult {
-
-			#[cfg(not(feature = "runtime-benchmarks"))]
-			ensure_root(origin)?;
-
-			<ChainLimit>::put(limits);
-			Ok(())
 		}
 
 		#[weight = <T as Config>::WeightInfo::set_collection_limits()]
@@ -1230,12 +1210,11 @@
 			let mut target_collection = Self::get_collection(collection_id)?;
 			Self::check_owner_permissions(&target_collection, sender.as_sub())?;
 			let old_limits = &target_collection.limits;
-			let chain_limits = ChainLimit::get();
 
 			// collection bounds
 			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&
 				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&
-				new_limits.sponsored_data_size <= chain_limits.custom_data_limit,
+				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,
 				Error::<T>::CollectionLimitBoundsExceeded);
 
 			// token_limit   check  prev
@@ -1471,7 +1450,7 @@
 		Self::token_exists(collection, item_id)?;
 
 		ensure!(
-			ChainLimit::get().custom_data_limit >= data.len() as u32,
+			CUSTOM_DATA_LIMIT >= data.len() as u32,
 			Error::<T>::TokenVariableDataLimitExceeded
 		);
 
@@ -1616,38 +1595,17 @@
 	) -> DispatchResult {
 		match target_collection.mode {
 			CollectionMode::NFT => {
-				if let CreateItemData::NFT(data) = data {
-					// check sizes
-					ensure!(
-						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,
-						Error::<T>::TokenConstDataLimitExceeded
-					);
-					ensure!(
-						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,
-						Error::<T>::TokenVariableDataLimitExceeded
-					);
-				} else {
+				if !matches!(data, CreateItemData::NFT(_)) {
 					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);
 				}
 			}
 			CollectionMode::Fungible(_) => {
-				if let CreateItemData::Fungible(_) = data {
-				} else {
+				if !matches!(data, CreateItemData::Fungible(_)) {
 					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);
 				}
 			}
 			CollectionMode::ReFungible => {
 				if let CreateItemData::ReFungible(data) = data {
-					// check sizes
-					ensure!(
-						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,
-						Error::<T>::TokenConstDataLimitExceeded
-					);
-					ensure!(
-						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,
-						Error::<T>::TokenVariableDataLimitExceeded
-					);
-
 					// Check refungibility limits
 					ensure!(
 						data.pieces <= MAX_REFUNGIBLE_PIECES,
@@ -1675,8 +1633,8 @@
 			CreateItemData::NFT(data) => {
 				let item = NftItemType {
 					owner: owner.clone(),
-					const_data: data.const_data,
-					variable_data: data.variable_data,
+					const_data: data.const_data.into_inner(),
+					variable_data: data.variable_data.into_inner(),
 				};
 
 				Self::add_nft_item(collection, item)?;
@@ -1692,8 +1650,8 @@
 
 				let item = ReFungibleItemType {
 					owner: owner_list,
-					const_data: data.const_data,
-					variable_data: data.variable_data,
+					const_data: data.const_data.into_inner(),
+					variable_data: data.variable_data.into_inner(),
 				};
 
 				Self::add_refungible_item(collection, item)?;
@@ -2292,7 +2250,7 @@
 			// bound Owned tokens by a single address
 			let count = <AccountItemCount<T>>::get(owner.as_sub());
 			ensure!(
-				count < ChainLimit::get().account_token_ownership_limit,
+				count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
 				Error::<T>::AddressOwnershipLimitExceeded
 			);
 

--- a/pallets/nft/src/sponsorship.rs
+++ b/pallets/nft/src/sponsorship.rs
@@ -1,15 +1,18 @@
 use crate::{
 	Config, Call, CollectionById, CreateItemBasket, VariableMetaDataBasket,
-	ReFungibleTransferBasket, FungibleTransferBasket, NftTransferBasket, ChainLimit,
-	CreateItemData, CollectionMode,
+	ReFungibleTransferBasket, FungibleTransferBasket, NftTransferBasket, CreateItemData,
+	CollectionMode,
 };
 use core::marker::PhantomData;
 use up_sponsorship::SponsorshipHandler;
 use frame_support::{
-	traits::IsSubType,
-	storage::{StorageMap, StorageDoubleMap, StorageValue},
+	traits::{IsSubType},
+	storage::{StorageMap, StorageDoubleMap},
+};
+use nft_data_structs::{
+	TokenId, CollectionId, NFT_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
+	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
 };
-use nft_data_structs::{TokenId, CollectionId};
 
 pub struct NftSponsorshipHandler<T>(PhantomData<T>);
 impl<T: Config> NftSponsorshipHandler<T> {
@@ -47,7 +50,6 @@
 		item_id: &TokenId,
 	) -> Option<T::AccountId> {
 		let collection = CollectionById::<T>::get(collection_id)?;
-		let limits = ChainLimit::get();
 
 		let mut sponsor_transfer = false;
 		if collection.sponsorship.confirmed() {
@@ -62,7 +64,7 @@
 					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
 						collection_limits.sponsor_transfer_timeout
 					} else {
-						limits.nft_sponsor_transfer_timeout
+						NFT_SPONSOR_TRANSFER_TIMEOUT
 					};
 
 					let mut sponsored = true;
@@ -84,7 +86,7 @@
 					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
 						collection_limits.sponsor_transfer_timeout
 					} else {
-						limits.fungible_sponsor_transfer_timeout
+						FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
 					};
 
 					let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;
@@ -107,7 +109,7 @@
 					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
 						collection_limits.sponsor_transfer_timeout
 					} else {
-						limits.refungible_sponsor_transfer_timeout
+						REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
 					};
 
 					let mut sponsored = true;

1// Tests to be written here1// Tests to be written here
2use super::*;2use super::*;
3use crate::mock::*;3use crate::mock::*;
4use crate::{AccessMode, CollectionMode, Ownership, ChainLimits, CreateItemData};4use crate::{AccessMode, CollectionMode, Ownership, CreateItemData};
5use nft_data_structs::{5use nft_data_structs::{
6	CreateNftData, CreateFungibleData, CreateReFungibleData, CollectionId, TokenId,6	CreateNftData, CreateFungibleData, CreateReFungibleData, CollectionId, TokenId,
7	MAX_DECIMAL_POINTS,7	MAX_DECIMAL_POINTS,
8};8};
9use frame_support::{assert_noop, assert_ok};9use frame_support::{assert_noop, assert_ok};
10use frame_system::{RawOrigin};10use sp_std::convert::TryInto;
1111
12fn default_collection_numbers_limit() -> u32 {
13	10
14}
15
16fn default_limits() {
17	assert_ok!(TemplateModule::set_chain_limits(
18		RawOrigin::Root.into(),
19		ChainLimits {
20			collection_numbers_limit: default_collection_numbers_limit(),
21			account_token_ownership_limit: 10,
22			collections_admins_limit: 5,
23			custom_data_limit: 2048,
24			nft_sponsor_transfer_timeout: 15,
25			fungible_sponsor_transfer_timeout: 15,
26			refungible_sponsor_transfer_timeout: 15,
27			const_on_chain_schema_limit: 1024,
28			offchain_schema_limit: 1024,
29			variable_on_chain_schema_limit: 1024,
30		}
31	));
32}
33
34fn default_nft_data() -> CreateNftData {12fn default_nft_data() -> CreateNftData {
35	CreateNftData {13	CreateNftData {
36		const_data: vec![1, 2, 3],14		const_data: vec![1, 2, 3].try_into().unwrap(),
37		variable_data: vec![3, 2, 1],15		variable_data: vec![3, 2, 1].try_into().unwrap(),
38	}16	}
39}17}
4018
4422
45fn default_re_fungible_data() -> CreateReFungibleData {23fn default_re_fungible_data() -> CreateReFungibleData {
46	CreateReFungibleData {24	CreateReFungibleData {
47		const_data: vec![1, 2, 3],25		const_data: vec![1, 2, 3].try_into().unwrap(),
48		variable_data: vec![3, 2, 1],26		variable_data: vec![3, 2, 1].try_into().unwrap(),
49		pieces: 1023,27		pieces: 1023,
50	}28	}
51}29}
112#[test]90#[test]
113fn set_version_schema() {91fn set_version_schema() {
114	new_test_ext().execute_with(|| {92	new_test_ext().execute_with(|| {
115		default_limits();
116		let origin1 = Origin::signed(1);93		let origin1 = Origin::signed(1);
117		let collection_id = create_test_collection(&CollectionMode::NFT, 1);94		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
11895
133#[test]110#[test]
134fn create_fungible_collection_fails_with_large_decimal_numbers() {111fn create_fungible_collection_fails_with_large_decimal_numbers() {
135	new_test_ext().execute_with(|| {112	new_test_ext().execute_with(|| {
136		default_limits();
137
138		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();113		let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
139		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();114		let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
140		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();115		let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
156#[test]131#[test]
157fn create_nft_item() {132fn create_nft_item() {
158	new_test_ext().execute_with(|| {133	new_test_ext().execute_with(|| {
159		default_limits();
160		let collection_id = create_test_collection(&CollectionMode::NFT, 1);134		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
161135
162		let data = default_nft_data();136		let data = default_nft_data();
163		create_test_item(collection_id, &data.clone().into());137		create_test_item(collection_id, &data.clone().into());
164		let item = TemplateModule::nft_item_id(collection_id, 1).unwrap();138		let item = TemplateModule::nft_item_id(collection_id, 1).unwrap();
165		assert_eq!(item.const_data, data.const_data);139		assert_eq!(item.const_data, data.const_data.into_inner());
166		assert_eq!(item.variable_data, data.variable_data);140		assert_eq!(item.variable_data, data.variable_data.into_inner());
167	});141	});
168}142}
169143
172#[test]146#[test]
173fn create_nft_multiple_items() {147fn create_nft_multiple_items() {
174	new_test_ext().execute_with(|| {148	new_test_ext().execute_with(|| {
175		default_limits();
176
177		create_test_collection(&CollectionMode::NFT, 1);149		create_test_collection(&CollectionMode::NFT, 1);
178150
179		let origin1 = Origin::signed(1);151		let origin1 = Origin::signed(1);
190				.map(|d| { d.into() })162				.map(|d| { d.into() })
191				.collect()163				.collect()
192		));164		));
193		for (index, data) in items_data.iter().enumerate() {165		for (index, data) in items_data.into_iter().enumerate() {
194			let item = TemplateModule::nft_item_id(1, (index + 1) as TokenId).unwrap();166			let item = TemplateModule::nft_item_id(1, (index + 1) as TokenId).unwrap();
195			assert_eq!(item.const_data.to_vec(), data.const_data);167			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());
196			assert_eq!(item.variable_data.to_vec(), data.variable_data);168			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());
197		}169		}
198	});170	});
199}171}
200172
201#[test]173#[test]
202fn create_refungible_item() {174fn create_refungible_item() {
203	new_test_ext().execute_with(|| {175	new_test_ext().execute_with(|| {
204		default_limits();
205		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);176		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);
206177
207		let data = default_re_fungible_data();178		let data = default_re_fungible_data();
208		create_test_item(collection_id, &data.clone().into());179		create_test_item(collection_id, &data.clone().into());
209		let item = TemplateModule::refungible_item_id(collection_id, 1).unwrap();180		let item = TemplateModule::refungible_item_id(collection_id, 1).unwrap();
210		assert_eq!(item.const_data, data.const_data);181		assert_eq!(item.const_data, data.const_data.into_inner());
211		assert_eq!(item.variable_data, data.variable_data);182		assert_eq!(item.variable_data, data.variable_data.into_inner());
212		assert_eq!(183		assert_eq!(
213			item.owner[0],184			item.owner[0],
214			Ownership {185			Ownership {
222#[test]193#[test]
223fn create_multiple_refungible_items() {194fn create_multiple_refungible_items() {
224	new_test_ext().execute_with(|| {195	new_test_ext().execute_with(|| {
225		default_limits();
226
227		create_test_collection(&CollectionMode::ReFungible, 1);196		create_test_collection(&CollectionMode::ReFungible, 1);
228197
229		let origin1 = Origin::signed(1);198		let origin1 = Origin::signed(1);
244				.map(|d| { d.into() })213				.map(|d| { d.into() })
245				.collect()214				.collect()
246		));215		));
247		for (index, data) in items_data.iter().enumerate() {216		for (index, data) in items_data.into_iter().enumerate() {
248			let item = TemplateModule::refungible_item_id(1, (index + 1) as TokenId).unwrap();217			let item = TemplateModule::refungible_item_id(1, (index + 1) as TokenId).unwrap();
249			assert_eq!(item.const_data.to_vec(), data.const_data);218			assert_eq!(item.const_data.to_vec(), data.const_data.into_inner());
250			assert_eq!(item.variable_data.to_vec(), data.variable_data);219			assert_eq!(item.variable_data.to_vec(), data.variable_data.into_inner());
251			assert_eq!(220			assert_eq!(
252				item.owner[0],221				item.owner[0],
253				Ownership {222				Ownership {
262#[test]231#[test]
263fn create_fungible_item() {232fn create_fungible_item() {
264	new_test_ext().execute_with(|| {233	new_test_ext().execute_with(|| {
265		default_limits();
266
267		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);234		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);
268235
269		let data = default_fungible_data();236		let data = default_fungible_data();
302#[test]269#[test]
303fn transfer_fungible_item() {270fn transfer_fungible_item() {
304	new_test_ext().execute_with(|| {271	new_test_ext().execute_with(|| {
305		default_limits();
306
307		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);272		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);
308273
309		let origin1 = Origin::signed(1);274		let origin1 = Origin::signed(1);
344#[test]309#[test]
345fn transfer_refungible_item() {310fn transfer_refungible_item() {
346	new_test_ext().execute_with(|| {311	new_test_ext().execute_with(|| {
347		default_limits();
348
349		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);312		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);
350313
351		let data = default_re_fungible_data();314		let data = default_re_fungible_data();
355		let origin2 = Origin::signed(2);318		let origin2 = Origin::signed(2);
356		{319		{
357			let item = TemplateModule::refungible_item_id(collection_id, 1).unwrap();320			let item = TemplateModule::refungible_item_id(collection_id, 1).unwrap();
358			assert_eq!(item.const_data, data.const_data);321			assert_eq!(item.const_data, data.const_data.into_inner());
359			assert_eq!(item.variable_data, data.variable_data);322			assert_eq!(item.variable_data, data.variable_data.into_inner());
360			assert_eq!(323			assert_eq!(
361				item.owner[0],324				item.owner[0],
362				Ownership {325				Ownership {
441#[test]404#[test]
442fn transfer_nft_item() {405fn transfer_nft_item() {
443	new_test_ext().execute_with(|| {406	new_test_ext().execute_with(|| {
444		default_limits();
445
446		let collection_id = create_test_collection(&CollectionMode::NFT, 1);407		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
447408
448		let data = default_nft_data();409		let data = default_nft_data();
464#[test]425#[test]
465fn nft_approve_and_transfer_from() {426fn nft_approve_and_transfer_from() {
466	new_test_ext().execute_with(|| {427	new_test_ext().execute_with(|| {
467		default_limits();
468
469		let collection_id = create_test_collection(&CollectionMode::NFT, 1);428		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
470429
471		let data = default_nft_data();430		let data = default_nft_data();
503#[test]462#[test]
504fn nft_approve_and_transfer_from_white_list() {463fn nft_approve_and_transfer_from_white_list() {
505	new_test_ext().execute_with(|| {464	new_test_ext().execute_with(|| {
506		default_limits();
507
508		let collection_id = create_test_collection(&CollectionMode::NFT, 1);465		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
509466
510		let origin1 = Origin::signed(1);467		let origin1 = Origin::signed(1);
514		create_test_item(collection_id, &data.clone().into());471		create_test_item(collection_id, &data.clone().into());
515472
516		assert_eq!(473		assert_eq!(
517			TemplateModule::nft_item_id(1, 1).unwrap().const_data,474			&TemplateModule::nft_item_id(1, 1).unwrap().const_data,
518			data.const_data475			&data.const_data.into_inner()
519		);476		);
520		assert_eq!(TemplateModule::balance_count(1, 1), 1);477		assert_eq!(TemplateModule::balance_count(1, 1), 1);
521		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);478		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
573#[test]530#[test]
574fn refungible_approve_and_transfer_from() {531fn refungible_approve_and_transfer_from() {
575	new_test_ext().execute_with(|| {532	new_test_ext().execute_with(|| {
576		default_limits();
577
578		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);533		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);
579534
580		let origin1 = Origin::signed(1);535		let origin1 = Origin::signed(1);
636#[test]591#[test]
637fn fungible_approve_and_transfer_from() {592fn fungible_approve_and_transfer_from() {
638	new_test_ext().execute_with(|| {593	new_test_ext().execute_with(|| {
639		default_limits();
640
641		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);594		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);
642595
643		let data = default_fungible_data();596		let data = default_fungible_data();
710#[test]663#[test]
711fn change_collection_owner() {664fn change_collection_owner() {
712	new_test_ext().execute_with(|| {665	new_test_ext().execute_with(|| {
713		default_limits();
714
715		let collection_id = create_test_collection(&CollectionMode::NFT, 1);666		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
716667
717		let origin1 = Origin::signed(1);668		let origin1 = Origin::signed(1);
730#[test]681#[test]
731fn destroy_collection() {682fn destroy_collection() {
732	new_test_ext().execute_with(|| {683	new_test_ext().execute_with(|| {
733		default_limits();
734
735		let collection_id = create_test_collection(&CollectionMode::NFT, 1);684		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
736685
737		let origin1 = Origin::signed(1);686		let origin1 = Origin::signed(1);
742#[test]691#[test]
743fn burn_nft_item() {692fn burn_nft_item() {
744	new_test_ext().execute_with(|| {693	new_test_ext().execute_with(|| {
745		default_limits();
746
747		let collection_id = create_test_collection(&CollectionMode::NFT, 1);694		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
748695
749		let origin1 = Origin::signed(1);696		let origin1 = Origin::signed(1);
773#[test]720#[test]
774fn burn_fungible_item() {721fn burn_fungible_item() {
775	new_test_ext().execute_with(|| {722	new_test_ext().execute_with(|| {
776		default_limits();
777
778		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);723		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);
779724
780		let origin1 = Origin::signed(1);725		let origin1 = Origin::signed(1);
804#[test]749#[test]
805fn burn_refungible_item() {750fn burn_refungible_item() {
806	new_test_ext().execute_with(|| {751	new_test_ext().execute_with(|| {
807		default_limits();
808
809		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);752		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);
810		let origin1 = Origin::signed(1);753		let origin1 = Origin::signed(1);
811754
851#[test]794#[test]
852fn add_collection_admin() {795fn add_collection_admin() {
853	new_test_ext().execute_with(|| {796	new_test_ext().execute_with(|| {
854		default_limits();
855
856		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);797		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);
857		create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);798		create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);
858		create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);799		create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);
879#[test]820#[test]
880fn remove_collection_admin() {821fn remove_collection_admin() {
881	new_test_ext().execute_with(|| {822	new_test_ext().execute_with(|| {
882		default_limits();
883
884		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);823		let collection1_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);
885		create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);824		create_test_collection_for_owner(&CollectionMode::NFT, 2, 2);
886		create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);825		create_test_collection_for_owner(&CollectionMode::NFT, 3, 3);
916#[test]855#[test]
917fn balance_of() {856fn balance_of() {
918	new_test_ext().execute_with(|| {857	new_test_ext().execute_with(|| {
919		default_limits();
920
921		let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1);858		let nft_collection_id = create_test_collection(&CollectionMode::NFT, 1);
922		let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2);859		let fungible_collection_id = create_test_collection(&CollectionMode::Fungible(3), 2);
923		let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible, 3);860		let re_fungible_collection_id = create_test_collection(&CollectionMode::ReFungible, 3);
969#[test]906#[test]
970fn approve() {907fn approve() {
971	new_test_ext().execute_with(|| {908	new_test_ext().execute_with(|| {
972		default_limits();
973
974		let collection_id = create_test_collection(&CollectionMode::NFT, 1);909		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
975910
976		let data = default_nft_data();911		let data = default_nft_data();
987#[test]922#[test]
988fn transfer_from() {923fn transfer_from() {
989	new_test_ext().execute_with(|| {924	new_test_ext().execute_with(|| {
990		default_limits();
991
992		let collection_id = create_test_collection(&CollectionMode::NFT, 1);925		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
993		let origin1 = Origin::signed(1);926		let origin1 = Origin::signed(1);
994		let origin2 = Origin::signed(2);927		let origin2 = Origin::signed(2);
1051#[test]984#[test]
1052fn owner_can_add_address_to_white_list() {985fn owner_can_add_address_to_white_list() {
1053	new_test_ext().execute_with(|| {986	new_test_ext().execute_with(|| {
1054		default_limits();
1055
1056		let collection_id = create_test_collection(&CollectionMode::NFT, 1);987		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1057988
1058		let origin1 = Origin::signed(1);989		let origin1 = Origin::signed(1);
1068#[test]999#[test]
1069fn admin_can_add_address_to_white_list() {1000fn admin_can_add_address_to_white_list() {
1070	new_test_ext().execute_with(|| {1001	new_test_ext().execute_with(|| {
1071		default_limits();
1072
1073		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1002		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1074		let origin1 = Origin::signed(1);1003		let origin1 = Origin::signed(1);
1075		let origin2 = Origin::signed(2);1004		let origin2 = Origin::signed(2);
1091#[test]1020#[test]
1092fn nonprivileged_user_cannot_add_address_to_white_list() {1021fn nonprivileged_user_cannot_add_address_to_white_list() {
1093	new_test_ext().execute_with(|| {1022	new_test_ext().execute_with(|| {
1094		default_limits();
1095
1096		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1023		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
10971024
1098		let origin2 = Origin::signed(2);1025		let origin2 = Origin::signed(2);
1106#[test]1033#[test]
1107fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {1034fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {
1108	new_test_ext().execute_with(|| {1035	new_test_ext().execute_with(|| {
1109		default_limits();
1110
1111		let origin1 = Origin::signed(1);1036		let origin1 = Origin::signed(1);
11121037
1113		assert_noop!(1038		assert_noop!(
1120#[test]1045#[test]
1121fn nobody_can_add_address_to_white_list_of_deleted_collection() {1046fn nobody_can_add_address_to_white_list_of_deleted_collection() {
1122	new_test_ext().execute_with(|| {1047	new_test_ext().execute_with(|| {
1123		default_limits();
1124
1125		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1048		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
11261049
1127		let origin1 = Origin::signed(1);1050		let origin1 = Origin::signed(1);
1140#[test]1063#[test]
1141fn address_is_already_added_to_white_list() {1064fn address_is_already_added_to_white_list() {
1142	new_test_ext().execute_with(|| {1065	new_test_ext().execute_with(|| {
1143		default_limits();
1144
1145		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1066		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1146		let origin1 = Origin::signed(1);1067		let origin1 = Origin::signed(1);
11471068
1162#[test]1083#[test]
1163fn owner_can_remove_address_from_white_list() {1084fn owner_can_remove_address_from_white_list() {
1164	new_test_ext().execute_with(|| {1085	new_test_ext().execute_with(|| {
1165		default_limits();
1166
1167		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1086		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
11681087
1169		let origin1 = Origin::signed(1);1088		let origin1 = Origin::signed(1);
1184#[test]1103#[test]
1185fn admin_can_remove_address_from_white_list() {1104fn admin_can_remove_address_from_white_list() {
1186	new_test_ext().execute_with(|| {1105	new_test_ext().execute_with(|| {
1187		default_limits();
1188
1189		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1106		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1190		let origin1 = Origin::signed(1);1107		let origin1 = Origin::signed(1);
1191		let origin2 = Origin::signed(2);1108		let origin2 = Origin::signed(2);
1213#[test]1130#[test]
1214fn nonprivileged_user_cannot_remove_address_from_white_list() {1131fn nonprivileged_user_cannot_remove_address_from_white_list() {
1215	new_test_ext().execute_with(|| {1132	new_test_ext().execute_with(|| {
1216		default_limits();
1217
1218		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1133		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1219		let origin1 = Origin::signed(1);1134		let origin1 = Origin::signed(1);
1220		let origin2 = Origin::signed(2);1135		let origin2 = Origin::signed(2);
1235#[test]1150#[test]
1236fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {1151fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {
1237	new_test_ext().execute_with(|| {1152	new_test_ext().execute_with(|| {
1238		default_limits();
1239		let origin1 = Origin::signed(1);1153		let origin1 = Origin::signed(1);
12401154
1241		assert_noop!(1155		assert_noop!(
1248#[test]1162#[test]
1249fn nobody_can_remove_address_from_white_list_of_deleted_collection() {1163fn nobody_can_remove_address_from_white_list_of_deleted_collection() {
1250	new_test_ext().execute_with(|| {1164	new_test_ext().execute_with(|| {
1251		default_limits();
1252
1253		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1165		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1254		let origin1 = Origin::signed(1);1166		let origin1 = Origin::signed(1);
1255		let origin2 = Origin::signed(2);1167		let origin2 = Origin::signed(2);
1272#[test]1184#[test]
1273fn address_is_already_removed_from_white_list() {1185fn address_is_already_removed_from_white_list() {
1274	new_test_ext().execute_with(|| {1186	new_test_ext().execute_with(|| {
1275		default_limits();
1276
1277		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1187		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1278		let origin1 = Origin::signed(1);1188		let origin1 = Origin::signed(1);
12791189
1300#[test]1210#[test]
1301fn white_list_test_1() {1211fn white_list_test_1() {
1302	new_test_ext().execute_with(|| {1212	new_test_ext().execute_with(|| {
1303		default_limits();
1304
1305		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1213		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
13061214
1307		let origin1 = Origin::signed(1);1215		let origin1 = Origin::signed(1);
1330#[test]1238#[test]
1331fn white_list_test_2() {1239fn white_list_test_2() {
1332	new_test_ext().execute_with(|| {1240	new_test_ext().execute_with(|| {
1333		default_limits();
1334
1335		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1241		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1336		let origin1 = Origin::signed(1);1242		let origin1 = Origin::signed(1);
13371243
1381#[test]1287#[test]
1382fn white_list_test_3() {1288fn white_list_test_3() {
1383	new_test_ext().execute_with(|| {1289	new_test_ext().execute_with(|| {
1384		default_limits();
1385
1386		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1290		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
13871291
1388		let origin1 = Origin::signed(1);1292		let origin1 = Origin::signed(1);
1411#[test]1315#[test]
1412fn white_list_test_4() {1316fn white_list_test_4() {
1413	new_test_ext().execute_with(|| {1317	new_test_ext().execute_with(|| {
1414		default_limits();
1415
1416		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1318		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
14171319
1418		let origin1 = Origin::signed(1);1320		let origin1 = Origin::signed(1);
1463#[test]1365#[test]
1464fn white_list_test_5() {1366fn white_list_test_5() {
1465	new_test_ext().execute_with(|| {1367	new_test_ext().execute_with(|| {
1466		default_limits();
1467
1468		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1368		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
14691369
1470		let origin1 = Origin::signed(1);1370		let origin1 = Origin::signed(1);
1488#[test]1388#[test]
1489fn white_list_test_6() {1389fn white_list_test_6() {
1490	new_test_ext().execute_with(|| {1390	new_test_ext().execute_with(|| {
1491		default_limits();
1492
1493		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1391		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
14941392
1495		let origin1 = Origin::signed(1);1393		let origin1 = Origin::signed(1);
1516#[test]1414#[test]
1517fn white_list_test_7() {1415fn white_list_test_7() {
1518	new_test_ext().execute_with(|| {1416	new_test_ext().execute_with(|| {
1519		default_limits();
1520
1521		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1417		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
15221418
1523		let data = default_nft_data();1419		let data = default_nft_data();
1548#[test]1444#[test]
1549fn white_list_test_8() {1445fn white_list_test_8() {
1550	new_test_ext().execute_with(|| {1446	new_test_ext().execute_with(|| {
1551		default_limits();
1552
1553		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1447		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
15541448
1555		let data = default_nft_data();1449		let data = default_nft_data();
1598#[test]1492#[test]
1599fn white_list_test_9() {1493fn white_list_test_9() {
1600	new_test_ext().execute_with(|| {1494	new_test_ext().execute_with(|| {
1601		default_limits();
1602
1603		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1495		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1604		let origin1 = Origin::signed(1);1496		let origin1 = Origin::signed(1);
16051497
1623#[test]1515#[test]
1624fn white_list_test_10() {1516fn white_list_test_10() {
1625	new_test_ext().execute_with(|| {1517	new_test_ext().execute_with(|| {
1626		default_limits();
1627
1628		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1518		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
16291519
1630		let origin1 = Origin::signed(1);1520		let origin1 = Origin::signed(1);
1660#[test]1550#[test]
1661fn white_list_test_11() {1551fn white_list_test_11() {
1662	new_test_ext().execute_with(|| {1552	new_test_ext().execute_with(|| {
1663		default_limits();
1664
1665		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1553		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
16661554
1667		let origin1 = Origin::signed(1);1555		let origin1 = Origin::signed(1);
1694#[test]1582#[test]
1695fn white_list_test_12() {1583fn white_list_test_12() {
1696	new_test_ext().execute_with(|| {1584	new_test_ext().execute_with(|| {
1697		default_limits();
1698
1699		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1585		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
17001586
1701		let origin1 = Origin::signed(1);1587		let origin1 = Origin::signed(1);
1723#[test]1609#[test]
1724fn white_list_test_13() {1610fn white_list_test_13() {
1725	new_test_ext().execute_with(|| {1611	new_test_ext().execute_with(|| {
1726		default_limits();
1727
1728		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1612		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
17291613
1730		let origin1 = Origin::signed(1);1614		let origin1 = Origin::signed(1);
1749#[test]1633#[test]
1750fn white_list_test_14() {1634fn white_list_test_14() {
1751	new_test_ext().execute_with(|| {1635	new_test_ext().execute_with(|| {
1752		default_limits();
1753
1754		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1636		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
17551637
1756		let origin1 = Origin::signed(1);1638		let origin1 = Origin::signed(1);
1786#[test]1668#[test]
1787fn white_list_test_15() {1669fn white_list_test_15() {
1788	new_test_ext().execute_with(|| {1670	new_test_ext().execute_with(|| {
1789		default_limits();
1790
1791		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1671		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
17921672
1793		let origin1 = Origin::signed(1);1673		let origin1 = Origin::signed(1);
1815#[test]1695#[test]
1816fn white_list_test_16() {1696fn white_list_test_16() {
1817	new_test_ext().execute_with(|| {1697	new_test_ext().execute_with(|| {
1818		default_limits();
1819
1820		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1698		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
18211699
1822		let origin1 = Origin::signed(1);1700		let origin1 = Origin::signed(1);
1851#[test]1729#[test]
1852fn total_number_collections_bound() {1730fn total_number_collections_bound() {
1853	new_test_ext().execute_with(|| {1731	new_test_ext().execute_with(|| {
1854		default_limits();
1855
1856		create_test_collection(&CollectionMode::NFT, 1);1732		create_test_collection(&CollectionMode::NFT, 1);
1857	});1733	});
1858}1734}
1861#[test]1737#[test]
1862fn total_number_collections_bound_neg() {1738fn total_number_collections_bound_neg() {
1863	new_test_ext().execute_with(|| {1739	new_test_ext().execute_with(|| {
1864		default_limits();
1865
1866		let origin1 = Origin::signed(1);1740		let origin1 = Origin::signed(1);
18671741
1868		for i in 0..default_collection_numbers_limit() {1742		for i in 0..COLLECTION_NUMBER_LIMIT {
1869			create_test_collection(&CollectionMode::NFT, i + 1);1743			create_test_collection(&CollectionMode::NFT, i + 1);
1870		}1744		}
18711745
1891#[test]1765#[test]
1892fn owned_tokens_bound() {1766fn owned_tokens_bound() {
1893	new_test_ext().execute_with(|| {1767	new_test_ext().execute_with(|| {
1894		default_limits();
1895
1896		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1768		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
18971769
1898		let data = default_nft_data();1770		let data = default_nft_data();
1905#[test]1777#[test]
1906fn owned_tokens_bound_neg() {1778fn owned_tokens_bound_neg() {
1907	new_test_ext().execute_with(|| {1779	new_test_ext().execute_with(|| {
1908		assert_ok!(TemplateModule::set_chain_limits(
1909			RawOrigin::Root.into(),
1910			ChainLimits {
1911				collection_numbers_limit: 10,
1912				account_token_ownership_limit: 1,
1913				collections_admins_limit: 5,
1914				custom_data_limit: 2048,
1915				nft_sponsor_transfer_timeout: 15,
1916				fungible_sponsor_transfer_timeout: 15,
1917				refungible_sponsor_transfer_timeout: 15,
1918				const_on_chain_schema_limit: 1024,
1919				offchain_schema_limit: 1024,
1920				variable_on_chain_schema_limit: 1024,
1921			}
1922		));
1923
1924		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1780		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
19251781
1926		let origin1 = Origin::signed(1);1782		let origin1 = Origin::signed(1);
1927		let data = default_nft_data();
1928		create_test_item(collection_id, &data.clone().into());
19291783
1784		for _ in 0..ACCOUNT_TOKEN_OWNERSHIP_LIMIT {
1785			let data = default_nft_data();
1786			create_test_item(collection_id, &data.clone().into());
1787		}
1788
1789		let data = default_nft_data();
1930		assert_noop!(1790		assert_noop!(
1931			TemplateModule::create_item(origin1, 1, account(1), data.into()),1791			TemplateModule::create_item(origin1, 1, account(1), data.into()),
1932			Error::<Test>::AddressOwnershipLimitExceeded1792			Error::<Test>::AddressOwnershipLimitExceeded
1938#[test]1798#[test]
1939fn collection_admins_bound() {1799fn collection_admins_bound() {
1940	new_test_ext().execute_with(|| {1800	new_test_ext().execute_with(|| {
1941		assert_ok!(TemplateModule::set_chain_limits(
1942			RawOrigin::Root.into(),
1943			ChainLimits {
1944				collection_numbers_limit: 10,
1945				account_token_ownership_limit: 10,
1946				collections_admins_limit: 2,
1947				custom_data_limit: 2048,
1948				nft_sponsor_transfer_timeout: 15,
1949				fungible_sponsor_transfer_timeout: 15,
1950				refungible_sponsor_transfer_timeout: 15,
1951				const_on_chain_schema_limit: 1024,
1952				offchain_schema_limit: 1024,
1953				variable_on_chain_schema_limit: 1024,
1954			}
1955		));
1956
1957		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1801		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
19581802
1959		let origin1 = Origin::signed(1);1803		let origin1 = Origin::signed(1);
1975#[test]1819#[test]
1976fn collection_admins_bound_neg() {1820fn collection_admins_bound_neg() {
1977	new_test_ext().execute_with(|| {1821	new_test_ext().execute_with(|| {
1978		assert_ok!(TemplateModule::set_chain_limits(
1979			RawOrigin::Root.into(),
1980			ChainLimits {
1981				collection_numbers_limit: 10,
1982				account_token_ownership_limit: 1,
1983				collections_admins_limit: 1,
1984				custom_data_limit: 2048,
1985				nft_sponsor_transfer_timeout: 15,
1986				fungible_sponsor_transfer_timeout: 15,
1987				refungible_sponsor_transfer_timeout: 15,
1988				const_on_chain_schema_limit: 1024,
1989				offchain_schema_limit: 1024,
1990				variable_on_chain_schema_limit: 1024,
1991			}
1992		));
1993
1994		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1822		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
19951823
1996		let origin1 = Origin::signed(1);1824		let origin1 = Origin::signed(1);
19971825
1998		assert_ok!(TemplateModule::add_collection_admin(1826		for i in 0..COLLECTION_ADMINS_LIMIT {
1827			assert_ok!(TemplateModule::add_collection_admin(
1999			origin1.clone(),1828				origin1.clone(),
2000			collection_id,1829				collection_id,
2001			account(2)1830				account(2 + i)
2002		));1831			));
1832		}
2003		assert_noop!(1833		assert_noop!(
2004			TemplateModule::add_collection_admin(origin1, collection_id, account(3)),1834			TemplateModule::add_collection_admin(
1835				origin1,
1836				collection_id,
1837				account(3 + COLLECTION_ADMINS_LIMIT)
1838			),
2005			Error::<Test>::CollectionAdminsLimitExceeded1839			Error::<Test>::CollectionAdminsLimitExceeded
2006		);1840		);
2007	});1841	});
2008}1842}
2009
2010// NFT custom data size. Negative test const_data.
2011#[test]
2012fn custom_data_size_nft_const_data_bound_neg() {
2013	new_test_ext().execute_with(|| {
2014		assert_ok!(TemplateModule::set_chain_limits(
2015			RawOrigin::Root.into(),
2016			ChainLimits {
2017				collection_numbers_limit: 10,
2018				account_token_ownership_limit: 10,
2019				collections_admins_limit: 5,
2020				custom_data_limit: 2,
2021				nft_sponsor_transfer_timeout: 15,
2022				fungible_sponsor_transfer_timeout: 15,
2023				refungible_sponsor_transfer_timeout: 15,
2024				const_on_chain_schema_limit: 1024,
2025				offchain_schema_limit: 1024,
2026				variable_on_chain_schema_limit: 1024,
2027			}
2028		));
2029
2030		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
2031
2032		let origin1 = Origin::signed(1);
2033		let too_big_const_data = CreateItemData::NFT(CreateNftData {
2034			const_data: vec![1, 2, 3, 4],
2035			variable_data: vec![],
2036		});
2037
2038		assert_noop!(
2039			TemplateModule::create_item(origin1, collection_id, account(1), too_big_const_data),
2040			Error::<Test>::TokenConstDataLimitExceeded
2041		);
2042	});
2043}
2044
2045// NFT custom data size. Negative test variable_data.
2046#[test]
2047fn custom_data_size_nft_variable_data_bound_neg() {
2048	new_test_ext().execute_with(|| {
2049		assert_ok!(TemplateModule::set_chain_limits(
2050			RawOrigin::Root.into(),
2051			ChainLimits {
2052				collection_numbers_limit: 10,
2053				account_token_ownership_limit: 10,
2054				collections_admins_limit: 5,
2055				custom_data_limit: 2,
2056				nft_sponsor_transfer_timeout: 15,
2057				fungible_sponsor_transfer_timeout: 15,
2058				refungible_sponsor_transfer_timeout: 15,
2059				const_on_chain_schema_limit: 1024,
2060				offchain_schema_limit: 1024,
2061				variable_on_chain_schema_limit: 1024,
2062			}
2063		));
2064
2065		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
2066
2067		let origin1 = Origin::signed(1);
2068		let too_big_const_data = CreateItemData::NFT(CreateNftData {
2069			const_data: vec![],
2070			variable_data: vec![1, 2, 3, 4],
2071		});
2072
2073		assert_noop!(
2074			TemplateModule::create_item(origin1, collection_id, account(1), too_big_const_data),
2075			Error::<Test>::TokenVariableDataLimitExceeded
2076		);
2077	});
2078}
2079
2080// Re fungible custom data size. Negative test const_data.
2081#[test]
2082fn custom_data_size_re_fungible_const_data_bound_neg() {
2083	new_test_ext().execute_with(|| {
2084		assert_ok!(TemplateModule::set_chain_limits(
2085			RawOrigin::Root.into(),
2086			ChainLimits {
2087				collection_numbers_limit: 10,
2088				account_token_ownership_limit: 10,
2089				collections_admins_limit: 5,
2090				custom_data_limit: 2,
2091				nft_sponsor_transfer_timeout: 15,
2092				fungible_sponsor_transfer_timeout: 15,
2093				refungible_sponsor_transfer_timeout: 15,
2094				const_on_chain_schema_limit: 1024,
2095				offchain_schema_limit: 1024,
2096				variable_on_chain_schema_limit: 1024,
2097			}
2098		));
2099
2100		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
2101
2102		let origin1 = Origin::signed(1);
2103		let too_big_const_data = CreateItemData::NFT(CreateNftData {
2104			const_data: vec![1, 2, 3, 4],
2105			variable_data: vec![],
2106		});
2107
2108		assert_noop!(
2109			TemplateModule::create_item(origin1, collection_id, account(1), too_big_const_data),
2110			Error::<Test>::TokenConstDataLimitExceeded
2111		);
2112	});
2113}
2114
2115// Re fungible custom data size. Negative test variable_data.
2116#[test]
2117fn custom_data_size_re_fungible_variable_data_bound_neg() {
2118	new_test_ext().execute_with(|| {
2119		assert_ok!(TemplateModule::set_chain_limits(
2120			RawOrigin::Root.into(),
2121			ChainLimits {
2122				collection_numbers_limit: 10,
2123				account_token_ownership_limit: 10,
2124				collections_admins_limit: 5,
2125				custom_data_limit: 2,
2126				nft_sponsor_transfer_timeout: 15,
2127				fungible_sponsor_transfer_timeout: 15,
2128				refungible_sponsor_transfer_timeout: 15,
2129				const_on_chain_schema_limit: 1024,
2130				offchain_schema_limit: 1024,
2131				variable_on_chain_schema_limit: 1024,
2132			}
2133		));
2134
2135		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
2136
2137		let origin1 = Origin::signed(1);
2138		let too_big_const_data = CreateItemData::NFT(CreateNftData {
2139			const_data: vec![],
2140			variable_data: vec![1, 2, 3, 4],
2141		});
2142
2143		assert_noop!(
2144			TemplateModule::create_item(origin1, collection_id, account(1), too_big_const_data),
2145			Error::<Test>::TokenVariableDataLimitExceeded
2146		);
2147	});
2148}
2149// #endregion1843// #endregion
21501844
2151#[test]1845#[test]
2152fn set_const_on_chain_schema() {1846fn set_const_on_chain_schema() {
2153	new_test_ext().execute_with(|| {1847	new_test_ext().execute_with(|| {
2154		default_limits();
2155
2156		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1848		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
21571849
2158		let origin1 = Origin::signed(1);1850		let origin1 = Origin::signed(1);
2180#[test]1872#[test]
2181fn set_variable_on_chain_schema() {1873fn set_variable_on_chain_schema() {
2182	new_test_ext().execute_with(|| {1874	new_test_ext().execute_with(|| {
2183		default_limits();
2184
2185		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1875		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
21861876
2187		let origin1 = Origin::signed(1);1877		let origin1 = Origin::signed(1);
2209#[test]1899#[test]
2210fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {1900fn set_variable_meta_data_on_nft_token_stores_variable_meta_data() {
2211	new_test_ext().execute_with(|| {1901	new_test_ext().execute_with(|| {
2212		default_limits();
2213
2214		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1902		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
22151903
2216		let origin1 = Origin::signed(1);1904		let origin1 = Origin::signed(1);
22171905
2218		let data = default_nft_data();1906		let data = default_nft_data();
2219		create_test_item(1, &data.into());1907		create_test_item(1, &data.into());
22201908
2221		let variable_data = b"test set_variable_meta_data method.".to_vec();1909		let variable_data = b"test data".to_vec();
2222		assert_ok!(TemplateModule::set_variable_meta_data(1910		assert_ok!(TemplateModule::set_variable_meta_data(
2223			origin1,1911			origin1,
2224			collection_id,1912			collection_id,
2238#[test]1926#[test]
2239fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {1927fn set_variable_meta_data_on_re_fungible_token_stores_variable_meta_data() {
2240	new_test_ext().execute_with(|| {1928	new_test_ext().execute_with(|| {
2241		default_limits();
2242
2243		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);1929		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);
22441930
2245		let origin1 = Origin::signed(1);1931		let origin1 = Origin::signed(1);
22461932
2247		let data = default_re_fungible_data();1933		let data = default_re_fungible_data();
2248		create_test_item(1, &data.into());1934		create_test_item(1, &data.into());
22491935
2250		let variable_data = b"test set_variable_meta_data method.".to_vec();1936		let variable_data = b"test data".to_vec();
2251		assert_ok!(TemplateModule::set_variable_meta_data(1937		assert_ok!(TemplateModule::set_variable_meta_data(
2252			origin1,1938			origin1,
2253			collection_id,1939			collection_id,
2267#[test]1953#[test]
2268fn set_variable_meta_data_on_fungible_token_fails() {1954fn set_variable_meta_data_on_fungible_token_fails() {
2269	new_test_ext().execute_with(|| {1955	new_test_ext().execute_with(|| {
2270		default_limits();
2271
2272		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);1956		let collection_id = create_test_collection(&CollectionMode::Fungible(3), 1);
22731957
2274		let origin1 = Origin::signed(1);1958		let origin1 = Origin::signed(1);
22751959
2276		let data = default_fungible_data();1960		let data = default_fungible_data();
2277		create_test_item(1, &data.into());1961		create_test_item(1, &data.into());
22781962
2279		let variable_data = b"test set_variable_meta_data method.".to_vec();1963		let variable_data = b"test data".to_vec();
2280		assert_noop!(1964		assert_noop!(
2281			TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data),1965			TemplateModule::set_variable_meta_data(origin1, collection_id, 1, variable_data),
2282			Error::<Test>::CantStoreMetadataInFungibleTokens1966			Error::<Test>::CantStoreMetadataInFungibleTokens
2287#[test]1971#[test]
2288fn set_variable_meta_data_on_nft_token_fails_for_big_data() {1972fn set_variable_meta_data_on_nft_token_fails_for_big_data() {
2289	new_test_ext().execute_with(|| {1973	new_test_ext().execute_with(|| {
2290		assert_ok!(TemplateModule::set_chain_limits(
2291			RawOrigin::Root.into(),
2292			ChainLimits {
2293				collection_numbers_limit: default_collection_numbers_limit(),
2294				account_token_ownership_limit: 10,
2295				collections_admins_limit: 5,
2296				custom_data_limit: 10,
2297				nft_sponsor_transfer_timeout: 15,
2298				fungible_sponsor_transfer_timeout: 15,
2299				refungible_sponsor_transfer_timeout: 15,
2300				const_on_chain_schema_limit: 1024,
2301				offchain_schema_limit: 1024,
2302				variable_on_chain_schema_limit: 1024,
2303			}
2304		));
2305
2306		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1974		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
23071975
2308		let origin1 = Origin::signed(1);1976		let origin1 = Origin::signed(1);
2321#[test]1989#[test]
2322fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {1990fn set_variable_meta_data_on_re_fungible_token_fails_for_big_data() {
2323	new_test_ext().execute_with(|| {1991	new_test_ext().execute_with(|| {
2324		assert_ok!(TemplateModule::set_chain_limits(
2325			RawOrigin::Root.into(),
2326			ChainLimits {
2327				collection_numbers_limit: default_collection_numbers_limit(),
2328				account_token_ownership_limit: 10,
2329				collections_admins_limit: 5,
2330				custom_data_limit: 10,
2331				nft_sponsor_transfer_timeout: 15,
2332				fungible_sponsor_transfer_timeout: 15,
2333				refungible_sponsor_transfer_timeout: 15,
2334				const_on_chain_schema_limit: 1024,
2335				offchain_schema_limit: 1024,
2336				variable_on_chain_schema_limit: 1024,
2337			}
2338		));
2339
2340		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);1992		let collection_id = create_test_collection(&CollectionMode::ReFungible, 1);
23411993
2342		let origin1 = Origin::signed(1);1994		let origin1 = Origin::signed(1);
2355#[test]2007#[test]
2356fn collection_transfer_flag_works() {2008fn collection_transfer_flag_works() {
2357	new_test_ext().execute_with(|| {2009	new_test_ext().execute_with(|| {
2358		default_limits();
2359
2360		let origin1 = Origin::signed(1);2010		let origin1 = Origin::signed(1);
23612011
2362		let collection_id = create_test_collection(&CollectionMode::NFT, 1);2012		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
2382#[test]2032#[test]
2383fn collection_transfer_flag_works_neg() {2033fn collection_transfer_flag_works_neg() {
2384	new_test_ext().execute_with(|| {2034	new_test_ext().execute_with(|| {
2385		default_limits();
2386
2387		let origin1 = Origin::signed(1);2035		let origin1 = Origin::signed(1);
23882036
2389		let collection_id = create_test_collection(&CollectionMode::NFT, 1);2037		let collection_id = create_test_collection(&CollectionMode::NFT, 1);

--- a/primitives/nft/Cargo.toml
+++ b/primitives/nft/Cargo.toml
@@ -9,20 +9,28 @@
 version = '0.9.0'
 
 [dependencies]
-codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false, features = ['derive'] }
-serde = { version = "1.0.119", features = ['derive'], default-features = false }
+codec = { package = "parity-scale-codec", version = "2.2.0", default-features = false, features = ['derive'] }
+serde = { version = "1.0.119", features = ['derive'], default-features = false, optional = true }
+max-encoded-len = { default-features = false, features = ['derive'], version = '3.0.0', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
 frame-support = { default-features = false, version = '3.0.0', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
 frame-system = { default-features = false, version = '3.0.0', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
 sp-core = { version = "3.0.0", default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
+sp-std = { version = "3.0.0", default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
 sp-runtime = { version = "3.0.0", default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
+derivative = "2.2.0"
 
 [features]
 default = ["std"]
 std = [
+  "serde1",
   "serde/std",
   "codec/std",
+  "max-encoded-len/std",
   "frame-system/std",
   "frame-support/std",
   "sp-runtime/std",
   "sp-core/std",
-]
\ No newline at end of file
+  "sp-std/std",
+]
+serde1 = ["serde"]
+limit-testing = []
\ No newline at end of file

--- a/primitives/nft/src/lib.rs
+++ b/primitives/nft/src/lib.rs
@@ -1,11 +1,13 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
+#[cfg(feature = "serde")]
 pub use serde::{Serialize, Deserialize};
 
 use sp_runtime::sp_std::prelude::Vec;
 use codec::{Decode, Encode};
+use max_encoded_len::MaxEncodedLen;
 pub use frame_support::{
-	construct_runtime, decl_event, decl_module, decl_storage, decl_error,
+	BoundedVec, construct_runtime, decl_event, decl_module, decl_storage, decl_error,
 	dispatch::DispatchResult,
 	ensure, fail, parameter_types,
 	traits::{
@@ -19,18 +21,54 @@
 	},
 	StorageValue, transactional,
 };
+use derivative::Derivative;
 
 pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;
 pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;
 pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;
 pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;
 
+pub const COLLECTION_NUMBER_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {
+	100000
+} else {
+	10
+};
+pub const CUSTOM_DATA_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {
+	2048
+} else {
+	10
+};
+pub const COLLECTION_ADMINS_LIMIT: u64 = 5;
+pub const ACCOUNT_TOKEN_OWNERSHIP_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {
+	1000000
+} else {
+	10
+};
+
+// Timeouts for item types in passed blocks
+pub const NFT_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;
+pub const FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;
+pub const REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;
+
+// Schema limits
+pub const OFFCHAIN_SCHEMA_LIMIT: u32 = 1024;
+pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 1024;
+pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 1024;
+
+/// How much items can be created per single
+/// create_many call
+pub const MAX_ITEMS_PER_BATCH: u32 = 200;
+
+parameter_types! {
+	pub const CustomDataLimit: u32 = CUSTOM_DATA_LIMIT;
+}
+
 pub type CollectionId = u32;
 pub type TokenId = u32;
 pub type DecimalPoints = u8;
 
 #[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub enum CollectionMode {
 	Invalid,
 	NFT,
@@ -61,7 +99,7 @@
 }
 
 #[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub enum AccessMode {
 	Normal,
 	WhiteList,
@@ -73,7 +111,7 @@
 }
 
 #[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub enum SchemaVersion {
 	ImageURL,
 	Unique,
@@ -85,14 +123,14 @@
 }
 
 #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub struct Ownership<AccountId> {
 	pub owner: AccountId,
 	pub fraction: u128,
 }
 
 #[derive(Encode, Decode, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub enum SponsorshipState<AccountId> {
 	/// The fees are applied to the transaction sender
 	Disabled,
@@ -128,7 +166,7 @@
 }
 
 #[derive(Encode, Decode, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub struct Collection<T: frame_system::Config> {
 	pub owner: T::AccountId,
 	pub mode: CollectionMode,
@@ -148,7 +186,7 @@
 }
 
 #[derive(Encode, Decode, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub struct NftItemType<AccountId> {
 	pub owner: AccountId,
 	pub const_data: Vec<u8>,
@@ -156,13 +194,13 @@
 }
 
 #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub struct FungibleItemType {
 	pub value: u128,
 }
 
 #[derive(Encode, Decode, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub struct ReFungibleItemType<AccountId> {
 	pub owner: Vec<Ownership<AccountId>>,
 	pub const_data: Vec<u8>,
@@ -170,7 +208,7 @@
 }
 
 #[derive(Encode, Decode, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub struct CollectionLimits<BlockNumber: Encode + Decode> {
 	pub account_token_ownership_limit: u32,
 	pub sponsored_data_size: u32,
@@ -200,48 +238,72 @@
 	}
 }
 
-#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-pub struct ChainLimits {
-	pub collection_numbers_limit: u32,
-	pub account_token_ownership_limit: u32,
-	pub collections_admins_limit: u64,
-	pub custom_data_limit: u32,
+/// BoundedVec doesn't supports serde
+#[cfg(feature = "serde1")]
+mod bounded_serde {
+	use core::convert::TryFrom;
+	use frame_support::{BoundedVec, traits::Get};
+	use serde::{
+		ser::{self, Serialize},
+		de::{self, Deserialize, Error},
+	};
+	use sp_std::vec::Vec;
 
-	// Timeouts for item types in passed blocks
-	pub nft_sponsor_transfer_timeout: u32,
-	pub fungible_sponsor_transfer_timeout: u32,
-	pub refungible_sponsor_transfer_timeout: u32,
+	pub fn serialize<D, V, S>(value: &BoundedVec<V, S>, serializer: D) -> Result<D::Ok, D::Error>
+	where
+		D: ser::Serializer,
+		V: Serialize,
+	{
+		let vec: &Vec<_> = &value;
+		vec.serialize(serializer)
+	}
 
-	// Schema limits
-	pub offchain_schema_limit: u32,
-	pub variable_on_chain_schema_limit: u32,
-	pub const_on_chain_schema_limit: u32,
+	pub fn deserialize<'de, D, V, S>(deserializer: D) -> Result<BoundedVec<V, S>, D::Error>
+	where
+		D: de::Deserializer<'de>,
+		V: de::Deserialize<'de>,
+		S: Get<u32>,
+	{
+		// TODO: Implement custom visitor, which will limit vec size at parse time? Will serde only be used by chainspec?
+		let vec = <Vec<V>>::deserialize(deserializer)?;
+		let len = vec.len();
+		TryFrom::try_from(vec).map_err(|_| D::Error::invalid_length(len, &"lesser size"))
+	}
 }
 
-#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+#[derivative(Debug)]
 pub struct CreateNftData {
-	pub const_data: Vec<u8>,
-	pub variable_data: Vec<u8>,
+	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]
+	#[derivative(Debug = "ignore")]
+	pub const_data: BoundedVec<u8, CustomDataLimit>,
+	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]
+	#[derivative(Debug = "ignore")]
+	pub variable_data: BoundedVec<u8, CustomDataLimit>,
 }
 
-#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub struct CreateFungibleData {
 	pub value: u128,
 }
 
-#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+#[derivative(Debug)]
 pub struct CreateReFungibleData {
-	pub const_data: Vec<u8>,
-	pub variable_data: Vec<u8>,
+	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]
+	#[derivative(Debug = "ignore")]
+	pub const_data: BoundedVec<u8, CustomDataLimit>,
+	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]
+	#[derivative(Debug = "ignore")]
+	pub variable_data: BoundedVec<u8, CustomDataLimit>,
 	pub pieces: u128,
 }
 
-#[derive(Encode, Decode, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub enum CreateItemData {
 	NFT(CreateNftData),
 	Fungible(CreateFungibleData),

--- a/runtime/Cargo.toml
+++ b/runtime/Cargo.toml
@@ -31,6 +31,7 @@
 ]
 std = [
     'codec/std',
+    'max-encoded-len/std',
     'cumulus-pallet-aura-ext/std',
     'cumulus-pallet-parachain-system/std',
     'cumulus-pallet-xcm/std',
@@ -84,6 +85,10 @@
     'xcm-builder/std',
     'xcm-executor/std',
 ]
+limit-testing = [
+    'pallet-nft/limit-testing',
+    'nft-data-structs/limit-testing',
+]
 
 ################################################################################
 # Substrate Dependencies
@@ -378,6 +383,8 @@
 # local dependencies
 
 [dependencies]
+max-encoded-len = { default-features = false, features = ['derive'], version = '3.0.0', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
+derivative = "2.2.0"
 pallet-nft = { path = '../pallets/nft', default-features = false, version = '3.0.0' }
 pallet-inflation = { path = '../pallets/inflation', default-features = false, version = '3.0.0' }
 nft-data-structs = { path = '../primitives/nft', default-features = false, version = '0.9.0' }

--- a/runtime/src/chain_extension.rs
+++ b/runtime/src/chain_extension.rs
@@ -6,6 +6,8 @@
 //
 
 use codec::{Decode, Encode};
+use max_encoded_len::MaxEncodedLen;
+use derivative::Derivative;
 
 pub use pallet_contracts::chain_extension::RetVal;
 use pallet_contracts::chain_extension::{
@@ -19,61 +21,63 @@
 pub use pallet_nft::*;
 use pallet_nft::CrossAccountId;
 use nft_data_structs::*;
-
-use crate::Vec;
 
 /// Create item parameters
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtCreateItem<E: Ext> {
-	pub owner: <E::T as SysConfig>::AccountId,
+#[derive(Debug, PartialEq, Encode, Decode, MaxEncodedLen)]
+pub struct NFTExtCreateItem<AccountId> {
+	pub owner: AccountId,
 	pub collection_id: u32,
 	pub data: CreateItemData,
 }
 
 /// Transfer parameters
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtTransfer<E: Ext> {
-	pub recipient: <E::T as SysConfig>::AccountId,
+#[derive(Debug, PartialEq, Encode, Decode, MaxEncodedLen)]
+pub struct NFTExtTransfer<AccountId> {
+	pub recipient: AccountId,
 	pub collection_id: u32,
 	pub token_id: u32,
 	pub amount: u128,
 }
 
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtCreateMultipleItems<E: Ext> {
-	pub owner: <E::T as SysConfig>::AccountId,
+#[derive(Derivative, PartialEq, Encode, Decode, MaxEncodedLen)]
+#[derivative(Debug)]
+pub struct NFTExtCreateMultipleItems<AccountId> {
+	pub owner: AccountId,
 	pub collection_id: u32,
-	pub data: Vec<CreateItemData>,
+	#[derivative(Debug = "ignore")]
+	pub data: BoundedVec<CreateItemData, MaxItemsPerBatch>,
 }
 
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtApprove<E: Ext> {
-	pub spender: <E::T as SysConfig>::AccountId,
+#[derive(Debug, PartialEq, Encode, Decode, MaxEncodedLen)]
+pub struct NFTExtApprove<AccountId> {
+	pub spender: AccountId,
 	pub collection_id: u32,
 	pub item_id: u32,
 	pub amount: u128,
 }
 
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtTransferFrom<E: Ext> {
-	pub owner: <E::T as SysConfig>::AccountId,
-	pub recipient: <E::T as SysConfig>::AccountId,
+#[derive(Debug, PartialEq, Encode, Decode, MaxEncodedLen)]
+pub struct NFTExtTransferFrom<AccountId> {
+	pub owner: AccountId,
+	pub recipient: AccountId,
 	pub collection_id: u32,
 	pub item_id: u32,
 	pub amount: u128,
 }
 
-#[derive(Debug, PartialEq, Encode, Decode)]
+#[derive(Derivative, PartialEq, Encode, Decode, MaxEncodedLen)]
+#[derivative(Debug)]
 pub struct NFTExtSetVariableMetaData {
 	pub collection_id: u32,
 	pub item_id: u32,
-	pub data: Vec<u8>,
+	#[derivative(Debug = "ignore")]
+	pub data: BoundedVec<u8, MaxDataSize>,
 }
 
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtToggleWhiteList<E: Ext> {
+#[derive(Debug, PartialEq, Encode, Decode, MaxEncodedLen)]
+pub struct NFTExtToggleWhiteList<AccountId> {
 	pub collection_id: u32,
-	pub address: <E::T as SysConfig>::AccountId,
+	pub address: AccountId,
 	pub whitelisted: bool,
 }
 
@@ -82,6 +86,8 @@
 
 pub type NftWeightInfoOf<C> = <C as pallet_nft::Config>::WeightInfo;
 
+pub type AccountIdOf<C> = <C as SysConfig>::AccountId;
+
 impl<C: Config + pallet_contracts::Config> ChainExtension<C> for NFTExtension {
 	fn call<E: Ext>(func_id: u32, env: Environment<E, InitState>) -> Result<RetVal, DispatchError>
 	where
@@ -93,7 +99,7 @@
 		match func_id {
 			0 => {
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtTransfer<E> = env.read_as()?;
+				let input: NFTExtTransfer<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::transfer())?;
 
 				let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
@@ -106,13 +112,13 @@
 					input.amount,
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			1 => {
 				// Create Item
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtCreateItem<E> = env.read_as()?;
+				let input: NFTExtCreateItem<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::create_item(input.data.data_size()))?;
 
 				let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
@@ -124,13 +130,13 @@
 					input.data,
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			2 => {
 				// Create multiple items
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtCreateMultipleItems<E> = env.read_as()?;
+				let input: NFTExtCreateMultipleItems<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::create_item(
 					input.data.iter().map(|i| i.data_size()).sum(),
 				))?;
@@ -141,16 +147,16 @@
 					&C::CrossAccountId::from_sub(env.ext().address().clone()),
 					&collection,
 					&C::CrossAccountId::from_sub(input.owner),
-					input.data,
+					input.data.into_inner(),
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			3 => {
 				// Approve
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtApprove<E> = env.read_as()?;
+				let input: NFTExtApprove<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::approve())?;
 
 				let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
@@ -163,13 +169,13 @@
 					input.amount,
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			4 => {
 				// Transfer from
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtTransferFrom<E> = env.read_as()?;
+				let input: NFTExtTransferFrom<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::transfer_from())?;
 
 				let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
@@ -183,7 +189,7 @@
 					input.amount,
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			5 => {
@@ -198,16 +204,16 @@
 					&C::CrossAccountId::from_sub(env.ext().address().clone()),
 					&collection,
 					input.item_id,
-					input.data,
+					input.data.into_inner(),
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			6 => {
 				// Toggle whitelist
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtToggleWhiteList<E> = env.read_as()?;
+				let input: NFTExtToggleWhiteList<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::add_to_white_list())?;
 
 				let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
@@ -219,7 +225,7 @@
 					input.whitelisted,
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			_ => Err(DispatchError::Other("unknown chain_extension func_id")),

--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -72,7 +72,6 @@
 use sp_runtime::{
 	traits::{Dispatchable},
 };
-// use pallet_contracts::chain_extension::UncheckedFrom;
 
 // pub use pallet_timestamp::Call as TimestampCall;
 pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;
@@ -419,7 +418,7 @@
 	type DepositPerStorageItem = DepositPerStorageItem;
 	type RentFraction = RentFraction;
 	type SurchargeReward = SurchargeReward;
-	type WeightPrice = pallet_transaction_payment::Module<Self>;
+	type WeightPrice = pallet_transaction_payment::Pallet<Self>;
 	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;
 	type ChainExtension = NFTExtension;
 	type DeletionQueueDepth = DeletionQueueDepth;

--- a/runtime/src/nft_weights.rs
+++ b/runtime/src/nft_weights.rs
@@ -123,11 +123,6 @@
 			.saturating_add(DbWeight::get().reads(2_u64))
 			.saturating_add(DbWeight::get().writes(1_u64))
 	}
-	fn set_chain_limits() -> Weight {
-		1_300_000_u64
-			.saturating_add(DbWeight::get().reads(0_u64))
-			.saturating_add(DbWeight::get().writes(1_u64))
-	}
 	fn set_contract_sponsoring_rate_limit() -> Weight {
 		3_500_000_u64
 			.saturating_add(DbWeight::get().reads(0_u64))

--- a/tests/src/addCollectionAdmin.test.ts
+++ b/tests/src/addCollectionAdmin.test.ts
@@ -117,8 +117,7 @@
       ];
       const collectionId = await createCollectionExpectSuccess();
 
-      const chainLimit = await api.query.nft.chainLimit() as unknown as { CollectionAdminsLimit: BN };
-      const chainAdminLimit = chainLimit.CollectionAdminsLimit.toNumber();
+      const chainAdminLimit = api.consts.nft.collectionAdminsLimit.toNumber();
       expect(chainAdminLimit).to.be.equal(5);
 
       for (let i = 0; i < chainAdminLimit; i++) {

--- a/tests/src/collision-tests/adminLimitsOff.test.ts
+++ b/tests/src/collision-tests/adminLimitsOff.test.ts
@@ -34,8 +34,7 @@
     await usingApi(async (api) => {
       const collectionId = await createCollectionExpectSuccess();
 
-      const chainLimit = await api.query.nft.chainLimit() as unknown as { CollectionAdminsLimit: BN };
-      const chainAdminLimit = chainLimit.CollectionAdminsLimit.toNumber();
+      const chainAdminLimit = api.consts.nft.collectionAdminsLimit.toNumber();
       expect(chainAdminLimit).to.be.equal(5);
 
       const changeAdminTx1 = api.tx.nft.addCollectionAdmin(collectionId, Eve.address);