git.delta.rocks / unique-network / refs/commits / 71be677911ce

--- a/pallets/balances-adapter/src/common.rs
+++ b/pallets/balances-adapter/src/common.rs
@@ -30,15 +30,7 @@
 		Weight::default()
 	}
 
-	fn delete_collection_properties(_amount: u32) -> Weight {
-		Weight::default()
-	}
-
 	fn set_token_properties(_amount: u32) -> Weight {
-		Weight::default()
-	}
-
-	fn delete_token_properties(_amount: u32) -> Weight {
 		Weight::default()
 	}
 
@@ -63,18 +55,6 @@
 	}
 
 	fn burn_from() -> Weight {
-		Weight::default()
-	}
-
-	fn burn_recursively_self_raw() -> Weight {
-		Weight::default()
-	}
-
-	fn burn_recursively_breadth_raw(_amount: u32) -> Weight {
-		Weight::default()
-	}
-
-	fn token_owner() -> Weight {
 		Weight::default()
 	}
 
@@ -124,16 +104,6 @@
 		_sender: <T>::CrossAccountId,
 		_token: TokenId,
 		_amount: u128,
-	) -> frame_support::pallet_prelude::DispatchResultWithPostInfo {
-		fail!(<pallet_common::Error<T>>::UnsupportedOperation);
-	}
-
-	fn burn_item_recursively(
-		&self,
-		_sender: <T>::CrossAccountId,
-		_token: TokenId,
-		_self_budget: &dyn up_data_structs::budget::Budget,
-		_breadth_budget: &dyn up_data_structs::budget::Budget,
 	) -> frame_support::pallet_prelude::DispatchResultWithPostInfo {
 		fail!(<pallet_common::Error<T>>::UnsupportedOperation);
 	}

--- a/pallets/common/src/benchmarking.rs
+++ b/pallets/common/src/benchmarking.rs
@@ -29,12 +29,11 @@
 use sp_std::{vec, vec::Vec};
 use up_data_structs::{
 	AccessMode, CollectionId, CollectionMode, CollectionPermissions, CreateCollectionData,
-	NestingPermissions, PropertiesPermissionMap, Property, PropertyKey, PropertyValue,
-	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_PROPERTIES_PER_ITEM,
-	MAX_TOKEN_PREFIX_LENGTH,
+	NestingPermissions, Property, PropertyKey, PropertyValue, MAX_COLLECTION_DESCRIPTION_LENGTH,
+	MAX_COLLECTION_NAME_LENGTH, MAX_PROPERTIES_PER_ITEM, MAX_TOKEN_PREFIX_LENGTH,
 };
 
-use crate::{CollectionHandle, Config, Pallet};
+use crate::{BenchmarkPropertyWriter, CollectionHandle, Config, Pallet};
 
 const SEED: u32 = 1;
 
@@ -126,16 +125,6 @@
 	)
 }
 
-pub fn load_is_admin_and_property_permissions<T: Config>(
-	collection: &CollectionHandle<T>,
-	sender: &T::CrossAccountId,
-) -> (bool, PropertiesPermissionMap) {
-	(
-		collection.is_owner_or_admin(sender),
-		<Pallet<T>>::property_permissions(collection.id),
-	)
-}
-
 /// Helper macros, which handles all benchmarking preparation in semi-declarative way
 ///
 /// `name` is a substrate account
@@ -200,31 +189,6 @@
 		#[block]
 		{
 			<Pallet<T>>::set_collection_properties(&collection, &owner, props.into_iter())?;
-		}
-
-		Ok(())
-	}
-
-	#[benchmark]
-	fn delete_collection_properties(
-		b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
-	) -> Result<(), BenchmarkError> {
-		bench_init! {
-			owner: sub; collection: collection(owner);
-			owner: cross_from_sub;
-		};
-		let props = (0..b)
-			.map(|p| Property {
-				key: property_key(p as usize),
-				value: property_value(),
-			})
-			.collect::<Vec<_>>();
-		<Pallet<T>>::set_collection_properties(&collection, &owner, props.into_iter())?;
-		let to_delete = (0..b).map(|p| property_key(p as usize)).collect::<Vec<_>>();
-
-		#[block]
-		{
-			<Pallet<T>>::delete_collection_properties(&collection, &owner, to_delete.into_iter())?;
 		}
 
 		Ok(())
@@ -263,7 +227,7 @@
 	}
 
 	#[benchmark]
-	fn init_token_properties_common() -> Result<(), BenchmarkError> {
+	fn property_writer_load_collection_info() -> Result<(), BenchmarkError> {
 		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: sub;
@@ -272,7 +236,7 @@
 
 		#[block]
 		{
-			load_is_admin_and_property_permissions(&collection, &sender);
+			<BenchmarkPropertyWriter<T>>::load_collection_info(&&collection, &sender);
 		}
 
 		Ok(())

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -126,7 +126,7 @@
 	///
 	/// @param key Property key.
 	#[solidity(hide)]
-	#[weight(<SelfWeightOf<T>>::delete_collection_properties(1))]
+	#[weight(<SelfWeightOf<T>>::set_collection_properties(1))]
 	fn delete_collection_property(&mut self, caller: Caller, key: String) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let key = <Vec<u8>>::from(key)
@@ -139,7 +139,7 @@
 	/// Delete collection properties.
 	///
 	/// @param keys Properties keys.
-	#[weight(<SelfWeightOf<T>>::delete_collection_properties(keys.len() as u32))]
+	#[weight(<SelfWeightOf<T>>::set_collection_properties(keys.len() as u32))]
 	fn delete_collection_properties(&mut self, caller: Caller, keys: Vec<String>) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let keys = keys

--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -53,10 +53,12 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 extern crate alloc;
 
+use alloc::boxed::Box;
 use core::{
 	marker::PhantomData,
 	ops::{Deref, DerefMut},
 	slice::from_ref,
+	unreachable,
 };
 
 use evm_coder::ToLog;
@@ -871,63 +873,77 @@
 	>;
 }
 
+enum LazyValueState<'a, T> {
+	Pending(Box<dyn FnOnce() -> T + 'a>),
+	InProgress,
+	Computed(T),
+}
+
 /// Value representation with delayed initialization time.
-pub struct LazyValue<T, F: FnOnce() -> T> {
-	value: Option<T>,
-	f: Option<F>,
+pub struct LazyValue<'a, T> {
+	state: LazyValueState<'a, T>,
 }
 
-impl<T, F: FnOnce() -> T> LazyValue<T, F> {
+impl<'a, T> LazyValue<'a, T> {
 	/// Create a new LazyValue.
-	pub fn new(f: F) -> Self {
+	pub fn new(f: impl FnOnce() -> T + 'a) -> Self {
 		Self {
-			value: None,
-			f: Some(f),
+			state: LazyValueState::Pending(Box::new(f)),
 		}
 	}
 
 	/// Get the value. If it is called the first time, the value will be initialized.
 	pub fn value(&mut self) -> &T {
 		self.force_value();
-		self.value.as_ref().unwrap()
+		self.value_mut()
 	}
 
 	/// Get the value. If it is called the first time, the value will be initialized.
 	pub fn value_mut(&mut self) -> &mut T {
 		self.force_value();
-		self.value.as_mut().unwrap()
+
+		if let LazyValueState::Computed(value) = &mut self.state {
+			value
+		} else {
+			unreachable!()
+		}
 	}
 
 	fn into_inner(mut self) -> T {
 		self.force_value();
-		self.value.unwrap()
+		if let LazyValueState::Computed(value) = self.state {
+			value
+		} else {
+			unreachable!()
+		}
 	}
 
 	/// Is value initialized?
 	pub fn has_value(&self) -> bool {
-		self.value.is_some()
+		matches!(self.state, LazyValueState::Computed(_))
 	}
 
 	fn force_value(&mut self) {
-		if self.value.is_none() {
-			self.value = Some(self.f.take().unwrap()())
+		use LazyValueState::*;
+
+		if self.has_value() {
+			return;
+		}
+
+		match sp_std::mem::replace(&mut self.state, InProgress) {
+			Pending(f) => self.state = Computed(f()),
+			_ => panic!("recursion isn't supported"),
 		}
 	}
 }
 
-fn check_token_permissions<T, FCA, FTO, FTE>(
+fn check_token_permissions<T: Config>(
 	collection_admin_permitted: bool,
 	token_owner_permitted: bool,
-	is_collection_admin: &mut LazyValue<bool, FCA>,
-	is_token_owner: &mut LazyValue<Result<bool, DispatchError>, FTO>,
-	is_token_exist: &mut LazyValue<bool, FTE>,
-) -> DispatchResult
-where
-	T: Config,
-	FCA: FnOnce() -> bool,
-	FTO: FnOnce() -> Result<bool, DispatchError>,
-	FTE: FnOnce() -> bool,
-{
+	is_collection_admin: &mut LazyValue<bool>,
+	is_token_owner: &mut LazyValue<Result<bool, DispatchError>>,
+	is_token_exist: &mut LazyValue<bool>,
+) -> DispatchResult {
 	if !(collection_admin_permitted && *is_collection_admin.value()
 		|| token_owner_permitted && (*is_token_owner.value())?)
 	{
@@ -1902,7 +1918,9 @@
 	/// Collection property deletion weight.
 	///
 	/// * `amount`- The number of properties to set.
-	fn delete_collection_properties(amount: u32) -> Weight;
+	fn delete_collection_properties(amount: u32) -> Weight {
+		Self::set_collection_properties(amount)
+	}
 
 	/// Token property setting weight.
 	///
@@ -1912,7 +1930,9 @@
 	/// Token property deletion weight.
 	///
 	/// * `amount`- The number of properties to delete.
-	fn delete_token_properties(amount: u32) -> Weight;
+	fn delete_token_properties(amount: u32) -> Weight {
+		Self::set_token_properties(amount)
+	}
 
 	/// Token property permissions set weight.
 	///
@@ -1933,31 +1953,7 @@
 
 	/// The price of burning a token from another user.
 	fn burn_from() -> Weight;
-
-	/// Differs from burn_item in case of Fungible and Refungible, as it should burn
-	/// whole users's balance.
-	///
-	/// This method shouldn't be used directly, as it doesn't count breadth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead
-	fn burn_recursively_self_raw() -> Weight;
 
-	/// Cost of iterating over `amount` children while burning, without counting child burning itself.
-	///
-	/// This method shouldn't be used directly, as it doesn't count depth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead
-	fn burn_recursively_breadth_raw(amount: u32) -> Weight;
-
-	/// The price of recursive burning a token.
-	///
-	/// `max_selfs` - The maximum burning weight of the token itself.
-	/// `max_breadth` - The maximum number of nested tokens to burn.
-	fn burn_recursively(max_selfs: u32, max_breadth: u32) -> Weight {
-		Self::burn_recursively_self_raw()
-			.saturating_mul(max_selfs.max(1) as u64)
-			.saturating_add(Self::burn_recursively_breadth_raw(max_breadth))
-	}
-
-	/// The price of retrieving token owner
-	fn token_owner() -> Weight;
-
 	/// The price of setting approval for all
 	fn set_allowance_for_all() -> Weight;
 
@@ -2029,20 +2025,6 @@
 		amount: u128,
 	) -> DispatchResultWithPostInfo;
 
-	/// Burn token and all nested tokens recursievly.
-	///
-	/// * `sender` - The user who owns the token.
-	/// * `token` - Token id that will burned.
-	/// * `self_budget` - The budget that can be spent on burning tokens.
-	/// * `breadth_budget` - The budget that can be spent on burning nested tokens.
-	fn burn_item_recursively(
-		&self,
-		sender: T::CrossAccountId,
-		token: TokenId,
-		self_budget: &dyn Budget,
-		breadth_budget: &dyn Budget,
-	) -> DispatchResultWithPostInfo;
-
 	/// Set collection properties.
 	///
 	/// * `sender` - Must be either the owner of the collection or its admin.
@@ -2374,160 +2356,33 @@
 	}
 }
 
-/// A marker structure that enables the writer implementation
-/// to provide the interface to write properties to **newly created** tokens.
-pub struct NewTokenPropertyWriter;
-
-/// A marker structure that enables the writer implementation
-/// to provide the interface to write properties to **already existing** tokens.
-pub struct ExistingTokenPropertyWriter;
-
 /// The type-safe interface for writing properties (setting or deleting) to tokens.
 /// It has two distinct implementations for newly created tokens and existing ones.
 ///
 /// This type utilizes the lazy evaluation to avoid repeating the computation
 /// of several performance-heavy or PoV-heavy tasks,
 /// such as checking the indirect ownership or reading the token property permissions.
-pub struct PropertyWriter<
-	'a,
-	T,
-	Handle,
-	WriterVariant,
-	FIsAdmin,
-	FPropertyPermissions,
-	FCheckTokenExist,
-	FGetProperties,
-> where
-	T: Config,
-	FIsAdmin: FnOnce() -> bool,
-	FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
-{
+pub struct PropertyWriter<'a, WriterVariant, T, Handle> {
 	collection: &'a Handle,
-	is_collection_admin: LazyValue<bool, FIsAdmin>,
-	property_permissions: LazyValue<PropertiesPermissionMap, FPropertyPermissions>,
-	check_token_exist: FCheckTokenExist,
-	get_properties: FGetProperties,
+	collection_lazy_info: PropertyWriterLazyCollectionInfo<'a>,
 	_phantom: PhantomData<(T, WriterVariant)>,
 }
 
-impl<'a, T, Handle, FIsAdmin, FPropertyPermissions, FCheckTokenExist, FGetProperties>
-	PropertyWriter<
-		'a,
-		T,
-		Handle,
-		NewTokenPropertyWriter,
-		FIsAdmin,
-		FPropertyPermissions,
-		FCheckTokenExist,
-		FGetProperties,
-	> where
-	T: Config,
-	Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
-	FIsAdmin: FnOnce() -> bool,
-	FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
-	FCheckTokenExist: Copy + FnOnce(TokenId) -> bool,
-	FGetProperties: Copy + FnOnce(TokenId) -> TokenProperties,
-{
-	/// A function to write properties to a **newly created** token.
-	pub fn write_token_properties(
-		&mut self,
-		mint_target_is_sender: bool,
-		token_id: TokenId,
-		properties_updates: impl Iterator<Item = Property>,
-		log: evm_coder::ethereum::Log,
-	) -> DispatchResult {
-		self.internal_write_token_properties(
-			token_id,
-			properties_updates.map(|p| (p.key, Some(p.value))),
-			|_| Ok(mint_target_is_sender),
-			log,
-		)
-	}
-}
-
-impl<'a, T, Handle, FIsAdmin, FPropertyPermissions, FCheckTokenExist, FGetProperties>
-	PropertyWriter<
-		'a,
-		T,
-		Handle,
-		ExistingTokenPropertyWriter,
-		FIsAdmin,
-		FPropertyPermissions,
-		FCheckTokenExist,
-		FGetProperties,
-	> where
+impl<'a, T, Handle, WriterVariant> PropertyWriter<'a, WriterVariant, T, Handle>
+where
 	T: Config,
 	Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
-	FIsAdmin: FnOnce() -> bool,
-	FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
-	FCheckTokenExist: Copy + FnOnce(TokenId) -> bool,
-	FGetProperties: Copy + FnOnce(TokenId) -> TokenProperties,
 {
-	/// A function to write properties to an **already existing** token.
-	pub fn write_token_properties(
+	fn internal_write_token_properties(
 		&mut self,
-		sender: &T::CrossAccountId,
 		token_id: TokenId,
+		mut token_lazy_info: PropertyWriterLazyTokenInfo,
 		properties_updates: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,
-		nesting_budget: &dyn Budget,
 		log: evm_coder::ethereum::Log,
 	) -> DispatchResult {
-		self.internal_write_token_properties(
-			token_id,
-			properties_updates,
-			|collection| collection.check_token_indirect_owner(token_id, sender, nesting_budget),
-			log,
-		)
-	}
-}
-
-impl<
-		'a,
-		T,
-		Handle,
-		WriterVariant,
-		FIsAdmin,
-		FPropertyPermissions,
-		FCheckTokenExist,
-		FGetProperties,
-	>
-	PropertyWriter<
-		'a,
-		T,
-		Handle,
-		WriterVariant,
-		FIsAdmin,
-		FPropertyPermissions,
-		FCheckTokenExist,
-		FGetProperties,
-	> where
-	T: Config,
-	Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
-	FIsAdmin: FnOnce() -> bool,
-	FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
-	FCheckTokenExist: Copy + FnOnce(TokenId) -> bool,
-	FGetProperties: Copy + FnOnce(TokenId) -> TokenProperties,
-{
-	fn internal_write_token_properties<FCheckTokenOwner>(
-		&mut self,
-		token_id: TokenId,
-		properties_updates: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,
-		check_token_owner: FCheckTokenOwner,
-		log: evm_coder::ethereum::Log,
-	) -> DispatchResult
-	where
-		FCheckTokenOwner: FnOnce(&Handle) -> Result<bool, DispatchError>,
-	{
-		let get_properties = self.get_properties;
-		let mut stored_properties = LazyValue::new(move || get_properties(token_id));
-
-		let mut is_token_owner = LazyValue::new(|| check_token_owner(self.collection));
-
-		let check_token_exist = self.check_token_exist;
-		let mut is_token_exist = LazyValue::new(move || check_token_exist(token_id));
-
 		for (key, value) in properties_updates {
 			let permission = self
+				.collection_lazy_info
 				.property_permissions
 				.value()
 				.get(&key)
@@ -2536,7 +2391,11 @@
 
 			match permission {
 				PropertyPermission { mutable: false, .. }
-					if stored_properties.value().get(&key).is_some() =>
+					if token_lazy_info
+						.stored_properties
+						.value()
+						.get(&key)
+						.is_some() =>
 				{
 					return Err(<Error<T>>::NoPermission.into());
 				}
@@ -2545,18 +2404,19 @@
 					collection_admin,
 					token_owner,
 					..
-				} => check_token_permissions::<T, _, _, _>(
+				} => check_token_permissions::<T>(
 					collection_admin,
 					token_owner,
-					&mut self.is_collection_admin,
-					&mut is_token_owner,
-					&mut is_token_exist,
+					&mut self.collection_lazy_info.is_collection_admin,
+					&mut token_lazy_info.is_token_owner,
+					&mut token_lazy_info.is_token_exist,
 				)?,
 			}
 
 			match value {
 				Some(value) => {
-					stored_properties
+					token_lazy_info
+						.stored_properties
 						.value_mut()
 						.try_set(key.clone(), value)
 						.map_err(<Error<T>>::from)?;
@@ -2568,7 +2428,8 @@
 					));
 				}
 				None => {
-					stored_properties
+					token_lazy_info
+						.stored_properties
 						.value_mut()
 						.remove(&key)
 						.map_err(<Error<T>>::from)?;
@@ -2582,142 +2443,292 @@
 			}
 		}
 
-		let properties_changed = stored_properties.has_value();
+		let properties_changed = token_lazy_info.stored_properties.has_value();
 		if properties_changed {
 			<PalletEvm<T>>::deposit_log(log);
 
 			self.collection
-				.set_token_properties_raw(token_id, stored_properties.into_inner());
+				.set_token_properties_raw(token_id, token_lazy_info.stored_properties.into_inner());
 		}
 
 		Ok(())
 	}
 }
 
-/// Create a [`PropertyWriter`] for newly created tokens.
-pub fn property_writer_for_new_token<'a, T, Handle>(
-	collection: &'a Handle,
-	sender: &'a T::CrossAccountId,
-) -> PropertyWriter<
-	'a,
-	T,
-	Handle,
-	NewTokenPropertyWriter,
-	impl FnOnce() -> bool + 'a,
-	impl FnOnce() -> PropertiesPermissionMap + 'a,
-	impl Copy + FnOnce(TokenId) -> bool + 'a,
-	impl Copy + FnOnce(TokenId) -> TokenProperties + 'a,
->
+/// A helper structure for the [`PropertyWriter`] that holds
+/// the collection-related info. The info is loaded using lazy evaluation.
+/// This info is common for any token for which we write properties.
+pub struct PropertyWriterLazyCollectionInfo<'a> {
+	is_collection_admin: LazyValue<'a, bool>,
+	property_permissions: LazyValue<'a, PropertiesPermissionMap>,
+}
+
+/// A helper structure for the [`PropertyWriter`] that holds
+/// the token-related info. The info is loaded using lazy evaluation.
+pub struct PropertyWriterLazyTokenInfo<'a> {
+	is_token_exist: LazyValue<'a, bool>,
+	is_token_owner: LazyValue<'a, Result<bool, DispatchError>>,
+	stored_properties: LazyValue<'a, TokenProperties>,
+}
+
+impl<'a> PropertyWriterLazyTokenInfo<'a> {
+	/// Create a lazy token info.
+	pub fn new(
+		check_token_exist: impl FnOnce() -> bool + 'a,
+		check_token_owner: impl FnOnce() -> Result<bool, DispatchError> + 'a,
+		get_token_properties: impl FnOnce() -> TokenProperties + 'a,
+	) -> Self {
+		Self {
+			is_token_exist: LazyValue::new(check_token_exist),
+			is_token_owner: LazyValue::new(check_token_owner),
+			stored_properties: LazyValue::new(get_token_properties),
+		}
+	}
+}
+
+/// A marker structure that enables the writer implementation
+/// to provide the interface to write properties to **newly created** tokens.
+pub struct NewTokenPropertyWriter<T>(PhantomData<T>);
+impl<T: Config> NewTokenPropertyWriter<T> {
+	/// Creates a [`PropertyWriter`] for **newly created** tokens.
+	pub fn new<'a, Handle>(
+		collection: &'a Handle,
+		sender: &'a T::CrossAccountId,
+	) -> PropertyWriter<'a, Self, T, Handle>
+	where
+		T: Config,
+		Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
+	{
+		PropertyWriter {
+			collection,
+			collection_lazy_info: PropertyWriterLazyCollectionInfo {
+				is_collection_admin: LazyValue::new(|| collection.is_owner_or_admin(sender)),
+				property_permissions: LazyValue::new(|| {
+					<Pallet<T>>::property_permissions(collection.id)
+				}),
+			},
+			_phantom: PhantomData,
+		}
+	}
+}
+
+impl<'a, T, Handle> PropertyWriter<'a, NewTokenPropertyWriter<T>, T, Handle>
 where
 	T: Config,
 	Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
 {
-	PropertyWriter {
-		collection,
-		is_collection_admin: LazyValue::new(|| collection.is_owner_or_admin(sender)),
-		property_permissions: LazyValue::new(|| <Pallet<T>>::property_permissions(collection.id)),
-		check_token_exist: |token_id| {
-			debug_assert!(collection.token_exists(token_id));
+	/// A function to write properties to a **newly created** token.
+	pub fn write_token_properties(
+		&mut self,
+		mint_target_is_sender: bool,
+		token_id: TokenId,
+		properties_updates: impl Iterator<Item = Property>,
+		log: evm_coder::ethereum::Log,
+	) -> DispatchResult {
+		let check_token_exist = || {
+			debug_assert!(self.collection.token_exists(token_id));
 			true
-		},
-		get_properties: |token_id| {
-			debug_assert!(collection.get_token_properties_raw(token_id).is_none());
+		};
+
+		let check_token_owner = || Ok(mint_target_is_sender);
+
+		let get_token_properties = || {
+			debug_assert!(self.collection.get_token_properties_raw(token_id).is_none());
 			TokenProperties::new()
-		},
-		_phantom: PhantomData,
+		};
+
+		self.internal_write_token_properties(
+			token_id,
+			PropertyWriterLazyTokenInfo::new(
+				check_token_exist,
+				check_token_owner,
+				get_token_properties,
+			),
+			properties_updates.map(|p| (p.key, Some(p.value))),
+			log,
+		)
 	}
 }
 
-#[cfg(feature = "runtime-benchmarks")]
-/// Create a `PropertyWriter` with preloaded `is_collection_admin` and `property_permissions.
-/// Also:
-/// * it will return `true` for the token ownership check.
-/// * it will return empty stored properties without reading them from the storage.
-pub fn collection_info_loaded_property_writer<T, Handle>(
-	collection: &Handle,
-	is_collection_admin: bool,
-	property_permissions: PropertiesPermissionMap,
-) -> PropertyWriter<
-	T,
-	Handle,
-	NewTokenPropertyWriter,
-	impl FnOnce() -> bool,
-	impl FnOnce() -> PropertiesPermissionMap,
-	impl Copy + FnOnce(TokenId) -> bool,
-	impl Copy + FnOnce(TokenId) -> TokenProperties,
->
+/// A marker structure that enables the writer implementation
+/// to provide the interface to write properties to **already existing** tokens.
+pub struct ExistingTokenPropertyWriter<T>(PhantomData<T>);
+impl<T: Config> ExistingTokenPropertyWriter<T> {
+	/// Creates a [`PropertyWriter`] for **already existing** tokens.
+	pub fn new<'a, Handle>(
+		collection: &'a Handle,
+		sender: &'a T::CrossAccountId,
+	) -> PropertyWriter<'a, Self, T, Handle>
+	where
+		Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
+	{
+		PropertyWriter {
+			collection,
+			collection_lazy_info: PropertyWriterLazyCollectionInfo {
+				is_collection_admin: LazyValue::new(|| collection.is_owner_or_admin(sender)),
+				property_permissions: LazyValue::new(|| {
+					<Pallet<T>>::property_permissions(collection.id)
+				}),
+			},
+			_phantom: PhantomData,
+		}
+	}
+}
+
+impl<'a, T, Handle> PropertyWriter<'a, ExistingTokenPropertyWriter<T>, T, Handle>
 where
 	T: Config,
 	Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
 {
-	PropertyWriter {
-		collection,
-		is_collection_admin: LazyValue::new(move || is_collection_admin),
-		property_permissions: LazyValue::new(move || property_permissions),
-		check_token_exist: |_token_id| true,
-		get_properties: |_token_id| TokenProperties::new(),
-		_phantom: PhantomData,
+	/// A function to write properties to an **already existing** token.
+	pub fn write_token_properties(
+		&mut self,
+		sender: &T::CrossAccountId,
+		token_id: TokenId,
+		properties_updates: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,
+		nesting_budget: &dyn Budget,
+		log: evm_coder::ethereum::Log,
+	) -> DispatchResult {
+		let check_token_exist = || self.collection.token_exists(token_id);
+		let check_token_owner = || {
+			self.collection
+				.check_token_indirect_owner(token_id, sender, nesting_budget)
+		};
+		let get_token_properties = || {
+			self.collection
+				.get_token_properties_raw(token_id)
+				.unwrap_or_default()
+		};
+
+		self.internal_write_token_properties(
+			token_id,
+			PropertyWriterLazyTokenInfo::new(
+				check_token_exist,
+				check_token_owner,
+				get_token_properties,
+			),
+			properties_updates,
+			log,
+		)
 	}
 }
 
-/// Create a [`PropertyWriter`] for already existing tokens.
-pub fn property_writer_for_existing_token<'a, T, Handle>(
-	collection: &'a Handle,
-	sender: &'a T::CrossAccountId,
-) -> PropertyWriter<
-	'a,
-	T,
-	Handle,
-	ExistingTokenPropertyWriter,
-	impl FnOnce() -> bool + 'a,
-	impl FnOnce() -> PropertiesPermissionMap + 'a,
-	impl Copy + FnOnce(TokenId) -> bool + 'a,
-	impl Copy + FnOnce(TokenId) -> TokenProperties + 'a,
->
+/// A marker structure that enables the writer implementation
+/// to benchmark the token properties writing.
+#[cfg(feature = "runtime-benchmarks")]
+pub struct BenchmarkPropertyWriter<T>(PhantomData<T>);
+
+#[cfg(feature = "runtime-benchmarks")]
+impl<T: Config> BenchmarkPropertyWriter<T> {
+	/// Creates a [`PropertyWriter`] for benchmarking tokens properties writing.
+	pub fn new<'a, Handle>(
+		collection: &'a Handle,
+		collection_lazy_info: PropertyWriterLazyCollectionInfo<'a>,
+	) -> PropertyWriter<'a, Self, T, Handle>
+	where
+		Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
+	{
+		PropertyWriter {
+			collection,
+			collection_lazy_info,
+			_phantom: PhantomData,
+		}
+	}
+
+	/// Load the [`PropertyWriterLazyCollectionInfo`] from the storage.
+	pub fn load_collection_info<Handle>(
+		collection_handle: &Handle,
+		sender: &T::CrossAccountId,
+	) -> PropertyWriterLazyCollectionInfo<'static>
+	where
+		Handle: Deref<Target = CollectionHandle<T>>,
+	{
+		let is_collection_admin = collection_handle.is_owner_or_admin(sender);
+		let property_permissions = <Pallet<T>>::property_permissions(collection_handle.id);
+
+		PropertyWriterLazyCollectionInfo {
+			is_collection_admin: LazyValue::new(move || is_collection_admin),
+			property_permissions: LazyValue::new(move || property_permissions),
+		}
+	}
+
+	/// Load the [`PropertyWriterLazyTokenInfo`] with token properties from the storage.
+	pub fn load_token_properties<Handle>(
+		collection: &Handle,
+		token_id: TokenId,
+	) -> PropertyWriterLazyTokenInfo
+	where
+		Handle: CommonCollectionOperations<T>,
+	{
+		let stored_properties = collection
+			.get_token_properties_raw(token_id)
+			.unwrap_or_default();
+
+		PropertyWriterLazyTokenInfo {
+			is_token_exist: LazyValue::new(|| true),
+			is_token_owner: LazyValue::new(|| Ok(true)),
+			stored_properties: LazyValue::new(move || stored_properties),
+		}
+	}
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+impl<'a, T, Handle> PropertyWriter<'a, BenchmarkPropertyWriter<T>, T, Handle>
 where
 	T: Config,
 	Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
 {
-	PropertyWriter {
-		collection,
-		is_collection_admin: LazyValue::new(|| collection.is_owner_or_admin(sender)),
-		property_permissions: LazyValue::new(|| <Pallet<T>>::property_permissions(collection.id)),
-		check_token_exist: |token_id| collection.token_exists(token_id),
-		get_properties: |token_id| {
-			collection
-				.get_token_properties_raw(token_id)
-				.unwrap_or_default()
-		},
-		_phantom: PhantomData,
+	/// A function to benchmark the writing of token properties.
+	pub fn write_token_properties(
+		&mut self,
+		token_id: TokenId,
+		properties_updates: impl Iterator<Item = Property>,
+		log: evm_coder::ethereum::Log,
+	) -> DispatchResult {
+		let check_token_exist = || true;
+		let check_token_owner = || Ok(true);
+		let get_token_properties = TokenProperties::new;
+
+		self.internal_write_token_properties(
+			token_id,
+			PropertyWriterLazyTokenInfo::new(
+				check_token_exist,
+				check_token_owner,
+				get_token_properties,
+			),
+			properties_updates.map(|p| (p.key, Some(p.value))),
+			log,
+		)
 	}
 }
 
-/// Computes the weight delta for newly created tokens with properties.
+/// Computes the weight of writing properties to tokens.
 /// * `properties_nums` - The properties num of each created token.
-/// * `init_token_properties` - The function to obtain the weight from a token's properties num.
-pub fn init_token_properties_delta<T: Config, I: Fn(u32) -> Weight>(
+/// * `per_token_weight_weight` - The function to obtain the weight
+/// of writing properties from a token's properties num.
+pub fn write_token_properties_total_weight<T: Config, I: Fn(u32) -> Weight>(
 	properties_nums: impl Iterator<Item = u32>,
-	init_token_properties: I,
+	per_token_weight: I,
 ) -> Weight {
-	let mut delta = properties_nums
+	let mut weight = properties_nums
 		.filter_map(|properties_num| {
 			if properties_num > 0 {
-				Some(init_token_properties(properties_num))
+				Some(per_token_weight(properties_num))
 			} else {
 				None
 			}
 		})
 		.fold(Weight::zero(), |a, b| a.saturating_add(b));
 
-	// If at least once the `init_token_properties` was called,
-	// it means at least one newly created token has properties.
-	// Becuase of that, some common collection data also was loaded and we need to add this weight.
-	// However, these common data was loaded only once which is guaranteed by the `PropertyWriter`.
-	if !delta.is_zero() {
-		delta = delta.saturating_add(<SelfWeightOf<T>>::init_token_properties_common())
+	if !weight.is_zero() {
+		// If we are here, it means the token properties were written at least once.
+		// Because of that, some common collection data was also loaded; we must add this weight.
+		// However, this common data was loaded only once, which is guaranteed by the `PropertyWriter`.
+
+		weight = weight.saturating_add(<SelfWeightOf<T>>::property_writer_load_collection_info());
 	}
 
-	delta
+	weight
 }
 
 #[cfg(any(feature = "tests", test))]
@@ -2781,20 +2792,14 @@
 		/* 15*/ TestCase::new(1, 1,  1, 1,  0),
 	];
 
-	pub fn check_token_permissions<T, FCA, FTO, FTE>(
+	pub fn check_token_permissions<T: Config>(
 		collection_admin_permitted: bool,
 		token_owner_permitted: bool,
-		is_collection_admin: &mut LazyValue<bool, FCA>,
-		check_token_ownership: &mut LazyValue<Result<bool, DispatchError>, FTO>,
-		check_token_existence: &mut LazyValue<bool, FTE>,
-	) -> DispatchResult
-	where
-		T: Config,
-		FCA: FnOnce() -> bool,
-		FTO: FnOnce() -> Result<bool, DispatchError>,
-		FTE: FnOnce() -> bool,
-	{
-		crate::check_token_permissions::<T, FCA, FTO, FTE>(
+		is_collection_admin: &mut LazyValue<bool>,
+		check_token_ownership: &mut LazyValue<Result<bool, DispatchError>>,
+		check_token_existence: &mut LazyValue<bool>,
+	) -> DispatchResult {
+		crate::check_token_permissions::<T>(
 			collection_admin_permitted,
 			token_owner_permitted,
 			is_collection_admin,

--- a/pallets/common/src/weights.rs
+++ b/pallets/common/src/weights.rs
@@ -3,13 +3,13 @@
 //! Autogenerated weights for pallet_common
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-09-30, STEPS: `50`, REPEAT: `400`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-10-13, STEPS: `50`, REPEAT: `80`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `bench-host`, CPU: `Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz`
-//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
+//! HOSTNAME: `hearthstone`, CPU: `AMD Ryzen 9 7950X3D 16-Core Processor`
+//! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
 
 // Executed Command:
-// target/production/unique-collator
+// ./target/production/unique-collator
 // benchmark
 // pallet
 // --pallet
@@ -20,7 +20,7 @@
 // *
 // --template=.maintain/frame-weight-template.hbs
 // --steps=50
-// --repeat=400
+// --repeat=80
 // --heap-pages=4096
 // --output=./pallets/common/src/weights.rs
 
@@ -34,116 +34,87 @@
 /// Weight functions needed for pallet_common.
 pub trait WeightInfo {
 	fn set_collection_properties(b: u32, ) -> Weight;
-	fn delete_collection_properties(b: u32, ) -> Weight;
 	fn check_accesslist() -> Weight;
-	fn init_token_properties_common() -> Weight;
+	fn property_writer_load_collection_info() -> Weight;
 }
 
 /// Weights for pallet_common using the Substrate node and recommended hardware.
 pub struct SubstrateWeight<T>(PhantomData<T>);
 impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
-	/// Storage: Common CollectionProperties (r:1 w:1)
-	/// Proof: Common CollectionProperties (max_values: None, max_size: Some(40992), added: 43467, mode: MaxEncodedLen)
+	/// Storage: `Common::CollectionProperties` (r:1 w:1)
+	/// Proof: `Common::CollectionProperties` (`max_values`: None, `max_size`: Some(40992), added: 43467, mode: `MaxEncodedLen`)
 	/// The range of component `b` is `[0, 64]`.
 	fn set_collection_properties(b: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `298`
 		//  Estimated: `44457`
-		// Minimum execution time: 4_987_000 picoseconds.
-		Weight::from_parts(5_119_000, 44457)
-			// Standard Error: 7_609
-			.saturating_add(Weight::from_parts(5_750_459, 0).saturating_mul(b.into()))
-			.saturating_add(T::DbWeight::get().reads(1_u64))
-			.saturating_add(T::DbWeight::get().writes(1_u64))
-	}
-	/// Storage: Common CollectionProperties (r:1 w:1)
-	/// Proof: Common CollectionProperties (max_values: None, max_size: Some(40992), added: 43467, mode: MaxEncodedLen)
-	/// The range of component `b` is `[0, 64]`.
-	fn delete_collection_properties(b: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `303 + b * (33030 ±0)`
-		//  Estimated: `44457`
-		// Minimum execution time: 4_923_000 picoseconds.
-		Weight::from_parts(5_074_000, 44457)
-			// Standard Error: 36_651
-			.saturating_add(Weight::from_parts(23_145_677, 0).saturating_mul(b.into()))
+		// Minimum execution time: 4_560_000 picoseconds.
+		Weight::from_parts(28_643_440, 44457)
+			// Standard Error: 28_941
+			.saturating_add(Weight::from_parts(18_277_422, 0).saturating_mul(b.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
-	/// Storage: Common Allowlist (r:1 w:0)
-	/// Proof: Common Allowlist (max_values: None, max_size: Some(70), added: 2545, mode: MaxEncodedLen)
+	/// Storage: `Common::Allowlist` (r:1 w:0)
+	/// Proof: `Common::Allowlist` (`max_values`: None, `max_size`: Some(70), added: 2545, mode: `MaxEncodedLen`)
 	fn check_accesslist() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `373`
 		//  Estimated: `3535`
-		// Minimum execution time: 4_271_000 picoseconds.
-		Weight::from_parts(4_461_000, 3535)
+		// Minimum execution time: 4_290_000 picoseconds.
+		Weight::from_parts(4_460_000, 3535)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
-	/// Storage: Common IsAdmin (r:1 w:0)
-	/// Proof: Common IsAdmin (max_values: None, max_size: Some(70), added: 2545, mode: MaxEncodedLen)
-	/// Storage: Common CollectionPropertyPermissions (r:1 w:0)
-	/// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
-	fn init_token_properties_common() -> Weight {
+	/// Storage: `Common::IsAdmin` (r:1 w:0)
+	/// Proof: `Common::IsAdmin` (`max_values`: None, `max_size`: Some(70), added: 2545, mode: `MaxEncodedLen`)
+	/// Storage: `Common::CollectionPropertyPermissions` (r:1 w:0)
+	/// Proof: `Common::CollectionPropertyPermissions` (`max_values`: None, `max_size`: Some(16726), added: 19201, mode: `MaxEncodedLen`)
+	fn property_writer_load_collection_info() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `326`
 		//  Estimated: `20191`
-		// Minimum execution time: 5_889_000 picoseconds.
-		Weight::from_parts(6_138_000, 20191)
+		// Minimum execution time: 6_100_000 picoseconds.
+		Weight::from_parts(6_350_000, 20191)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 	}
 }
 
 // For backwards compatibility and tests
 impl WeightInfo for () {
-	/// Storage: Common CollectionProperties (r:1 w:1)
-	/// Proof: Common CollectionProperties (max_values: None, max_size: Some(40992), added: 43467, mode: MaxEncodedLen)
+	/// Storage: `Common::CollectionProperties` (r:1 w:1)
+	/// Proof: `Common::CollectionProperties` (`max_values`: None, `max_size`: Some(40992), added: 43467, mode: `MaxEncodedLen`)
 	/// The range of component `b` is `[0, 64]`.
 	fn set_collection_properties(b: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `298`
 		//  Estimated: `44457`
-		// Minimum execution time: 4_987_000 picoseconds.
-		Weight::from_parts(5_119_000, 44457)
-			// Standard Error: 7_609
-			.saturating_add(Weight::from_parts(5_750_459, 0).saturating_mul(b.into()))
+		// Minimum execution time: 4_560_000 picoseconds.
+		Weight::from_parts(28_643_440, 44457)
+			// Standard Error: 28_941
+			.saturating_add(Weight::from_parts(18_277_422, 0).saturating_mul(b.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
-	/// Storage: Common CollectionProperties (r:1 w:1)
-	/// Proof: Common CollectionProperties (max_values: None, max_size: Some(40992), added: 43467, mode: MaxEncodedLen)
-	/// The range of component `b` is `[0, 64]`.
-	fn delete_collection_properties(b: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `303 + b * (33030 ±0)`
-		//  Estimated: `44457`
-		// Minimum execution time: 4_923_000 picoseconds.
-		Weight::from_parts(5_074_000, 44457)
-			// Standard Error: 36_651
-			.saturating_add(Weight::from_parts(23_145_677, 0).saturating_mul(b.into()))
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
-			.saturating_add(RocksDbWeight::get().writes(1_u64))
-	}
-	/// Storage: Common Allowlist (r:1 w:0)
-	/// Proof: Common Allowlist (max_values: None, max_size: Some(70), added: 2545, mode: MaxEncodedLen)
+	/// Storage: `Common::Allowlist` (r:1 w:0)
+	/// Proof: `Common::Allowlist` (`max_values`: None, `max_size`: Some(70), added: 2545, mode: `MaxEncodedLen`)
 	fn check_accesslist() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `373`
 		//  Estimated: `3535`
-		// Minimum execution time: 4_271_000 picoseconds.
-		Weight::from_parts(4_461_000, 3535)
+		// Minimum execution time: 4_290_000 picoseconds.
+		Weight::from_parts(4_460_000, 3535)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
-	/// Storage: Common IsAdmin (r:1 w:0)
-	/// Proof: Common IsAdmin (max_values: None, max_size: Some(70), added: 2545, mode: MaxEncodedLen)
-	/// Storage: Common CollectionPropertyPermissions (r:1 w:0)
-	/// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
-	fn init_token_properties_common() -> Weight {
+	/// Storage: `Common::IsAdmin` (r:1 w:0)
+	/// Proof: `Common::IsAdmin` (`max_values`: None, `max_size`: Some(70), added: 2545, mode: `MaxEncodedLen`)
+	/// Storage: `Common::CollectionPropertyPermissions` (r:1 w:0)
+	/// Proof: `Common::CollectionPropertyPermissions` (`max_values`: None, `max_size`: Some(16726), added: 19201, mode: `MaxEncodedLen`)
+	fn property_writer_load_collection_info() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `326`
 		//  Estimated: `20191`
-		// Minimum execution time: 5_889_000 picoseconds.
-		Weight::from_parts(6_138_000, 20191)
+		// Minimum execution time: 6_100_000 picoseconds.
+		Weight::from_parts(6_350_000, 20191)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 	}
 }

--- a/pallets/evm-coder-substrate/src/lib.rs
+++ b/pallets/evm-coder-substrate/src/lib.rs
@@ -84,7 +84,7 @@
 }
 impl<T: Config> budget::Budget for GasCallsBudget<'_, T> {
 	fn consume_custom(&self, calls: u32) -> bool {
-		let (gas, overflown) = (calls as u64).overflowing_add(self.gas_per_call);
+		let (gas, overflown) = (calls as u64).overflowing_mul(self.gas_per_call);
 		if overflown {
 			return false;
 		}

--- a/pallets/foreign-assets/src/impl_fungibles.rs
+++ b/pallets/foreign-assets/src/impl_fungibles.rs
@@ -23,7 +23,7 @@
 use pallet_common::{CollectionHandle, CommonCollectionOperations};
 use pallet_fungible::FungibleHandle;
 use sp_runtime::traits::{CheckedAdd, CheckedSub};
-use up_data_structs::budget::Value;
+use up_data_structs::budget;
 
 use super::*;
 
@@ -327,7 +327,7 @@
 					&collection,
 					&account,
 					amount_data,
-					&Value::new(0),
+					&budget::Value::new(0),
 				)?;
 
 				Ok(amount)
@@ -440,7 +440,7 @@
 					&T::CrossAccountId::from_sub(source.clone()),
 					&T::CrossAccountId::from_sub(dest.clone()),
 					amount.into(),
-					&Value::new(0),
+					&budget::Value::new(0),
 				)
 				.map_err(|e| e.error)?;
 

--- a/pallets/fungible/src/common.rs
+++ b/pallets/fungible/src/common.rs
@@ -16,14 +16,11 @@
 
 use core::marker::PhantomData;
 
-use frame_support::{
-	dispatch::DispatchResultWithPostInfo, ensure, fail, traits::Get, weights::Weight,
-};
+use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
 use pallet_common::{
 	weights::WeightInfo as _, with_weight, CommonCollectionOperations, CommonWeightInfo,
 	RefungibleExtensions, SelfWeightOf as PalletCommonWeightOf,
 };
-use pallet_structure::Error as StructureError;
 use sp_runtime::{ArithmeticError, DispatchError};
 use sp_std::{vec, vec::Vec};
 use up_data_structs::{
@@ -58,18 +55,9 @@
 
 	fn set_collection_properties(amount: u32) -> Weight {
 		<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)
-	}
-
-	fn delete_collection_properties(amount: u32) -> Weight {
-		<pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)
 	}
 
 	fn set_token_properties(_amount: u32) -> Weight {
-		// Error
-		Weight::zero()
-	}
-
-	fn delete_token_properties(_amount: u32) -> Weight {
 		// Error
 		Weight::zero()
 	}
@@ -80,7 +68,8 @@
 	}
 
 	fn transfer() -> Weight {
-		<SelfWeightOf<T>>::transfer_raw() + <PalletCommonWeightOf<T>>::check_accesslist() * 2
+		<SelfWeightOf<T>>::transfer_raw()
+			.saturating_add(<PalletCommonWeightOf<T>>::check_accesslist().saturating_mul(2))
 	}
 
 	fn approve() -> Weight {
@@ -93,28 +82,14 @@
 
 	fn transfer_from() -> Weight {
 		Self::transfer()
-			+ <SelfWeightOf<T>>::check_allowed_raw()
-			+ <SelfWeightOf<T>>::set_allowance_unchecked_raw()
+			.saturating_add(<SelfWeightOf<T>>::check_allowed_raw())
+			.saturating_add(<SelfWeightOf<T>>::set_allowance_unchecked_raw())
 	}
 
 	fn burn_from() -> Weight {
 		<SelfWeightOf<T>>::burn_from()
 	}
 
-	fn burn_recursively_self_raw() -> Weight {
-		// Read to get total balance
-		Self::burn_item() + T::DbWeight::get().reads(1)
-	}
-
-	fn burn_recursively_breadth_raw(_amount: u32) -> Weight {
-		// Fungible tokens can't have children
-		Weight::zero()
-	}
-
-	fn token_owner() -> Weight {
-		Weight::zero()
-	}
-
 	fn set_allowance_for_all() -> Weight {
 		Weight::zero()
 	}
@@ -200,26 +175,6 @@
 		with_weight(
 			<Pallet<T>>::burn(self, &sender, amount),
 			<CommonWeights<T>>::burn_item(),
-		)
-	}
-
-	fn burn_item_recursively(
-		&self,
-		sender: T::CrossAccountId,
-		token: TokenId,
-		self_budget: &dyn Budget,
-		_breadth_budget: &dyn Budget,
-	) -> DispatchResultWithPostInfo {
-		// Should not happen?
-		ensure!(
-			token == TokenId::default(),
-			<Error<T>>::FungibleItemsHaveNoId
-		);
-		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);
-
-		with_weight(
-			<Pallet<T>>::burn(self, &sender, <Balance<T>>::get((self.id, &sender))),
-			<CommonWeights<T>>::burn_recursively_self_raw(),
 		)
 	}
 

--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -32,12 +32,12 @@
 use pallet_evm_coder_substrate::{
 	call, dispatch_to_evm,
 	execution::{PreDispatch, Result},
-	frontier_contract,
+	frontier_contract, SubstrateRecorder,
 };
 use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight};
 use sp_core::{Get, U256};
 use sp_std::vec::Vec;
-use up_data_structs::CollectionMode;
+use up_data_structs::{budget::Budget, CollectionMode};
 
 use crate::{
 	common::CommonWeights, weights::WeightInfo, Allowance, Balance, Config, FungibleHandle, Pallet,
@@ -73,6 +73,10 @@
 	amount: U256,
 }
 
+fn nesting_budget<T: Config>(recorder: &SubstrateRecorder<T>) -> impl Budget + '_ {
+	recorder.weight_calls_budget(<StructureWeight<T>>::find_parent())
+}
+
 #[solidity_interface(name = ERC20, events(ERC20Events), enum(derive(PreDispatch)), enum_attr(weight), expect_selector = 0x942e8b22)]
 impl<T: Config> FungibleHandle<T> {
 	fn name(&self) -> Result<String> {
@@ -106,11 +110,8 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
-		<Pallet<T>>::transfer(self, &caller, &to, amount, &budget)
+		<Pallet<T>>::transfer(self, &caller, &to, amount, &nesting_budget(&self.recorder))
 			.map_err(|e| dispatch_to_evm::<T>(e.error))?;
 		Ok(true)
 	}
@@ -127,12 +128,16 @@
 		let from = T::CrossAccountId::from_eth(from);
 		let to = T::CrossAccountId::from_eth(to);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
-		<Pallet<T>>::transfer_from(self, &caller, &from, &to, amount, &budget)
-			.map_err(|e| dispatch_to_evm::<T>(e.error))?;
+		<Pallet<T>>::transfer_from(
+			self,
+			&caller,
+			&from,
+			&to,
+			amount,
+			&nesting_budget(&self.recorder),
+		)
+		.map_err(|e| dispatch_to_evm::<T>(e.error))?;
 		Ok(true)
 	}
 	#[weight(<SelfWeightOf<T>>::approve())]
@@ -164,10 +169,8 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
-		<Pallet<T>>::create_item(self, &caller, (to, amount), &budget)
+
+		<Pallet<T>>::create_item(self, &caller, (to, amount), &nesting_budget(&self.recorder))
 			.map_err(dispatch_to_evm::<T>)?;
 		Ok(true)
 	}
@@ -201,10 +204,8 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = to.into_sub_cross_account::<T>()?;
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
-		<Pallet<T>>::create_item(self, &caller, (to, amount), &budget)
+
+		<Pallet<T>>::create_item(self, &caller, (to, amount), &nesting_budget(&self.recorder))
 			.map_err(dispatch_to_evm::<T>)?;
 		Ok(true)
 	}
@@ -236,12 +237,15 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
-		<Pallet<T>>::burn_from(self, &caller, &from, amount, &budget)
-			.map_err(dispatch_to_evm::<T>)?;
+		<Pallet<T>>::burn_from(
+			self,
+			&caller,
+			&from,
+			amount,
+			&nesting_budget(&self.recorder),
+		)
+		.map_err(dispatch_to_evm::<T>)?;
 		Ok(true)
 	}
 
@@ -260,12 +264,15 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = from.into_sub_cross_account::<T>()?;
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
-		<Pallet<T>>::burn_from(self, &caller, &from, amount, &budget)
-			.map_err(dispatch_to_evm::<T>)?;
+		<Pallet<T>>::burn_from(
+			self,
+			&caller,
+			&from,
+			amount,
+			&nesting_budget(&self.recorder),
+		)
+		.map_err(dispatch_to_evm::<T>)?;
 		Ok(true)
 	}
 
@@ -274,9 +281,6 @@
 	#[weight(<SelfWeightOf<T>>::create_multiple_items_ex(amounts.len() as u32))]
 	fn mint_bulk(&mut self, caller: Caller, amounts: Vec<AmountForAddress>) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 		let amounts = amounts
 			.into_iter()
 			.map(|AmountForAddress { to, amount }| {
@@ -287,7 +291,7 @@
 			})
 			.collect::<Result<_>>()?;
 
-		<Pallet<T>>::create_multiple_items(self, &caller, amounts, &budget)
+		<Pallet<T>>::create_multiple_items(self, &caller, amounts, &nesting_budget(&self.recorder))
 			.map_err(dispatch_to_evm::<T>)?;
 		Ok(true)
 	}
@@ -297,11 +301,9 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = to.into_sub_cross_account::<T>()?;
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
-		<Pallet<T>>::transfer(self, &caller, &to, amount, &budget).map_err(|_| "transfer error")?;
+		<Pallet<T>>::transfer(self, &caller, &to, amount, &nesting_budget(&self.recorder))
+			.map_err(|_| "transfer error")?;
 		Ok(true)
 	}
 
@@ -317,12 +319,16 @@
 		let from = from.into_sub_cross_account::<T>()?;
 		let to = to.into_sub_cross_account::<T>()?;
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
-		<Pallet<T>>::transfer_from(self, &caller, &from, &to, amount, &budget)
-			.map_err(|e| dispatch_to_evm::<T>(e.error))?;
+		<Pallet<T>>::transfer_from(
+			self,
+			&caller,
+			&from,
+			&to,
+			amount,
+			&nesting_budget(&self.recorder),
+		)
+		.map_err(|e| dispatch_to_evm::<T>(e.error))?;
 		Ok(true)
 	}
 

--- a/pallets/nonfungible/src/benchmarking.rs
+++ b/pallets/nonfungible/src/benchmarking.rs
@@ -18,7 +18,6 @@
 use pallet_common::{
 	bench_init,
 	benchmarking::{create_collection_raw, property_key, property_value},
-	CommonCollectionOperations,
 };
 use sp_std::prelude::*;
 use up_data_structs::{
@@ -131,49 +130,8 @@
 		#[block]
 		{
 			<Pallet<T>>::burn(&collection, &burner, item)?;
-		}
-
-		Ok(())
-	}
-
-	#[benchmark]
-	fn burn_recursively_self_raw() -> Result<(), BenchmarkError> {
-		bench_init! {
-			owner: sub; collection: collection(owner);
-			sender: cross_from_sub(owner); burner: cross_sub;
-		};
-		let item = create_max_item(&collection, &sender, burner.clone())?;
-
-		#[block]
-		{
-			<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?;
-		}
-
-		Ok(())
-	}
-
-	#[benchmark]
-	fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(
-		b: Linear<0, 200>,
-	) -> Result<(), BenchmarkError> {
-		bench_init! {
-			owner: sub; collection: collection(owner);
-			sender: cross_from_sub(owner); burner: cross_sub;
-		};
-		let item = create_max_item(&collection, &sender, burner.clone())?;
-		for _ in 0..b {
-			create_max_item(
-				&collection,
-				&sender,
-				T::CrossTokenAddressMapping::token_to_address(collection.id, item),
-			)?;
 		}
 
-		#[block]
-		{
-			<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?;
-		}
-
 		Ok(())
 	}
 
@@ -267,38 +225,29 @@
 	}
 
 	#[benchmark]
-	fn set_token_property_permissions(
-		b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
-	) -> Result<(), BenchmarkError> {
+	fn load_token_properties() -> Result<(), BenchmarkError> {
 		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub;
 		};
-		let perms = (0..b)
-			.map(|k| PropertyKeyPermission {
-				key: property_key(k as usize),
-				permission: PropertyPermission {
-					mutable: false,
-					collection_admin: false,
-					token_owner: false,
-				},
-			})
-			.collect::<Vec<_>>();
 
+		let item = create_max_item(&collection, &owner, owner.clone())?;
+
 		#[block]
 		{
-			<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
+			pallet_common::BenchmarkPropertyWriter::<T>::load_token_properties(&collection, item);
 		}
 
 		Ok(())
 	}
 
 	#[benchmark]
-	fn set_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
+	fn write_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
 		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub;
 		};
+
 		let perms = (0..b)
 			.map(|k| PropertyKeyPermission {
 				key: property_key(k as usize),
@@ -318,71 +267,29 @@
 			.collect::<Vec<_>>();
 		let item = create_max_item(&collection, &owner, owner.clone())?;
 
+		let lazy_collection_info =
+			pallet_common::BenchmarkPropertyWriter::<T>::load_collection_info(&collection, &owner);
+
 		#[block]
 		{
-			<Pallet<T>>::set_token_properties(
-				&collection,
-				&owner,
+			let mut property_writer =
+				pallet_common::BenchmarkPropertyWriter::new(&collection, lazy_collection_info);
+
+			property_writer.write_token_properties(
 				item,
 				props.into_iter(),
-				&Unlimited,
+				crate::erc::ERC721TokenEvent::TokenChanged {
+					token_id: item.into(),
+				}
+				.to_log(T::ContractAddress::get()),
 			)?;
 		}
 
 		Ok(())
 	}
 
-	// TODO:
 	#[benchmark]
-	fn init_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
-		// bench_init! {
-		// 	owner: sub; collection: collection(owner);
-		// 	owner: cross_from_sub;
-		// };
-
-		// let perms = (0..b)
-		// 	.map(|k| PropertyKeyPermission {
-		// 		key: property_key(k as usize),
-		// 		permission: PropertyPermission {
-		// 			mutable: false,
-		// 			collection_admin: true,
-		// 			token_owner: true,
-		// 		},
-		// 	})
-		// 	.collect::<Vec<_>>();
-		// <Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
-		#[block]
-		{}
-		// let props = (0..b)
-		// 	.map(|k| Property {
-		// 		key: property_key(k as usize),
-		// 		value: property_value(),
-		// 	})
-		// 	.collect::<Vec<_>>();
-		// let item = create_max_item(&collection, &owner, owner.clone())?;
-
-		// let (is_collection_admin, property_permissions) =
-		// 	load_is_admin_and_property_permissions(&collection, &owner);
-		// #[block]
-		// {
-		// 	let mut property_writer =
-		// 		pallet_common::BenchmarkPropertyWriter::new(&collection, lazy_collection_info);
-
-		// 	property_writer.write_token_properties(
-		// 		item,
-		// 		props.into_iter(),
-		// 		crate::erc::ERC721TokenEvent::TokenChanged {
-		// 			token_id: item.into(),
-		// 		}
-		// 		.to_log(T::ContractAddress::get()),
-		// 	)?;
-		// }
-
-		Ok(())
-	}
-
-	#[benchmark]
-	fn delete_token_properties(
+	fn set_token_property_permissions(
 		b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
 	) -> Result<(), BenchmarkError> {
 		bench_init! {
@@ -393,54 +300,16 @@
 			.map(|k| PropertyKeyPermission {
 				key: property_key(k as usize),
 				permission: PropertyPermission {
-					mutable: true,
-					collection_admin: true,
-					token_owner: true,
+					mutable: false,
+					collection_admin: false,
+					token_owner: false,
 				},
 			})
 			.collect::<Vec<_>>();
-		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
-		let props = (0..b)
-			.map(|k| Property {
-				key: property_key(k as usize),
-				value: property_value(),
-			})
-			.collect::<Vec<_>>();
-		let item = create_max_item(&collection, &owner, owner.clone())?;
-		<Pallet<T>>::set_token_properties(
-			&collection,
-			&owner,
-			item,
-			props.into_iter(),
-			&Unlimited,
-		)?;
-		let to_delete = (0..b).map(|k| property_key(k as usize)).collect::<Vec<_>>();
 
 		#[block]
 		{
-			<Pallet<T>>::delete_token_properties(
-				&collection,
-				&owner,
-				item,
-				to_delete.into_iter(),
-				&Unlimited,
-			)?;
-		}
-
-		Ok(())
-	}
-
-	#[benchmark]
-	fn token_owner() -> Result<(), BenchmarkError> {
-		bench_init! {
-			owner: sub; collection: collection(owner);
-			owner: cross_from_sub;
-		};
-		let item = create_max_item(&collection, &owner, owner.clone())?;
-
-		#[block]
-		{
-			collection.token_owner(item).unwrap();
+			<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
 		}
 
 		Ok(())

--- a/pallets/nonfungible/src/common.rs
+++ b/pallets/nonfungible/src/common.rs
@@ -18,8 +18,9 @@
 
 use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
 use pallet_common::{
-	init_token_properties_delta, weights::WeightInfo as _, with_weight, CommonCollectionOperations,
-	CommonWeightInfo, RefungibleExtensions, SelfWeightOf as PalletCommonWeightOf,
+	weights::WeightInfo as _, with_weight, write_token_properties_total_weight,
+	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions,
+	SelfWeightOf as PalletCommonWeightOf,
 };
 use pallet_structure::Pallet as PalletStructure;
 use sp_runtime::DispatchError;
@@ -38,24 +39,21 @@
 impl<T: Config> CommonWeightInfo<T::CrossAccountId> for CommonWeights<T> {
 	fn create_multiple_items_ex(data: &CreateItemExData<T::CrossAccountId>) -> Weight {
 		match data {
-			CreateItemExData::NFT(t) => <SelfWeightOf<T>>::create_multiple_items_ex(t.len() as u32)
-				.saturating_add(init_token_properties_delta::<T, _>(
-					t.iter().map(|t| t.properties.len() as u32),
-					<SelfWeightOf<T>>::init_token_properties,
-				)),
+			CreateItemExData::NFT(t) => mint_with_props_weight::<T>(
+				<SelfWeightOf<T>>::create_multiple_items_ex(t.len() as u32),
+				t.iter().map(|t| t.properties.len() as u32),
+			),
 			_ => Weight::zero(),
 		}
 	}
 
 	fn create_multiple_items(data: &[up_data_structs::CreateItemData]) -> Weight {
-		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32).saturating_add(
-			init_token_properties_delta::<T, _>(
-				data.iter().map(|t| match t {
-					up_data_structs::CreateItemData::NFT(n) => n.properties.len() as u32,
-					_ => 0,
-				}),
-				<SelfWeightOf<T>>::init_token_properties,
-			),
+		mint_with_props_weight::<T>(
+			<SelfWeightOf<T>>::create_multiple_items(data.len() as u32),
+			data.iter().map(|t| match t {
+				up_data_structs::CreateItemData::NFT(n) => n.properties.len() as u32,
+				_ => 0,
+			}),
 		)
 	}
 
@@ -65,18 +63,17 @@
 
 	fn set_collection_properties(amount: u32) -> Weight {
 		<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)
-	}
-
-	fn delete_collection_properties(amount: u32) -> Weight {
-		<pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)
 	}
 
 	fn set_token_properties(amount: u32) -> Weight {
-		<SelfWeightOf<T>>::set_token_properties(amount)
+		write_token_properties_total_weight::<T, _>([amount].into_iter(), |amount| {
+			<SelfWeightOf<T>>::load_token_properties()
+				.saturating_add(<SelfWeightOf<T>>::write_token_properties(amount))
+		})
 	}
 
 	fn delete_token_properties(amount: u32) -> Weight {
-		<SelfWeightOf<T>>::delete_token_properties(amount)
+		Self::set_token_properties(amount)
 	}
 
 	fn set_token_property_permissions(amount: u32) -> Weight {
@@ -84,7 +81,8 @@
 	}
 
 	fn transfer() -> Weight {
-		<SelfWeightOf<T>>::transfer_raw() + <PalletCommonWeightOf<T>>::check_accesslist() * 2
+		<SelfWeightOf<T>>::transfer_raw()
+			.saturating_add(<PalletCommonWeightOf<T>>::check_accesslist().saturating_mul(2))
 	}
 
 	fn approve() -> Weight {
@@ -96,24 +94,11 @@
 	}
 
 	fn transfer_from() -> Weight {
-		Self::transfer() + <SelfWeightOf<T>>::check_allowed_raw()
+		Self::transfer().saturating_add(<SelfWeightOf<T>>::check_allowed_raw())
 	}
 
 	fn burn_from() -> Weight {
 		<SelfWeightOf<T>>::burn_from()
-	}
-
-	fn burn_recursively_self_raw() -> Weight {
-		<SelfWeightOf<T>>::burn_recursively_self_raw()
-	}
-
-	fn burn_recursively_breadth_raw(amount: u32) -> Weight {
-		<SelfWeightOf<T>>::burn_recursively_breadth_plus_self_plus_self_per_each_raw(amount)
-			.saturating_sub(Self::burn_recursively_self_raw().saturating_mul(amount as u64 + 1))
-	}
-
-	fn token_owner() -> Weight {
-		<SelfWeightOf<T>>::token_owner()
 	}
 
 	fn set_allowance_for_all() -> Weight {
@@ -125,6 +110,20 @@
 	}
 }
 
+/// Weight of minting tokens with properties
+/// * `create_no_data_weight` -- the weight of minting without properties
+/// * `token_properties_nums` -- number of properties of each token
+#[inline]
+pub(crate) fn mint_with_props_weight<T: Config>(
+	create_no_data_weight: Weight,
+	token_properties_nums: impl Iterator<Item = u32> + Clone,
+) -> Weight {
+	create_no_data_weight.saturating_add(write_token_properties_total_weight::<T, _>(
+		token_properties_nums,
+		<SelfWeightOf<T>>::write_token_properties,
+	))
+}
+
 fn map_create_data<T: Config>(
 	data: up_data_structs::CreateItemData,
 	to: &T::CrossAccountId,
@@ -306,16 +305,6 @@
 			<Pallet<T>>::check_token_immediate_ownership(self, token, &sender)?;
 			Ok(().into())
 		}
-	}
-
-	fn burn_item_recursively(
-		&self,
-		sender: T::CrossAccountId,
-		token: TokenId,
-		self_budget: &dyn Budget,
-		breadth_budget: &dyn Budget,
-	) -> DispatchResultWithPostInfo {
-		<Pallet<T>>::burn_recursively(self, &sender, token, self_budget, breadth_budget)
 	}
 
 	fn transfer(

--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -38,19 +38,21 @@
 use pallet_evm_coder_substrate::{
 	call, dispatch_to_evm,
 	execution::{Error, PreDispatch, Result},
-	frontier_contract,
+	frontier_contract, SubstrateRecorder,
 };
 use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight};
 use sp_core::{Get, U256};
 use sp_std::{vec, vec::Vec};
 use up_data_structs::{
-	CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission,
-	PropertyPermission, TokenId,
+	budget::Budget, CollectionId, CollectionPropertiesVec, Property, PropertyKey,
+	PropertyKeyPermission, PropertyPermission, TokenId,
 };
 
 use crate::{
-	common::CommonWeights, weights::WeightInfo, AccountBalance, Config, CreateItemData,
-	NonfungibleHandle, Pallet, SelfWeightOf, TokenData, TokenProperties, TokensMinted,
+	common::{mint_with_props_weight, CommonWeights},
+	weights::WeightInfo,
+	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, SelfWeightOf, TokenData,
+	TokenProperties, TokensMinted,
 };
 
 /// Nft events.
@@ -78,6 +80,10 @@
 	impl<T: Config> Contract for NonfungibleHandle<T> {...}
 }
 
+fn nesting_budget<T: Config>(recorder: &SubstrateRecorder<T>) -> impl Budget + '_ {
+	recorder.weight_calls_budget(<StructureWeight<T>>::find_parent())
+}
+
 /// @title A contract that allows to set and delete token properties and change token property permissions.
 #[solidity_interface(name = TokenProperties, events(ERC721TokenEvent), enum(derive(PreDispatch)), enum_attr(weight))]
 impl<T: Config> NonfungibleHandle<T> {
@@ -146,7 +152,7 @@
 	/// @param key Property key.
 	/// @param value Property value.
 	#[solidity(hide)]
-	#[weight(<SelfWeightOf<T>>::set_token_properties(1))]
+	#[weight(<CommonWeights<T>>::set_token_properties(1))]
 	fn set_property(
 		&mut self,
 		caller: Caller,
@@ -161,16 +167,12 @@
 			.map_err(|_| "key too long")?;
 		let value = value.0.try_into().map_err(|_| "value too long")?;
 
-		let nesting_budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
-
 		<Pallet<T>>::set_token_property(
 			self,
 			&caller,
 			TokenId(token_id),
 			Property { key, value },
-			&nesting_budget,
+			&nesting_budget(&self.recorder),
 		)
 		.map_err(dispatch_to_evm::<T>)
 	}
@@ -179,7 +181,7 @@
 	/// @dev Throws error if `msg.sender` has no permission to edit the property.
 	/// @param tokenId ID of the token.
 	/// @param properties settable properties
-	#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]
+	#[weight(<CommonWeights<T>>::set_token_properties(properties.len() as u32))]
 	fn set_properties(
 		&mut self,
 		caller: Caller,
@@ -189,10 +191,6 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
 
-		let nesting_budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
-
 		let properties = properties
 			.into_iter()
 			.map(eth::Property::try_into)
@@ -203,7 +201,7 @@
 			&caller,
 			TokenId(token_id),
 			properties.into_iter(),
-			&nesting_budget,
+			&nesting_budget(&self.recorder),
 		)
 		.map_err(dispatch_to_evm::<T>)
 	}
@@ -213,7 +211,7 @@
 	/// @param tokenId ID of the token.
 	/// @param key Property key.
 	#[solidity(hide)]
-	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]
+	#[weight(<CommonWeights<T>>::delete_token_properties(1))]
 	fn delete_property(&mut self, token_id: U256, caller: Caller, key: String) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
@@ -221,19 +219,21 @@
 			.try_into()
 			.map_err(|_| "key too long")?;
 
-		let nesting_budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
-
-		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)
-			.map_err(dispatch_to_evm::<T>)
+		<Pallet<T>>::delete_token_property(
+			self,
+			&caller,
+			TokenId(token_id),
+			key,
+			&nesting_budget(&self.recorder),
+		)
+		.map_err(dispatch_to_evm::<T>)
 	}
 
 	/// @notice Delete token properties value.
 	/// @dev Throws error if `msg.sender` has no permission to edit the property.
 	/// @param tokenId ID of the token.
 	/// @param keys Properties key.
-	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]
+	#[weight(<CommonWeights<T>>::delete_token_properties(keys.len() as u32))]
 	fn delete_properties(
 		&mut self,
 		token_id: U256,
@@ -247,16 +247,12 @@
 			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))
 			.collect::<Result<Vec<_>>>()?;
 
-		let nesting_budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
-
 		<Pallet<T>>::delete_token_properties(
 			self,
 			&caller,
 			TokenId(token_id),
 			keys.into_iter(),
-			&nesting_budget,
+			&nesting_budget(&self.recorder),
 		)
 		.map_err(dispatch_to_evm::<T>)
 	}
@@ -481,12 +477,16 @@
 		let from = T::CrossAccountId::from_eth(from);
 		let to = T::CrossAccountId::from_eth(to);
 		let token = token_id.try_into()?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
-		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)
-			.map_err(|e| dispatch_to_evm::<T>(e.error))?;
+		<Pallet<T>>::transfer_from(
+			self,
+			&caller,
+			&from,
+			&to,
+			token,
+			&nesting_budget(&self.recorder),
+		)
+		.map_err(|e| dispatch_to_evm::<T>(e.error))?;
 		Ok(())
 	}
 
@@ -594,9 +594,6 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let token_id: u32 = token_id.try_into()?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
 		if <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
@@ -613,7 +610,7 @@
 				properties: BoundedVec::default(),
 				owner: to,
 			},
-			&budget,
+			&nesting_budget(&self.recorder),
 		)
 		.map_err(dispatch_to_evm::<T>)?;
 
@@ -625,7 +622,7 @@
 	/// @param tokenUri Token URI that would be stored in the NFT properties
 	/// @return uint256 The id of the newly minted token
 	#[solidity(rename_selector = "mintWithTokenURI")]
-	#[weight(<SelfWeightOf<T>>::create_item() + <SelfWeightOf<T>>::set_token_properties(1))]
+	#[weight(mint_with_props_weight::<T>(<SelfWeightOf<T>>::create_item(), [1].into_iter()))]
 	fn mint_with_token_uri(
 		&mut self,
 		caller: Caller,
@@ -647,7 +644,7 @@
 	/// @param tokenId ID of the minted NFT
 	/// @param tokenUri Token URI that would be stored in the NFT properties
 	#[solidity(hide, rename_selector = "mintWithTokenURI")]
-	#[weight(<SelfWeightOf<T>>::create_item() + <SelfWeightOf<T>>::set_token_properties(1))]
+	#[weight(mint_with_props_weight::<T>(<SelfWeightOf<T>>::create_item(), [1].into_iter()))]
 	fn mint_with_token_uri_check_id(
 		&mut self,
 		caller: Caller,
@@ -664,9 +661,6 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
 		if <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
@@ -694,7 +688,7 @@
 				properties,
 				owner: to,
 			},
-			&budget,
+			&nesting_budget(&self.recorder),
 		)
 		.map_err(dispatch_to_evm::<T>)?;
 		Ok(true)
@@ -840,11 +834,8 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let token = token_id.try_into()?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
-		<Pallet<T>>::transfer(self, &caller, &to, token, &budget)
+		<Pallet<T>>::transfer(self, &caller, &to, token, &nesting_budget(&self.recorder))
 			.map_err(|e| dispatch_to_evm::<T>(e.error))?;
 		Ok(())
 	}
@@ -864,11 +855,8 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = to.into_sub_cross_account::<T>()?;
 		let token = token_id.try_into()?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
-		<Pallet<T>>::transfer(self, &caller, &to, token, &budget)
+		<Pallet<T>>::transfer(self, &caller, &to, token, &nesting_budget(&self.recorder))
 			.map_err(|e| dispatch_to_evm::<T>(e.error))?;
 		Ok(())
 	}
@@ -891,11 +879,16 @@
 		let from = from.into_sub_cross_account::<T>()?;
 		let to = to.into_sub_cross_account::<T>()?;
 		let token_id = token_id.try_into()?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
-		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)
-			.map_err(|e| dispatch_to_evm::<T>(e.error))?;
+
+		Pallet::<T>::transfer_from(
+			self,
+			&caller,
+			&from,
+			&to,
+			token_id,
+			&nesting_budget(&self.recorder),
+		)
+		.map_err(|e| dispatch_to_evm::<T>(e.error))?;
 		Ok(())
 	}
 
@@ -911,11 +904,8 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
 		let token = token_id.try_into()?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
-		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)
+		<Pallet<T>>::burn_from(self, &caller, &from, token, &nesting_budget(&self.recorder))
 			.map_err(dispatch_to_evm::<T>)?;
 		Ok(())
 	}
@@ -936,11 +926,8 @@
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = from.into_sub_cross_account::<T>()?;
 		let token = token_id.try_into()?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
-		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)
+		<Pallet<T>>::burn_from(self, &caller, &from, token, &nesting_budget(&self.recorder))
 			.map_err(dispatch_to_evm::<T>)?;
 		Ok(())
 	}
@@ -966,9 +953,6 @@
 		let mut expected_index = <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
 			.ok_or("item id overflow")?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
 		let total_tokens = token_ids.len();
 		for id in token_ids.into_iter() {
@@ -985,19 +969,21 @@
 			})
 			.collect();
 
-		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)
+		<Pallet<T>>::create_multiple_items(self, &caller, data, &nesting_budget(&self.recorder))
 			.map_err(dispatch_to_evm::<T>)?;
 		Ok(true)
 	}
 
 	/// @notice Function to mint a token.
 	/// @param data Array of pairs of token owner and token's properties for minted token
-	#[weight(<SelfWeightOf<T>>::create_multiple_items(data.len() as u32) + <SelfWeightOf<T>>::set_token_properties(data.len() as u32))]
+	#[weight(
+		mint_with_props_weight::<T>(
+			<SelfWeightOf<T>>::create_multiple_items_ex(data.len() as u32),
+			data.iter().map(|d| d.properties.len() as u32),
+		)
+	)]
 	fn mint_bulk_cross(&mut self, caller: Caller, data: Vec<MintTokenData>) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
 		let mut create_nft_data = Vec::with_capacity(data.len());
 		for MintTokenData { owner, properties } in data {
@@ -1013,8 +999,13 @@
 			});
 		}
 
-		<Pallet<T>>::create_multiple_items(self, &caller, create_nft_data, &budget)
-			.map_err(dispatch_to_evm::<T>)?;
+		<Pallet<T>>::create_multiple_items(
+			self,
+			&caller,
+			create_nft_data,
+			&nesting_budget(&self.recorder),
+		)
+		.map_err(dispatch_to_evm::<T>)?;
 		Ok(true)
 	}
 
@@ -1024,7 +1015,12 @@
 	/// @param to The new owner
 	/// @param tokens array of pairs of token ID and token URI for minted tokens
 	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]
-	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32) + <SelfWeightOf<T>>::set_token_properties(tokens.len() as u32))]
+	#[weight(
+		mint_with_props_weight::<T>(
+			<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32),
+			tokens.iter().map(|_| 1),
+		)
+	)]
 	fn mint_bulk_with_token_uri(
 		&mut self,
 		caller: Caller,
@@ -1037,9 +1033,6 @@
 		let mut expected_index = <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
 			.ok_or("item id overflow")?;
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
 		let mut data = Vec::with_capacity(tokens.len());
 		for TokenUri { id, uri } in tokens {
@@ -1066,7 +1059,7 @@
 			});
 		}
 
-		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)
+		<Pallet<T>>::create_multiple_items(self, &caller, data, &nesting_budget(&self.recorder))
 			.map_err(dispatch_to_evm::<T>)?;
 		Ok(true)
 	}
@@ -1075,7 +1068,7 @@
 	/// @param to The new owner crossAccountId
 	/// @param properties Properties of minted token
 	/// @return uint256 The id of the newly minted token
-	#[weight(<SelfWeightOf<T>>::create_item() + <SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]
+	#[weight(mint_with_props_weight::<T>(<SelfWeightOf<T>>::create_item(), [properties.len() as u32].into_iter()))]
 	fn mint_cross(
 		&mut self,
 		caller: Caller,
@@ -1096,10 +1089,6 @@
 			.map_err(|_| Error::Revert("too many properties".to_string()))?;
 
 		let caller = T::CrossAccountId::from_eth(caller);
-
-		let budget = self
-			.recorder
-			.weight_calls_budget(<StructureWeight<T>>::find_parent());
 
 		<Pallet<T>>::create_item(
 			self,
@@ -1108,7 +1097,7 @@
 				properties,
 				owner: to,
 			},
-			&budget,
+			&nesting_budget(&self.recorder),
 		)
 		.map_err(dispatch_to_evm::<T>)?;
 

--- a/pallets/nonfungible/src/lib.rs
+++ b/pallets/nonfungible/src/lib.rs
@@ -109,7 +109,7 @@
 };
 use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};
 use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};
-use pallet_structure::{Error as StructureError, Pallet as PalletStructure};
+use pallet_structure::Pallet as PalletStructure;
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 use sp_core::{Get, H160};
@@ -502,52 +502,7 @@
 		));
 		Ok(())
 	}
-
-	/// Same as [`burn`] but burns all the tokens that are nested in the token first
-	///
-	/// - `self_budget`: Limit for searching children in depth.
-	/// - `breadth_budget`: Limit of breadth of searching children.
-	///
-	/// [`burn`]: struct.Pallet.html#method.burn
-	#[transactional]
-	pub fn burn_recursively(
-		collection: &NonfungibleHandle<T>,
-		sender: &T::CrossAccountId,
-		token: TokenId,
-		self_budget: &dyn Budget,
-		breadth_budget: &dyn Budget,
-	) -> DispatchResultWithPostInfo {
-		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);
 
-		let current_token_account =
-			T::CrossTokenAddressMapping::token_to_address(collection.id, token);
-
-		let mut weight = Weight::zero();
-
-		// This method is transactional, if user in fact doesn't have permissions to remove token -
-		// tokens removed here will be restored after rejected transaction
-		for ((collection, token), _) in <TokenChildren<T>>::iter_prefix((collection.id, token)) {
-			ensure!(breadth_budget.consume(), <StructureError<T>>::BreadthLimit,);
-			let PostDispatchInfo { actual_weight, .. } =
-				<PalletStructure<T>>::burn_item_recursively(
-					current_token_account.clone(),
-					collection,
-					token,
-					self_budget,
-					breadth_budget,
-				)?;
-			if let Some(actual_weight) = actual_weight {
-				weight = weight.saturating_add(actual_weight);
-			}
-		}
-
-		Self::burn(collection, sender, token)?;
-		DispatchResultWithPostInfo::Ok(PostDispatchInfo {
-			actual_weight: Some(weight + <SelfWeightOf<T>>::burn_item()),
-			pays_fee: Pays::Yes,
-		})
-	}
-
 	/// A batch operation to add, edit or remove properties for a token.
 	///
 	/// - `nesting_budget`: Limit for searching parents in-depth to check ownership.
@@ -568,7 +523,7 @@
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
 		let mut property_writer =
-			pallet_common::property_writer_for_existing_token(collection, sender);
+			pallet_common::ExistingTokenPropertyWriter::new(collection, sender);
 
 		property_writer.write_token_properties(
 			sender,
@@ -915,7 +870,7 @@
 
 		// =========
 
-		let mut property_writer = pallet_common::property_writer_for_new_token(collection, sender);
+		let mut property_writer = pallet_common::NewTokenPropertyWriter::new(collection, sender);
 
 		with_transaction(|| {
 			for (i, data) in data.iter().enumerate() {

3//! Autogenerated weights for pallet_nonfungible3//! Autogenerated weights for pallet_nonfungible
4//!4//!
5//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev5//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
6//! DATE: 2023-09-30, STEPS: `50`, REPEAT: `400`, LOW RANGE: `[]`, HIGH RANGE: `[]`6//! DATE: 2023-10-13, STEPS: `50`, REPEAT: `80`, LOW RANGE: `[]`, HIGH RANGE: `[]`
7//! WORST CASE MAP SIZE: `1000000`7//! WORST CASE MAP SIZE: `1000000`
8//! HOSTNAME: `bench-host`, CPU: `Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz`8//! HOSTNAME: `hearthstone`, CPU: `AMD Ryzen 9 7950X3D 16-Core Processor`
9//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 10249//! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
1010
11// Executed Command:11// Executed Command:
12// target/production/unique-collator12// ./target/production/unique-collator
13// benchmark13// benchmark
14// pallet14// pallet
15// --pallet15// --pallet
20// *20// *
21// --template=.maintain/frame-weight-template.hbs21// --template=.maintain/frame-weight-template.hbs
22// --steps=5022// --steps=50
23// --repeat=40023// --repeat=80
24// --heap-pages=409624// --heap-pages=4096
25// --output=./pallets/nonfungible/src/weights.rs25// --output=./pallets/nonfungible/src/weights.rs
2626
37	fn create_multiple_items(b: u32, ) -> Weight;37	fn create_multiple_items(b: u32, ) -> 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 burn_recursively_self_raw() -> Weight;
41	fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight;
42	fn transfer_raw() -> Weight;40	fn transfer_raw() -> Weight;
43	fn approve() -> Weight;41	fn approve() -> Weight;
44	fn approve_from() -> Weight;42	fn approve_from() -> Weight;
45	fn check_allowed_raw() -> Weight;43	fn check_allowed_raw() -> Weight;
46	fn burn_from() -> Weight;44	fn burn_from() -> Weight;
47	fn set_token_property_permissions(b: u32, ) -> Weight;45	fn load_token_properties() -> Weight;
48	fn set_token_properties(b: u32, ) -> Weight;46	fn write_token_properties(b: u32, ) -> Weight;
49	fn init_token_properties(b: u32, ) -> Weight;47	fn set_token_property_permissions(b: u32, ) -> Weight;
50	fn delete_token_properties(b: u32, ) -> Weight;
51	fn token_owner() -> Weight;
52	fn set_allowance_for_all() -> Weight;48	fn set_allowance_for_all() -> Weight;
53	fn allowance_for_all() -> Weight;49	fn allowance_for_all() -> Weight;
54	fn repair_item() -> Weight;50	fn repair_item() -> Weight;
57/// Weights for pallet_nonfungible using the Substrate node and recommended hardware.53/// Weights for pallet_nonfungible using the Substrate node and recommended hardware.
58pub struct SubstrateWeight<T>(PhantomData<T>);54pub struct SubstrateWeight<T>(PhantomData<T>);
59impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {55impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
60	/// Storage: Nonfungible TokensMinted (r:1 w:1)56	/// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
61	/// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)57	/// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
62	/// Storage: Nonfungible AccountBalance (r:1 w:1)58	/// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
63	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)59	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
64	/// Storage: Nonfungible TokenData (r:0 w:1)60	/// Storage: `Nonfungible::TokenData` (r:0 w:1)
65	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)61	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
66	/// Storage: Nonfungible Owned (r:0 w:1)62	/// Storage: `Nonfungible::Owned` (r:0 w:1)
67	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)63	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
68	fn create_item() -> Weight {64	fn create_item() -> Weight {
69		// Proof Size summary in bytes:65		// Proof Size summary in bytes:
70		//  Measured:  `142`66		//  Measured:  `142`
71		//  Estimated: `3530`67		//  Estimated: `3530`
72		// Minimum execution time: 9_726_000 picoseconds.68		// Minimum execution time: 15_410_000 picoseconds.
73		Weight::from_parts(10_059_000, 3530)69		Weight::from_parts(15_850_000, 3530)
74			.saturating_add(T::DbWeight::get().reads(2_u64))70			.saturating_add(T::DbWeight::get().reads(2_u64))
75			.saturating_add(T::DbWeight::get().writes(4_u64))71			.saturating_add(T::DbWeight::get().writes(4_u64))
76	}72	}
77	/// Storage: Nonfungible TokensMinted (r:1 w:1)73	/// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
78	/// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)74	/// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
79	/// Storage: Nonfungible AccountBalance (r:1 w:1)75	/// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
80	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)76	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
81	/// Storage: Nonfungible TokenData (r:0 w:200)77	/// Storage: `Nonfungible::TokenData` (r:0 w:200)
82	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)78	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
83	/// Storage: Nonfungible Owned (r:0 w:200)79	/// Storage: `Nonfungible::Owned` (r:0 w:200)
84	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)80	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
85	/// The range of component `b` is `[0, 200]`.81	/// The range of component `b` is `[0, 200]`.
86	fn create_multiple_items(b: u32, ) -> Weight {82	fn create_multiple_items(b: u32, ) -> Weight {
87		// Proof Size summary in bytes:83		// Proof Size summary in bytes:
88		//  Measured:  `142`84		//  Measured:  `142`
89		//  Estimated: `3530`85		//  Estimated: `3530`
90		// Minimum execution time: 3_270_000 picoseconds.86		// Minimum execution time: 3_300_000 picoseconds.
91		Weight::from_parts(3_693_659, 3530)87		Weight::from_parts(5_992_994, 3530)
92			// Standard Error: 25588			// Standard Error: 4_478
93			.saturating_add(Weight::from_parts(3_024_284, 0).saturating_mul(b.into()))89			.saturating_add(Weight::from_parts(8_002_092, 0).saturating_mul(b.into()))
94			.saturating_add(T::DbWeight::get().reads(2_u64))90			.saturating_add(T::DbWeight::get().reads(2_u64))
95			.saturating_add(T::DbWeight::get().writes(2_u64))91			.saturating_add(T::DbWeight::get().writes(2_u64))
96			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(b.into())))92			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(b.into())))
97	}93	}
98	/// Storage: Nonfungible TokensMinted (r:1 w:1)94	/// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
99	/// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)95	/// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
100	/// Storage: Nonfungible AccountBalance (r:200 w:200)96	/// Storage: `Nonfungible::AccountBalance` (r:200 w:200)
101	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)97	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
102	/// Storage: Nonfungible TokenData (r:0 w:200)98	/// Storage: `Nonfungible::TokenData` (r:0 w:200)
103	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)99	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
104	/// Storage: Nonfungible Owned (r:0 w:200)100	/// Storage: `Nonfungible::Owned` (r:0 w:200)
105	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)101	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
106	/// The range of component `b` is `[0, 200]`.102	/// The range of component `b` is `[0, 200]`.
107	fn create_multiple_items_ex(b: u32, ) -> Weight {103	fn create_multiple_items_ex(b: u32, ) -> Weight {
108		// Proof Size summary in bytes:104		// Proof Size summary in bytes:
109		//  Measured:  `142`105		//  Measured:  `142`
110		//  Estimated: `3481 + b * (2540 ±0)`106		//  Estimated: `3481 + b * (2540 ±0)`
111		// Minimum execution time: 3_188_000 picoseconds.107		// Minimum execution time: 3_300_000 picoseconds.
112		Weight::from_parts(3_307_000, 3481)108		Weight::from_parts(3_980_000, 3481)
113			// Standard Error: 567109			// Standard Error: 1_382
114			.saturating_add(Weight::from_parts(4_320_449, 0).saturating_mul(b.into()))110			.saturating_add(Weight::from_parts(11_259_286, 0).saturating_mul(b.into()))
115			.saturating_add(T::DbWeight::get().reads(1_u64))111			.saturating_add(T::DbWeight::get().reads(1_u64))
116			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(b.into())))112			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(b.into())))
117			.saturating_add(T::DbWeight::get().writes(1_u64))113			.saturating_add(T::DbWeight::get().writes(1_u64))
118			.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(b.into())))114			.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(b.into())))
119			.saturating_add(Weight::from_parts(0, 2540).saturating_mul(b.into()))115			.saturating_add(Weight::from_parts(0, 2540).saturating_mul(b.into()))
120	}116	}
121	/// Storage: Nonfungible TokenData (r:1 w:1)117	/// Storage: `Nonfungible::TokenData` (r:1 w:1)
122	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)118	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
123	/// Storage: Nonfungible TokenChildren (r:1 w:0)119	/// Storage: `Nonfungible::TokenChildren` (r:1 w:0)
124	/// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)120	/// Proof: `Nonfungible::TokenChildren` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`)
125	/// Storage: Nonfungible TokensBurnt (r:1 w:1)121	/// Storage: `Nonfungible::TokensBurnt` (r:1 w:1)
126	/// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)122	/// Proof: `Nonfungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
127	/// Storage: Nonfungible AccountBalance (r:1 w:1)123	/// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
128	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)124	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
129	/// Storage: Nonfungible Allowance (r:1 w:0)125	/// Storage: `Nonfungible::Allowance` (r:1 w:0)
130	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)126	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
131	/// Storage: Nonfungible Owned (r:0 w:1)127	/// Storage: `Nonfungible::Owned` (r:0 w:1)
132	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)128	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
133	/// Storage: Nonfungible TokenProperties (r:0 w:1)129	/// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
134	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)130	/// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
135	fn burn_item() -> Weight {131	fn burn_item() -> Weight {
136		// Proof Size summary in bytes:132		// Proof Size summary in bytes:
137		//  Measured:  `380`133		//  Measured:  `380`
138		//  Estimated: `3530`134		//  Estimated: `3530`
139		// Minimum execution time: 18_062_000 picoseconds.135		// Minimum execution time: 26_360_000 picoseconds.
140		Weight::from_parts(18_433_000, 3530)136		Weight::from_parts(26_850_000, 3530)
141			.saturating_add(T::DbWeight::get().reads(5_u64))137			.saturating_add(T::DbWeight::get().reads(5_u64))
142			.saturating_add(T::DbWeight::get().writes(5_u64))138			.saturating_add(T::DbWeight::get().writes(5_u64))
143	}139	}
144	/// Storage: Nonfungible TokenChildren (r:1 w:0)
145	/// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
146	/// Storage: Nonfungible TokenData (r:1 w:1)
147	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
148	/// Storage: Nonfungible TokensBurnt (r:1 w:1)
149	/// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
150	/// Storage: Nonfungible AccountBalance (r:1 w:1)
151	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
152	/// Storage: Nonfungible Allowance (r:1 w:0)
153	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
154	/// Storage: Nonfungible Owned (r:0 w:1)
155	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
156	/// Storage: Nonfungible TokenProperties (r:0 w:1)
157	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
158	fn burn_recursively_self_raw() -> Weight {
159		// Proof Size summary in bytes:
160		//  Measured:  `380`
161		//  Estimated: `3530`
162		// Minimum execution time: 22_942_000 picoseconds.
163		Weight::from_parts(23_527_000, 3530)
164			.saturating_add(T::DbWeight::get().reads(5_u64))
165			.saturating_add(T::DbWeight::get().writes(5_u64))
166	}
167	/// Storage: Nonfungible TokenChildren (r:401 w:200)
168	/// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
169	/// Storage: Common CollectionById (r:1 w:0)
170	/// Proof: Common CollectionById (max_values: None, max_size: Some(860), added: 3335, mode: MaxEncodedLen)
171	/// Storage: Nonfungible TokenData (r:201 w:201)
172	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
173	/// Storage: Nonfungible TokensBurnt (r:1 w:1)
174	/// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
175	/// Storage: Nonfungible AccountBalance (r:2 w:2)
176	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
177	/// Storage: Nonfungible Allowance (r:201 w:0)
178	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
179	/// Storage: Nonfungible Owned (r:0 w:201)
180	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
181	/// Storage: Nonfungible TokenProperties (r:0 w:201)
182	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
183	/// The range of component `b` is `[0, 200]`.
184	fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight {
185		// Proof Size summary in bytes:
186		//  Measured:  `1500 + b * (58 ±0)`
187		//  Estimated: `5874 + b * (5032 ±0)`
188		// Minimum execution time: 22_709_000 picoseconds.
189		Weight::from_parts(23_287_000, 5874)
190			// Standard Error: 89_471
191			.saturating_add(Weight::from_parts(63_285_201, 0).saturating_mul(b.into()))
192			.saturating_add(T::DbWeight::get().reads(7_u64))
193			.saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(b.into())))
194			.saturating_add(T::DbWeight::get().writes(6_u64))
195			.saturating_add(T::DbWeight::get().writes((4_u64).saturating_mul(b.into())))
196			.saturating_add(Weight::from_parts(0, 5032).saturating_mul(b.into()))
197	}
198	/// Storage: Nonfungible TokenData (r:1 w:1)140	/// Storage: `Nonfungible::TokenData` (r:1 w:1)
199	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)141	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
200	/// Storage: Nonfungible AccountBalance (r:2 w:2)142	/// Storage: `Nonfungible::AccountBalance` (r:2 w:2)
201	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)143	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
202	/// Storage: Nonfungible Allowance (r:1 w:0)144	/// Storage: `Nonfungible::Allowance` (r:1 w:0)
203	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)145	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
204	/// Storage: Nonfungible Owned (r:0 w:2)146	/// Storage: `Nonfungible::Owned` (r:0 w:2)
205	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)147	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
206	fn transfer_raw() -> Weight {148	fn transfer_raw() -> Weight {
207		// Proof Size summary in bytes:149		// Proof Size summary in bytes:
208		//  Measured:  `380`150		//  Measured:  `380`
209		//  Estimated: `6070`151		//  Estimated: `6070`
210		// Minimum execution time: 13_652_000 picoseconds.152		// Minimum execution time: 22_710_000 picoseconds.
211		Weight::from_parts(13_981_000, 6070)153		Weight::from_parts(23_130_000, 6070)
212			.saturating_add(T::DbWeight::get().reads(4_u64))154			.saturating_add(T::DbWeight::get().reads(4_u64))
213			.saturating_add(T::DbWeight::get().writes(5_u64))155			.saturating_add(T::DbWeight::get().writes(5_u64))
214	}156	}
215	/// Storage: Nonfungible TokenData (r:1 w:0)157	/// Storage: `Nonfungible::TokenData` (r:1 w:0)
216	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)158	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
217	/// Storage: Nonfungible Allowance (r:1 w:1)159	/// Storage: `Nonfungible::Allowance` (r:1 w:1)
218	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)160	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
219	fn approve() -> Weight {161	fn approve() -> Weight {
220		// Proof Size summary in bytes:162		// Proof Size summary in bytes:
221		//  Measured:  `326`163		//  Measured:  `326`
222		//  Estimated: `3522`164		//  Estimated: `3522`
223		// Minimum execution time: 7_837_000 picoseconds.165		// Minimum execution time: 11_520_000 picoseconds.
224		Weight::from_parts(8_113_000, 3522)166		Weight::from_parts(12_030_000, 3522)
225			.saturating_add(T::DbWeight::get().reads(2_u64))167			.saturating_add(T::DbWeight::get().reads(2_u64))
226			.saturating_add(T::DbWeight::get().writes(1_u64))168			.saturating_add(T::DbWeight::get().writes(1_u64))
227	}169	}
228	/// Storage: Nonfungible TokenData (r:1 w:0)170	/// Storage: `Nonfungible::TokenData` (r:1 w:0)
229	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)171	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
230	/// Storage: Nonfungible Allowance (r:1 w:1)172	/// Storage: `Nonfungible::Allowance` (r:1 w:1)
231	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)173	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
232	fn approve_from() -> Weight {174	fn approve_from() -> Weight {
233		// Proof Size summary in bytes:175		// Proof Size summary in bytes:
234		//  Measured:  `313`176		//  Measured:  `313`
235		//  Estimated: `3522`177		//  Estimated: `3522`
236		// Minimum execution time: 7_769_000 picoseconds.178		// Minimum execution time: 11_570_000 picoseconds.
237		Weight::from_parts(7_979_000, 3522)179		Weight::from_parts(12_139_000, 3522)
238			.saturating_add(T::DbWeight::get().reads(2_u64))180			.saturating_add(T::DbWeight::get().reads(2_u64))
239			.saturating_add(T::DbWeight::get().writes(1_u64))181			.saturating_add(T::DbWeight::get().writes(1_u64))
240	}182	}
241	/// Storage: Nonfungible Allowance (r:1 w:0)183	/// Storage: `Nonfungible::Allowance` (r:1 w:0)
242	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)184	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
243	fn check_allowed_raw() -> Weight {185	fn check_allowed_raw() -> Weight {
244		// Proof Size summary in bytes:186		// Proof Size summary in bytes:
245		//  Measured:  `362`187		//  Measured:  `362`
246		//  Estimated: `3522`188		//  Estimated: `3522`
247		// Minimum execution time: 4_194_000 picoseconds.189		// Minimum execution time: 4_210_000 picoseconds.
248		Weight::from_parts(4_353_000, 3522)190		Weight::from_parts(4_350_000, 3522)
249			.saturating_add(T::DbWeight::get().reads(1_u64))191			.saturating_add(T::DbWeight::get().reads(1_u64))
250	}192	}
251	/// Storage: Nonfungible Allowance (r:1 w:1)193	/// Storage: `Nonfungible::Allowance` (r:1 w:1)
252	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)194	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
253	/// Storage: Nonfungible TokenData (r:1 w:1)195	/// Storage: `Nonfungible::TokenData` (r:1 w:1)
254	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)196	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
255	/// Storage: Nonfungible TokenChildren (r:1 w:0)197	/// Storage: `Nonfungible::TokenChildren` (r:1 w:0)
256	/// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)198	/// Proof: `Nonfungible::TokenChildren` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`)
257	/// Storage: Nonfungible TokensBurnt (r:1 w:1)199	/// Storage: `Nonfungible::TokensBurnt` (r:1 w:1)
258	/// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)200	/// Proof: `Nonfungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
259	/// Storage: Nonfungible AccountBalance (r:1 w:1)201	/// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
260	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)202	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
261	/// Storage: Nonfungible Owned (r:0 w:1)203	/// Storage: `Nonfungible::Owned` (r:0 w:1)
262	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)204	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
263	/// Storage: Nonfungible TokenProperties (r:0 w:1)205	/// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
264	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)206	/// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
265	fn burn_from() -> Weight {207	fn burn_from() -> Weight {
266		// Proof Size summary in bytes:208		// Proof Size summary in bytes:
267		//  Measured:  `463`209		//  Measured:  `463`
268		//  Estimated: `3530`210		//  Estimated: `3530`
269		// Minimum execution time: 21_978_000 picoseconds.211		// Minimum execution time: 32_230_000 picoseconds.
270		Weight::from_parts(22_519_000, 3530)212		Weight::from_parts(33_210_000, 3530)
271			.saturating_add(T::DbWeight::get().reads(5_u64))213			.saturating_add(T::DbWeight::get().reads(5_u64))
272			.saturating_add(T::DbWeight::get().writes(6_u64))214			.saturating_add(T::DbWeight::get().writes(6_u64))
273	}215	}
274	/// Storage: Common CollectionPropertyPermissions (r:1 w:1)
275	/// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
276	/// The range of component `b` is `[0, 64]`.
277	fn set_token_property_permissions(b: u32, ) -> Weight {
278		// Proof Size summary in bytes:
279		//  Measured:  `314`
280		//  Estimated: `20191`
281		// Minimum execution time: 1_457_000 picoseconds.
282		Weight::from_parts(1_563_000, 20191)
283			// Standard Error: 14_041
284			.saturating_add(Weight::from_parts(8_452_415, 0).saturating_mul(b.into()))
285			.saturating_add(T::DbWeight::get().reads(1_u64))
286			.saturating_add(T::DbWeight::get().writes(1_u64))
287	}
288	/// Storage: Common CollectionPropertyPermissions (r:1 w:0)
289	/// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
290	/// Storage: Nonfungible TokenProperties (r:1 w:1)216	/// Storage: `Nonfungible::TokenProperties` (r:1 w:0)
291	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)217	/// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
292	/// Storage: Nonfungible TokenData (r:1 w:0)
293	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
294	/// The range of component `b` is `[0, 64]`.
295	fn set_token_properties(b: u32, ) -> Weight {218	fn load_token_properties() -> Weight {
296		// Proof Size summary in bytes:219		// Proof Size summary in bytes:
297		//  Measured:  `640 + b * (261 ±0)`220		//  Measured:  `279`
298		//  Estimated: `36269`221		//  Estimated: `36269`
299		// Minimum execution time: 963_000 picoseconds.222		// Minimum execution time: 3_180_000 picoseconds.
300		Weight::from_parts(1_126_511, 36269)223		Weight::from_parts(3_370_000, 36269)
301			// Standard Error: 9_175
302			.saturating_add(Weight::from_parts(5_096_011, 0).saturating_mul(b.into()))
303			.saturating_add(T::DbWeight::get().reads(3_u64))
304			.saturating_add(T::DbWeight::get().writes(1_u64))224			.saturating_add(T::DbWeight::get().reads(1_u64))
305	}225	}
306	/// Storage: Nonfungible TokenProperties (r:0 w:1)226	/// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
307	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)227	/// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
308	/// The range of component `b` is `[0, 64]`.228	/// The range of component `b` is `[0, 64]`.
309	fn init_token_properties(b: u32, ) -> Weight {229	fn write_token_properties(b: u32, ) -> Weight {
310		// Proof Size summary in bytes:230		// Proof Size summary in bytes:
311		//  Measured:  `0`231		//  Measured:  `0`
312		//  Estimated: `0`232		//  Estimated: `0`
313		// Minimum execution time: 194_000 picoseconds.233		// Minimum execution time: 440_000 picoseconds.
314		Weight::from_parts(222_000, 0)234		Weight::from_parts(3_567_990, 0)
315			// Standard Error: 7_295235			// Standard Error: 24_013
316			.saturating_add(Weight::from_parts(4_499_463, 0).saturating_mul(b.into()))236			.saturating_add(Weight::from_parts(19_386_123, 0).saturating_mul(b.into()))
317			.saturating_add(T::DbWeight::get().writes(1_u64))237			.saturating_add(T::DbWeight::get().writes(1_u64))
318	}238	}
319	/// Storage: Common CollectionPropertyPermissions (r:1 w:0)239	/// Storage: `Common::CollectionPropertyPermissions` (r:1 w:1)
320	/// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)240	/// Proof: `Common::CollectionPropertyPermissions` (`max_values`: None, `max_size`: Some(16726), added: 19201, mode: `MaxEncodedLen`)
321	/// Storage: Nonfungible TokenData (r:1 w:0)
322	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
323	/// Storage: Nonfungible TokenProperties (r:1 w:1)
324	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
325	/// The range of component `b` is `[0, 64]`.241	/// The range of component `b` is `[0, 64]`.
326	fn delete_token_properties(b: u32, ) -> Weight {242	fn set_token_property_permissions(b: u32, ) -> Weight {
327		// Proof Size summary in bytes:243		// Proof Size summary in bytes:
328		//  Measured:  `699 + b * (33291 ±0)`244		//  Measured:  `314`
329		//  Estimated: `36269`245		//  Estimated: `20191`
330		// Minimum execution time: 992_000 picoseconds.246		// Minimum execution time: 1_460_000 picoseconds.
331		Weight::from_parts(1_043_000, 36269)247		Weight::from_parts(1_530_000, 20191)
332			// Standard Error: 37_370248			// Standard Error: 124_929
333			.saturating_add(Weight::from_parts(23_672_870, 0).saturating_mul(b.into()))249			.saturating_add(Weight::from_parts(28_397_581, 0).saturating_mul(b.into()))
334			.saturating_add(T::DbWeight::get().reads(3_u64))250			.saturating_add(T::DbWeight::get().reads(1_u64))
335			.saturating_add(T::DbWeight::get().writes(1_u64))251			.saturating_add(T::DbWeight::get().writes(1_u64))
336	}252	}
337	/// Storage: Nonfungible TokenData (r:1 w:0)
338	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
339	fn token_owner() -> Weight {
340		// Proof Size summary in bytes:
341		//  Measured:  `326`
342		//  Estimated: `3522`
343		// Minimum execution time: 3_743_000 picoseconds.
344		Weight::from_parts(3_908_000, 3522)
345			.saturating_add(T::DbWeight::get().reads(1_u64))
346	}
347	/// Storage: Nonfungible CollectionAllowance (r:0 w:1)253	/// Storage: `Nonfungible::CollectionAllowance` (r:0 w:1)
348	/// Proof: Nonfungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)254	/// Proof: `Nonfungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
349	fn set_allowance_for_all() -> Weight {255	fn set_allowance_for_all() -> Weight {
350		// Proof Size summary in bytes:256		// Proof Size summary in bytes:
351		//  Measured:  `0`257		//  Measured:  `0`
352		//  Estimated: `0`258		//  Estimated: `0`
353		// Minimum execution time: 4_106_000 picoseconds.259		// Minimum execution time: 6_840_000 picoseconds.
354		Weight::from_parts(4_293_000, 0)260		Weight::from_parts(7_160_000, 0)
355			.saturating_add(T::DbWeight::get().writes(1_u64))261			.saturating_add(T::DbWeight::get().writes(1_u64))
356	}262	}
357	/// Storage: Nonfungible CollectionAllowance (r:1 w:0)263	/// Storage: `Nonfungible::CollectionAllowance` (r:1 w:0)
358	/// Proof: Nonfungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)264	/// Proof: `Nonfungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
359	fn allowance_for_all() -> Weight {265	fn allowance_for_all() -> Weight {
360		// Proof Size summary in bytes:266		// Proof Size summary in bytes:
361		//  Measured:  `142`267		//  Measured:  `142`
362		//  Estimated: `3576`268		//  Estimated: `3576`
363		// Minimum execution time: 2_775_000 picoseconds.269		// Minimum execution time: 3_630_000 picoseconds.
364		Weight::from_parts(2_923_000, 3576)270		Weight::from_parts(3_780_000, 3576)
365			.saturating_add(T::DbWeight::get().reads(1_u64))271			.saturating_add(T::DbWeight::get().reads(1_u64))
366	}272	}
367	/// Storage: Nonfungible TokenProperties (r:1 w:1)273	/// Storage: `Nonfungible::TokenProperties` (r:1 w:1)
368	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)274	/// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
369	fn repair_item() -> Weight {275	fn repair_item() -> Weight {
370		// Proof Size summary in bytes:276		// Proof Size summary in bytes:
371		//  Measured:  `279`277		//  Measured:  `279`
372		//  Estimated: `36269`278		//  Estimated: `36269`
373		// Minimum execution time: 3_033_000 picoseconds.279		// Minimum execution time: 3_280_000 picoseconds.
374		Weight::from_parts(3_174_000, 36269)280		Weight::from_parts(3_480_000, 36269)
375			.saturating_add(T::DbWeight::get().reads(1_u64))281			.saturating_add(T::DbWeight::get().reads(1_u64))
376			.saturating_add(T::DbWeight::get().writes(1_u64))282			.saturating_add(T::DbWeight::get().writes(1_u64))
377	}283	}
378}284}
379285
380// For backwards compatibility and tests286// For backwards compatibility and tests
381impl WeightInfo for () {287impl WeightInfo for () {
382	/// Storage: Nonfungible TokensMinted (r:1 w:1)288	/// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
383	/// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)289	/// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
384	/// Storage: Nonfungible AccountBalance (r:1 w:1)290	/// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
385	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)291	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
386	/// Storage: Nonfungible TokenData (r:0 w:1)292	/// Storage: `Nonfungible::TokenData` (r:0 w:1)
387	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)293	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
388	/// Storage: Nonfungible Owned (r:0 w:1)294	/// Storage: `Nonfungible::Owned` (r:0 w:1)
389	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)295	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
390	fn create_item() -> Weight {296	fn create_item() -> Weight {
391		// Proof Size summary in bytes:297		// Proof Size summary in bytes:
392		//  Measured:  `142`298		//  Measured:  `142`
393		//  Estimated: `3530`299		//  Estimated: `3530`
394		// Minimum execution time: 9_726_000 picoseconds.300		// Minimum execution time: 15_410_000 picoseconds.
395		Weight::from_parts(10_059_000, 3530)301		Weight::from_parts(15_850_000, 3530)
396			.saturating_add(RocksDbWeight::get().reads(2_u64))302			.saturating_add(RocksDbWeight::get().reads(2_u64))
397			.saturating_add(RocksDbWeight::get().writes(4_u64))303			.saturating_add(RocksDbWeight::get().writes(4_u64))
398	}304	}
399	/// Storage: Nonfungible TokensMinted (r:1 w:1)305	/// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
400	/// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)306	/// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
401	/// Storage: Nonfungible AccountBalance (r:1 w:1)307	/// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
402	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)308	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
403	/// Storage: Nonfungible TokenData (r:0 w:200)309	/// Storage: `Nonfungible::TokenData` (r:0 w:200)
404	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)310	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
405	/// Storage: Nonfungible Owned (r:0 w:200)311	/// Storage: `Nonfungible::Owned` (r:0 w:200)
406	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)312	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
407	/// The range of component `b` is `[0, 200]`.313	/// The range of component `b` is `[0, 200]`.
408	fn create_multiple_items(b: u32, ) -> Weight {314	fn create_multiple_items(b: u32, ) -> Weight {
409		// Proof Size summary in bytes:315		// Proof Size summary in bytes:
410		//  Measured:  `142`316		//  Measured:  `142`
411		//  Estimated: `3530`317		//  Estimated: `3530`
412		// Minimum execution time: 3_270_000 picoseconds.318		// Minimum execution time: 3_300_000 picoseconds.
413		Weight::from_parts(3_693_659, 3530)319		Weight::from_parts(5_992_994, 3530)
414			// Standard Error: 255320			// Standard Error: 4_478
415			.saturating_add(Weight::from_parts(3_024_284, 0).saturating_mul(b.into()))321			.saturating_add(Weight::from_parts(8_002_092, 0).saturating_mul(b.into()))
416			.saturating_add(RocksDbWeight::get().reads(2_u64))322			.saturating_add(RocksDbWeight::get().reads(2_u64))
417			.saturating_add(RocksDbWeight::get().writes(2_u64))323			.saturating_add(RocksDbWeight::get().writes(2_u64))
418			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(b.into())))324			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(b.into())))
419	}325	}
420	/// Storage: Nonfungible TokensMinted (r:1 w:1)326	/// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
421	/// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)327	/// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
422	/// Storage: Nonfungible AccountBalance (r:200 w:200)328	/// Storage: `Nonfungible::AccountBalance` (r:200 w:200)
423	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)329	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
424	/// Storage: Nonfungible TokenData (r:0 w:200)330	/// Storage: `Nonfungible::TokenData` (r:0 w:200)
425	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)331	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
426	/// Storage: Nonfungible Owned (r:0 w:200)332	/// Storage: `Nonfungible::Owned` (r:0 w:200)
427	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)333	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
428	/// The range of component `b` is `[0, 200]`.334	/// The range of component `b` is `[0, 200]`.
429	fn create_multiple_items_ex(b: u32, ) -> Weight {335	fn create_multiple_items_ex(b: u32, ) -> Weight {
430		// Proof Size summary in bytes:336		// Proof Size summary in bytes:
431		//  Measured:  `142`337		//  Measured:  `142`
432		//  Estimated: `3481 + b * (2540 ±0)`338		//  Estimated: `3481 + b * (2540 ±0)`
433		// Minimum execution time: 3_188_000 picoseconds.339		// Minimum execution time: 3_300_000 picoseconds.
434		Weight::from_parts(3_307_000, 3481)340		Weight::from_parts(3_980_000, 3481)
435			// Standard Error: 567341			// Standard Error: 1_382
436			.saturating_add(Weight::from_parts(4_320_449, 0).saturating_mul(b.into()))342			.saturating_add(Weight::from_parts(11_259_286, 0).saturating_mul(b.into()))
437			.saturating_add(RocksDbWeight::get().reads(1_u64))343			.saturating_add(RocksDbWeight::get().reads(1_u64))
438			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(b.into())))344			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(b.into())))
439			.saturating_add(RocksDbWeight::get().writes(1_u64))345			.saturating_add(RocksDbWeight::get().writes(1_u64))
440			.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(b.into())))346			.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(b.into())))
441			.saturating_add(Weight::from_parts(0, 2540).saturating_mul(b.into()))347			.saturating_add(Weight::from_parts(0, 2540).saturating_mul(b.into()))
442	}348	}
443	/// Storage: Nonfungible TokenData (r:1 w:1)349	/// Storage: `Nonfungible::TokenData` (r:1 w:1)
444	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)350	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
445	/// Storage: Nonfungible TokenChildren (r:1 w:0)351	/// Storage: `Nonfungible::TokenChildren` (r:1 w:0)
446	/// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)352	/// Proof: `Nonfungible::TokenChildren` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`)
447	/// Storage: Nonfungible TokensBurnt (r:1 w:1)353	/// Storage: `Nonfungible::TokensBurnt` (r:1 w:1)
448	/// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)354	/// Proof: `Nonfungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
449	/// Storage: Nonfungible AccountBalance (r:1 w:1)355	/// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
450	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)356	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
451	/// Storage: Nonfungible Allowance (r:1 w:0)357	/// Storage: `Nonfungible::Allowance` (r:1 w:0)
452	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)358	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
453	/// Storage: Nonfungible Owned (r:0 w:1)359	/// Storage: `Nonfungible::Owned` (r:0 w:1)
454	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)360	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
455	/// Storage: Nonfungible TokenProperties (r:0 w:1)361	/// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
456	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)362	/// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
457	fn burn_item() -> Weight {363	fn burn_item() -> Weight {
458		// Proof Size summary in bytes:364		// Proof Size summary in bytes:
459		//  Measured:  `380`365		//  Measured:  `380`
460		//  Estimated: `3530`366		//  Estimated: `3530`
461		// Minimum execution time: 18_062_000 picoseconds.367		// Minimum execution time: 26_360_000 picoseconds.
462		Weight::from_parts(18_433_000, 3530)368		Weight::from_parts(26_850_000, 3530)
463			.saturating_add(RocksDbWeight::get().reads(5_u64))369			.saturating_add(RocksDbWeight::get().reads(5_u64))
464			.saturating_add(RocksDbWeight::get().writes(5_u64))370			.saturating_add(RocksDbWeight::get().writes(5_u64))
465	}371	}
466	/// Storage: Nonfungible TokenChildren (r:1 w:0)
467	/// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
468	/// Storage: Nonfungible TokenData (r:1 w:1)
469	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
470	/// Storage: Nonfungible TokensBurnt (r:1 w:1)
471	/// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
472	/// Storage: Nonfungible AccountBalance (r:1 w:1)
473	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
474	/// Storage: Nonfungible Allowance (r:1 w:0)
475	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
476	/// Storage: Nonfungible Owned (r:0 w:1)
477	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
478	/// Storage: Nonfungible TokenProperties (r:0 w:1)
479	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
480	fn burn_recursively_self_raw() -> Weight {
481		// Proof Size summary in bytes:
482		//  Measured:  `380`
483		//  Estimated: `3530`
484		// Minimum execution time: 22_942_000 picoseconds.
485		Weight::from_parts(23_527_000, 3530)
486			.saturating_add(RocksDbWeight::get().reads(5_u64))
487			.saturating_add(RocksDbWeight::get().writes(5_u64))
488	}
489	/// Storage: Nonfungible TokenChildren (r:401 w:200)
490	/// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
491	/// Storage: Common CollectionById (r:1 w:0)
492	/// Proof: Common CollectionById (max_values: None, max_size: Some(860), added: 3335, mode: MaxEncodedLen)
493	/// Storage: Nonfungible TokenData (r:201 w:201)
494	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
495	/// Storage: Nonfungible TokensBurnt (r:1 w:1)
496	/// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
497	/// Storage: Nonfungible AccountBalance (r:2 w:2)
498	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
499	/// Storage: Nonfungible Allowance (r:201 w:0)
500	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
501	/// Storage: Nonfungible Owned (r:0 w:201)
502	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
503	/// Storage: Nonfungible TokenProperties (r:0 w:201)
504	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
505	/// The range of component `b` is `[0, 200]`.
506	fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight {
507		// Proof Size summary in bytes:
508		//  Measured:  `1500 + b * (58 ±0)`
509		//  Estimated: `5874 + b * (5032 ±0)`
510		// Minimum execution time: 22_709_000 picoseconds.
511		Weight::from_parts(23_287_000, 5874)
512			// Standard Error: 89_471
513			.saturating_add(Weight::from_parts(63_285_201, 0).saturating_mul(b.into()))
514			.saturating_add(RocksDbWeight::get().reads(7_u64))
515			.saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(b.into())))
516			.saturating_add(RocksDbWeight::get().writes(6_u64))
517			.saturating_add(RocksDbWeight::get().writes((4_u64).saturating_mul(b.into())))
518			.saturating_add(Weight::from_parts(0, 5032).saturating_mul(b.into()))
519	}
520	/// Storage: Nonfungible TokenData (r:1 w:1)372	/// Storage: `Nonfungible::TokenData` (r:1 w:1)
521	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)373	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
522	/// Storage: Nonfungible AccountBalance (r:2 w:2)374	/// Storage: `Nonfungible::AccountBalance` (r:2 w:2)
523	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)375	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
524	/// Storage: Nonfungible Allowance (r:1 w:0)376	/// Storage: `Nonfungible::Allowance` (r:1 w:0)
525	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)377	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
526	/// Storage: Nonfungible Owned (r:0 w:2)378	/// Storage: `Nonfungible::Owned` (r:0 w:2)
527	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)379	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
528	fn transfer_raw() -> Weight {380	fn transfer_raw() -> Weight {
529		// Proof Size summary in bytes:381		// Proof Size summary in bytes:
530		//  Measured:  `380`382		//  Measured:  `380`
531		//  Estimated: `6070`383		//  Estimated: `6070`
532		// Minimum execution time: 13_652_000 picoseconds.384		// Minimum execution time: 22_710_000 picoseconds.
533		Weight::from_parts(13_981_000, 6070)385		Weight::from_parts(23_130_000, 6070)
534			.saturating_add(RocksDbWeight::get().reads(4_u64))386			.saturating_add(RocksDbWeight::get().reads(4_u64))
535			.saturating_add(RocksDbWeight::get().writes(5_u64))387			.saturating_add(RocksDbWeight::get().writes(5_u64))
536	}388	}
537	/// Storage: Nonfungible TokenData (r:1 w:0)389	/// Storage: `Nonfungible::TokenData` (r:1 w:0)
538	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)390	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
539	/// Storage: Nonfungible Allowance (r:1 w:1)391	/// Storage: `Nonfungible::Allowance` (r:1 w:1)
540	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)392	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
541	fn approve() -> Weight {393	fn approve() -> Weight {
542		// Proof Size summary in bytes:394		// Proof Size summary in bytes:
543		//  Measured:  `326`395		//  Measured:  `326`
544		//  Estimated: `3522`396		//  Estimated: `3522`
545		// Minimum execution time: 7_837_000 picoseconds.397		// Minimum execution time: 11_520_000 picoseconds.
546		Weight::from_parts(8_113_000, 3522)398		Weight::from_parts(12_030_000, 3522)
547			.saturating_add(RocksDbWeight::get().reads(2_u64))399			.saturating_add(RocksDbWeight::get().reads(2_u64))
548			.saturating_add(RocksDbWeight::get().writes(1_u64))400			.saturating_add(RocksDbWeight::get().writes(1_u64))
549	}401	}
550	/// Storage: Nonfungible TokenData (r:1 w:0)402	/// Storage: `Nonfungible::TokenData` (r:1 w:0)
551	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)403	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
552	/// Storage: Nonfungible Allowance (r:1 w:1)404	/// Storage: `Nonfungible::Allowance` (r:1 w:1)
553	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)405	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
554	fn approve_from() -> Weight {406	fn approve_from() -> Weight {
555		// Proof Size summary in bytes:407		// Proof Size summary in bytes:
556		//  Measured:  `313`408		//  Measured:  `313`
557		//  Estimated: `3522`409		//  Estimated: `3522`
558		// Minimum execution time: 7_769_000 picoseconds.410		// Minimum execution time: 11_570_000 picoseconds.
559		Weight::from_parts(7_979_000, 3522)411		Weight::from_parts(12_139_000, 3522)
560			.saturating_add(RocksDbWeight::get().reads(2_u64))412			.saturating_add(RocksDbWeight::get().reads(2_u64))
561			.saturating_add(RocksDbWeight::get().writes(1_u64))413			.saturating_add(RocksDbWeight::get().writes(1_u64))
562	}414	}
563	/// Storage: Nonfungible Allowance (r:1 w:0)415	/// Storage: `Nonfungible::Allowance` (r:1 w:0)
564	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)416	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
565	fn check_allowed_raw() -> Weight {417	fn check_allowed_raw() -> Weight {
566		// Proof Size summary in bytes:418		// Proof Size summary in bytes:
567		//  Measured:  `362`419		//  Measured:  `362`
568		//  Estimated: `3522`420		//  Estimated: `3522`
569		// Minimum execution time: 4_194_000 picoseconds.421		// Minimum execution time: 4_210_000 picoseconds.
570		Weight::from_parts(4_353_000, 3522)422		Weight::from_parts(4_350_000, 3522)
571			.saturating_add(RocksDbWeight::get().reads(1_u64))423			.saturating_add(RocksDbWeight::get().reads(1_u64))
572	}424	}
573	/// Storage: Nonfungible Allowance (r:1 w:1)425	/// Storage: `Nonfungible::Allowance` (r:1 w:1)
574	/// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)426	/// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
575	/// Storage: Nonfungible TokenData (r:1 w:1)427	/// Storage: `Nonfungible::TokenData` (r:1 w:1)
576	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)428	/// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
577	/// Storage: Nonfungible TokenChildren (r:1 w:0)429	/// Storage: `Nonfungible::TokenChildren` (r:1 w:0)
578	/// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)430	/// Proof: `Nonfungible::TokenChildren` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`)
579	/// Storage: Nonfungible TokensBurnt (r:1 w:1)431	/// Storage: `Nonfungible::TokensBurnt` (r:1 w:1)
580	/// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)432	/// Proof: `Nonfungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
581	/// Storage: Nonfungible AccountBalance (r:1 w:1)433	/// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
582	/// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)434	/// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
583	/// Storage: Nonfungible Owned (r:0 w:1)435	/// Storage: `Nonfungible::Owned` (r:0 w:1)
584	/// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)436	/// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
585	/// Storage: Nonfungible TokenProperties (r:0 w:1)437	/// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
586	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)438	/// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
587	fn burn_from() -> Weight {439	fn burn_from() -> Weight {
588		// Proof Size summary in bytes:440		// Proof Size summary in bytes:
589		//  Measured:  `463`441		//  Measured:  `463`
590		//  Estimated: `3530`442		//  Estimated: `3530`
591		// Minimum execution time: 21_978_000 picoseconds.443		// Minimum execution time: 32_230_000 picoseconds.
592		Weight::from_parts(22_519_000, 3530)444		Weight::from_parts(33_210_000, 3530)
593			.saturating_add(RocksDbWeight::get().reads(5_u64))445			.saturating_add(RocksDbWeight::get().reads(5_u64))
594			.saturating_add(RocksDbWeight::get().writes(6_u64))446			.saturating_add(RocksDbWeight::get().writes(6_u64))
595	}447	}
596	/// Storage: Common CollectionPropertyPermissions (r:1 w:1)
597	/// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
598	/// The range of component `b` is `[0, 64]`.
599	fn set_token_property_permissions(b: u32, ) -> Weight {
600		// Proof Size summary in bytes:
601		//  Measured:  `314`
602		//  Estimated: `20191`
603		// Minimum execution time: 1_457_000 picoseconds.
604		Weight::from_parts(1_563_000, 20191)
605			// Standard Error: 14_041
606			.saturating_add(Weight::from_parts(8_452_415, 0).saturating_mul(b.into()))
607			.saturating_add(RocksDbWeight::get().reads(1_u64))
608			.saturating_add(RocksDbWeight::get().writes(1_u64))
609	}
610	/// Storage: Common CollectionPropertyPermissions (r:1 w:0)
611	/// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
612	/// Storage: Nonfungible TokenProperties (r:1 w:1)448	/// Storage: `Nonfungible::TokenProperties` (r:1 w:0)
613	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)449	/// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
614	/// Storage: Nonfungible TokenData (r:1 w:0)
615	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
616	/// The range of component `b` is `[0, 64]`.
617	fn set_token_properties(b: u32, ) -> Weight {450	fn load_token_properties() -> Weight {
618		// Proof Size summary in bytes:451		// Proof Size summary in bytes:
619		//  Measured:  `640 + b * (261 ±0)`452		//  Measured:  `279`
620		//  Estimated: `36269`453		//  Estimated: `36269`
621		// Minimum execution time: 963_000 picoseconds.454		// Minimum execution time: 3_180_000 picoseconds.
622		Weight::from_parts(1_126_511, 36269)455		Weight::from_parts(3_370_000, 36269)
623			// Standard Error: 9_175
624			.saturating_add(Weight::from_parts(5_096_011, 0).saturating_mul(b.into()))
625			.saturating_add(RocksDbWeight::get().reads(3_u64))
626			.saturating_add(RocksDbWeight::get().writes(1_u64))456			.saturating_add(RocksDbWeight::get().reads(1_u64))
627	}457	}
628	/// Storage: Nonfungible TokenProperties (r:0 w:1)458	/// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
629	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)459	/// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
630	/// The range of component `b` is `[0, 64]`.460	/// The range of component `b` is `[0, 64]`.
631	fn init_token_properties(b: u32, ) -> Weight {461	fn write_token_properties(b: u32, ) -> Weight {
632		// Proof Size summary in bytes:462		// Proof Size summary in bytes:
633		//  Measured:  `0`463		//  Measured:  `0`
634		//  Estimated: `0`464		//  Estimated: `0`
635		// Minimum execution time: 194_000 picoseconds.465		// Minimum execution time: 440_000 picoseconds.
636		Weight::from_parts(222_000, 0)466		Weight::from_parts(3_567_990, 0)
637			// Standard Error: 7_295467			// Standard Error: 24_013
638			.saturating_add(Weight::from_parts(4_499_463, 0).saturating_mul(b.into()))468			.saturating_add(Weight::from_parts(19_386_123, 0).saturating_mul(b.into()))
639			.saturating_add(RocksDbWeight::get().writes(1_u64))469			.saturating_add(RocksDbWeight::get().writes(1_u64))
640	}470	}
641	/// Storage: Common CollectionPropertyPermissions (r:1 w:0)471	/// Storage: `Common::CollectionPropertyPermissions` (r:1 w:1)
642	/// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)472	/// Proof: `Common::CollectionPropertyPermissions` (`max_values`: None, `max_size`: Some(16726), added: 19201, mode: `MaxEncodedLen`)
643	/// Storage: Nonfungible TokenData (r:1 w:0)
644	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
645	/// Storage: Nonfungible TokenProperties (r:1 w:1)
646	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
647	/// The range of component `b` is `[0, 64]`.473	/// The range of component `b` is `[0, 64]`.
648	fn delete_token_properties(b: u32, ) -> Weight {474	fn set_token_property_permissions(b: u32, ) -> Weight {
649		// Proof Size summary in bytes:475		// Proof Size summary in bytes:
650		//  Measured:  `699 + b * (33291 ±0)`476		//  Measured:  `314`
651		//  Estimated: `36269`477		//  Estimated: `20191`
652		// Minimum execution time: 992_000 picoseconds.478		// Minimum execution time: 1_460_000 picoseconds.
653		Weight::from_parts(1_043_000, 36269)479		Weight::from_parts(1_530_000, 20191)
654			// Standard Error: 37_370480			// Standard Error: 124_929
655			.saturating_add(Weight::from_parts(23_672_870, 0).saturating_mul(b.into()))481			.saturating_add(Weight::from_parts(28_397_581, 0).saturating_mul(b.into()))
656			.saturating_add(RocksDbWeight::get().reads(3_u64))482			.saturating_add(RocksDbWeight::get().reads(1_u64))
657			.saturating_add(RocksDbWeight::get().writes(1_u64))483			.saturating_add(RocksDbWeight::get().writes(1_u64))
658	}484	}
659	/// Storage: Nonfungible TokenData (r:1 w:0)
660	/// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
661	fn token_owner() -> Weight {
662		// Proof Size summary in bytes:
663		//  Measured:  `326`
664		//  Estimated: `3522`
665		// Minimum execution time: 3_743_000 picoseconds.
666		Weight::from_parts(3_908_000, 3522)
667			.saturating_add(RocksDbWeight::get().reads(1_u64))
668	}
669	/// Storage: Nonfungible CollectionAllowance (r:0 w:1)485	/// Storage: `Nonfungible::CollectionAllowance` (r:0 w:1)
670	/// Proof: Nonfungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)486	/// Proof: `Nonfungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
671	fn set_allowance_for_all() -> Weight {487	fn set_allowance_for_all() -> Weight {
672		// Proof Size summary in bytes:488		// Proof Size summary in bytes:
673		//  Measured:  `0`489		//  Measured:  `0`
674		//  Estimated: `0`490		//  Estimated: `0`
675		// Minimum execution time: 4_106_000 picoseconds.491		// Minimum execution time: 6_840_000 picoseconds.
676		Weight::from_parts(4_293_000, 0)492		Weight::from_parts(7_160_000, 0)
677			.saturating_add(RocksDbWeight::get().writes(1_u64))493			.saturating_add(RocksDbWeight::get().writes(1_u64))
678	}494	}
679	/// Storage: Nonfungible CollectionAllowance (r:1 w:0)495	/// Storage: `Nonfungible::CollectionAllowance` (r:1 w:0)
680	/// Proof: Nonfungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)496	/// Proof: `Nonfungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
681	fn allowance_for_all() -> Weight {497	fn allowance_for_all() -> Weight {
682		// Proof Size summary in bytes:498		// Proof Size summary in bytes:
683		//  Measured:  `142`499		//  Measured:  `142`
684		//  Estimated: `3576`500		//  Estimated: `3576`
685		// Minimum execution time: 2_775_000 picoseconds.501		// Minimum execution time: 3_630_000 picoseconds.
686		Weight::from_parts(2_923_000, 3576)502		Weight::from_parts(3_780_000, 3576)
687			.saturating_add(RocksDbWeight::get().reads(1_u64))503			.saturating_add(RocksDbWeight::get().reads(1_u64))
688	}504	}
689	/// Storage: Nonfungible TokenProperties (r:1 w:1)505	/// Storage: `Nonfungible::TokenProperties` (r:1 w:1)
690	/// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)506	/// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
691	fn repair_item() -> Weight {507	fn repair_item() -> Weight {
692		// Proof Size summary in bytes:508		// Proof Size summary in bytes:
693		//  Measured:  `279`509		//  Measured:  `279`
694		//  Estimated: `36269`510		//  Estimated: `36269`
695		// Minimum execution time: 3_033_000 picoseconds.511		// Minimum execution time: 3_280_000 picoseconds.
696		Weight::from_parts(3_174_000, 36269)512		Weight::from_parts(3_480_000, 36269)
697			.saturating_add(RocksDbWeight::get().reads(1_u64))513			.saturating_add(RocksDbWeight::get().reads(1_u64))
698			.saturating_add(RocksDbWeight::get().writes(1_u64))514			.saturating_add(RocksDbWeight::get().writes(1_u64))
699	}515	}