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

4935name = "nft-data-structs"4935name = "nft-data-structs"
4936version = "0.9.0"4936version = "0.9.0"
4937dependencies = [4937dependencies = [
4938 "derivative",
4938 "frame-support",4939 "frame-support",
4939 "frame-system",4940 "frame-system",
4941 "max-encoded-len",
4940 "parity-scale-codec",4942 "parity-scale-codec",
4941 "serde",4943 "serde",
4942 "sp-core",4944 "sp-core",
4943 "sp-runtime",4945 "sp-runtime",
4946 "sp-std",
4944]4947]
49454948
4946[[package]]4949[[package]]
4999 "cumulus-primitives-core",5002 "cumulus-primitives-core",
5000 "cumulus-primitives-timestamp",5003 "cumulus-primitives-timestamp",
5001 "cumulus-primitives-utility",5004 "cumulus-primitives-utility",
5005 "derivative",
5002 "fp-rpc",5006 "fp-rpc",
5003 "frame-benchmarking",5007 "frame-benchmarking",
5004 "frame-executive",5008 "frame-executive",
5007 "frame-system-benchmarking",5011 "frame-system-benchmarking",
5008 "frame-system-rpc-runtime-api",5012 "frame-system-rpc-runtime-api",
5009 "hex-literal",5013 "hex-literal",
5014 "max-encoded-len",
5010 "nft-data-structs",5015 "nft-data-structs",
5011 "pallet-aura",5016 "pallet-aura",
5012 "pallet-balances",5017 "pallet-balances",

202			nft_item_id: vec![],202			nft_item_id: vec![],
203			fungible_item_id: vec![],203			fungible_item_id: vec![],
204			refungible_item_id: vec![],204			refungible_item_id: vec![],
205			chain_limit: ChainLimits {
206				collection_numbers_limit: 100000,
207				account_token_ownership_limit: 1000000,
208				collections_admins_limit: 5,
209				custom_data_limit: 2048,
210				nft_sponsor_transfer_timeout: 15,
211				fungible_sponsor_transfer_timeout: 15,
212				refungible_sponsor_transfer_timeout: 15,
213				offchain_schema_limit: 1024,
214				variable_on_chain_schema_limit: 1024,
215				const_on_chain_schema_limit: 1024,
216			},
217		},205		},
218		parachain_info: nft_runtime::ParachainInfoConfig { parachain_id: id },206		parachain_info: nft_runtime::ParachainInfoConfig { parachain_id: id },
219		aura: nft_runtime::AuraConfig {207		aura: nft_runtime::AuraConfig {

41    'evm-coder/std',41    'evm-coder/std',
42    'pallet-evm-coder-substrate/std',42    'pallet-evm-coder-substrate/std',
43]43]
44limit-testing = ["nft-data-structs/limit-testing"]
4445
45################################################################################46################################################################################
46# Substrate Dependencies47# Substrate Dependencies

117			.saturating_add(DbWeight::get().reads(2_u64))117			.saturating_add(DbWeight::get().reads(2_u64))
118			.saturating_add(DbWeight::get().writes(1_u64))118			.saturating_add(DbWeight::get().writes(1_u64))
119	}119	}
120	fn set_chain_limits() -> Weight {
121		1_300_000_u64
122			.saturating_add(DbWeight::get().reads(0_u64))
123			.saturating_add(DbWeight::get().writes(1_u64))
124	}
125	fn set_contract_sponsoring_rate_limit() -> Weight {120	fn set_contract_sponsoring_rate_limit() -> Weight {
126		3_500_000_u64121		3_500_000_u64
127			.saturating_add(DbWeight::get().reads(0_u64))122			.saturating_add(DbWeight::get().reads(0_u64))

1//! Implements EVM sponsoring logic via OnChargeEVMTransaction1//! Implements EVM sponsoring logic via OnChargeEVMTransaction
22
3use crate::{3use crate::{
4	ChainLimit, Collection, CollectionById, Config, FungibleTransferBasket, NftTransferBasket,4	Collection, CollectionById, Config, FungibleTransferBasket, NftTransferBasket,
5	eth::{account::EvmBackwardsAddressMapping, map_eth_to_id},5	eth::{account::EvmBackwardsAddressMapping, map_eth_to_id},
6};6};
7use evm_coder::{Call, abi::AbiReader};7use evm_coder::{Call, abi::AbiReader};
8use frame_support::{8use frame_support::{
9	storage::{StorageMap, StorageDoubleMap, StorageValue},9	storage::{StorageMap, StorageDoubleMap},
10};10};
11use sp_core::H160;11use sp_core::H160;
12use sp_std::prelude::*;12use sp_std::prelude::*;
17};17};
18use core::convert::TryInto;18use core::convert::TryInto;
19use core::marker::PhantomData;19use core::marker::PhantomData;
20use nft_data_structs::{NFT_SPONSOR_TRANSFER_TIMEOUT, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT};
2021
21struct AnyError;22struct AnyError;
2223
43					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {44					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
44						collection_limits.sponsor_transfer_timeout45						collection_limits.sponsor_transfer_timeout
45					} else {46					} else {
46						ChainLimit::get().nft_sponsor_transfer_timeout47						NFT_SPONSOR_TRANSFER_TIMEOUT
47					};48					};
4849
49					let mut sponsor = true;50					let mut sponsor = true;
74					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {75					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
75						collection_limits.sponsor_transfer_timeout76						collection_limits.sponsor_transfer_timeout
76					} else {77					} else {
77						ChainLimit::get().fungible_sponsor_transfer_timeout78						FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
78					};79					};
7980
80					let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;81					let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;

31	StorageValue, transactional,31	StorageValue, transactional,
32};32};
3333
34use frame_system::{self as system, ensure_signed, ensure_root};34use frame_system::{self as system, ensure_signed};
35use sp_core::H160;35use sp_core::H160;
36use sp_std::vec;36use sp_std::vec;
37use sp_runtime::sp_std::prelude::Vec;37use sp_runtime::sp_std::prelude::Vec;
38use core::ops::{Deref, DerefMut};38use core::ops::{Deref, DerefMut};
39use nft_data_structs::{39use nft_data_structs::{
40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,
41	CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
42	VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,
41	AccessMode, ChainLimits, Collection, CreateItemData, CollectionLimits, CollectionId,43	OFFCHAIN_SCHEMA_LIMIT, AccessMode, Collection, CreateItemData, CollectionLimits, CollectionId,
42	CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,44	CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,
43	FungibleItemType, ReFungibleItemType,45	FungibleItemType, ReFungibleItemType,
44};46};
86	fn set_variable_meta_data() -> Weight;88	fn set_variable_meta_data() -> Weight;
87	fn enable_contract_sponsoring() -> Weight;89	fn enable_contract_sponsoring() -> Weight;
88	fn set_schema_version() -> Weight;90	fn set_schema_version() -> Weight;
89	fn set_chain_limits() -> Weight;
90	fn set_contract_sponsoring_rate_limit() -> Weight;91	fn set_contract_sponsoring_rate_limit() -> Weight;
91	fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;92	fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;
92	fn toggle_contract_white_list() -> Weight;93	fn toggle_contract_white_list() -> Weight;
280		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;281		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;
281		//#endregion282		//#endregion
282
283		//#region Chain limits struct
284		pub ChainLimit get(fn chain_limit) config(): ChainLimits;
285		//#endregion
286283
287		//#region Bound counters284		//#region Bound counters
288		/// Amount of collections destroyed, used for total amount tracking with285		/// Amount of collections destroyed, used for total amount tracking with
435		origin: T::Origin432		origin: T::Origin
436	{433	{
437		fn deposit_event() = default;434		fn deposit_event() = default;
435		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;
438		type Error = Error<T>;436		type Error = Error<T>;
439437
440		fn on_initialize(_now: T::BlockNumber) -> Weight {438		fn on_initialize(_now: T::BlockNumber) -> Weight {
486				_ => 0484				_ => 0
487			};485			};
488
489			let chain_limit = ChainLimit::get();
490486
491			let created_count = CreatedCollectionCount::get();487			let created_count = CreatedCollectionCount::get();
492			let destroyed_count = DestroyedCollectionCount::get();488			let destroyed_count = DestroyedCollectionCount::get();
493489
494			// bound Total number of collections490			// bound Total number of collections
495			ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);491			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);
496492
497			// check params493			// check params
498			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);494			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);
508			CreatedCollectionCount::put(next_id);504			CreatedCollectionCount::put(next_id);
509505
510			let limits = CollectionLimits {506			let limits = CollectionLimits {
511				sponsored_data_size: chain_limit.custom_data_limit,507				sponsored_data_size: CUSTOM_DATA_LIMIT,
512				..Default::default()508				..Default::default()
513			};509			};
514510
737			match admin_arr.binary_search(&new_admin_id) {733			match admin_arr.binary_search(&new_admin_id) {
738				Ok(_) => {},734				Ok(_) => {},
739				Err(idx) => {735				Err(idx) => {
740					let limits = ChainLimit::get();
741					ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);736					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);
742					admin_arr.insert(idx, new_admin_id);737					admin_arr.insert(idx, new_admin_id);
743					<AdminList<T>>::insert(collection_id, admin_arr);738					<AdminList<T>>::insert(collection_id, admin_arr);
744				}739				}
1138			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1133			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
11391134
1140			// check schema limit1135			// check schema limit
1141			ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");1136			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");
11421137
1143			target_collection.offchain_schema = schema;1138			target_collection.offchain_schema = schema;
1144			target_collection.save()1139			target_collection.save()
1168			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1163			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
11691164
1170			// check schema limit1165			// check schema limit
1171			ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");1166			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");
11721167
1173			target_collection.const_on_chain_schema = schema;1168			target_collection.const_on_chain_schema = schema;
1174			target_collection.save()1169			target_collection.save()
1198			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1193			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
11991194
1200			// check schema limit1195			// check schema limit
1201			ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");1196			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");
12021197
1203			target_collection.variable_on_chain_schema = schema;1198			target_collection.variable_on_chain_schema = schema;
1204			target_collection.save()1199			target_collection.save()
1205		}1200		}
1206
1207		// Sudo permissions function
1208		#[weight = <T as Config>::WeightInfo::set_chain_limits()]
1209		#[transactional]
1210		pub fn set_chain_limits(
1211			origin,
1212			limits: ChainLimits
1213		) -> DispatchResult {
1214
1215			#[cfg(not(feature = "runtime-benchmarks"))]
1216			ensure_root(origin)?;
1217
1218			<ChainLimit>::put(limits);
1219			Ok(())
1220		}
12211201
1222		#[weight = <T as Config>::WeightInfo::set_collection_limits()]1202		#[weight = <T as Config>::WeightInfo::set_collection_limits()]
1223		#[transactional]1203		#[transactional]
1230			let mut target_collection = Self::get_collection(collection_id)?;1210			let mut target_collection = Self::get_collection(collection_id)?;
1231			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1211			Self::check_owner_permissions(&target_collection, sender.as_sub())?;
1232			let old_limits = &target_collection.limits;1212			let old_limits = &target_collection.limits;
1233			let chain_limits = ChainLimit::get();
12341213
1235			// collection bounds1214			// collection bounds
1236			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1215			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&
1237				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1216				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&
1238				new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1217				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,
1239				Error::<T>::CollectionLimitBoundsExceeded);1218				Error::<T>::CollectionLimitBoundsExceeded);
12401219
1241			// token_limit   check  prev1220			// token_limit   check  prev
1471		Self::token_exists(collection, item_id)?;1450		Self::token_exists(collection, item_id)?;
14721451
1473		ensure!(1452		ensure!(
1474			ChainLimit::get().custom_data_limit >= data.len() as u32,1453			CUSTOM_DATA_LIMIT >= data.len() as u32,
1475			Error::<T>::TokenVariableDataLimitExceeded1454			Error::<T>::TokenVariableDataLimitExceeded
1476		);1455		);
14771456
1616	) -> DispatchResult {1595	) -> DispatchResult {
1617		match target_collection.mode {1596		match target_collection.mode {
1618			CollectionMode::NFT => {1597			CollectionMode::NFT => {
1619				if let CreateItemData::NFT(data) = data {1598				if !matches!(data, CreateItemData::NFT(_)) {
1620					// check sizes
1621					ensure!(
1622						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,
1623						Error::<T>::TokenConstDataLimitExceeded
1624					);
1625					ensure!(
1626						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,
1627						Error::<T>::TokenVariableDataLimitExceeded
1628					);
1629				} else {
1630					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1599					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);
1631				}1600				}
1632			}1601			}
1633			CollectionMode::Fungible(_) => {1602			CollectionMode::Fungible(_) => {
1634				if let CreateItemData::Fungible(_) = data {1603				if !matches!(data, CreateItemData::Fungible(_)) {
1635				} else {
1636					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1604					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);
1637				}1605				}
1638			}1606			}
1639			CollectionMode::ReFungible => {1607			CollectionMode::ReFungible => {
1640				if let CreateItemData::ReFungible(data) = data {1608				if let CreateItemData::ReFungible(data) = data {
1641					// check sizes
1642					ensure!(
1643						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,
1644						Error::<T>::TokenConstDataLimitExceeded
1645					);
1646					ensure!(
1647						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,
1648						Error::<T>::TokenVariableDataLimitExceeded
1649					);
1650
1651					// Check refungibility limits1609					// Check refungibility limits
1652					ensure!(1610					ensure!(
1675			CreateItemData::NFT(data) => {1633			CreateItemData::NFT(data) => {
1676				let item = NftItemType {1634				let item = NftItemType {
1677					owner: owner.clone(),1635					owner: owner.clone(),
1678					const_data: data.const_data,1636					const_data: data.const_data.into_inner(),
1679					variable_data: data.variable_data,1637					variable_data: data.variable_data.into_inner(),
1680				};1638				};
16811639
1682				Self::add_nft_item(collection, item)?;1640				Self::add_nft_item(collection, item)?;
16921650
1693				let item = ReFungibleItemType {1651				let item = ReFungibleItemType {
1694					owner: owner_list,1652					owner: owner_list,
1695					const_data: data.const_data,1653					const_data: data.const_data.into_inner(),
1696					variable_data: data.variable_data,1654					variable_data: data.variable_data.into_inner(),
1697				};1655				};
16981656
1699				Self::add_refungible_item(collection, item)?;1657				Self::add_refungible_item(collection, item)?;
2292			// bound Owned tokens by a single address2250			// bound Owned tokens by a single address
2293			let count = <AccountItemCount<T>>::get(owner.as_sub());2251			let count = <AccountItemCount<T>>::get(owner.as_sub());
2294			ensure!(2252			ensure!(
2295				count < ChainLimit::get().account_token_ownership_limit,2253				count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
2296				Error::<T>::AddressOwnershipLimitExceeded2254				Error::<T>::AddressOwnershipLimitExceeded
2297			);2255			);
22982256

1use crate::{1use crate::{
2	Config, Call, CollectionById, CreateItemBasket, VariableMetaDataBasket,2	Config, Call, CollectionById, CreateItemBasket, VariableMetaDataBasket,
3	ReFungibleTransferBasket, FungibleTransferBasket, NftTransferBasket, ChainLimit,3	ReFungibleTransferBasket, FungibleTransferBasket, NftTransferBasket, CreateItemData,
4	CreateItemData, CollectionMode,4	CollectionMode,
5};5};
6use core::marker::PhantomData;6use core::marker::PhantomData;
7use up_sponsorship::SponsorshipHandler;7use up_sponsorship::SponsorshipHandler;
8use frame_support::{8use frame_support::{
9	traits::IsSubType,9	traits::{IsSubType},
10	storage::{StorageMap, StorageDoubleMap, StorageValue},10	storage::{StorageMap, StorageDoubleMap},
11};11};
12use nft_data_structs::{TokenId, CollectionId};12use nft_data_structs::{
13	TokenId, CollectionId, NFT_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
14	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
15};
1316
14pub struct NftSponsorshipHandler<T>(PhantomData<T>);17pub struct NftSponsorshipHandler<T>(PhantomData<T>);
47		item_id: &TokenId,50		item_id: &TokenId,
48	) -> Option<T::AccountId> {51	) -> Option<T::AccountId> {
49		let collection = CollectionById::<T>::get(collection_id)?;52		let collection = CollectionById::<T>::get(collection_id)?;
50		let limits = ChainLimit::get();
5153
52		let mut sponsor_transfer = false;54		let mut sponsor_transfer = false;
53		if collection.sponsorship.confirmed() {55		if collection.sponsorship.confirmed() {
62					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {64					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
63						collection_limits.sponsor_transfer_timeout65						collection_limits.sponsor_transfer_timeout
64					} else {66					} else {
65						limits.nft_sponsor_transfer_timeout67						NFT_SPONSOR_TRANSFER_TIMEOUT
66					};68					};
6769
68					let mut sponsored = true;70					let mut sponsored = true;
84					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {86					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
85						collection_limits.sponsor_transfer_timeout87						collection_limits.sponsor_transfer_timeout
86					} else {88					} else {
87						limits.fungible_sponsor_transfer_timeout89						FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
88					};90					};
8991
90					let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;92					let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;
107					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {109					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
108						collection_limits.sponsor_transfer_timeout110						collection_limits.sponsor_transfer_timeout
109					} else {111					} else {
110						limits.refungible_sponsor_transfer_timeout112						REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
111					};113					};
112114
113					let mut sponsored = true;115					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);