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

--- a/Makefile
+++ b/Makefile
@@ -35,5 +35,9 @@
 bench-evm-migration:
 	make _bench PALLET=evm-migration
 
+.PHONY: bench-nft
+bench-nft:
+	make _bench PALLET=nft
+
 .PHONY: bench
-bench: bench-evm-migration
+bench: bench-evm-migration bench-nft

1#![cfg(feature = "runtime-benchmarks")]1#![cfg(feature = "runtime-benchmarks")]
22
3use super::*;3use super::*;
4use crate::Module as Nft;4use crate::Pallet;
5
6use sp_std::prelude::*;
7use frame_system::RawOrigin;5use frame_system::RawOrigin;
8use frame_benchmarking::{benchmarks, account, whitelisted_caller}; // , TrackedStorageKey,6use frame_benchmarking::{benchmarks, account};
7use nft_data_structs::*;
8use core::convert::TryInto;
9use sp_runtime::DispatchError;
910
10const SEED: u32 = 1;11const SEED: u32 = 1;
11/*12
12fn default_nft_data() -> CreateItemData {13fn create_data(size: usize) -> Vec<u8> {
13	CreateItemData::NFT(CreateNftData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] })14	(0..size).map(|v| (v & 0xff) as u8).collect()
14}15}
1516fn create_u16_data(size: usize) -> Vec<u16> {
16fn default_fungible_data () -> CreateItemData {17	(0..size).map(|v| (v & 0xffff) as u16).collect()
17	CreateItemData::Fungible(CreateFungibleData { })18}
18}19
1920fn default_nft_data() -> CreateItemData {
20fn default_re_fungible_data () -> CreateItemData {21	CreateItemData::NFT(CreateNftData {
21	CreateItemData::ReFungible(CreateReFungibleData { const_data: vec![1, 2, 3], variable_data: vec![3, 2, 1] })22		const_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
22}23		variable_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
23*/24	})
25}
26
27fn default_fungible_data() -> CreateItemData {
28	CreateItemData::Fungible(CreateFungibleData { value: 1000 })
29}
30
31fn default_re_fungible_data() -> CreateItemData {
32	CreateItemData::ReFungible(CreateReFungibleData {
33		const_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
34		variable_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
35		pieces: 1000,
36	})
37}
38
39fn create_collection_helper<T: Config>(
40	owner: T::AccountId,
41	mode: CollectionMode,
42) -> Result<CollectionId, DispatchError> {
43	T::Currency::deposit_creating(&owner, T::CollectionCreationPrice::get());
44	let col_name = create_u16_data(MAX_COLLECTION_NAME_LENGTH)
45		.try_into()
46		.unwrap();
47	let col_desc = create_u16_data(MAX_COLLECTION_DESCRIPTION_LENGTH)
48		.try_into()
49		.unwrap();
50	let token_prefix = create_data(MAX_TOKEN_PREFIX_LENGTH).try_into().unwrap();
51	<Pallet<T>>::create_collection(
52		RawOrigin::Signed(owner).into(),
53		col_name,
54		col_desc,
55		token_prefix,
56		mode,
57	)?;
58	Ok(CreatedCollectionCount::get())
59}
60fn create_nft_collection<T: Config>(owner: T::AccountId) -> Result<CollectionId, DispatchError> {
61	create_collection_helper::<T>(owner, CollectionMode::NFT)
62}
63fn create_fungible_collection<T: Config>(
64	owner: T::AccountId,
65) -> Result<CollectionId, DispatchError> {
66	create_collection_helper::<T>(owner, CollectionMode::Fungible(0))
67}
68fn create_refungible_collection<T: Config>(
69	owner: T::AccountId,
70) -> Result<CollectionId, DispatchError> {
71	create_collection_helper::<T>(owner, CollectionMode::ReFungible)
72}
2473
25benchmarks! {74benchmarks! {
2675
27	create_collection {76	create_collection {
28		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();77		let col_name: Vec<u16> = create_u16_data(MAX_COLLECTION_NAME_LENGTH);
78		let col_desc: Vec<u16> = create_u16_data(MAX_COLLECTION_DESCRIPTION_LENGTH);
79		let token_prefix: Vec<u8> = create_data(MAX_TOKEN_PREFIX_LENGTH);
80		let mode: CollectionMode = CollectionMode::NFT;
81		let caller: T::AccountId = account("caller", 0, SEED);
82		T::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
83	}: _(RawOrigin::Signed(caller.clone()), col_name.clone(), col_desc.clone(), token_prefix.clone(), mode)
84	verify {
85		assert_eq!(<Pallet<T>>::collection_id(2).unwrap().owner, caller);
86	}
87
88	destroy_collection {
89		let caller: T::AccountId = account("caller", 0, SEED);
90		let collection = create_nft_collection::<T>(caller.clone())?;
91	}: _(RawOrigin::Signed(caller.clone()), collection)
92
93	add_to_white_list {
94		let caller: T::AccountId = account("caller", 0, SEED);
95		let whitelist_account: T::AccountId = account("admin", 0, SEED);
96		let collection = create_nft_collection::<T>(caller.clone())?;
97	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(whitelist_account))
98
99	remove_from_white_list {
100		let caller: T::AccountId = account("caller", 0, SEED);
101		let whitelist_account: T::AccountId = account("admin", 0, SEED);
102		let collection = create_nft_collection::<T>(caller.clone())?;
103		<Pallet<T>>::add_to_white_list(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(whitelist_account.clone()))?;
104	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(whitelist_account))
105
106	set_public_access_mode {
107		let caller: T::AccountId = account("caller", 0, SEED);
108		let collection = create_nft_collection::<T>(caller.clone())?;
109	}: _(RawOrigin::Signed(caller.clone()), collection, AccessMode::WhiteList)
110
111	set_mint_permission {
112		let caller: T::AccountId = account("caller", 0, SEED);
113		let collection = create_nft_collection::<T>(caller.clone())?;
114	}: _(RawOrigin::Signed(caller.clone()), collection, true)
115
116	change_collection_owner {
117		let caller: T::AccountId = account("caller", 0, SEED);
118		let collection = create_nft_collection::<T>(caller.clone())?;
119		let new_owner: T::AccountId = account("admin", 0, SEED);
120	}: _(RawOrigin::Signed(caller.clone()), collection, new_owner)
121
122	add_collection_admin {
123		let caller: T::AccountId = account("caller", 0, SEED);
124		let collection = create_nft_collection::<T>(caller.clone())?;
125		let new_admin: T::AccountId = account("admin", 0, SEED);
126	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(new_admin))
127
128	remove_collection_admin {
129		let caller: T::AccountId = account("caller", 0, SEED);
130		let collection = create_nft_collection::<T>(caller.clone())?;
131		let new_admin: T::AccountId = account("admin", 0, SEED);
132		<Pallet<T>>::add_collection_admin(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(new_admin.clone()))?;
133	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(new_admin))
134
135	set_collection_sponsor {
136		let caller: T::AccountId = account("caller", 0, SEED);
137		let collection = create_nft_collection::<T>(caller.clone())?;
138	}: _(RawOrigin::Signed(caller.clone()), collection, caller.clone())
139
140	confirm_sponsorship {
141		let caller: T::AccountId = account("caller", 0, SEED);
29		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();142		let collection = create_nft_collection::<T>(caller.clone())?;
143		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone())?;
144	}: _(RawOrigin::Signed(caller.clone()), collection)
145
146	remove_collection_sponsor {
147		let caller: T::AccountId = account("caller", 0, SEED);
148		let collection = create_nft_collection::<T>(caller.clone())?;
149		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone())?;
150		<Pallet<T>>::confirm_sponsorship(RawOrigin::Signed(caller.clone()).into(), 2)?;
151	}: _(RawOrigin::Signed(caller.clone()), collection)
152
153	// nft item
154	create_item_nft {
155		let b in 0..(CUSTOM_DATA_LIMIT * 2);
156
157		let caller: T::AccountId = account("caller", 0, SEED);
158		let collection = create_nft_collection::<T>(caller.clone())?;
159		let data = CreateItemData::NFT(CreateNftData {
160			const_data: create_data(b.min(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
161			variable_data: create_data(b.saturating_sub(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
162		});
163	}: create_item(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
164
165	create_multiple_items_nft {
166		// TODO: Take item data size into account. As create_item_nft bench shows, this parameter has no effect on execution time,
167		// but it may if we increase CUSTOM_DATA_LIMIT
168		let b in 1..1000;
169
170		let caller: T::AccountId = account("caller", 0, SEED);
171		let collection = create_nft_collection::<T>(caller.clone())?;
172		let data = (0..b).map(|_| default_nft_data()).collect();
173	}: create_multiple_items(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
174
175	// fungible item
176	create_item_fungible {
177		let caller: T::AccountId = account("caller", 0, SEED);
178		let collection = create_fungible_collection::<T>(caller.clone())?;
179		let data = CreateItemData::Fungible(CreateFungibleData {
180			value: 1000,
181		});
182	}: create_item(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
183
184	create_multiple_items_fungible {
185		let b in 1..1000;
186
187		let caller: T::AccountId = account("caller", 0, SEED);
188		let collection = create_fungible_collection::<T>(caller.clone())?;
189		let data = (0..b).map(|_| default_fungible_data()).collect();
190	}: create_multiple_items(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
191
192	// refungible item
193	create_item_refungible {
194		let b in 0..(CUSTOM_DATA_LIMIT * 2);
195
196		let caller: T::AccountId = account("caller", 0, SEED);
197		let collection = create_refungible_collection::<T>(caller.clone())?;
198		let data = CreateItemData::ReFungible(CreateReFungibleData {
199			const_data: create_data(b.min(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
200			variable_data: create_data(b.saturating_sub(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
201			pieces: 1000,
202		});
203	}: create_item(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
204
205	create_multiple_items_refungible {
206		// TODO: Take item data size into account. As create_item_nft bench shows, this parameter has no effect on execution time,
207		// but it may if we increase CUSTOM_DATA_LIMIT
208		let b in 1..1000;
209
210		let caller: T::AccountId = account("caller", 0, SEED);
211		let collection = create_refungible_collection::<T>(caller.clone())?;
212		let data = (0..b).map(|_| default_re_fungible_data()).collect();
213	}: create_multiple_items(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
214
215	burn_item_nft {
216		let caller: T::AccountId = account("caller", 0, SEED);
217		let collection = create_nft_collection::<T>(caller.clone())?;
218		let data = default_nft_data();
219		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
220	}: burn_item(RawOrigin::Signed(caller.clone()), collection, 1, 1)
221
222	transfer_nft {
30		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();223		let caller: T::AccountId = account("caller", 0, SEED);
224		let collection = create_nft_collection::<T>(caller.clone())?;
225		let recipient: T::AccountId = account("recipient", 0, SEED);
226		let data = default_nft_data();
227		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
228	}: transfer(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
229
230	transfer_fungible {
231		let caller: T::AccountId = account("caller", 0, SEED);
232		let collection = create_fungible_collection::<T>(caller.clone())?;
233		let recipient: T::AccountId = account("recipient", 0, SEED);
234		let data = default_fungible_data();
235		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
236	}: transfer(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
237
238	transfer_refungible {
31		let mode: CollectionMode = CollectionMode::NFT;239		let caller: T::AccountId = account("caller", 0, SEED);
240		let collection = create_refungible_collection::<T>(caller.clone())?;
32		let caller: T::AccountId = account("caller", 0, SEED);241		let recipient: T::AccountId = account("recipient", 0, SEED);
242		let data = default_re_fungible_data();
243		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
244	}: transfer(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
245
246	set_transfers_enabled_flag {
247		let caller: T::AccountId = account("caller", 0, SEED);
248		let collection = create_nft_collection::<T>(caller.clone())?;
33	}: _(RawOrigin::Signed(caller.clone()), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode)249	}: _(RawOrigin::Signed(caller.clone()), collection, false)
34/*250
35	verify {251	approve_nft {
36		assert_eq!(Nft::<T>::collection_id(2).owner, caller);252		let caller: T::AccountId = account("caller", 0, SEED);
37	}253		let collection = create_nft_collection::<T>(caller.clone())?;
38	destroy_collection {254		let recipient: T::AccountId = account("recipient", 0, SEED);
39		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();255		let data = default_nft_data();
40		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();256		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
41		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();257	}: approve(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
42		let mode: CollectionMode = CollectionMode::NFT;258
43		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());259	// Nft
44		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;260	transfer_from_nft {
45	}: _(RawOrigin::Signed(caller.clone()), 2)261		let caller: T::AccountId = account("caller", 0, SEED);
46262		let collection = create_nft_collection::<T>(caller.clone())?;
47	add_to_white_list {263		let recipient: T::AccountId = account("recipient", 0, SEED);
48		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();264		let data = default_nft_data();
49		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();265		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
50		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();266		<Pallet<T>>::approve(RawOrigin::Signed(caller.clone()).into(), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)?;
51		let mode: CollectionMode = CollectionMode::NFT;267	}: transfer_from(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)
52		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());268
53		let whitelist_account: T::AccountId = account("admin", 0, SEED);269	// Fungible
54		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;270	transfer_from_fungible {
55	}: add_to_white_list(RawOrigin::Signed(caller.clone()), 2, whitelist_account)271		let caller: T::AccountId = account("caller", 0, SEED);
56272		let collection = create_fungible_collection::<T>(caller.clone())?;
57	remove_from_white_list {273		let recipient: T::AccountId = account("recipient", 0, SEED);
58		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();274		let data = default_fungible_data();
59		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();275		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
60		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();276		<Pallet<T>>::approve(RawOrigin::Signed(caller.clone()).into(), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)?;
61		let mode: CollectionMode = CollectionMode::NFT;277	}: transfer_from(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)
62		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());278
63		let whitelist_account: T::AccountId = account("admin", 0, SEED);279	// ReFungible
64		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;280	transfer_from_refungible {
65		Nft::<T>::add_to_white_list(RawOrigin::Signed(caller.clone()).into(), 2, whitelist_account.clone())?;281		let caller: T::AccountId = account("caller", 0, SEED);
66	}: remove_from_white_list(RawOrigin::Signed(caller.clone()), 2, whitelist_account)282		let collection = create_refungible_collection::<T>(caller.clone())?;
67283		let recipient: T::AccountId = account("recipient", 0, SEED);
68	set_public_access_mode {284		let data = default_re_fungible_data();
69		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();285		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
70		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();286		<Pallet<T>>::approve(RawOrigin::Signed(caller.clone()).into(), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)?;
71		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();287	}: transfer_from(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)
72		let mode: CollectionMode = CollectionMode::NFT;288
73		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());289	set_offchain_schema {
74		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;290		let b in 0..OFFCHAIN_SCHEMA_LIMIT;
75	}: set_public_access_mode(RawOrigin::Signed(caller.clone()), 2, AccessMode::WhiteList)291
76292		let caller: T::AccountId = account("caller", 0, SEED);
77	set_mint_permission {293		let collection = create_nft_collection::<T>(caller.clone())?;
78		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();294		let data = create_data(b as usize);
79		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();295	}: set_offchain_schema(RawOrigin::Signed(caller.clone()), collection, data)
80		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();296
81		let mode: CollectionMode = CollectionMode::NFT;297	set_const_on_chain_schema {
82		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());298		let b in 0..CONST_ON_CHAIN_SCHEMA_LIMIT;
83		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;299
84	}: set_mint_permission(RawOrigin::Signed(caller.clone()), 2, true)300		let caller: T::AccountId = account("caller", 0, SEED);
85301		let collection = create_nft_collection::<T>(caller.clone())?;
86	change_collection_owner {302		let data = create_data(b as usize);
87		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();303	}: set_const_on_chain_schema(RawOrigin::Signed(caller.clone()), collection, data)
88		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();304
89		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();305	set_variable_on_chain_schema {
90		let mode: CollectionMode = CollectionMode::NFT;306		let b in 0..VARIABLE_ON_CHAIN_SCHEMA_LIMIT;
91		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());307
92		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;308		let caller: T::AccountId = account("caller", 0, SEED);
93		let new_owner: T::AccountId = account("admin", 0, SEED);309		let collection = create_nft_collection::<T>(caller.clone())?;
94	}: change_collection_owner(RawOrigin::Signed(caller.clone()), 2, new_owner)310		let data = create_data(b as usize);
95311	}: set_variable_on_chain_schema(RawOrigin::Signed(caller.clone()), 2, data)
96	add_collection_admin {312
97		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();313	set_variable_meta_data_nft {
98		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();314		let b in 0..CUSTOM_DATA_LIMIT;
99		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();315
100		let mode: CollectionMode = CollectionMode::NFT;316		let caller: T::AccountId = account("caller", 0, SEED);
101		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());317		let collection = create_nft_collection::<T>(caller.clone())?;
102		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;318		let data = default_nft_data();
103		let new_admin: T::AccountId = account("admin", 0, SEED);319		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
104	}: add_collection_admin(RawOrigin::Signed(caller.clone()), 2, new_admin)320		let data = create_data(b as usize);
105321	}: set_variable_meta_data(RawOrigin::Signed(caller.clone()), collection, 1, data)
106	remove_collection_admin {322
107		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();323	set_schema_version {
108		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();324		let caller: T::AccountId = account("caller", 0, SEED);
109		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();325		let collection = create_nft_collection::<T>(caller.clone())?;
110		let mode: CollectionMode = CollectionMode::NFT;326	}: set_schema_version(RawOrigin::Signed(caller.clone()), 2, SchemaVersion::Unique)
111		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());327
112		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;328	set_collection_limits{
113		let new_admin: T::AccountId = account("admin", 0, SEED);329		let caller: T::AccountId = account("caller", 0, SEED);
114		Nft::<T>::add_collection_admin(RawOrigin::Signed(caller.clone()).into(), 2, new_admin.clone())?;330		let collection = create_nft_collection::<T>(caller.clone())?;
115	}: remove_collection_admin(RawOrigin::Signed(caller.clone()), 2, new_admin)331
116332		let cl = CollectionLimits {
117	set_collection_sponsor {333			account_token_ownership_limit: 0,
118		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();334			sponsored_data_size: 0,
119		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();335			token_limit: 1,
120		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();336			sponsor_transfer_timeout: 0,
121		let mode: CollectionMode = CollectionMode::NFT;337			owner_can_destroy: true,
122		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());338			owner_can_transfer: true,
123		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;339			sponsored_data_rate_limit: None,
124	}: set_collection_sponsor(RawOrigin::Signed(caller.clone()), 2, caller.clone())340		};
125341	}: set_collection_limits(RawOrigin::Signed(caller.clone()), 2, cl)
126	confirm_sponsorship {
127		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
128		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
129		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
130		let mode: CollectionMode = CollectionMode::NFT;
131		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
132		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
133		Nft::<T>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone())?;
134	}: confirm_sponsorship(RawOrigin::Signed(caller.clone()), 2)
135
136	remove_collection_sponsor {
137		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
138		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
139		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
140		let mode: CollectionMode = CollectionMode::NFT;
141		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
142		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
143		Nft::<T>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone())?;
144		Nft::<T>::confirm_sponsorship(RawOrigin::Signed(caller.clone()).into(), 2)?;
145	}: remove_collection_sponsor(RawOrigin::Signed(caller.clone()), 2)
146
147	// nft item
148	create_item_nft {
149		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
150		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
151		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
152		let mode: CollectionMode = CollectionMode::NFT;
153		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
154		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
155		let data = default_nft_data();
156
157	}: create_item(RawOrigin::Signed(caller.clone()), 2, caller.clone(), data)
158
159	#[extra]
160	create_item_nft_large {
161		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
162		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
163		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
164		let mode: CollectionMode = CollectionMode::NFT;
165		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
166		let mut nft_data = CreateNftData {
167			const_data: vec![],
168			variable_data: vec![]
169		};
170		for i in 0..1998 {
171			nft_data.const_data.push(10);
172			nft_data.variable_data.push(10);
173		}
174		let data = CreateItemData::NFT(nft_data);
175		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
176
177	}: create_item(RawOrigin::Signed(caller.clone()), 2, caller.clone(), data)
178
179	// fungible item
180	create_item_fungible {
181		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
182		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
183		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
184		let mode: CollectionMode = CollectionMode::Fungible(3);
185		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
186		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
187		let data = default_fungible_data();
188
189	}: create_item(RawOrigin::Signed(caller.clone()), 2, caller.clone(), data)
190
191	// refungible item
192	create_item_refungible {
193		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
194		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
195		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
196		let mode: CollectionMode = CollectionMode::ReFungible(3);
197		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
198		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
199		let data = default_re_fungible_data();
200
201	}: create_item(RawOrigin::Signed(caller.clone()), 2, caller.clone(), data)
202
203	burn_item {
204		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
205		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
206		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
207		let mode: CollectionMode = CollectionMode::NFT;
208		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
209		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
210		let data = default_nft_data();
211		Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
212
213	}: burn_item(RawOrigin::Signed(caller.clone()), 2, 1)
214
215	transfer_nft {
216		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
217		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
218		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
219		let mode: CollectionMode = CollectionMode::NFT;
220		let recipient: T::AccountId = account("recipient", 0, SEED);
221		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
222		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
223		let data = default_nft_data();
224		Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
225
226	}: transfer(RawOrigin::Signed(caller.clone()), recipient.clone(), 2, 1, 1)
227
228	transfer_fungible {
229		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
230		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
231		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
232		let mode: CollectionMode = CollectionMode::Fungible(3);
233		let recipient: T::AccountId = account("recipient", 0, SEED);
234		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
235		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
236		let data = default_fungible_data();
237		Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
238
239	}: transfer(RawOrigin::Signed(caller.clone()), recipient.clone(), 2, 1, 1)
240
241	transfer_refungible {
242		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
243		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
244		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
245		let mode: CollectionMode = CollectionMode::ReFungible(3);
246		let recipient: T::AccountId = account("recipient", 0, SEED);
247		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
248		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
249		let data = default_re_fungible_data();
250		Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
251
252	}: transfer(RawOrigin::Signed(caller.clone()), recipient.clone(), 2, 1, 1)
253
254	approve {
255		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
256		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
257		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
258		let mode: CollectionMode = CollectionMode::ReFungible(3);
259		let recipient: T::AccountId = account("recipient", 0, SEED);
260		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
261		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
262		let data = default_re_fungible_data();
263		Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
264
265	}: approve(RawOrigin::Signed(caller.clone()), recipient.clone(), 2, 1)
266
267	// Nft
268	transfer_from_nft {
269		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
270		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
271		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
272		let mode: CollectionMode = CollectionMode::NFT;
273		let recipient: T::AccountId = account("recipient", 0, SEED);
274		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
275		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
276		let data = default_nft_data();
277		Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
278		Nft::<T>::approve(RawOrigin::Signed(caller.clone()).into(), recipient.clone(), 2, 1)?;
279
280	}: transfer_from(RawOrigin::Signed(caller.clone()), caller.clone(), recipient.clone(), 2, 1, 1)
281
282	// Fungible
283	transfer_from_fungible {
284		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
285		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
286		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
287		let mode: CollectionMode = CollectionMode::Fungible(3);
288		let recipient: T::AccountId = account("recipient", 0, SEED);
289		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
290		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
291		let data = default_fungible_data();
292		Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
293		Nft::<T>::approve(RawOrigin::Signed(caller.clone()).into(), recipient.clone(), 2, 1)?;
294
295	}: transfer_from(RawOrigin::Signed(caller.clone()), caller.clone(), recipient.clone(), 2, 1, 1)
296
297	// ReFungible
298	transfer_from_refungible {
299		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
300		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
301		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
302		let mode: CollectionMode = CollectionMode::ReFungible(3);
303		let recipient: T::AccountId = account("recipient", 0, SEED);
304		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
305		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
306		let data = default_re_fungible_data();
307		Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
308		Nft::<T>::approve(RawOrigin::Signed(caller.clone()).into(), recipient.clone(), 2, 1)?;
309
310	}: transfer_from(RawOrigin::Signed(caller.clone()), caller.clone(), recipient.clone(), 2, 1, 1)
311
312	enable_contract_sponsoring {
313		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
314
315	}: enable_contract_sponsoring(RawOrigin::Signed(caller.clone()), caller.clone(), true)
316
317	set_offchain_schema {
318		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
319		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
320		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
321		let mode: CollectionMode = CollectionMode::ReFungible(3);
322		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
323		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
324
325	}: set_offchain_schema(RawOrigin::Signed(caller.clone()), 2, [1,2,3].to_vec())
326
327	set_const_on_chain_schema {
328		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
329		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
330		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
331		let mode: CollectionMode = CollectionMode::ReFungible(3);
332		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
333		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
334	}: set_const_on_chain_schema(RawOrigin::Signed(caller.clone()), 2, [1,2,3].to_vec())
335
336	set_variable_on_chain_schema {
337		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
338		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
339		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
340		let mode: CollectionMode = CollectionMode::ReFungible(3);
341		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
342		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
343	}: set_variable_on_chain_schema(RawOrigin::Signed(caller.clone()), 2, [1,2,3].to_vec())
344
345	set_variable_meta_data {
346		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
347		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
348		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
349		let mode: CollectionMode = CollectionMode::NFT;
350		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
351		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
352		let data = default_nft_data();
353		Nft::<T>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone(), data)?;
354
355	}: set_variable_meta_data(RawOrigin::Signed(caller.clone()), 2, 1, [1, 2, 3].to_vec())
356
357	set_schema_version {
358		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
359		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
360		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
361		let mode: CollectionMode = CollectionMode::NFT;
362		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
363		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
364	}: set_schema_version(RawOrigin::Signed(caller.clone()), 2, SchemaVersion::Unique)
365
366	set_chain_limits {
367		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
368		let limits = ChainLimits {
369			collection_numbers_limit: 0,
370			account_token_ownership_limit: 0,
371			collections_admins_limit: 0,
372			custom_data_limit: 0,
373			nft_sponsor_transfer_timeout: 0,
374			fungible_sponsor_transfer_timeout: 0,
375			refungible_sponsor_transfer_timeout: 0
376		};
377	}: set_chain_limits(RawOrigin::Signed(caller.clone()), limits)
378
379	set_contract_sponsoring_rate_limit {
380		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
381		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
382		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
383		let mode: CollectionMode = CollectionMode::NFT;
384		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
385		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
386		let block_number: T::BlockNumber = 0.into();
387	}: set_contract_sponsoring_rate_limit(RawOrigin::Signed(caller.clone()), caller.clone(), block_number)
388
389	set_collection_limits{
390		let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
391		let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
392		let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
393		let mode: CollectionMode = CollectionMode::NFT;
394		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
395		Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
396
397		let cl = CollectionLimits {
398			account_token_ownership_limit: 0,
399			sponsored_data_size: 0,
400			token_limit: 0,
401			sponsor_transfer_timeout: 0
402		};
403
404	}: set_collection_limits(RawOrigin::Signed(caller.clone()), 2, cl)
405
406	add_to_contract_white_list{
407		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
408	}: add_to_contract_white_list(RawOrigin::Signed(caller.clone()), caller.clone(), caller.clone())
409
410	remove_from_contract_white_list{
411		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
412		Nft::<T>::add_to_contract_white_list(RawOrigin::Signed(caller.clone()).into(), caller.clone(), caller.clone())?;
413	}: remove_from_contract_white_list(RawOrigin::Signed(caller.clone()), caller.clone(), caller.clone())
414
415	toggle_contract_white_list{
416		let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
417	}: toggle_contract_white_list(RawOrigin::Signed(caller.clone()), caller.clone(), true)
418*/
419}342}
420343

--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -40,8 +40,9 @@
 	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,
 	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,
+	OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,
+	MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,
+	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,
 	FungibleItemType, ReFungibleItemType,
 };
 
@@ -51,7 +52,6 @@
 #[cfg(test)]
 mod tests;
 
-mod default_weights;
 mod eth;
 mod sponsorship;
 pub use sponsorship::NftSponsorshipHandler;
@@ -63,38 +63,8 @@
 
 #[cfg(feature = "runtime-benchmarks")]
 mod benchmarking;
-
-pub trait WeightInfo {
-	fn create_collection() -> Weight;
-	fn destroy_collection() -> Weight;
-	fn add_to_white_list() -> Weight;
-	fn remove_from_white_list() -> Weight;
-	fn set_public_access_mode() -> Weight;
-	fn set_mint_permission() -> Weight;
-	fn change_collection_owner() -> Weight;
-	fn add_collection_admin() -> Weight;
-	fn remove_collection_admin() -> Weight;
-	fn set_collection_sponsor() -> Weight;
-	fn confirm_sponsorship() -> Weight;
-	fn remove_collection_sponsor() -> Weight;
-	fn create_item(s: usize) -> Weight;
-	fn burn_item() -> Weight;
-	fn transfer() -> Weight;
-	fn approve() -> Weight;
-	fn transfer_from() -> Weight;
-	fn set_offchain_schema() -> Weight;
-	fn set_const_on_chain_schema() -> Weight;
-	fn set_variable_on_chain_schema() -> Weight;
-	fn set_variable_meta_data() -> Weight;
-	fn enable_contract_sponsoring() -> Weight;
-	fn set_schema_version() -> Weight;
-	fn set_contract_sponsoring_rate_limit() -> Weight;
-	fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;
-	fn toggle_contract_white_list() -> Weight;
-	fn add_to_contract_white_list() -> Weight;
-	fn remove_from_contract_white_list() -> Weight;
-	fn set_collection_limits() -> Weight;
-}
+pub mod weights;
+use weights::WeightInfo;
 
 decl_error! {
 	/// Error for non-fungible-token module.
@@ -255,6 +225,39 @@
 	type TreasuryAccountId: Get<Self::AccountId>;
 }
 
+type SelfWeightOf<T> = <T as Config>::WeightInfo;
+
+trait WeightInfoHelpers: WeightInfo {
+	fn transfer() -> Weight {
+		Self::transfer_nft()
+			.max(Self::transfer_fungible())
+			.max(Self::transfer_refungible())
+	}
+	fn transfer_from() -> Weight {
+		Self::transfer_from_nft()
+			.max(Self::transfer_from_fungible())
+			.max(Self::transfer_from_refungible())
+	}
+	fn approve() -> Weight {
+		// TODO: refungible, fungible
+		Self::approve_nft()
+	}
+	fn set_variable_meta_data(data: u32) -> Weight {
+		// TODO: refungible
+		Self::set_variable_meta_data_nft(data)
+	}
+	fn create_item(data: u32) -> Weight {
+		Self::create_item_nft(data)
+			.max(Self::create_item_fungible())
+			.max(Self::create_item_refungible(data))
+	}
+	fn burn_item() -> Weight {
+		// TODO: refungible, fungible
+		Self::burn_item_nft()
+	}
+}
+impl<T: WeightInfo> WeightInfoHelpers for T {}
+
 // # Used definitions
 //
 // ## User control levels
@@ -464,7 +467,7 @@
 		///
 		/// * mode: [CollectionMode] collection type and type dependent data.
 		// returns collection ID
-		#[weight = <T as Config>::WeightInfo::create_collection()]
+		#[weight = <SelfWeightOf<T>>::create_collection()]
 		#[transactional]
 		pub fn create_collection(origin,
 								 collection_name: Vec<u16>,
@@ -501,9 +504,9 @@
 
 			// check params
 			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);
-			ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);
-			ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);
-			ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);
+			ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);
+			ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);
+			ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);
 
 			// Generate next collection ID
 			let next_id = created_count
@@ -554,7 +557,7 @@
 		/// # Arguments
 		///
 		/// * collection_id: collection to destroy.
-		#[weight = <T as Config>::WeightInfo::destroy_collection()]
+		#[weight = <SelfWeightOf<T>>::destroy_collection()]
 		#[transactional]
 		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {
 
@@ -602,7 +605,7 @@
 		/// * collection_id.
 		///
 		/// * address.
-		#[weight = <T as Config>::WeightInfo::add_to_white_list()]
+		#[weight = <SelfWeightOf<T>>::add_to_white_list()]
 		#[transactional]
 		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
 
@@ -631,7 +634,7 @@
 		/// * collection_id.
 		///
 		/// * address.
-		#[weight = <T as Config>::WeightInfo::remove_from_white_list()]
+		#[weight = <SelfWeightOf<T>>::remove_from_white_list()]
 		#[transactional]
 		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
 
@@ -659,7 +662,7 @@
 		/// * collection_id.
 		///
 		/// * mode: [AccessMode]
-		#[weight = <T as Config>::WeightInfo::set_public_access_mode()]
+		#[weight = <SelfWeightOf<T>>::set_public_access_mode()]
 		#[transactional]
 		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult
 		{
@@ -684,7 +687,7 @@
 		/// * collection_id.
 		///
 		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.
-		#[weight = <T as Config>::WeightInfo::set_mint_permission()]
+		#[weight = <SelfWeightOf<T>>::set_mint_permission()]
 		#[transactional]
 		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult
 		{
@@ -707,7 +710,7 @@
 		/// * collection_id.
 		///
 		/// * new_owner.
-		#[weight = <T as Config>::WeightInfo::change_collection_owner()]
+		#[weight = <SelfWeightOf<T>>::change_collection_owner()]
 		#[transactional]
 		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {
 
@@ -731,7 +734,7 @@
 		/// * collection_id: ID of the Collection to add admin for.
 		///
 		/// * new_admin_id: Address of new admin to add.
-		#[weight = <T as Config>::WeightInfo::add_collection_admin()]
+		#[weight = <SelfWeightOf<T>>::add_collection_admin()]
 		#[transactional]
 		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
@@ -762,7 +765,7 @@
 		/// * collection_id: ID of the Collection to remove admin for.
 		///
 		/// * account_id: Address of admin to remove.
-		#[weight = <T as Config>::WeightInfo::remove_collection_admin()]
+		#[weight = <SelfWeightOf<T>>::remove_collection_admin()]
 		#[transactional]
 		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
@@ -786,7 +789,7 @@
 		/// * collection_id.
 		///
 		/// * new_sponsor.
-		#[weight = <T as Config>::WeightInfo::set_collection_sponsor()]
+		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]
 		#[transactional]
 		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {
 			let sender = ensure_signed(origin)?;
@@ -804,7 +807,7 @@
 		/// # Arguments
 		///
 		/// * collection_id.
-		#[weight = <T as Config>::WeightInfo::confirm_sponsorship()]
+		#[weight = <SelfWeightOf<T>>::confirm_sponsorship()]
 		#[transactional]
 		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {
 			let sender = ensure_signed(origin)?;
@@ -828,7 +831,7 @@
 		/// # Arguments
 		///
 		/// * collection_id.
-		#[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]
+		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]
 		#[transactional]
 		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {
 			let sender = ensure_signed(origin)?;
@@ -864,7 +867,7 @@
 		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))
 		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]
 
-		#[weight = <T as Config>::WeightInfo::create_item(data.data_size())]
+		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]
 		#[transactional]
 		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
@@ -893,8 +896,8 @@
 		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].
 		///
 		/// * owner: Address, initial owner of the NFT.
-		#[weight = <T as Config>::WeightInfo::create_item(items_data.iter()
-							   .map(|data| { data.data_size() })
+		#[weight = <SelfWeightOf<T>>::create_item(items_data.iter()
+							   .map(|data| { data.data_size() as u32 })
 							   .sum())]
 		#[transactional]
 		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {
@@ -921,7 +924,7 @@
 		/// * collection_id: ID of the collection.
 		///
 		/// * value: New flag value.
-		#[weight = <T as Config>::WeightInfo::burn_item()]
+		#[weight = <SelfWeightOf<T>>::burn_item()]
 		#[transactional]
 		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {
 
@@ -947,7 +950,7 @@
 		/// * collection_id: ID of the collection.
 		///
 		/// * item_id: ID of NFT to burn.
-		#[weight = <T as Config>::WeightInfo::burn_item()]
+		#[weight = <SelfWeightOf<T>>::burn_item()]
 		#[transactional]
 		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {
 
@@ -982,7 +985,7 @@
 		///     * Non-Fungible Mode: Ignored
 		///     * Fungible Mode: Must specify transferred amount
 		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)
-		#[weight = <T as Config>::WeightInfo::transfer()]
+		#[weight = <SelfWeightOf<T>>::transfer()]
 		#[transactional]
 		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
@@ -1008,7 +1011,7 @@
 		/// * collection_id.
 		///
 		/// * item_id: ID of the item.
-		#[weight = <T as Config>::WeightInfo::approve()]
+		#[weight = <SelfWeightOf<T>>::approve()]
 		#[transactional]
 		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
@@ -1038,7 +1041,7 @@
 		/// * item_id: ID of the item.
 		///
 		/// * value: Amount to transfer.
-		#[weight = <T as Config>::WeightInfo::transfer_from()]
+		#[weight = <SelfWeightOf<T>>::transfer_from()]
 		#[transactional]
 		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
@@ -1073,7 +1076,7 @@
 		/// * collection_id.
 		///
 		/// * schema: String representing the offchain data schema.
-		#[weight = <T as Config>::WeightInfo::set_variable_meta_data()]
+		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]
 		#[transactional]
 		pub fn set_variable_meta_data (
 			origin,
@@ -1104,7 +1107,7 @@
 		/// * collection_id.
 		///
 		/// * schema: SchemaVersion: enum
-		#[weight = <T as Config>::WeightInfo::set_schema_version()]
+		#[weight = <SelfWeightOf<T>>::set_schema_version()]
 		#[transactional]
 		pub fn set_schema_version(
 			origin,
@@ -1130,7 +1133,7 @@
 		/// * collection_id.
 		///
 		/// * schema: String representing the offchain data schema.
-		#[weight = <T as Config>::WeightInfo::set_offchain_schema()]
+		#[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]
 		#[transactional]
 		pub fn set_offchain_schema(
 			origin,
@@ -1160,7 +1163,7 @@
 		/// * collection_id.
 		///
 		/// * schema: String representing the const on-chain data schema.
-		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]
+		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]
 		#[transactional]
 		pub fn set_const_on_chain_schema (
 			origin,
@@ -1190,7 +1193,7 @@
 		/// * collection_id.
 		///
 		/// * schema: String representing the variable on-chain data schema.
-		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]
+		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]
 		#[transactional]
 		pub fn set_variable_on_chain_schema (
 			origin,
@@ -1208,7 +1211,7 @@
 			target_collection.save()
 		}
 
-		#[weight = <T as Config>::WeightInfo::set_collection_limits()]
+		#[weight = <SelfWeightOf<T>>::set_collection_limits()]
 		#[transactional]
 		pub fn set_collection_limits(
 			origin,

--- a/primitives/nft/src/lib.rs
+++ b/primitives/nft/src/lib.rs
@@ -55,6 +55,10 @@
 pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 1024;
 pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 1024;
 
+pub const MAX_COLLECTION_NAME_LENGTH: usize = 64;
+pub const MAX_COLLECTION_DESCRIPTION_LENGTH: usize = 256;
+pub const MAX_TOKEN_PREFIX_LENGTH: usize = 16;
+
 /// How much items can be created per single
 /// create_many call
 pub const MAX_ITEMS_PER_BATCH: u32 = 200;

--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -119,8 +119,6 @@
 /// Digest item type.
 pub type DigestItem = generic::DigestItem<Hash>;
 
-mod nft_weights;
-
 /// Opaque types. These are used by the CLI to instantiate machinery that don't need to know
 /// the specifics of the runtime. They can then be made to be agnostic over specific formats
 /// of data like extrinsics, allowing for them to continue syncing the network through upgrades
@@ -695,7 +693,7 @@
 /// Used for the pallet nft in `./nft.rs`
 impl pallet_nft::Config for Runtime {
 	type Event = Event;
-	type WeightInfo = nft_weights::WeightInfo;
+	type WeightInfo = pallet_nft::weights::SubstrateWeight<Self>;
 
 	type EvmBackwardsAddressMapping = pallet_nft::MapBackwardsAddressTruncated;
 	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;