git.delta.rocks / unique-network / refs/commits / 59e224731e80

5913dependencies = [5913dependencies = [
5914 "evm-coder",5914 "evm-coder",
5915 "fp-evm-mapping",5915 "fp-evm-mapping",
5916 "frame-benchmarking",
5916 "frame-support",5917 "frame-support",
5917 "frame-system",5918 "frame-system",
5918 "pallet-evm",5919 "pallet-evm",
6649 "frame-support",6650 "frame-support",
6650 "frame-system",6651 "frame-system",
6651 "pallet-common",6652 "pallet-common",
6653 "pallet-evm",
6652 "parity-scale-codec 3.1.2",6654 "parity-scale-codec 3.1.2",
6653 "scale-info",6655 "scale-info",
6654 "sp-std",6656 "sp-std",

41bench-evm-migration:41bench-evm-migration:
42	make _bench PALLET=evm-migration42	make _bench PALLET=evm-migration
43
44.PHONY: bench-common
45bench-common:
46	make _bench PALLET=common
4347
44.PHONY: bench-unique48.PHONY: bench-unique
45bench-unique:49bench-unique:

25scale-info = { version = "2.0.1", default-features = false, features = [25scale-info = { version = "2.0.1", default-features = false, features = [
26    "derive",26    "derive",
27] }27] }
28frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
2829
29[features]30[features]
30default = ["std"]31default = ["std"]
38    "pallet-evm/std",39    "pallet-evm/std",
39]40]
40runtime-benchmarks = []41runtime-benchmarks = [
42    "frame-benchmarking"
43]
4144

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17use sp_std::vec::Vec;17use sp_std::vec::Vec;
18use crate::{Config, CollectionHandle};18use crate::{Config, CollectionHandle, Pallet};
19use pallet_evm::account::CrossAccountId;
20use frame_benchmarking::{benchmarks, account};
19use up_data_structs::{21use up_data_structs::{
20	CollectionMode, CreateCollectionData, CollectionId, MAX_COLLECTION_NAME_LENGTH,22	CollectionMode, CreateCollectionData, CollectionId, Property, PropertyKey, PropertyValue,
21	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH, OFFCHAIN_SCHEMA_LIMIT,23	MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH,
22	CONST_ON_CHAIN_SCHEMA_LIMIT,24	OFFCHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, MAX_PROPERTIES_PER_ITEM,
23};25};
24use frame_support::{26use frame_support::{
25	traits::{Currency, Get},27	traits::{Currency, Get},
29use core::convert::TryInto;31use core::convert::TryInto;
30use sp_runtime::DispatchError;32use sp_runtime::DispatchError;
33
34const SEED: u32 = 1;
3135
32pub fn create_data<const S: u32>() -> BoundedVec<u8, ConstU32<S>> {36pub fn create_data<const S: u32>() -> BoundedVec<u8, ConstU32<S>> {
33	create_var_data::<S>(S)37	create_var_data::<S>(S)
52		.try_into()56		.try_into()
53		.unwrap()57		.unwrap()
54}58}
59pub fn property_key(id: usize) -> PropertyKey {
60	#[cfg(not(feature = "std"))]
61	use alloc::string::ToString;
62	let mut data = create_data();
63	// No DerefMut available for .fill
64	for i in 0..data.len() {
65		data[i] = b'0';
66	}
67	let bytes = id.to_string();
68	let len = data.len();
69	data[len - bytes.len()..].copy_from_slice(&bytes.as_bytes());
70	data
71}
72pub fn property_value() -> PropertyValue {
73	create_data()
74}
5575
56pub fn create_collection_raw<T: Config, R>(76pub fn create_collection_raw<T: Config, R>(
57	owner: T::AccountId,77	owner: T::AccountId,
83	.and_then(CollectionHandle::try_get)103	.and_then(CollectionHandle::try_get)
84	.map(cast)104	.map(cast)
85}105}
106fn create_collection<T: Config>(owner: T::AccountId) -> Result<CollectionHandle<T>, DispatchError> {
107	create_collection_raw(
108		owner,
109		CollectionMode::NFT,
110		|owner, data| <Pallet<T>>::init_collection(owner, data),
111		|h| h,
112	)
113}
86114
87/// Helper macros, which handles all benchmarking preparation in semi-declarative way115/// Helper macros, which handles all benchmarking preparation in semi-declarative way
88///116///
126	() => {}154	() => {}
127}155}
156
157benchmarks! {
158	set_collection_properties {
159		let b in 0..MAX_PROPERTIES_PER_ITEM;
160		bench_init!{
161			owner: sub; collection: collection(owner);
162			owner: cross_from_sub;
163		};
164		let props = (0..b).map(|p| Property {
165			key: property_key(p as usize),
166			value: property_value(),
167		}).collect::<Vec<_>>();
168	}: {<Pallet<T>>::set_collection_properties(&collection, &owner, props)?}
169
170	delete_collection_properties {
171		let b in 0..MAX_PROPERTIES_PER_ITEM;
172		bench_init!{
173			owner: sub; collection: collection(owner);
174			owner: cross_from_sub;
175		};
176		let props = (0..b).map(|p| Property {
177			key: property_key(p as usize),
178			value: property_value(),
179		}).collect::<Vec<_>>();
180		<Pallet<T>>::set_collection_properties(&collection, &owner, props)?;
181		let to_delete = (0..b).map(|p| property_key(p as usize)).collect::<Vec<_>>();
182	}: {<Pallet<T>>::delete_collection_properties(&collection, &owner, to_delete)?}
183}
128184

1616
17#![cfg_attr(not(feature = "std"), no_std)]17#![cfg_attr(not(feature = "std"), no_std)]
18
19extern crate alloc;
1820
19use core::ops::{Deref, DerefMut};21use core::ops::{Deref, DerefMut};
20use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};22use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};
85pub mod dispatch;87pub mod dispatch;
86pub mod erc;88pub mod erc;
87pub mod eth;89pub mod eth;
90pub mod weights;
91
92pub type SelfWeightOf<T> = <T as Config>::WeightInfo;
8893
89#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]94#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]
90pub struct CollectionHandle<T: Config> {95pub struct CollectionHandle<T: Config> {
186	use frame_support::traits::Currency;191	use frame_support::traits::Currency;
187	use up_data_structs::{TokenId, mapping::TokenAddressMapping};192	use up_data_structs::{TokenId, mapping::TokenAddressMapping};
188	use scale_info::TypeInfo;193	use scale_info::TypeInfo;
194	use weights::WeightInfo;
189195
190	#[pallet::config]196	#[pallet::config]
191	pub trait Config:197	pub trait Config:
192		frame_system::Config + pallet_evm_coder_substrate::Config + TypeInfo + account::Config198		frame_system::Config + pallet_evm_coder_substrate::Config + TypeInfo + account::Config
193	{199	{
200		type WeightInfo: WeightInfo;
194		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;201		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;
195202
196		type Currency: Currency<Self::AccountId>;203		type Currency: Currency<Self::AccountId>;
1131/// Worst cases1139/// Worst cases
1132pub trait CommonWeightInfo<CrossAccountId> {1140pub trait CommonWeightInfo<CrossAccountId> {
1133	fn create_item() -> Weight;1141	fn create_item() -> Weight;
1134	fn create_multiple_items(amount: u32) -> Weight;1142	fn create_multiple_items(amount: &[CreateItemData]) -> Weight;
1135	fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;1143	fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;
1136	fn burn_item() -> Weight;1144	fn burn_item() -> Weight;
1137	fn set_collection_properties(amount: u32) -> Weight;1145	fn set_collection_properties(amount: u32) -> Weight;

40			owner: sub; collection: collection(owner);40			owner: sub; collection: collection(owner);
41			sender: cross_from_sub(owner); to: cross_sub;41			sender: cross_from_sub(owner); to: cross_sub;
42		};42		};
43	}: {<Pallet<T>>::create_item(&collection, &sender, (to, 200))?}43	}: {<Pallet<T>>::create_item(&collection, &sender, (to, 200), &Unlimited)?}
4444
45	create_multiple_items_ex {45	create_multiple_items_ex {
46		let b in 0..MAX_ITEMS_PER_BATCH;46		let b in 0..MAX_ITEMS_PER_BATCH;
52			bench_init!(to: cross_sub(i););52			bench_init!(to: cross_sub(i););
53			(to, 200)53			(to, 200)
54		}).collect::<BTreeMap<_, _>>().try_into().unwrap();54		}).collect::<BTreeMap<_, _>>().try_into().unwrap();
55	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data)?}55	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?}
5656
57	burn_item {57	burn_item {
58		bench_init!{58		bench_init!{
59			owner: sub; collection: collection(owner);59			owner: sub; collection: collection(owner);
60			owner: cross_from_sub; burner: cross_sub;60			owner: cross_from_sub; burner: cross_sub;
61		};61		};
62		<Pallet<T>>::create_item(&collection, &owner, (burner.clone(), 200))?;62		<Pallet<T>>::create_item(&collection, &owner, (burner.clone(), 200), &Unlimited)?;
63	}: {<Pallet<T>>::burn(&collection, &burner, 100)?}63	}: {<Pallet<T>>::burn(&collection, &burner, 100)?}
6464
65	transfer {65	transfer {
66		bench_init!{66		bench_init!{
67			owner: sub; collection: collection(owner);67			owner: sub; collection: collection(owner);
68			owner: cross_from_sub; sender: cross_sub; to: cross_sub;68			owner: cross_from_sub; sender: cross_sub; to: cross_sub;
69		};69		};
70		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200))?;70		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
71	}: {<Pallet<T>>::transfer(&collection, &sender, &to, 200)?}71	}: {<Pallet<T>>::transfer(&collection, &sender, &to, 200, &Unlimited)?}
7272
73	approve {73	approve {
74		bench_init!{74		bench_init!{
75			owner: sub; collection: collection(owner);75			owner: sub; collection: collection(owner);
76			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;76			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
77		};77		};
78		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200))?;78		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
79	}: {<Pallet<T>>::set_allowance(&collection, &sender, &spender, 100)?}79	}: {<Pallet<T>>::set_allowance(&collection, &sender, &spender, 100)?}
8080
81	transfer_from {81	transfer_from {
82		bench_init!{82		bench_init!{
83			owner: sub; collection: collection(owner);83			owner: sub; collection: collection(owner);
84			owner: cross_from_sub; sender: cross_sub; spender: cross_sub; receiver: cross_sub;84			owner: cross_from_sub; sender: cross_sub; spender: cross_sub; receiver: cross_sub;
85		};85		};
86		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200))?;86		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
87		<Pallet<T>>::set_allowance(&collection, &sender, &spender, 200)?;87		<Pallet<T>>::set_allowance(&collection, &sender, &spender, 200)?;
88	}: {<Pallet<T>>::transfer_from(&collection, &spender, &sender, &receiver, 100, &Unlimited)?}88	}: {<Pallet<T>>::transfer_from(&collection, &spender, &sender, &receiver, 100, &Unlimited)?}
8989
92			owner: sub; collection: collection(owner);92			owner: sub; collection: collection(owner);
93			owner: cross_from_sub; sender: cross_sub; burner: cross_sub;93			owner: cross_from_sub; sender: cross_sub; burner: cross_sub;
94		};94		};
95		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200))?;95		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
96		<Pallet<T>>::set_allowance(&collection, &sender, &burner, 200)?;96		<Pallet<T>>::set_allowance(&collection, &sender, &burner, 200)?;
97	}: {<Pallet<T>>::burn_from(&collection, &burner, &sender, 100, &Unlimited)?}97	}: {<Pallet<T>>::burn_from(&collection, &burner, &sender, 100, &Unlimited)?}
98}98}

17use core::marker::PhantomData;17use core::marker::PhantomData;
1818
19use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};19use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
20use up_data_structs::{TokenId, CollectionId, CreateItemExData, budget::Budget};20use up_data_structs::{TokenId, CollectionId, CreateItemExData, budget::Budget, CreateItemData};
21use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};21use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};
22use sp_runtime::ArithmeticError;22use sp_runtime::ArithmeticError;
23use sp_std::{vec::Vec, vec};23use sp_std::{vec::Vec, vec};
33		<SelfWeightOf<T>>::create_item()33		<SelfWeightOf<T>>::create_item()
34	}34	}
3535
36	fn create_multiple_items(_amount: u32) -> Weight {36	fn create_multiple_items(_data: &[CreateItemData]) -> Weight {
37		// All items minted for the same user, so it works same as create_item
37		Self::create_item()38		Self::create_item()
38	}39	}
3940
51	}52	}
5253
53	fn set_collection_properties(amount: u32) -> Weight {54	fn set_collection_properties(amount: u32) -> Weight {
54		<SelfWeightOf<T>>::set_collection_properties(amount)55		// Error
56		0
55	}57	}
5658
57	fn delete_collection_properties(amount: u32) -> Weight {59	fn delete_collection_properties(amount: u32) -> Weight {
58		<SelfWeightOf<T>>::delete_collection_properties(amount)60		// Error
61		0
59	}62	}
6063
61	fn set_token_properties(amount: u32) -> Weight {64	fn set_token_properties(amount: u32) -> Weight {
62		<SelfWeightOf<T>>::set_token_properties(amount)65		// Error
66		0
63	}67	}
6468
65	fn delete_token_properties(amount: u32) -> Weight {69	fn delete_token_properties(amount: u32) -> Weight {
66		<SelfWeightOf<T>>::delete_token_properties(amount)70		// Error
71		0
67	}72	}
6873
69	fn set_property_permissions(amount: u32) -> Weight {74	fn set_property_permissions(amount: u32) -> Weight {
70		<SelfWeightOf<T>>::set_property_permissions(amount)75		// Error
76		0
71	}77	}
7278
73	fn transfer() -> Weight {79	fn transfer() -> Weight {

35	fn create_item() -> Weight;35	fn create_item() -> Weight;
36	fn create_multiple_items_ex(b: u32, ) -> Weight;36	fn create_multiple_items_ex(b: u32, ) -> Weight;
37	fn burn_item() -> Weight;37	fn burn_item() -> Weight;
38	fn set_collection_properties(amount: u32) -> Weight;
39	fn delete_collection_properties(amount: u32) -> Weight;
40	fn set_token_properties(amount: u32) -> Weight;
41	fn delete_token_properties(amount: u32) -> Weight;
42	fn set_property_permissions(amount: u32) -> Weight;
43	fn transfer() -> Weight;38	fn transfer() -> Weight;
44	fn approve() -> Weight;39	fn approve() -> Weight;
45	fn transfer_from() -> Weight;40	fn transfer_from() -> Weight;
75			.saturating_add(T::DbWeight::get().writes(2 as Weight))70			.saturating_add(T::DbWeight::get().writes(2 as Weight))
76	}71	}
77
78	fn set_collection_properties(_amount: u32) -> Weight {
79		// Error
80		0
81	}
82
83	fn delete_collection_properties(_amount: u32) -> Weight {
84		// Error
85		0
86	}
87
88	fn set_token_properties(_amount: u32) -> Weight {
89		// Error
90		0
91	}
92
93	fn delete_token_properties(_amount: u32) -> Weight {
94		// Error
95		0
96	}
97
98	fn set_property_permissions(_amount: u32) -> Weight {
99		// Error
100		0
101	}
10272
103	// Storage: Fungible Balance (r:2 w:2)73	// Storage: Fungible Balance (r:2 w:2)
104	fn transfer() -> Weight {74	fn transfer() -> Weight {
158			.saturating_add(RocksDbWeight::get().writes(2 as Weight))128			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
159	}129	}
160
161	fn set_collection_properties(_amount: u32) -> Weight {
162		// Error
163		0
164	}
165
166	fn delete_collection_properties(_amount: u32) -> Weight {
167		// Error
168		0
169	}
170
171	fn set_token_properties(_amount: u32) -> Weight {
172		// Error
173		0
174	}
175
176	fn delete_token_properties(_amount: u32) -> Weight {
177		// Error
178		0
179	}
180
181	fn set_property_permissions(_amount: u32) -> Weight {
182		// Error
183		0
184	}
185130
186	// Storage: Fungible Balance (r:2 w:2)131	// Storage: Fungible Balance (r:2 w:2)
187	fn transfer() -> Weight {132	fn transfer() -> Weight {

49    'frame-benchmarking',49    'frame-benchmarking',
50    'frame-support/runtime-benchmarks',50    'frame-support/runtime-benchmarks',
51    'frame-system/runtime-benchmarks',51    'frame-system/runtime-benchmarks',
52    'up-data-structs/runtime-benchmarks',
52]53]
5354

18use crate::{Pallet, Config, NonfungibleHandle};18use crate::{Pallet, Config, NonfungibleHandle};
1919
20use sp_std::prelude::*;20use sp_std::prelude::*;
21use pallet_common::benchmarking::{create_collection_raw, create_data, create_var_data};21use pallet_common::benchmarking::{create_collection_raw, create_data, property_key, property_value};
22use frame_benchmarking::{benchmarks, account};22use frame_benchmarking::{benchmarks, account};
23use up_data_structs::{CollectionMode, MAX_ITEMS_PER_BATCH, CUSTOM_DATA_LIMIT, budget::Unlimited};23use up_data_structs::{
24	CollectionMode, MAX_ITEMS_PER_BATCH, MAX_PROPERTIES_PER_ITEM, CUSTOM_DATA_LIMIT,
25	budget::Unlimited,
26};
24use pallet_common::bench_init;27use pallet_common::bench_init;
25use core::convert::TryInto;
2628
27const SEED: u32 = 1;29const SEED: u32 = 1;
2830
29fn create_max_item_data<T: Config>(owner: T::CrossAccountId) -> CreateItemData<T> {31fn create_max_item_data<T: Config>(owner: T::CrossAccountId) -> CreateItemData<T> {
30	let const_data = create_data::<CUSTOM_DATA_LIMIT>();32	let const_data = create_data::<CUSTOM_DATA_LIMIT>();
31	CreateItemData::<T> { const_data, owner }33	CreateItemData::<T> {
34		const_data,
35		owner,
36		properties: Default::default(),
37	}
32}38}
33fn create_max_item<T: Config>(39fn create_max_item<T: Config>(
34	collection: &NonfungibleHandle<T>,40	collection: &NonfungibleHandle<T>,
35	sender: &T::CrossAccountId,41	sender: &T::CrossAccountId,
36	owner: T::CrossAccountId,42	owner: T::CrossAccountId,
37) -> Result<TokenId, DispatchError> {43) -> Result<TokenId, DispatchError> {
38	<Pallet<T>>::create_item(&collection, sender, create_max_item_data::<T>(owner))?;44	<Pallet<T>>::create_item(
45		&collection,
46		sender,
47		create_max_item_data::<T>(owner),
48		&Unlimited,
49	)?;
39	Ok(TokenId(<TokensMinted<T>>::get(&collection.id)))50	Ok(TokenId(<TokensMinted<T>>::get(&collection.id)))
40}51}
65			sender: cross_from_sub(owner); to: cross_sub;76			sender: cross_from_sub(owner); to: cross_sub;
66		};77		};
67		let data = (0..b).map(|_| create_max_item_data::<T>(to.clone())).collect();78		let data = (0..b).map(|_| create_max_item_data::<T>(to.clone())).collect();
68	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data)?}79	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?}
6980
70	create_multiple_items_ex {81	create_multiple_items_ex {
71		let b in 0..MAX_ITEMS_PER_BATCH;82		let b in 0..MAX_ITEMS_PER_BATCH;
77			bench_init!(to: cross_sub(i););88			bench_init!(to: cross_sub(i););
78			create_max_item_data::<T>(to)89			create_max_item_data::<T>(to)
79		}).collect();90		}).collect();
80	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data)?}91	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?}
8192
82	burn_item {93	burn_item {
83		bench_init!{94		bench_init!{
93			owner: cross_from_sub; sender: cross_sub; receiver: cross_sub;104			owner: cross_from_sub; sender: cross_sub; receiver: cross_sub;
94		};105		};
95		let item = create_max_item(&collection, &owner, sender.clone())?;106		let item = create_max_item(&collection, &owner, sender.clone())?;
96	}: {<Pallet<T>>::transfer(&collection, &sender, &receiver, item)?}107	}: {<Pallet<T>>::transfer(&collection, &sender, &receiver, item, &Unlimited)?}
97108
98	approve {109	approve {
99		bench_init!{110		bench_init!{
121		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&burner))?;132		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&burner))?;
122	}: {<Pallet<T>>::burn_from(&collection, &burner, &sender, item, &Unlimited)?}133	}: {<Pallet<T>>::burn_from(&collection, &burner, &sender, item, &Unlimited)?}
134
135	set_property_permissions {
136		let b in 0..MAX_PROPERTIES_PER_ITEM;
137		bench_init!{
138			owner: sub; collection: collection(owner);
139			owner: cross_from_sub;
140		};
141		let perms = (0..b).map(|k| PropertyKeyPermission {
142			key: property_key(k as usize),
143			permission: PropertyPermission {
144				mutable: false,
145				collection_admin: false,
146				token_owner: false,
147			},
148		}).collect::<Vec<_>>();
149	}: {<Pallet<T>>::set_property_permissions(&collection, &owner, perms)?}
150
151	set_token_properties {
152		let b in 0..MAX_PROPERTIES_PER_ITEM;
153		bench_init!{
154			owner: sub; collection: collection(owner);
155			owner: cross_from_sub;
156		};
157		let perms = (0..b).map(|k| PropertyKeyPermission {
158			key: property_key(k as usize),
159			permission: PropertyPermission {
160				mutable: false,
161				collection_admin: true,
162				token_owner: true,
163			},
164		}).collect::<Vec<_>>();
165		<Pallet<T>>::set_property_permissions(&collection, &owner, perms)?;
166		let props = (0..b).map(|k| Property {
167			key: property_key(k as usize),
168			value: property_value(),
169		}).collect::<Vec<_>>();
170		let item = create_max_item(&collection, &owner, owner.clone())?;
171	}: {<Pallet<T>>::set_token_properties(&collection, &owner, item, props)?}
172
173	delete_token_properties {
174		let b in 0..MAX_PROPERTIES_PER_ITEM;
175		bench_init!{
176			owner: sub; collection: collection(owner);
177			owner: cross_from_sub;
178		};
179		let perms = (0..b).map(|k| PropertyKeyPermission {
180			key: property_key(k as usize),
181			permission: PropertyPermission {
182				mutable: true,
183				collection_admin: true,
184				token_owner: true,
185			},
186		}).collect::<Vec<_>>();
187		<Pallet<T>>::set_property_permissions(&collection, &owner, perms)?;
188		let props = (0..b).map(|k| Property {
189			key: property_key(k as usize),
190			value: property_value(),
191		}).collect::<Vec<_>>();
192		let item = create_max_item(&collection, &owner, owner.clone())?;
193		<Pallet<T>>::set_token_properties(&collection, &owner, item, props)?;
194		let to_delete = (0..b).map(|k| property_key(k as usize)).collect::<Vec<_>>();
195	}: {<Pallet<T>>::delete_token_properties(&collection, &owner, item, to_delete)?}
123}196}
124197

22	PropertyKeyPermission, PropertyValue,22	PropertyKeyPermission, PropertyValue,
23};23};
24use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};24use pallet_common::{
25	CommonCollectionOperations, CommonWeightInfo, with_weight, weights::WeightInfo as _,
26};
25use sp_runtime::DispatchError;27use sp_runtime::DispatchError;
26use sp_std::vec::Vec;28use sp_std::vec::Vec;
3840
39	fn create_multiple_items_ex(data: &CreateItemExData<T::CrossAccountId>) -> Weight {41	fn create_multiple_items_ex(data: &CreateItemExData<T::CrossAccountId>) -> Weight {
40		match data {42		match data {
41			CreateItemExData::NFT(t) => <SelfWeightOf<T>>::create_multiple_items_ex(t.len() as u32),43			CreateItemExData::NFT(t) => {
44				<SelfWeightOf<T>>::create_multiple_items_ex(t.len() as u32)
45					+ t.iter()
46						.map(|t| {
47							if t.properties.len() > 0 {
48								Self::set_token_properties(t.properties.len() as u32)
49							} else {
50								0
51							}
52						})
53						.sum::<u64>()
54			}
42			_ => 0,55			_ => 0,
43		}56		}
44	}57	}
4558
46	fn create_multiple_items(amount: u32) -> Weight {59	fn create_multiple_items(data: &[up_data_structs::CreateItemData]) -> Weight {
47		<SelfWeightOf<T>>::create_multiple_items(amount)60		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32)
61			+ data
62				.iter()
63				.filter_map(|t| match t {
64					up_data_structs::CreateItemData::NFT(n) if n.properties.len() > 0 => {
65						Some(Self::set_token_properties(n.properties.len() as u32))
66					}
67					_ => None,
68				})
69				.sum::<u64>()
48	}70	}
4971
50	fn burn_item() -> Weight {72	fn burn_item() -> Weight {
51		<SelfWeightOf<T>>::burn_item()73		<SelfWeightOf<T>>::burn_item()
52	}74	}
5375
54	fn set_collection_properties(amount: u32) -> Weight {76	fn set_collection_properties(amount: u32) -> Weight {
55		<SelfWeightOf<T>>::set_collection_properties(amount)77		<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)
56	}78	}
5779
58	fn delete_collection_properties(amount: u32) -> Weight {80	fn delete_collection_properties(amount: u32) -> Weight {
59		<SelfWeightOf<T>>::delete_collection_properties(amount)81		<pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)
60	}82	}
6183
62	fn set_token_properties(amount: u32) -> Weight {84	fn set_token_properties(amount: u32) -> Weight {
128		data: Vec<up_data_structs::CreateItemData>,150		data: Vec<up_data_structs::CreateItemData>,
129		nesting_budget: &dyn Budget,151		nesting_budget: &dyn Budget,
130	) -> DispatchResultWithPostInfo {152	) -> DispatchResultWithPostInfo {
153		let weight = <CommonWeights<T>>::create_multiple_items(&data);
131		let data = data154		let data = data
132			.into_iter()155			.into_iter()
133			.map(|d| map_create_data::<T>(d, &to))156			.map(|d| map_create_data::<T>(d, &to))
134			.collect::<Result<Vec<_>, DispatchError>>()?;157			.collect::<Result<Vec<_>, DispatchError>>()?;
135158
136		let amount = data.len();
137		with_weight(159		with_weight(
138			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),160			<Pallet<T>>::create_multiple_items(self, &sender, data, nesting_budget),
139			<CommonWeights<T>>::create_multiple_items(amount as u32),161			weight,
140		)162		)
141	}163	}
142164

1818
19use erc::ERC721Events;19use erc::ERC721Events;
20use evm_coder::ToLog;20use evm_coder::ToLog;
21use frame_support::{BoundedVec, ensure, fail, transactional};21use frame_support::{BoundedVec, ensure, fail, transactional, storage::with_transaction};
22use up_data_structs::{22use up_data_structs::{
23	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,23	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,
24	mapping::TokenAddressMapping, NestingRule, budget::Budget, Property, PropertyPermission,24	mapping::TokenAddressMapping, NestingRule, budget::Budget, Property, PropertyPermission,
32use pallet_structure::Pallet as PalletStructure;32use pallet_structure::Pallet as PalletStructure;
33use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};33use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};
34use sp_core::H160;34use sp_core::H160;
35use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};35use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};
36use sp_std::{vec::Vec, vec};36use sp_std::{vec::Vec, vec};
37use core::ops::Deref;37use core::ops::Deref;
38use sp_std::collections::btree_map::BTreeMap;38use sp_std::collections::btree_map::BTreeMap;
600600
601		// =========601		// =========
602
603		with_transaction(|| {
604			for (i, data) in data.iter().enumerate() {
605				let token = first_token + i as u32 + 1;
606
607				<TokenData<T>>::insert(
608					(collection.id, token),
609					ItemData {
610						const_data: data.const_data.clone(),
611						owner: data.owner.clone(),
612					},
613				);
614
615				if let Err(e) = Self::set_token_properties(
616					collection,
617					sender,
618					TokenId(token),
619					data.properties.clone().into_inner(),
620				) {
621					return TransactionOutcome::Rollback(Err(e));
622				}
623			}
624			TransactionOutcome::Commit(Ok(()))
625		})?;
602626
603		<TokensMinted<T>>::insert(collection.id, tokens_minted);627		<TokensMinted<T>>::insert(collection.id, tokens_minted);
604		for (account, balance) in balances {628		for (account, balance) in balances {
607		for (i, data) in data.into_iter().enumerate() {631		for (i, data) in data.into_iter().enumerate() {
608			let token = first_token + i as u32 + 1;632			let token = first_token + i as u32 + 1;
609
610			<TokenData<T>>::insert(
611				(collection.id, token),
612				ItemData {
613					const_data: data.const_data,
614					owner: data.owner.clone(),
615				},
616			);
617			<Owned<T>>::insert((collection.id, &data.owner, token), true);633			<Owned<T>>::insert((collection.id, &data.owner, token), true);
618
619			Self::set_token_properties(
620				collection,
621				sender,
622				TokenId(token),
623				data.properties.into_inner(),
624			)?;
625634
626			<PalletEvm<T>>::deposit_log(635			<PalletEvm<T>>::deposit_log(
627				ERC721Events::Transfer {636				ERC721Events::Transfer {