git.delta.rocks / unique-network / refs/commits / 2eecdab55d8c

62626262
6263[[package]]6263[[package]]
6264name = "pallet-common"6264name = "pallet-common"
6265version = "0.1.13"6265version = "0.1.14"
6266dependencies = [6266dependencies = [
6267 "ethereum",6267 "ethereum",
6268 "evm-coder",6268 "evm-coder",
65586558
6559[[package]]6559[[package]]
6560name = "pallet-fungible"6560name = "pallet-fungible"
6561version = "0.1.10"6561version = "0.1.11"
6562dependencies = [6562dependencies = [
6563 "evm-coder",6563 "evm-coder",
6564 "frame-benchmarking",6564 "frame-benchmarking",
68146814
6815[[package]]6815[[package]]
6816name = "pallet-nonfungible"6816name = "pallet-nonfungible"
6817version = "0.1.13"6817version = "0.1.14"
6818dependencies = [6818dependencies = [
6819 "evm-coder",6819 "evm-coder",
6820 "frame-benchmarking",6820 "frame-benchmarking",

845	/// - `staker`: staker account.845	/// - `staker`: staker account.
846	pub fn total_staked_by_id(staker: impl EncodeLike<T::AccountId>) -> Option<BalanceOf<T>> {846	pub fn total_staked_by_id(staker: impl EncodeLike<T::AccountId>) -> Option<BalanceOf<T>> {
847		let staked = Staked::<T>::iter_prefix((staker,))847		let staked = Staked::<T>::iter_prefix((staker,))
848			.into_iter()
849			.fold(<BalanceOf<T>>::default(), |acc, (_, (amount, _))| {848			.fold(<BalanceOf<T>>::default(), |acc, (_, (amount, _))| {
850				acc + amount849				acc + amount
851			});850			});
864		staker: impl EncodeLike<T::AccountId>,863		staker: impl EncodeLike<T::AccountId>,
865	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {864	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {
866		let mut staked = Staked::<T>::iter_prefix((staker,))865		let mut staked = Staked::<T>::iter_prefix((staker,))
867			.into_iter()
868			.map(|(block, (amount, _))| (block, amount))866			.map(|(block, (amount, _))| (block, amount))
869			.collect::<Vec<_>>();867			.collect::<Vec<_>>();
870		staked.sort_by_key(|(block, _)| *block);868		staked.sort_by_key(|(block, _)| *block);
884		})882		})
885	}883	}
886
887	// pub fn cross_id_locked_balance(staker: T::CrossAccountId) -> BalanceOf<T> {
888	// 	Self::get_locked_balance(staker.as_sub())
889	// 		.map(|l| l.amount)
890	// 		.unwrap_or_default()
891	// }
892884
893	/// Returns all relay block numbers when stake was made,885	/// Returns all relay block numbers when stake was made,
894	/// the amount of the stake.886	/// the amount of the stake.

44
5<!-- bureaucrate goes here -->5<!-- bureaucrate goes here -->
66
7## [0.1.14] - 2023-03-28
8
9### Added
10
11- Added benchmark to check if user is contained in AllowList (`check_accesslist()`).
12
7## [0.1.13] - 2023-01-2013## [0.1.13] - 2023-01-20
814
9### Changed15### Changed

2edition = "2021"2edition = "2021"
3license = "GPLv3"3license = "GPLv3"
4name = "pallet-common"4name = "pallet-common"
5version = "0.1.13"5version = "0.1.14"
66
7[dependencies]7[dependencies]
8# Note: `package = "parity-scale-codec"` must be supplied since the `Encode` macro searches for it.8# Note: `package = "parity-scale-codec"` must be supplied since the `Encode` macro searches for it.

22use frame_benchmarking::{benchmarks, account};22use frame_benchmarking::{benchmarks, account};
23use up_data_structs::{23use up_data_structs::{
24	CollectionMode, CollectionFlags, CreateCollectionData, CollectionId, Property, PropertyKey,24	CollectionMode, CollectionFlags, CreateCollectionData, CollectionId, Property, PropertyKey,
25	PropertyValue, CollectionPermissions, NestingPermissions, MAX_COLLECTION_NAME_LENGTH,25	PropertyValue, CollectionPermissions, NestingPermissions, AccessMode,
26	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH, MAX_PROPERTIES_PER_ITEM,26	MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH,
27	MAX_PROPERTIES_PER_ITEM,
27};28};
194		let to_delete = (0..b).map(|p| property_key(p as usize)).collect::<Vec<_>>();195		let to_delete = (0..b).map(|p| property_key(p as usize)).collect::<Vec<_>>();
195	}: {<Pallet<T>>::delete_collection_properties(&collection, &owner, to_delete.into_iter())?}196	}: {<Pallet<T>>::delete_collection_properties(&collection, &owner, to_delete.into_iter())?}
197
198	check_accesslist{
199		bench_init!{
200			owner: sub; collection: collection(owner);
201			sender: cross_from_sub(owner);
202		};
203
204		let mut collection_handle = <CollectionHandle<T>>::try_get(collection.id)?;
205			<Pallet<T>>::update_permissions(
206				&sender,
207				&mut collection_handle,
208				CollectionPermissions { access: Some(AccessMode::AllowList), ..Default::default() }
209			)?;
210
211		<Pallet<T>>::toggle_allowlist(
212				&collection,
213				&sender,
214				&sender,
215				true,
216			)?;
217
218		assert_eq!(collection_handle.permissions.access(), AccessMode::AllowList);
219
220	}: {collection_handle.check_allowlist(&sender)?;}
196}221}
197222

92pub mod dispatch;92pub mod dispatch;
93pub mod erc;93pub mod erc;
94pub mod eth;94pub mod eth;
95pub mod helpers;
95#[allow(missing_docs)]96#[allow(missing_docs)]
96pub mod weights;97pub mod weights;
97

36pub trait WeightInfo {36pub trait WeightInfo {
37	fn set_collection_properties(b: u32, ) -> Weight;37	fn set_collection_properties(b: u32, ) -> Weight;
38	fn delete_collection_properties(b: u32, ) -> Weight;38	fn delete_collection_properties(b: u32, ) -> Weight;
39	fn check_accesslist() -> Weight;
39}40}
4041
41/// Weights for pallet_common using the Substrate node and recommended hardware.42/// Weights for pallet_common using the Substrate node and recommended hardware.
69			.saturating_add(T::DbWeight::get().reads(1_u64))70			.saturating_add(T::DbWeight::get().reads(1_u64))
70			.saturating_add(T::DbWeight::get().writes(1_u64))71			.saturating_add(T::DbWeight::get().writes(1_u64))
71	}72	}
73	/// Storage: Common Allowlist (r:1 w:0)
74	/// Proof: Common Allowlist (max_values: None, max_size: Some(70), added: 2545, mode: MaxEncodedLen)
75	fn check_accesslist() -> Weight {
76		// Proof Size summary in bytes:
77		//  Measured:  `340`
78		//  Estimated: `2545`
79		// Minimum execution time: 2_887_000 picoseconds.
80		Weight::from_parts(3_072_000, 2545)
81			.saturating_add(T::DbWeight::get().reads(1_u64))
82	}
72}83}
7384
74// For backwards compatibility and tests85// For backwards compatibility and tests
101			.saturating_add(RocksDbWeight::get().reads(1_u64))112			.saturating_add(RocksDbWeight::get().reads(1_u64))
102			.saturating_add(RocksDbWeight::get().writes(1_u64))113			.saturating_add(RocksDbWeight::get().writes(1_u64))
103	}114	}
115	/// Storage: Common Allowlist (r:1 w:0)
116	/// Proof: Common Allowlist (max_values: None, max_size: Some(70), added: 2545, mode: MaxEncodedLen)
117	fn check_accesslist() -> Weight {
118		// Proof Size summary in bytes:
119		//  Measured:  `340`
120		//  Estimated: `2545`
121		// Minimum execution time: 2_887_000 picoseconds.
122		Weight::from_parts(3_072_000, 2545)
123			.saturating_add(RocksDbWeight::get().reads(1_u64))
124	}
104}125}
105126
106127

453					amount.into(),453					amount.into(),
454					&Value::new(0),454					&Value::new(0),
455				)?;455				)
456				.map_err(|e| e.error)?;
456457
457				Ok(amount)458				Ok(amount)
458			}459			}

44
5<!-- bureaucrate goes here -->5<!-- bureaucrate goes here -->
66
7## [0.1.11] - 2023-03-28
8
9### Fixed
10
11- The weight of `transfer` and `transfer_from`.
12
7## [0.1.10] - 2023-02-0113## [0.1.10] - 2023-02-01
814
9### Added15### Added

2edition = "2021"2edition = "2021"
3license = "GPLv3"3license = "GPLv3"
4name = "pallet-fungible"4name = "pallet-fungible"
5version = "0.1.10"5version = "0.1.11"
66
7[dependencies]7[dependencies]
8# Note: `package = "parity-scale-codec"` must be supplied since the `Encode` macro searches for it.8# Note: `package = "parity-scale-codec"` must be supplied since the `Encode` macro searches for it.

66		<Pallet<T>>::create_item(&collection, &owner, (burner.clone(), 200), &Unlimited)?;66		<Pallet<T>>::create_item(&collection, &owner, (burner.clone(), 200), &Unlimited)?;
67	}: {<Pallet<T>>::burn(&collection, &burner, 100)?}67	}: {<Pallet<T>>::burn(&collection, &burner, 100)?}
6868
69	transfer {69	transfer_raw {
70		bench_init!{70		bench_init!{
71			owner: sub; collection: collection(owner);71			owner: sub; collection: collection(owner);
72			owner: cross_from_sub; sender: cross_sub; to: cross_sub;72			owner: cross_from_sub; sender: cross_sub; to: cross_sub;
92		<Pallet<T>>::create_item(&collection, &owner, (owner_eth.clone(), 200), &Unlimited)?;92		<Pallet<T>>::create_item(&collection, &owner, (owner_eth.clone(), 200), &Unlimited)?;
93	}: {<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, &spender, 100)?}93	}: {<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, &spender, 100)?}
9494
95	transfer_from {95	check_allowed_raw {
96		bench_init!{96		bench_init!{
97			owner: sub; collection: collection(owner);97			owner: sub; collection: collection(owner);
98			owner: cross_from_sub; sender: cross_sub; spender: cross_sub; receiver: cross_sub;98			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
99		};99		};
100		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;100		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
101		<Pallet<T>>::set_allowance(&collection, &sender, &spender, 200)?;101		<Pallet<T>>::set_allowance(&collection, &sender, &spender, 200)?;
102	}: {<Pallet<T>>::transfer_from(&collection, &spender, &sender, &receiver, 100, &Unlimited)?}102	}: {<Pallet<T>>::check_allowed(&collection, &spender, &sender, 200, &Unlimited)?;}
103
104	set_allowance_unchecked_raw {
105		bench_init!{
106			owner: sub; collection: collection(owner);
107			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
108		};
109		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
110	}: {<Pallet<T>>::set_allowance_unchecked(&collection, &sender, &spender, 200);}
103111
104	burn_from {112	burn_from {
105		bench_init!{113		bench_init!{

22};22};
23use pallet_common::{23use pallet_common::{
24	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight,24	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight,
25	weights::WeightInfo as _,25	weights::WeightInfo as _, SelfWeightOf as PalletCommonWeightOf,
26};26};
27use pallet_structure::Error as StructureError;27use pallet_structure::Error as StructureError;
28use sp_runtime::ArithmeticError;28use sp_runtime::ArithmeticError;
78	}78	}
7979
80	fn transfer() -> Weight {80	fn transfer() -> Weight {
81		<SelfWeightOf<T>>::transfer()81		<SelfWeightOf<T>>::transfer_raw() + <PalletCommonWeightOf<T>>::check_accesslist() * 2
82	}82	}
8383
84	fn approve() -> Weight {84	fn approve() -> Weight {
90	}90	}
9191
92	fn transfer_from() -> Weight {92	fn transfer_from() -> Weight {
93		Self::transfer()
94			+ <SelfWeightOf<T>>::check_allowed_raw()
93		<SelfWeightOf<T>>::transfer_from()95			+ <SelfWeightOf<T>>::set_allowance_unchecked_raw()
94	}96	}
9597
96	fn burn_from() -> Weight {98	fn burn_from() -> Weight {
232			<Error<T>>::FungibleItemsHaveNoId234			<Error<T>>::FungibleItemsHaveNoId
233		);235		);
234236
235		with_weight(
236			<Pallet<T>>::transfer(self, &from, &to, amount, nesting_budget),237		<Pallet<T>>::transfer(self, &from, &to, amount, nesting_budget)
237			<CommonWeights<T>>::transfer(),
238		)
239	}238	}
240239
241	fn approve(240	fn approve(
289			<Error<T>>::FungibleItemsHaveNoId288			<Error<T>>::FungibleItemsHaveNoId
290		);289		);
291290
292		with_weight(
293			<Pallet<T>>::transfer_from(self, &sender, &from, &to, amount, nesting_budget),291		<Pallet<T>>::transfer_from(self, &sender, &from, &to, amount, nesting_budget)
294			<CommonWeights<T>>::transfer_from(),
295		)
296	}292	}
297293
298	fn burn_from(294	fn burn_from(

26	CollectionHandle,26	CollectionHandle,
27	erc::{CommonEvmHandler, PrecompileResult, CollectionCall},27	erc::{CommonEvmHandler, PrecompileResult, CollectionCall},
28	eth::CrossAddress,28	eth::CrossAddress,
29	CommonWeightInfo as _,
29};30};
30use sp_std::vec::Vec;31use sp_std::vec::Vec;
31use pallet_evm::{account::CrossAccountId, PrecompileHandle};32use pallet_evm::{account::CrossAccountId, PrecompileHandle};
3940
40use crate::{41use crate::{
41	Allowance, Balance, Config, FungibleHandle, Pallet, TotalSupply, SelfWeightOf,42	Allowance, Balance, Config, FungibleHandle, Pallet, TotalSupply, SelfWeightOf,
42	weights::WeightInfo,43	weights::WeightInfo, common::CommonWeights,
43};44};
4445
45frontier_contract! {46frontier_contract! {
99		let balance = <Balance<T>>::get((self.id, owner));100		let balance = <Balance<T>>::get((self.id, owner));
100		Ok(balance.into())101		Ok(balance.into())
101	}102	}
102	#[weight(<SelfWeightOf<T>>::transfer())]103	#[weight(<CommonWeights<T>>::transfer())]
103	fn transfer(&mut self, caller: Caller, to: Address, amount: U256) -> Result<bool> {104	fn transfer(&mut self, caller: Caller, to: Address, amount: U256) -> Result<bool> {
104		let caller = T::CrossAccountId::from_eth(caller);105		let caller = T::CrossAccountId::from_eth(caller);
105		let to = T::CrossAccountId::from_eth(to);106		let to = T::CrossAccountId::from_eth(to);
112		Ok(true)113		Ok(true)
113	}114	}
114115
115	#[weight(<SelfWeightOf<T>>::transfer_from())]116	#[weight(<CommonWeights<T>>::transfer_from())]
116	fn transfer_from(117	fn transfer_from(
117		&mut self,118		&mut self,
118		caller: Caller,119		caller: Caller,
129			.weight_calls_budget(<StructureWeight<T>>::find_parent());130			.weight_calls_budget(<StructureWeight<T>>::find_parent());
130131
131		<Pallet<T>>::transfer_from(self, &caller, &from, &to, amount, &budget)132		<Pallet<T>>::transfer_from(self, &caller, &from, &to, amount, &budget)
132			.map_err(dispatch_to_evm::<T>)?;133			.map_err(|e| dispatch_to_evm::<T>(e.error))?;
133		Ok(true)134		Ok(true)
134	}135	}
135	#[weight(<SelfWeightOf<T>>::approve())]136	#[weight(<SelfWeightOf<T>>::approve())]
201		let budget = self202		let budget = self
202			.recorder203			.recorder
203			.weight_calls_budget(<StructureWeight<T>>::find_parent());204			.weight_calls_budget(<StructureWeight<T>>::find_parent());
204		<Pallet<T>>::create_item(&self, &caller, (to, amount), &budget)205		<Pallet<T>>::create_item(self, &caller, (to, amount), &budget)
205			.map_err(dispatch_to_evm::<T>)?;206			.map_err(dispatch_to_evm::<T>)?;
206		Ok(true)207		Ok(true)
207	}208	}
289		Ok(true)290		Ok(true)
290	}291	}
291292
292	#[weight(<SelfWeightOf<T>>::transfer())]293	#[weight(<CommonWeights<T>>::transfer())]
293	fn transfer_cross(&mut self, caller: Caller, to: CrossAddress, amount: U256) -> Result<bool> {294	fn transfer_cross(&mut self, caller: Caller, to: CrossAddress, amount: U256) -> Result<bool> {
294		let caller = T::CrossAccountId::from_eth(caller);295		let caller = T::CrossAccountId::from_eth(caller);
295		let to = to.into_sub_cross_account::<T>()?;296		let to = to.into_sub_cross_account::<T>()?;
302		Ok(true)303		Ok(true)
303	}304	}
304305
305	#[weight(<SelfWeightOf<T>>::transfer_from())]306	#[weight(<CommonWeights<T>>::transfer_from())]
306	fn transfer_from_cross(307	fn transfer_from_cross(
307		&mut self,308		&mut self,
308		caller: Caller,309		caller: Caller,
319			.weight_calls_budget(<StructureWeight<T>>::find_parent());320			.weight_calls_budget(<StructureWeight<T>>::find_parent());
320321
321		<Pallet<T>>::transfer_from(self, &caller, &from, &to, amount, &budget)322		<Pallet<T>>::transfer_from(self, &caller, &from, &to, amount, &budget)
322			.map_err(dispatch_to_evm::<T>)?;323			.map_err(|e| dispatch_to_evm::<T>(e.error))?;
323		Ok(true)324		Ok(true)
324	}325	}
325326

8080
81use core::ops::Deref;81use core::ops::Deref;
82use evm_coder::ToLog;82use evm_coder::ToLog;
83use frame_support::ensure;83use frame_support::{
84	ensure,
85	pallet_prelude::{DispatchResultWithPostInfo, Pays},
86	dispatch::PostDispatchInfo,
87};
84use pallet_evm::account::CrossAccountId;88use pallet_evm::account::CrossAccountId;
85use up_data_structs::{89use up_data_structs::{
86	AccessMode, CollectionId, CollectionFlags, TokenId, CreateCollectionData,90	AccessMode, CollectionId, CollectionFlags, TokenId, CreateCollectionData,
87	mapping::TokenAddressMapping, budget::Budget, PropertyKey, Property,91	mapping::TokenAddressMapping, budget::Budget, PropertyKey, Property,
88};92};
89use pallet_common::{93use pallet_common::{
90	Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,94	Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,
91	eth::collection_id_to_address,95	eth::collection_id_to_address, SelfWeightOf as PalletCommonWeightOf,
96	weights::WeightInfo as CommonWeightInfo, helpers::add_weight_to_post_info,
92};97};
93use pallet_evm::Pallet as PalletEvm;98use pallet_evm::Pallet as PalletEvm;
94use pallet_structure::Pallet as PalletStructure;99use pallet_structure::Pallet as PalletStructure;
95use pallet_evm_coder_substrate::WithRecorder;100use pallet_evm_coder_substrate::WithRecorder;
96use sp_core::H160;101use sp_core::H160;
97use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};102use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};
98use sp_std::{collections::btree_map::BTreeMap, vec::Vec};103use sp_std::{collections::btree_map::BTreeMap, vec::Vec};
99104use weights::WeightInfo;
100pub use pallet::*;105pub use pallet::*;
101106
102use crate::erc::ERC20Events;107use crate::erc::ERC20Events;
389		to: &T::CrossAccountId,394		to: &T::CrossAccountId,
390		amount: u128,395		amount: u128,
391		nesting_budget: &dyn Budget,396		nesting_budget: &dyn Budget,
392	) -> DispatchResult {397	) -> DispatchResultWithPostInfo {
393		ensure!(398		ensure!(
394			collection.limits.transfers_enabled(),399			collection.limits.transfers_enabled(),
395			<CommonError<T>>::TransferNotAllowed,400			<CommonError<T>>::TransferNotAllowed,
396		);401		);
402
403		let mut actual_weight = <SelfWeightOf<T>>::transfer_raw();
397404
398		if collection.permissions.access() == AccessMode::AllowList {405		if collection.permissions.access() == AccessMode::AllowList {
399			collection.check_allowlist(from)?;406			collection.check_allowlist(from)?;
400			collection.check_allowlist(to)?;407			collection.check_allowlist(to)?;
408			actual_weight += <PalletCommonWeightOf<T>>::check_accesslist() * 2;
401		}409		}
402		<PalletCommon<T>>::ensure_correct_receiver(to)?;410		<PalletCommon<T>>::ensure_correct_receiver(to)?;
403
452			amount,459			amount,
453		));460		));
461
454		Ok(())462		Ok(PostDispatchInfo {
463			actual_weight: Some(actual_weight),
464			pays_fee: Pays::Yes,
465		})
455	}466	}
456467
457	/// Minting tokens for multiple IDs.468	/// Minting tokens for multiple IDs.
464		nesting_budget: &dyn Budget,475		nesting_budget: &dyn Budget,
465	) -> DispatchResult {476	) -> DispatchResult {
466		let total_supply = data477		let total_supply = data
467			.iter()478			.values()
468			.map(|(_, v)| *v)479			.copied()
469			.try_fold(<TotalSupply<T>>::get(collection.id), |acc, v| {480			.try_fold(<TotalSupply<T>>::get(collection.id), |acc, v| {
470				acc.checked_add(v)481				acc.checked_add(v)
471			})482			})
726		to: &T::CrossAccountId,736		to: &T::CrossAccountId,
727		amount: u128,737		amount: u128,
728		nesting_budget: &dyn Budget,738		nesting_budget: &dyn Budget,
729	) -> DispatchResult {739	) -> DispatchResultWithPostInfo {
730		let allowance = Self::check_allowed(collection, spender, from, amount, nesting_budget)?;740		let allowance = Self::check_allowed(collection, spender, from, amount, nesting_budget)?;
731741
732		// =========742		// =========
733743
734		Self::transfer(collection, from, to, amount, nesting_budget)?;744		let mut result = Self::transfer(collection, from, to, amount, nesting_budget);
745		add_weight_to_post_info(&mut result, <SelfWeightOf<T>>::check_allowed_raw());
746		result?;
747
735		if let Some(allowance) = allowance {748		if let Some(allowance) = allowance {
736			Self::set_allowance_unchecked(collection, from, spender, allowance);749			Self::set_allowance_unchecked(collection, from, spender, allowance);
750			add_weight_to_post_info(
751				&mut result,
752				<SelfWeightOf<T>>::set_allowance_unchecked_raw(),
753			)
737		}754		}
738		Ok(())755		result
739	}756	}
740757
741	/// Burn fungible tokens from the account.758	/// Burn fungible tokens from the account.

37	fn create_item() -> Weight;37	fn create_item() -> Weight;
38	fn create_multiple_items_ex(b: u32, ) -> Weight;38	fn create_multiple_items_ex(b: u32, ) -> Weight;
39	fn burn_item() -> Weight;39	fn burn_item() -> Weight;
40	fn transfer() -> Weight;40	fn transfer_raw() -> Weight;
41	fn approve() -> Weight;41	fn approve() -> Weight;
42	fn approve_from() -> Weight;42	fn approve_from() -> Weight;
43	fn transfer_from() -> Weight;43	fn check_allowed_raw() -> Weight;
44	fn set_allowance_unchecked_raw() -> Weight;
44	fn burn_from() -> Weight;45	fn burn_from() -> Weight;
45}46}
4647
94	}95	}
95	/// Storage: Fungible Balance (r:2 w:2)96	/// Storage: Fungible Balance (r:2 w:2)
96	/// Proof: Fungible Balance (max_values: None, max_size: Some(77), added: 2552, mode: MaxEncodedLen)97	/// Proof: Fungible Balance (max_values: None, max_size: Some(77), added: 2552, mode: MaxEncodedLen)
97	fn transfer() -> Weight {98	fn transfer_raw() -> Weight {
98		// Proof Size summary in bytes:99		// Proof Size summary in bytes:
99		//  Measured:  `182`100		//  Measured:  `182`
100		//  Estimated: `5104`101		//  Estimated: `5104`
101		// Minimum execution time: 13_832_000 picoseconds.102		// Minimum execution time: 6_678_000 picoseconds.
102		Weight::from_parts(14_064_000, 5104)103		Weight::from_parts(7_151_000, 5104)
103			.saturating_add(T::DbWeight::get().reads(2_u64))104			.saturating_add(T::DbWeight::get().reads(2_u64))
104			.saturating_add(T::DbWeight::get().writes(2_u64))105			.saturating_add(T::DbWeight::get().writes(2_u64))
105	}106	}
129			.saturating_add(T::DbWeight::get().reads(1_u64))130			.saturating_add(T::DbWeight::get().reads(1_u64))
130			.saturating_add(T::DbWeight::get().writes(1_u64))131			.saturating_add(T::DbWeight::get().writes(1_u64))
131	}132	}
133	/// Storage: Fungible Allowance (r:1 w:0)
134	/// Proof: Fungible Allowance (max_values: None, max_size: Some(93), added: 2568, mode: MaxEncodedLen)
135	fn check_allowed_raw() -> Weight {
136		// Proof Size summary in bytes:
137		//  Measured:  `210`
138		//  Estimated: `2568`
139		// Minimum execution time: 2_842_000 picoseconds.
140		Weight::from_parts(3_077_000, 2568)
141			.saturating_add(T::DbWeight::get().reads(1_u64))
142	}
132	/// Storage: Fungible Allowance (r:1 w:1)143	/// Storage: Fungible Allowance (r:0 w:1)
133	/// Proof: Fungible Allowance (max_values: None, max_size: Some(93), added: 2568, mode: MaxEncodedLen)144	/// Proof: Fungible Allowance (max_values: None, max_size: Some(93), added: 2568, mode: MaxEncodedLen)
134	/// Storage: Fungible Balance (r:2 w:2)
135	/// Proof: Fungible Balance (max_values: None, max_size: Some(77), added: 2552, mode: MaxEncodedLen)
136	fn transfer_from() -> Weight {145	fn set_allowance_unchecked_raw() -> Weight {
137		// Proof Size summary in bytes:146		// Proof Size summary in bytes:
138		//  Measured:  `300`147		//  Measured:  `0`
139		//  Estimated: `7672`148		//  Estimated: `0`
140		// Minimum execution time: 21_667_000 picoseconds.149		// Minimum execution time: 2_532_000 picoseconds.
141		Weight::from_parts(22_166_000, 7672)150		Weight::from_parts(2_680_000, 0)
142			.saturating_add(T::DbWeight::get().reads(3_u64))
143			.saturating_add(T::DbWeight::get().writes(3_u64))151			.saturating_add(T::DbWeight::get().writes(1_u64))
144	}152	}
145	/// Storage: Fungible Allowance (r:1 w:1)153	/// Storage: Fungible Allowance (r:1 w:1)
146	/// Proof: Fungible Allowance (max_values: None, max_size: Some(93), added: 2568, mode: MaxEncodedLen)154	/// Proof: Fungible Allowance (max_values: None, max_size: Some(93), added: 2568, mode: MaxEncodedLen)
208	}216	}
209	/// Storage: Fungible Balance (r:2 w:2)217	/// Storage: Fungible Balance (r:2 w:2)
210	/// Proof: Fungible Balance (max_values: None, max_size: Some(77), added: 2552, mode: MaxEncodedLen)218	/// Proof: Fungible Balance (max_values: None, max_size: Some(77), added: 2552, mode: MaxEncodedLen)
211	fn transfer() -> Weight {219	fn transfer_raw() -> Weight {
212		// Proof Size summary in bytes:220		// Proof Size summary in bytes:
213		//  Measured:  `182`221		//  Measured:  `182`
214		//  Estimated: `5104`222		//  Estimated: `5104`
215		// Minimum execution time: 13_832_000 picoseconds.223		// Minimum execution time: 6_678_000 picoseconds.
216		Weight::from_parts(14_064_000, 5104)224		Weight::from_parts(7_151_000, 5104)
217			.saturating_add(RocksDbWeight::get().reads(2_u64))225			.saturating_add(RocksDbWeight::get().reads(2_u64))
218			.saturating_add(RocksDbWeight::get().writes(2_u64))226			.saturating_add(RocksDbWeight::get().writes(2_u64))
219	}227	}
243			.saturating_add(RocksDbWeight::get().reads(1_u64))251			.saturating_add(RocksDbWeight::get().reads(1_u64))
244			.saturating_add(RocksDbWeight::get().writes(1_u64))252			.saturating_add(RocksDbWeight::get().writes(1_u64))
245	}253	}
254	/// Storage: Fungible Allowance (r:1 w:0)
255	/// Proof: Fungible Allowance (max_values: None, max_size: Some(93), added: 2568, mode: MaxEncodedLen)
256	fn check_allowed_raw() -> Weight {
257		// Proof Size summary in bytes:
258		//  Measured:  `210`
259		//  Estimated: `2568`
260		// Minimum execution time: 2_842_000 picoseconds.
261		Weight::from_parts(3_077_000, 2568)
262			.saturating_add(RocksDbWeight::get().reads(1_u64))
263	}
246	/// Storage: Fungible Allowance (r:1 w:1)264	/// Storage: Fungible Allowance (r:0 w:1)
247	/// Proof: Fungible Allowance (max_values: None, max_size: Some(93), added: 2568, mode: MaxEncodedLen)265	/// Proof: Fungible Allowance (max_values: None, max_size: Some(93), added: 2568, mode: MaxEncodedLen)
248	/// Storage: Fungible Balance (r:2 w:2)
249	/// Proof: Fungible Balance (max_values: None, max_size: Some(77), added: 2552, mode: MaxEncodedLen)
250	fn transfer_from() -> Weight {266	fn set_allowance_unchecked_raw() -> Weight {
251		// Proof Size summary in bytes:267		// Proof Size summary in bytes:
252		//  Measured:  `300`268		//  Measured:  `0`
253		//  Estimated: `7672`269		//  Estimated: `0`
254		// Minimum execution time: 21_667_000 picoseconds.270		// Minimum execution time: 2_532_000 picoseconds.
255		Weight::from_parts(22_166_000, 7672)271		Weight::from_parts(2_680_000, 0)
256			.saturating_add(RocksDbWeight::get().reads(3_u64))
257			.saturating_add(RocksDbWeight::get().writes(3_u64))272			.saturating_add(RocksDbWeight::get().writes(1_u64))
258	}273	}
259	/// Storage: Fungible Allowance (r:1 w:1)274	/// Storage: Fungible Allowance (r:1 w:1)
260	/// Proof: Fungible Allowance (max_values: None, max_size: Some(93), added: 2568, mode: MaxEncodedLen)275	/// Proof: Fungible Allowance (max_values: None, max_size: Some(93), added: 2568, mode: MaxEncodedLen)

44
5<!-- bureaucrate goes here -->5<!-- bureaucrate goes here -->
66
7## [0.1.14] - 2023-03-28
8
9### Fixed
10
11- The weight of `transfer` and `transfer_from`.
12
7## [0.1.13] - 2023-01-2013## [0.1.13] - 2023-01-20
814
9### Fixed15### Fixed

2edition = "2021"2edition = "2021"
3license = "GPLv3"3license = "GPLv3"
4name = "pallet-nonfungible"4name = "pallet-nonfungible"
5version = "0.1.13"5version = "0.1.14"
66
7[dependencies]7[dependencies]
8# Note: `package = "parity-scale-codec"` must be supplied since the `Encode` macro searches for it.8# Note: `package = "parity-scale-codec"` must be supplied since the `Encode` macro searches for it.

121		}121		}
122	}: {<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?}122	}: {<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?}
123123
124	transfer {124	transfer_raw {
125		bench_init!{125		bench_init!{
126			owner: sub; collection: collection(owner);126			owner: sub; collection: collection(owner);
127			owner: cross_from_sub; sender: cross_sub; receiver: cross_sub;127			owner: cross_from_sub; sender: cross_sub; receiver: cross_sub;
146		let item = create_max_item(&collection, &owner, owner_eth.clone())?;146		let item = create_max_item(&collection, &owner, owner_eth.clone())?;
147	}: {<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, item, Some(&spender))?}147	}: {<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, item, Some(&spender))?}
148148
149	transfer_from {149	check_allowed_raw {
150		bench_init!{150		bench_init!{
151			owner: sub; collection: collection(owner);151			owner: sub; collection: collection(owner);
152			owner: cross_from_sub; sender: cross_sub; spender: cross_sub; receiver: cross_sub;152			owner: cross_from_sub; sender: cross_sub; spender: cross_sub; receiver: cross_sub;
153		};153		};
154		let item = create_max_item(&collection, &owner, sender.clone())?;154		let item = create_max_item(&collection, &owner, sender.clone())?;
155		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&spender))?;155		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&spender))?;
156	}: {<Pallet<T>>::transfer_from(&collection, &spender, &sender, &receiver, item, &Unlimited)?}156	}: {<Pallet<T>>::check_allowed(&collection, &spender, &sender, item, &Unlimited)?}
157157
158	burn_from {158	burn_from {
159		bench_init!{159		bench_init!{