git.delta.rocks / unique-network / refs/commits / 437764b749e7

--- 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
@@ -34,7 +34,7 @@
 	MAX_TOKEN_PREFIX_LENGTH,
 };
 
-use crate::{CollectionHandle, Config, Pallet};
+use crate::{BenchmarkPropertyWriter, CollectionHandle, Config, Pallet};
 
 const SEED: u32 = 1;
 
@@ -123,16 +123,6 @@
 		CollectionMode::NFT,
 		|owner: T::CrossAccountId, data| <Pallet<T>>::init_collection(owner.clone(), owner, data),
 		|h| h,
-	)
-}
-
-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),
 	)
 }
 
@@ -272,7 +262,7 @@
 
 		#[block]
 		{
-			load_is_admin_and_property_permissions(&collection, &sender);
+			<BenchmarkPropertyWriter<T>>::load_collection_info(&&collection, &sender);
 		}
 
 		Ok(())

--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -872,7 +872,7 @@
 }
 
 /// Value representation with delayed initialization time.
-pub struct LazyValue<T, F: FnOnce() -> T> {
+pub struct LazyValue<T, F> {
 	value: Option<T>,
 	f: Option<F>,
 }
@@ -1902,7 +1902,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 +1914,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.
 	///
@@ -1934,30 +1938,6 @@
 	/// 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 +2009,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.
@@ -2373,14 +2339,6 @@
 		}
 	}
 }
-
-/// 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.
@@ -2388,146 +2346,39 @@
 /// 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, FIsAdmin, FPropertyPermissions> {
 	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<FIsAdmin, FPropertyPermissions>,
 	_phantom: PhantomData<(T, WriterVariant)>,
 }
 
-impl<'a, T, Handle, FIsAdmin, FPropertyPermissions, FCheckTokenExist, FGetProperties>
-	PropertyWriter<
-		'a,
-		T,
-		Handle,
-		NewTokenPropertyWriter,
-		FIsAdmin,
-		FPropertyPermissions,
-		FCheckTokenExist,
-		FGetProperties,
-	> where
+impl<'a, T, Handle, WriterVariant, FIsAdmin, FPropertyPermissions>
+	PropertyWriter<'a, WriterVariant, T, Handle, FIsAdmin, FPropertyPermissions>
+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(
+	fn internal_write_token_properties<FCheckTokenExist, FCheckTokenOwner, FGetProperties>(
 		&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
-	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(
-		&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 {
-		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,
+		mut token_lazy_info: PropertyWriterLazyTokenInfo<
+			FCheckTokenExist,
+			FCheckTokenOwner,
+			FGetProperties,
+		>,
 		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>,
+		FCheckTokenExist: FnOnce() -> bool,
+		FCheckTokenOwner: FnOnce() -> Result<bool, DispatchError>,
+		FGetProperties: FnOnce() -> TokenProperties,
 	{
-		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 +2387,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());
 				}
@@ -2548,15 +2403,16 @@
 				} => 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 +2424,8 @@
 					));
 				}
 				None => {
-					stored_properties
+					token_lazy_info
+						.stored_properties
 						.value_mut()
 						.remove(&key)
 						.map_err(<Error<T>>::from)?;
@@ -2582,142 +2439,330 @@
 			}
 		}
 
-		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<FIsAdmin, FPropertyPermissions> {
+	is_collection_admin: LazyValue<bool, FIsAdmin>,
+	property_permissions: LazyValue<PropertiesPermissionMap, FPropertyPermissions>,
+}
+
+/// A helper structure for the [`PropertyWriter`] that holds
+/// the token-related info. The info is loaded using lazy evaluation.
+pub struct PropertyWriterLazyTokenInfo<FCheckTokenExist, FCheckTokenOwner, FGetProperties> {
+	is_token_exist: LazyValue<bool, FCheckTokenExist>,
+	is_token_owner: LazyValue<Result<bool, DispatchError>, FCheckTokenOwner>,
+	stored_properties: LazyValue<TokenProperties, FGetProperties>,
+}
+
+impl<FCheckTokenExist, FCheckTokenOwner, FGetProperties>
+	PropertyWriterLazyTokenInfo<FCheckTokenExist, FCheckTokenOwner, FGetProperties>
 where
+	FCheckTokenExist: FnOnce() -> bool,
+	FCheckTokenOwner: FnOnce() -> Result<bool, DispatchError>,
+	FGetProperties: FnOnce() -> TokenProperties,
+{
+	/// Create a lazy token info.
+	pub fn new(
+		check_token_exist: FCheckTokenExist,
+		check_token_owner: FCheckTokenOwner,
+		get_token_properties: FGetProperties,
+	) -> 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,
+		impl FnOnce() -> bool + 'a,
+		impl FnOnce() -> PropertiesPermissionMap + 'a,
+	>
+	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, FIsAdmin, FPropertyPermissions>
+	PropertyWriter<'a, NewTokenPropertyWriter<T>, T, Handle, FIsAdmin, FPropertyPermissions>
+where
 	T: Config,
 	Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
+	FIsAdmin: FnOnce() -> bool,
+	FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
 {
-	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,
+		impl FnOnce() -> bool + 'a,
+		impl FnOnce() -> PropertiesPermissionMap + 'a,
+	>
+	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, FIsAdmin, FPropertyPermissions>
+	PropertyWriter<'a, ExistingTokenPropertyWriter<T>, T, Handle, FIsAdmin, FPropertyPermissions>
 where
 	T: Config,
 	Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
+	FIsAdmin: FnOnce() -> bool,
+	FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
 {
-	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, FIsAdmin, FPropertyPermissions>(
+		collection: &Handle,
+		collection_lazy_info: PropertyWriterLazyCollectionInfo<FIsAdmin, FPropertyPermissions>,
+	) -> PropertyWriter<Self, T, Handle, FIsAdmin, FPropertyPermissions>
+	where
+		Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
+		FIsAdmin: FnOnce() -> bool,
+		FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
+	{
+		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<
+		impl FnOnce() -> bool,
+		impl FnOnce() -> PropertiesPermissionMap,
+	>
+	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<
+		impl FnOnce() -> bool,
+		impl FnOnce() -> Result<bool, DispatchError>,
+		impl FnOnce() -> TokenProperties,
+	>
+	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, FIsAdmin, FPropertyPermissions>
+	PropertyWriter<'a, BenchmarkPropertyWriter<T>, T, Handle, FIsAdmin, FPropertyPermissions>
 where
 	T: Config,
 	Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
+	FIsAdmin: FnOnce() -> bool,
+	FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
 {
-	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))]

--- a/pallets/common/src/weights.rs
+++ b/pallets/common/src/weights.rs
@@ -3,9 +3,9 @@
 //! 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-05, 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`
+//! HOSTNAME: `hearthstone`, CPU: `AMD Ryzen 9 7950X3D 16-Core Processor`
 //! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
 
 // Executed Command:
@@ -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
 
@@ -36,7 +36,7 @@
 	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.
@@ -49,10 +49,10 @@
 		// 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: 2_840_000 picoseconds.
+		Weight::from_parts(1_988_405, 44457)
+			// Standard Error: 7_834
+			.saturating_add(Weight::from_parts(3_053_965, 0).saturating_mul(b.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -63,10 +63,10 @@
 		// 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: 2_770_000 picoseconds.
+		Weight::from_parts(2_940_000, 44457)
+			// Standard Error: 30_686
+			.saturating_add(Weight::from_parts(9_801_835, 0).saturating_mul(b.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -76,20 +76,20 @@
 		// 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: 2_830_000 picoseconds.
+		Weight::from_parts(2_950_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 {
+	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: 3_970_000 picoseconds.
+		Weight::from_parts(4_140_000, 20191)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 	}
 }
@@ -103,10 +103,10 @@
 		// 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: 2_840_000 picoseconds.
+		Weight::from_parts(1_988_405, 44457)
+			// Standard Error: 7_834
+			.saturating_add(Weight::from_parts(3_053_965, 0).saturating_mul(b.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -117,10 +117,10 @@
 		// 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: 2_770_000 picoseconds.
+		Weight::from_parts(2_940_000, 44457)
+			// Standard Error: 30_686
+			.saturating_add(Weight::from_parts(9_801_835, 0).saturating_mul(b.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -130,20 +130,20 @@
 		// 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: 2_830_000 picoseconds.
+		Weight::from_parts(2_950_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 {
+	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: 3_970_000 picoseconds.
+		Weight::from_parts(4_140_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
@@ -262,9 +262,82 @@
 		{
 			<Pallet<T>>::burn_from(&collection, &burner, &sender, item, &Unlimited)?;
 		}
+	}
 
-		Ok(())
-	}
+	// set_token_properties {
+	// 	let b in 0..MAX_PROPERTIES_PER_ITEM;
+	// 	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)?;
+	// 	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)?}
+
+	// load_token_properties {
+	// 	bench_init!{
+	// 		owner: sub; collection: collection(owner);
+	// 		owner: cross_from_sub;
+	// 	};
+
+	// 	let item = create_max_item(&collection, &owner, owner.clone())?;
+	// }: {
+	// 	pallet_common::BenchmarkPropertyWriter::<T>::load_token_properties(
+	// 		&collection,
+	// 		item,
+	// 	)
+	// }
+
+	// write_token_properties {
+	// 	let b in 0..MAX_PROPERTIES_PER_ITEM;
+	// 	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)?;
+	// 	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 lazy_collection_info = pallet_common::BenchmarkPropertyWriter::<T>::load_collection_info(
+	// 		&collection,
+	// 		&owner,
+	// 	);
+	// }: {
+	// 	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()),
+	// 	)?
+	// }
 
 	#[benchmark]
 	fn set_token_property_permissions(

--- 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;
@@ -39,9 +40,9 @@
 	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, _>(
+				.saturating_add(write_token_properties_total_weight::<T, _>(
 					t.iter().map(|t| t.properties.len() as u32),
-					<SelfWeightOf<T>>::init_token_properties,
+					<SelfWeightOf<T>>::write_token_properties,
 				)),
 			_ => Weight::zero(),
 		}
@@ -49,12 +50,12 @@
 
 	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, _>(
+			write_token_properties_total_weight::<T, _>(
 				data.iter().map(|t| match t {
 					up_data_structs::CreateItemData::NFT(n) => n.properties.len() as u32,
 					_ => 0,
 				}),
-				<SelfWeightOf<T>>::init_token_properties,
+				<SelfWeightOf<T>>::write_token_properties,
 			),
 		)
 	}
@@ -67,16 +68,15 @@
 		<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 +84,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 +97,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 {
@@ -306,16 +294,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(