diff --git a/pallets/nfts/src/benchmarking.rs b/pallets/nfts/src/benchmarking.rs
index 9533bade..bc25602c 100644
--- a/pallets/nfts/src/benchmarking.rs
+++ b/pallets/nfts/src/benchmarking.rs
@@ -62,27 +62,6 @@ fn add_collection_metadata<T: Config<I>, I: 'static>() -> (T::AccountId, Account
 	(caller, caller_lookup)
 }
 
-fn approve_collection<T: Config<I>, I: 'static>(
-	index: u32,
-) -> (T::AccountId, AccountIdLookupOf<T>) {
-	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
-	if caller != whitelisted_caller() {
-		whitelist_account!(caller);
-	}
-	let caller_lookup = T::Lookup::unlookup(caller.clone());
-	let delegate: T::AccountId = account("delegate", 0, SEED + index);
-	let delegate_lookup = T::Lookup::unlookup(delegate.clone());
-	let deadline = BlockNumberFor::<T>::max_value();
-	assert_ok!(Nfts::<T, I>::approve_transfer(
-		SystemOrigin::Signed(caller.clone()).into(),
-		T::Helper::collection(0),
-		None,
-		delegate_lookup.clone(),
-		Some(deadline),
-	));
-	(caller, caller_lookup)
-}
-
 fn mint_item<T: Config<I>, I: 'static>(
 	index: u16,
 ) -> (T::ItemId, T::AccountId, AccountIdLookupOf<T>) {
@@ -96,7 +75,7 @@ fn mint_item<T: Config<I>, I: 'static>(
 	let item_exists = Item::<T, I>::contains_key(collection, item);
 	let item_config = ItemConfigOf::<T, I>::get(collection, item);
 	if item_exists {
-		return (item, caller, caller_lookup);
+		return (item, caller, caller_lookup)
 	} else if let Some(item_config) = item_config {
 		assert_ok!(Nfts::<T, I>::force_mint(
 			SystemOrigin::Signed(caller.clone()).into(),
@@ -269,8 +248,6 @@ benchmarks_instance_pallet! {
 		let m in 0 .. 1_000;
 		let c in 0 .. 1_000;
 		let a in 0 .. 1_000;
-		let h in 0 .. 1_000;
-		let l in 0 .. 1_000;
 
 		let (collection, caller, _) = create_collection::<T, I>();
 		add_collection_metadata::<T, I>();
@@ -288,13 +265,6 @@ benchmarks_instance_pallet! {
 		for i in 0..a {
 			add_collection_attribute::<T, I>(i as u16);
 		}
-		for i in 0..h {
-			mint_item::<T, I>(i as u16);
-			burn_item::<T, I>(i as u16);
-		}
-		for i in 0..l {
-			approve_collection::<T, I>(i);
-		}
 		let witness = Collection::<T, I>::get(collection).unwrap().destroy_witness();
 	}: _(SystemOrigin::Signed(caller), collection, witness)
 	verify {
@@ -601,45 +571,27 @@ benchmarks_instance_pallet! {
 	}
 
 	approve_transfer {
-		let i in 0..1;
-
 		let (collection, caller, _) = create_collection::<T, I>();
 		let (item, ..) = mint_item::<T, I>(0);
 		let delegate: T::AccountId = account("delegate", 0, SEED);
 		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
-		let maybe_deadline = if i == 0 {
-			None
-		} else {
-			Some(BlockNumberFor::<T>::max_value())
-		};
-		let maybe_item = if i == 0 {
-			None
-		} else {
-			Some(item)
-		};
-	}: _(SystemOrigin::Signed(caller.clone()), collection, maybe_item, delegate_lookup, maybe_deadline)
+		let deadline = BlockNumberFor::<T>::max_value();
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, delegate_lookup, Some(deadline))
 	verify {
-		assert_last_event::<T, I>(Event::TransferApproved { collection, item: maybe_item, owner: caller, delegate, deadline: maybe_deadline }.into());
+		assert_last_event::<T, I>(Event::TransferApproved { collection, item, owner: caller, delegate, deadline: Some(deadline) }.into());
 	}
 
 	cancel_approval {
-		let i in 0..1;
-
 		let (collection, caller, _) = create_collection::<T, I>();
 		let (item, ..) = mint_item::<T, I>(0);
 		let delegate: T::AccountId = account("delegate", 0, SEED);
 		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
 		let origin = SystemOrigin::Signed(caller.clone()).into();
 		let deadline = BlockNumberFor::<T>::max_value();
-		let maybe_item = if i == 0 {
-		  None
-		} else {
-		  Some(item)
-		};
-		Nfts::<T, I>::approve_transfer(origin, collection, maybe_item, delegate_lookup.clone(), Some(deadline))?;
-	}: _(SystemOrigin::Signed(caller.clone()), collection, maybe_item, delegate_lookup)
+		Nfts::<T, I>::approve_transfer(origin, collection, item, delegate_lookup.clone(), Some(deadline))?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, delegate_lookup)
 	verify {
-		assert_last_event::<T, I>(Event::ApprovalCancelled { collection, item: maybe_item, owner: caller, delegate }.into());
+		assert_last_event::<T, I>(Event::ApprovalCancelled { collection, item, owner: caller, delegate }.into());
 	}
 
 	clear_all_transfer_approvals {
@@ -649,7 +601,7 @@ benchmarks_instance_pallet! {
 		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
 		let origin = SystemOrigin::Signed(caller.clone()).into();
 		let deadline = BlockNumberFor::<T>::max_value();
-		Nfts::<T, I>::approve_transfer(origin, collection, Some(item), delegate_lookup.clone(), Some(deadline))?;
+		Nfts::<T, I>::approve_transfer(origin, collection, item, delegate_lookup.clone(), Some(deadline))?;
 	}: _(SystemOrigin::Signed(caller.clone()), collection, item)
 	verify {
 		assert_last_event::<T, I>(Event::AllApprovalsCancelled {collection, item, owner: caller}.into());
diff --git a/pallets/nfts/src/common_functions.rs b/pallets/nfts/src/common_functions.rs
index 9cc7d3b4..f9224046 100644
--- a/pallets/nfts/src/common_functions.rs
+++ b/pallets/nfts/src/common_functions.rs
@@ -34,24 +34,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Collection::<T, I>::get(collection).map(|i| i.owner)
 	}
 
-	/// Get the total number of items in the collection, if the collection exists.
-	pub fn collection_items(collection: T::CollectionId) -> Option<u32> {
-		Collection::<T, I>::get(collection).map(|i| i.items)
-	}
-
-	/// Get the allowances to spend items within the collection.
-	pub fn collection_allowances(collection: T::CollectionId) -> Option<u32> {
-		Collection::<T, I>::get(collection).map(|i| i.allowances)
-	}
-
-	/// Get the metadata of the collection item.
-	pub fn item_metadata(
-		collection: T::CollectionId,
-		item: T::ItemId,
-	) -> Option<BoundedVec<u8, T::StringLimit>> {
-		ItemMetadataOf::<T, I>::get(collection, item).map(|metadata| metadata.data)
-	}
-
 	/// Validates the signature of the given data with the provided signer's account ID.
 	///
 	/// # Errors
diff --git a/pallets/nfts/src/features/approvals.rs b/pallets/nfts/src/features/approvals.rs
index 75de1f94..5ffaeea7 100644
--- a/pallets/nfts/src/features/approvals.rs
+++ b/pallets/nfts/src/features/approvals.rs
@@ -64,6 +64,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		if let Some(check_origin) = maybe_check_origin {
 			ensure!(check_origin == details.owner, Error::<T, I>::NoPermission);
 		}
+
 		let now = frame_system::Pallet::<T>::block_number();
 		let deadline = maybe_deadline.map(|d| d.saturating_add(now));
 
@@ -75,11 +76,12 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 		Self::deposit_event(Event::TransferApproved {
 			collection,
-			item: Some(item),
+			item,
 			owner: details.owner,
 			delegate,
 			deadline,
 		});
+
 		Ok(())
 	}
 
@@ -125,7 +127,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 		Self::deposit_event(Event::ApprovalCancelled {
 			collection,
-			item: Some(item),
+			item,
 			owner: details.owner,
 			delegate,
 		});
@@ -169,102 +171,4 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 		Ok(())
 	}
-
-	pub(crate) fn do_approve_collection(
-		maybe_check_origin: Option<T::AccountId>,
-		collection: T::CollectionId,
-		delegate: T::AccountId,
-	) -> DispatchResult {
-		ensure!(
-			Self::is_pallet_feature_enabled(PalletFeature::Approvals),
-			Error::<T, I>::MethodDisabled
-		);
-		let owner = Self::collection_owner(collection).ok_or(Error::<T, I>::UnknownCollection)?;
-
-		let collection_config = Self::get_collection_config(&collection)?;
-		ensure!(
-			collection_config.is_setting_enabled(CollectionSetting::TransferableItems),
-			Error::<T, I>::ItemsNonTransferable
-		);
-
-		if let Some(check_origin) = maybe_check_origin {
-			ensure!(check_origin == owner, Error::<T, I>::NoPermission);
-		}
-
-		Allowances::<T, I>::mutate((&collection, &owner, &delegate), |allowance| {
-			*allowance = true;
-		});
-		Collection::<T, I>::try_mutate(
-			&collection,
-			|maybe_collection_details| -> Result<(), DispatchError> {
-				let collection_details =
-					maybe_collection_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
-				collection_details.allowances.saturating_inc();
-				Ok(())
-			},
-		)?;
-
-		Self::deposit_event(Event::TransferApproved {
-			collection,
-			item: None,
-			owner,
-			delegate,
-			deadline: None,
-		});
-		Ok(())
-	}
-
-	pub(crate) fn do_cancel_collection(
-		maybe_check_origin: Option<T::AccountId>,
-		collection: T::CollectionId,
-		delegate: T::AccountId,
-	) -> DispatchResult {
-		let owner = Self::collection_owner(collection).ok_or(Error::<T, I>::UnknownCollection)?;
-
-		if let Some(check_origin) = maybe_check_origin {
-			ensure!(check_origin == owner, Error::<T, I>::NoPermission);
-		}
-		Allowances::<T, I>::remove((&collection, &owner, &delegate));
-		Collection::<T, I>::try_mutate(
-			&collection,
-			|maybe_collection_details| -> Result<(), DispatchError> {
-				let collection_details =
-					maybe_collection_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
-				collection_details.allowances.saturating_dec();
-				Ok(())
-			},
-		)?;
-
-		Self::deposit_event(Event::ApprovalCancelled { collection, owner, item: None, delegate });
-
-		Ok(())
-	}
-
-	pub fn check_allowance(
-		collection: &T::CollectionId,
-		item: &Option<T::ItemId>,
-		owner: &T::AccountId,
-		delegate: &T::AccountId,
-	) -> Result<(), DispatchError> {
-		// Check if a `delegate` has a permission to spend the collection.
-		if Allowances::<T, I>::get((&collection, &owner, &delegate)) {
-			if let Some(item) = item {
-				Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
-			};
-			return Ok(());
-		}
-		// Check if a `delegate` has a permission to spend the collection item.
-		if let Some(item) = item {
-			let details =
-				Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
-
-			let deadline = details.approvals.get(&delegate).ok_or(Error::<T, I>::NoPermission)?;
-			if let Some(d) = deadline {
-				let block_number = frame_system::Pallet::<T>::block_number();
-				ensure!(block_number <= *d, Error::<T, I>::ApprovalExpired);
-			}
-			return Ok(());
-		};
-		Err(Error::<T, I>::NoPermission.into())
-	}
 }
diff --git a/pallets/nfts/src/features/create_delete_collection.rs b/pallets/nfts/src/features/create_delete_collection.rs
index 9be73a3b..4b4cc28b 100644
--- a/pallets/nfts/src/features/create_delete_collection.rs
+++ b/pallets/nfts/src/features/create_delete_collection.rs
@@ -54,9 +54,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				items: 0,
 				item_metadatas: 0,
 				item_configs: 0,
-				item_holders: 0,
 				attributes: 0,
-				allowances: 0,
 			},
 		);
 		CollectionRoleOf::<T, I>::insert(
@@ -121,11 +119,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				collection_details.item_configs == witness.item_configs,
 				Error::<T, I>::BadWitness
 			);
-			ensure!(
-				collection_details.item_holders == witness.item_holders,
-				Error::<T, I>::BadWitness
-			);
-			ensure!(collection_details.allowances == witness.allowances, Error::<T, I>::BadWitness);
 
 			for (_, metadata) in ItemMetadataOf::<T, I>::drain_prefix(collection) {
 				if let Some(depositor) = metadata.deposit.account {
@@ -144,9 +137,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				}
 			}
 
-			let _ =
-				AccountBalance::<T, I>::clear_prefix(collection, collection_details.items, None);
-			let _ = Allowances::<T, I>::clear_prefix((collection,), collection_details.items, None);
 			CollectionAccount::<T, I>::remove(&collection_details.owner, &collection);
 			T::Currency::unreserve(&collection_details.owner, collection_details.owner_deposit);
 			CollectionConfigOf::<T, I>::remove(collection);
@@ -157,9 +147,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			Ok(DestroyWitness {
 				item_metadatas: collection_details.item_metadatas,
 				item_configs: collection_details.item_configs,
-				item_holders: collection_details.item_holders,
 				attributes: collection_details.attributes,
-				allowances: collection_details.allowances,
 			})
 		})
 	}
diff --git a/pallets/nfts/src/features/create_delete_item.rs b/pallets/nfts/src/features/create_delete_item.rs
index aed2c204..2a7df32e 100644
--- a/pallets/nfts/src/features/create_delete_item.rs
+++ b/pallets/nfts/src/features/create_delete_item.rs
@@ -259,10 +259,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 					}
 				}
 
-				if AccountBalance::<T, I>::get(collection, &details.owner) == 1 {
-					collection_details.item_holders.saturating_dec();
-				}
-
 				Ok(details.owner)
 			},
 		)?;
@@ -272,9 +268,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		ItemPriceOf::<T, I>::remove(&collection, &item);
 		PendingSwapOf::<T, I>::remove(&collection, &item);
 		ItemAttributesApprovalsOf::<T, I>::remove(&collection, &item);
-		AccountBalance::<T, I>::mutate(collection, &owner, |balance| {
-			balance.saturating_dec();
-		});
 
 		if remove_config {
 			ItemConfigOf::<T, I>::remove(collection, item);
diff --git a/pallets/nfts/src/features/transfer.rs b/pallets/nfts/src/features/transfer.rs
index af34c471..18b71d58 100644
--- a/pallets/nfts/src/features/transfer.rs
+++ b/pallets/nfts/src/features/transfer.rs
@@ -54,7 +54,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		) -> DispatchResult,
 	) -> DispatchResult {
 		// Retrieve collection details.
-		let mut collection_details =
+		let collection_details =
 			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
 
 		// Ensure the item is not locked.
@@ -86,24 +86,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		// Perform the transfer with custom details using the provided closure.
 		with_details(&collection_details, &mut details)?;
 
-		// Update account balance of the owner.
-		let owner_balance =
-			AccountBalance::<T, I>::mutate(collection, &details.owner, |balance| -> u32 {
-				balance.saturating_dec();
-				*balance
-			});
-		if owner_balance == 0 {
-			collection_details.item_holders.saturating_dec();
-		}
-		// Update account balance of the destination account.
-		let dest_balance = AccountBalance::<T, I>::mutate(collection, &dest, |balance| -> u32 {
-			balance.saturating_inc();
-			*balance
-		});
-		if dest_balance == 1 {
-			collection_details.item_holders.saturating_inc();
-		}
-
 		// Update account ownership information.
 		Account::<T, I>::remove((&details.owner, &collection, &item));
 		Account::<T, I>::insert((&dest, &collection, &item), ());
@@ -155,7 +137,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			// Check if the `origin` is the current owner of the collection.
 			ensure!(origin == details.owner, Error::<T, I>::NoPermission);
 			if details.owner == new_owner {
-				return Ok(());
+				return Ok(())
 			}
 
 			// Move the deposit to the new owner.
@@ -230,7 +212,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Collection::<T, I>::try_mutate(collection, |maybe_details| {
 			let details = maybe_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
 			if details.owner == owner {
-				return Ok(());
+				return Ok(())
 			}
 
 			// Move the deposit to the new owner.
diff --git a/pallets/nfts/src/lib.rs b/pallets/nfts/src/lib.rs
index 8756c85c..5aff3ed7 100644
--- a/pallets/nfts/src/lib.rs
+++ b/pallets/nfts/src/lib.rs
@@ -30,6 +30,7 @@
 
 #[cfg(feature = "runtime-benchmarks")]
 mod benchmarking;
+pub mod migration;
 #[cfg(test)]
 pub mod mock;
 #[cfg(test)]
@@ -404,34 +405,6 @@ pub mod pallet {
 	pub type CollectionConfigOf<T: Config<I>, I: 'static = ()> =
 		StorageMap<_, Blake2_128Concat, T::CollectionId, CollectionConfigFor<T, I>, OptionQuery>;
 
-	/// Number of collection items that accounts own.
-	#[pallet::storage]
-	pub type AccountBalance<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
-		_,
-		Twox64Concat,
-		T::CollectionId,
-		Blake2_128Concat,
-		T::AccountId,
-		u32,
-		ValueQuery,
-	>;
-
-	/// Permission for the delegate to transfer all owner's items within a collection.
-	#[pallet::storage]
-	pub type Allowances<T: Config<I>, I: 'static = ()> = StorageNMap<
-		_,
-		(
-			// Collection ID.
-			NMapKey<Twox64Concat, T::CollectionId>,
-			// Collection Owner Id.
-			NMapKey<Blake2_128Concat, T::AccountId>,
-			// Delegate Id.
-			NMapKey<Blake2_128Concat, T::AccountId>,
-		),
-		bool,
-		ValueQuery,
-	>;
-
 	/// Config of an item.
 	#[pallet::storage]
 	pub type ItemConfigOf<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
@@ -491,7 +464,7 @@ pub mod pallet {
 		/// a `delegate`.
 		TransferApproved {
 			collection: T::CollectionId,
-			item: Option<T::ItemId>,
+			item: T::ItemId,
 			owner: T::AccountId,
 			delegate: T::AccountId,
 			deadline: Option<BlockNumberFor<T>>,
@@ -500,7 +473,7 @@ pub mod pallet {
 		/// `collection` was cancelled by its `owner`.
 		ApprovalCancelled {
 			collection: T::CollectionId,
-			item: Option<T::ItemId>,
+			item: T::ItemId,
 			owner: T::AccountId,
 			delegate: T::AccountId,
 		},
@@ -835,8 +808,6 @@ pub mod pallet {
 			witness.item_metadatas,
 			witness.item_configs,
 			witness.attributes,
-			witness.item_holders,
-			witness.allowances,
  		))]
 		pub fn destroy(
 			origin: OriginFor<T>,
@@ -852,8 +823,6 @@ pub mod pallet {
 				details.item_metadatas,
 				details.item_configs,
 				details.attributes,
-				details.item_holders,
-				details.allowances,
 			))
 			.into())
 		}
@@ -1065,7 +1034,12 @@ pub mod pallet {
 
 			Self::do_transfer(collection, item, dest, |_, details| {
 				if details.owner != origin {
-					Self::check_allowance(&collection, &Some(item), &details.owner, &origin)?;
+					let deadline =
+						details.approvals.get(&origin).ok_or(Error::<T, I>::NoPermission)?;
+					if let Some(d) = deadline {
+						let block_number = frame_system::Pallet::<T>::block_number();
+						ensure!(block_number <= *d, Error::<T, I>::ApprovalExpired);
+					}
 				}
 				Ok(())
 			})
@@ -1320,11 +1294,11 @@ pub mod pallet {
 		///
 		/// Weight: `O(1)`
 		#[pallet::call_index(15)]
-		#[pallet::weight(T::WeightInfo::approve_transfer(maybe_item.is_some() as u32))]
+		#[pallet::weight(T::WeightInfo::approve_transfer())]
 		pub fn approve_transfer(
 			origin: OriginFor<T>,
 			collection: T::CollectionId,
-			maybe_item: Option<T::ItemId>,
+			item: T::ItemId,
 			delegate: AccountIdLookupOf<T>,
 			maybe_deadline: Option<BlockNumberFor<T>>,
 		) -> DispatchResult {
@@ -1332,16 +1306,13 @@ pub mod pallet {
 				.map(|_| None)
 				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
 			let delegate = T::Lookup::lookup(delegate)?;
-			match maybe_item {
-				Some(item) => Self::do_approve_transfer(
-					maybe_check_origin,
-					collection,
-					item,
-					delegate,
-					maybe_deadline,
-				),
-				None => Self::do_approve_collection(maybe_check_origin, collection, delegate),
-			}
+			Self::do_approve_transfer(
+				maybe_check_origin,
+				collection,
+				item,
+				delegate,
+				maybe_deadline,
+			)
 		}
 
 		/// Cancel one of the transfer approvals for a specific item.
@@ -1359,11 +1330,11 @@ pub mod pallet {
 		///
 		/// Weight: `O(1)`
 		#[pallet::call_index(16)]
-		#[pallet::weight(T::WeightInfo::cancel_approval(maybe_item.is_some() as u32))]
+		#[pallet::weight(T::WeightInfo::cancel_approval())]
 		pub fn cancel_approval(
 			origin: OriginFor<T>,
 			collection: T::CollectionId,
-			maybe_item: Option<T::ItemId>,
+			item: T::ItemId,
 			delegate: AccountIdLookupOf<T>,
 		) -> DispatchResult {
 			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
diff --git a/pallets/nfts/src/migration.rs b/pallets/nfts/src/migration.rs
new file mode 100644
index 00000000..af611bf1
--- /dev/null
+++ b/pallets/nfts/src/migration.rs
@@ -0,0 +1,120 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use frame_support::traits::OnRuntimeUpgrade;
+use log;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+use super::*;
+
+pub mod v1 {
+	use frame_support::{pallet_prelude::*, weights::Weight};
+
+	use super::*;
+
+	#[derive(Decode)]
+	pub struct OldCollectionDetails<AccountId, DepositBalance> {
+		pub owner: AccountId,
+		pub owner_deposit: DepositBalance,
+		pub items: u32,
+		pub item_metadatas: u32,
+		pub attributes: u32,
+	}
+
+	impl<AccountId, DepositBalance> OldCollectionDetails<AccountId, DepositBalance> {
+		/// Migrates the old collection details to the new v1 format.
+		fn migrate_to_v1(self, item_configs: u32) -> CollectionDetails<AccountId, DepositBalance> {
+			CollectionDetails {
+				owner: self.owner,
+				owner_deposit: self.owner_deposit,
+				items: self.items,
+				item_metadatas: self.item_metadatas,
+				item_configs,
+				attributes: self.attributes,
+			}
+		}
+	}
+
+	/// A migration utility to update the storage version from v0 to v1 for the pallet.
+	pub struct MigrateToV1<T>(core::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV1<T> {
+		fn on_runtime_upgrade() -> Weight {
+			let in_code_version = Pallet::<T>::in_code_storage_version();
+			let on_chain_version = Pallet::<T>::on_chain_storage_version();
+
+			log::info!(
+				target: LOG_TARGET,
+				"Running migration with in-code storage version {:?} / onchain {:?}",
+				in_code_version,
+				on_chain_version
+			);
+
+			if on_chain_version == 0 && in_code_version == 1 {
+				let mut translated = 0u64;
+				let mut configs_iterated = 0u64;
+				Collection::<T>::translate::<
+					OldCollectionDetails<T::AccountId, DepositBalanceOf<T>>,
+					_,
+				>(|key, old_value| {
+					let item_configs = ItemConfigOf::<T>::iter_prefix(&key).count() as u32;
+					configs_iterated += item_configs as u64;
+					translated.saturating_inc();
+					Some(old_value.migrate_to_v1(item_configs))
+				});
+
+				in_code_version.put::<Pallet<T>>();
+
+				log::info!(
+					target: LOG_TARGET,
+					"Upgraded {} records, storage to version {:?}",
+					translated,
+					in_code_version
+				);
+				T::DbWeight::get().reads_writes(translated + configs_iterated + 1, translated + 1)
+			} else {
+				log::info!(
+					target: LOG_TARGET,
+					"Migration did not execute. This probably should be removed"
+				);
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			let prev_count = Collection::<T>::iter().count();
+			Ok((prev_count as u32).encode())
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(prev_count: Vec<u8>) -> Result<(), TryRuntimeError> {
+			let prev_count: u32 = Decode::decode(&mut prev_count.as_slice()).expect(
+				"the state parameter should be something that was generated by pre_upgrade",
+			);
+			let post_count = Collection::<T>::iter().count() as u32;
+			ensure!(
+				prev_count == post_count,
+				"the records count before and after the migration should be the same"
+			);
+
+			ensure!(Pallet::<T>::on_chain_storage_version() >= 1, "wrong storage version");
+
+			Ok(())
+		}
+	}
+}
diff --git a/pallets/nfts/src/tests.rs b/pallets/nfts/src/tests.rs
index 6d0c894a..44f2f32a 100644
--- a/pallets/nfts/src/tests.rs
+++ b/pallets/nfts/src/tests.rs
@@ -164,8 +164,6 @@ fn basic_minting_should_work() {
 		));
 		assert_eq!(collections(), vec![(account(1), 0)]);
 		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 42, account(1), None));
-		assert_eq!(AccountBalance::<Test>::get(0, account(1)), 1);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 1);
 		assert_eq!(items(), vec![(account(1), 0, 42)]);
 
 		assert_ok!(Nfts::force_create(
@@ -175,38 +173,10 @@ fn basic_minting_should_work() {
 		));
 		assert_eq!(collections(), vec![(account(1), 0), (account(2), 1)]);
 		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(2)), 1, 69, account(1), None));
-		assert_eq!(AccountBalance::<Test>::get(1, account(1)), 1);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 1);
 		assert_eq!(items(), vec![(account(1), 0, 42), (account(1), 1, 69)]);
 	});
 }
 
-#[test]
-fn collection_item_holders_should_works() {
-	new_test_ext().execute_with(|| {
-		assert_ok!(Nfts::force_create(
-			RuntimeOrigin::root(),
-			account(1),
-			default_collection_config()
-		));
-		assert_eq!(collections(), vec![(account(1), 0)]);
-		let total = 5;
-		for i in 0..total {
-			assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, i, account(1), None));
-		}
-		assert_eq!(AccountBalance::<Test>::get(0, account(1)), total);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 1);
-
-		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, total, account(2), None));
-		assert_eq!(AccountBalance::<Test>::get(0, account(2)), 1);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 2);
-
-		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(2)), 0, total));
-		assert_eq!(AccountBalance::<Test>::get(0, account(2)), 0);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 1);
-	});
-}
-
 #[test]
 fn lifecycle_should_work() {
 	new_test_ext().execute_with(|| {
@@ -234,7 +204,6 @@ fn lifecycle_should_work() {
 			account(10),
 			default_item_config()
 		));
-		assert_eq!(AccountBalance::<Test>::get(0, account(10)), 1);
 		assert_eq!(Balances::reserved_balance(&account(1)), 6);
 		assert_ok!(Nfts::force_mint(
 			RuntimeOrigin::signed(account(1)),
@@ -243,20 +212,15 @@ fn lifecycle_should_work() {
 			account(20),
 			default_item_config()
 		));
-		assert_eq!(AccountBalance::<Test>::get(0, account(20)), 1);
 		assert_eq!(Balances::reserved_balance(&account(1)), 7);
 		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 70, account(1), None));
-		assert_eq!(AccountBalance::<Test>::get(0, account(1)), 1);
 		assert_eq!(items(), vec![(account(1), 0, 70), (account(10), 0, 42), (account(20), 0, 69)]);
 		assert_eq!(Collection::<Test>::get(0).unwrap().items, 3);
 		assert_eq!(Collection::<Test>::get(0).unwrap().item_metadatas, 0);
 		assert_eq!(Collection::<Test>::get(0).unwrap().item_configs, 3);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 3);
 
 		assert_eq!(Balances::reserved_balance(&account(1)), 8);
 		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(1)), 0, 70, account(2)));
-		assert_eq!(AccountBalance::<Test>::get(0, account(1)), 0);
-		assert_eq!(AccountBalance::<Test>::get(0, account(2)), 1);
 		assert_eq!(Balances::reserved_balance(&account(1)), 8);
 		assert_eq!(Balances::reserved_balance(&account(2)), 0);
 
@@ -274,7 +238,6 @@ fn lifecycle_should_work() {
 			Nfts::destroy(RuntimeOrigin::signed(account(1)), 0, w),
 			Error::<Test>::CollectionNotEmpty
 		);
-		assert_eq!(AccountBalance::<Test>::get(0, account(1)), 0);
 
 		assert_ok!(Nfts::set_attribute(
 			RuntimeOrigin::signed(account(1)),
@@ -285,9 +248,7 @@ fn lifecycle_should_work() {
 			bvec![0],
 		));
 		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(10)), 0, 42));
-		assert_eq!(AccountBalance::<Test>::get(0, account(10)), 0);
 		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(20)), 0, 69));
-		assert_eq!(AccountBalance::<Test>::get(0, account(10)), 0);
 		assert_ok!(Nfts::burn(RuntimeOrigin::root(), 0, 70));
 
 		let w = Nfts::get_destroy_witness(&0).unwrap();
@@ -295,7 +256,6 @@ fn lifecycle_should_work() {
 		assert_eq!(w.item_metadatas, 0);
 		assert_eq!(w.item_configs, 0);
 		assert_ok!(Nfts::destroy(RuntimeOrigin::signed(account(1)), 0, w));
-		assert_eq!(AccountBalance::<Test>::get(0, account(1)), 0);
 		assert_eq!(Balances::reserved_balance(&account(1)), 0);
 
 		assert!(!Collection::<Test>::contains_key(0));
@@ -345,15 +305,6 @@ fn destroy_should_work() {
 		));
 
 		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 42, account(2), None));
-		assert_eq!(AccountBalance::<Test>::get(0, account(2)), 1);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 1);
-		assert_ok!(Nfts::approve_transfer(
-			RuntimeOrigin::signed(account(1)),
-			0,
-			None,
-			account(3),
-			None
-		));
 		assert_noop!(
 			Nfts::destroy(
 				RuntimeOrigin::signed(account(1)),
@@ -372,8 +323,6 @@ fn destroy_should_work() {
 			0,
 			Nfts::get_destroy_witness(&0).unwrap()
 		));
-		assert_eq!(AccountBalance::<Test>::iter_prefix(0).count(), 0);
-		assert_eq!(Allowances::<Test>::iter_prefix((0,)).count(), 0);
 		assert!(!ItemConfigOf::<Test>::contains_key(0, 42));
 		assert_eq!(ItemConfigOf::<Test>::iter_prefix(0).count() as u32, 0);
 	});
@@ -388,9 +337,7 @@ fn mint_should_work() {
 			default_collection_config()
 		));
 		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 42, account(1), None));
-		assert_eq!(AccountBalance::<Test>::get(0, account(1)), 1);
 		assert_eq!(Nfts::owner(0, 42).unwrap(), account(1));
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 1);
 		assert_eq!(collections(), vec![(account(1), 0)]);
 		assert_eq!(items(), vec![(account(1), 0, 42)]);
 
@@ -455,8 +402,6 @@ fn mint_should_work() {
 			account(2),
 			Some(MintWitness { mint_price: Some(1), ..Default::default() })
 		));
-		assert_eq!(AccountBalance::<Test>::get(0, account(2)), 1);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 2);
 		assert_eq!(Balances::total_balance(&account(2)), 99);
 
 		// validate types
@@ -495,8 +440,6 @@ fn mint_should_work() {
 			account(2),
 			Some(MintWitness { owned_item: Some(43), ..Default::default() })
 		));
-		assert_eq!(AccountBalance::<Test>::get(1, account(2)), 1);
-		assert_eq!(Collection::<Test>::get(1).unwrap().item_holders, 1);
 		assert!(events().contains(&Event::<Test>::PalletAttributeSet {
 			collection: 0,
 			item: Some(43),
@@ -533,11 +476,8 @@ fn transfer_should_work() {
 			account(2),
 			default_item_config()
 		));
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 1);
+
 		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(2)), 0, 42, account(3)));
-		assert_eq!(AccountBalance::<Test>::get(0, account(2)), 0);
-		assert_eq!(AccountBalance::<Test>::get(0, account(3)), 1);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 1);
 		assert_eq!(items(), vec![(account(3), 0, 42)]);
 		assert_noop!(
 			Nfts::transfer(RuntimeOrigin::signed(account(2)), 0, 42, account(4)),
@@ -547,15 +487,12 @@ fn transfer_should_work() {
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(3)),
 			0,
-			Some(42),
+			42,
 			account(2),
 			None
 		));
 		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(2)), 0, 42, account(4)));
-		assert_eq!(AccountBalance::<Test>::get(0, account(2)), 0);
-		assert_eq!(AccountBalance::<Test>::get(0, account(3)), 0);
-		assert_eq!(AccountBalance::<Test>::get(0, account(4)), 1);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 1);
+
 		// validate we can't transfer non-transferable items
 		let collection_id = 1;
 		assert_ok!(Nfts::force_create(
@@ -1809,20 +1746,15 @@ fn burn_works() {
 			account(5),
 			default_item_config()
 		));
-		assert_eq!(AccountBalance::<Test>::get(0, account(5)), 2);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 1);
 		assert_eq!(Balances::reserved_balance(account(1)), 2);
 
 		assert_noop!(
 			Nfts::burn(RuntimeOrigin::signed(account(0)), 0, 42),
 			Error::<Test>::NoPermission
 		);
+
 		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(5)), 0, 42));
-		assert_eq!(AccountBalance::<Test>::get(0, account(5)), 1);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 1);
 		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(5)), 0, 69));
-		assert_eq!(AccountBalance::<Test>::get(0, account(5)), 0);
-		assert_eq!(Collection::<Test>::get(0).unwrap().item_holders, 0);
 		assert_eq!(Balances::reserved_balance(account(1)), 0);
 	});
 }
@@ -1845,7 +1777,7 @@ fn approval_lifecycle_works() {
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(2)),
 			0,
-			Some(42),
+			42,
 			account(3),
 			None
 		));
@@ -1859,7 +1791,7 @@ fn approval_lifecycle_works() {
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(4)),
 			0,
-			Some(42),
+			42,
 			account(2),
 			None
 		));
@@ -1887,7 +1819,7 @@ fn approval_lifecycle_works() {
 			Nfts::approve_transfer(
 				RuntimeOrigin::signed(account(1)),
 				collection_id,
-				Some(1),
+				1,
 				account(2),
 				None
 			),
@@ -1896,63 +1828,6 @@ fn approval_lifecycle_works() {
 	});
 }
 
-#[test]
-fn check_allowance_works() {
-	new_test_ext().execute_with(|| {
-		assert_ok!(Nfts::force_create(
-			RuntimeOrigin::root(),
-			account(1),
-			default_collection_config()
-		));
-		assert_ok!(Nfts::force_mint(
-			RuntimeOrigin::signed(account(1)),
-			0,
-			42,
-			account(2),
-			default_item_config()
-		));
-
-		assert_ok!(Nfts::approve_transfer(
-			RuntimeOrigin::signed(account(1)),
-			0,
-			None,
-			account(2),
-			None
-		));
-
-		// collection transfer approved.
-		assert_noop!(
-			Nfts::check_allowance(&1, &None, &account(1), &account(2)),
-			Error::<Test>::NoPermission
-		);
-		assert_noop!(
-			Nfts::check_allowance(&1, &Some(43), &account(1), &account(2)),
-			Error::<Test>::UnknownItem
-		);
-		assert_ok!(Nfts::check_allowance(&0, &None, &account(1), &account(2)));
-		assert_ok!(Nfts::check_allowance(&0, &Some(42), &account(1), &account(2)));
-
-		// collection item transfer approved.
-		assert_ok!(Nfts::approve_transfer(
-			RuntimeOrigin::signed(account(2)),
-			0,
-			Some(42),
-			account(3),
-			None
-		));
-
-		assert_noop!(
-			Nfts::check_allowance(&0, &Some(43), &account(2), &account(3)),
-			Error::<Test>::UnknownItem
-		);
-		assert_noop!(
-			Nfts::check_allowance(&0, &Some(42), &account(2), &account(4)),
-			Error::<Test>::NoPermission
-		);
-		assert_ok!(Nfts::check_allowance(&0, &Some(42), &account(2), &account(3)));
-	});
-}
-
 #[test]
 fn cancel_approval_works() {
 	new_test_ext().execute_with(|| {
@@ -1972,35 +1847,30 @@ fn cancel_approval_works() {
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(2)),
 			0,
-			Some(42),
+			42,
 			account(3),
 			None
 		));
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 1, Some(42), account(3)),
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 1, 42, account(3)),
 			Error::<Test>::UnknownItem
 		);
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, Some(43), account(3)),
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 43, account(3)),
 			Error::<Test>::UnknownItem
 		);
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::signed(account(3)), 0, Some(42), account(3)),
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(3)), 0, 42, account(3)),
 			Error::<Test>::NoPermission
 		);
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, Some(42), account(4)),
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(4)),
 			Error::<Test>::NotDelegate
 		);
 
-		assert_ok!(Nfts::cancel_approval(
-			RuntimeOrigin::signed(account(2)),
-			0,
-			Some(42),
-			account(3)
-		));
+		assert_ok!(Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(3)));
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, Some(42), account(3)),
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(3)),
 			Error::<Test>::NotDelegate
 		);
 
@@ -2017,72 +1887,22 @@ fn cancel_approval_works() {
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(2)),
 			0,
-			Some(42),
+			42,
 			account(3),
 			Some(2)
 		));
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::signed(account(5)), 0, Some(42), account(3)),
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(5)), 0, 42, account(3)),
 			Error::<Test>::NoPermission
 		);
 
 		System::set_block_number(current_block + 3);
 		// 5 can cancel the approval since the deadline has passed.
-		assert_ok!(Nfts::cancel_approval(
-			RuntimeOrigin::signed(account(5)),
-			0,
-			Some(42),
-			account(3)
-		));
+		assert_ok!(Nfts::cancel_approval(RuntimeOrigin::signed(account(5)), 0, 42, account(3)));
 		assert_eq!(approvals(0, 69), vec![]);
 	});
 }
 
-#[test]
-fn cancel_approval_collection_works_with_admin() {
-	new_test_ext().execute_with(|| {
-		assert_ok!(Nfts::force_create(
-			RuntimeOrigin::root(),
-			account(1),
-			default_collection_config()
-		));
-		assert_ok!(Nfts::force_mint(
-			RuntimeOrigin::signed(account(1)),
-			0,
-			42,
-			account(2),
-			default_item_config()
-		));
-
-		assert_ok!(Nfts::approve_transfer(
-			RuntimeOrigin::signed(account(1)),
-			0,
-			None,
-			account(3),
-			None
-		));
-		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::signed(account(1)), 1, None, account(3)),
-			Error::<Test>::UnknownCollection
-		);
-
-		assert_ok!(Nfts::cancel_approval(RuntimeOrigin::signed(account(1)), 0, None, account(3)));
-		assert!(events().contains(&Event::<Test>::ApprovalCancelled {
-			collection: 0,
-			item: None,
-			owner: account(1),
-			delegate: account(3)
-		}));
-		assert_eq!(Allowances::<Test>::get((0, account(2), account(3))), false);
-		assert_eq!(Nfts::collection_allowances(0).unwrap(), 0);
-
-		assert_noop!(
-			Nfts::transfer(RuntimeOrigin::signed(account(3)), 0, 42, account(4)),
-			Error::<Test>::NoPermission
-		);
-	});
-}
-
 #[test]
 fn approving_multiple_accounts_works() {
 	new_test_ext().execute_with(|| {
@@ -2104,21 +1924,21 @@ fn approving_multiple_accounts_works() {
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(2)),
 			0,
-			Some(42),
+			42,
 			account(3),
 			None
 		));
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(2)),
 			0,
-			Some(42),
+			42,
 			account(4),
 			None
 		));
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(2)),
 			0,
-			Some(42),
+			42,
 			account(5),
 			Some(2)
 		));
@@ -2159,83 +1979,19 @@ fn approvals_limit_works() {
 			assert_ok!(Nfts::approve_transfer(
 				RuntimeOrigin::signed(account(2)),
 				0,
-				Some(42),
+				42,
 				account(i),
 				None
 			));
 		}
 		// the limit is 10
 		assert_noop!(
-			Nfts::approve_transfer(
-				RuntimeOrigin::signed(account(2)),
-				0,
-				Some(42),
-				account(14),
-				None
-			),
+			Nfts::approve_transfer(RuntimeOrigin::signed(account(2)), 0, 42, account(14), None),
 			Error::<Test>::ReachedApprovalLimit
 		);
 	});
 }
 
-#[test]
-fn approval_collection_works_with_admin() {
-	new_test_ext().execute_with(|| {
-		assert_ok!(Nfts::force_create(
-			RuntimeOrigin::root(),
-			account(1),
-			default_collection_config()
-		));
-		assert_ok!(Nfts::force_create(
-			RuntimeOrigin::root(),
-			account(1),
-			default_collection_config()
-		));
-		assert_ok!(Nfts::force_mint(
-			RuntimeOrigin::signed(account(1)),
-			0,
-			42,
-			account(1),
-			default_item_config()
-		));
-
-		// Error::ItemsNonTransferable.
-		assert_ok!(Nfts::lock_collection(
-			RuntimeOrigin::signed(account(1)),
-			1,
-			CollectionSettings::from_disabled(CollectionSetting::TransferableItems.into())
-		));
-		assert_noop!(
-			Nfts::approve_transfer(RuntimeOrigin::signed(account(1)), 1, None, account(2), None),
-			Error::<Test>::ItemsNonTransferable
-		);
-
-		// Error::UnknownCollection.
-		assert_noop!(
-			Nfts::approve_transfer(RuntimeOrigin::signed(account(2)), 2, None, account(3), None),
-			Error::<Test>::UnknownCollection
-		);
-
-		assert_ok!(Nfts::approve_transfer(
-			RuntimeOrigin::signed(account(1)),
-			0,
-			None,
-			account(3),
-			None
-		));
-		assert!(events().contains(&Event::<Test>::TransferApproved {
-			collection: 0,
-			item: None,
-			owner: account(1),
-			delegate: account(3),
-			deadline: None
-		}));
-		assert_eq!(Allowances::<Test>::get((0, account(1), account(3))), true);
-		assert_eq!(Nfts::collection_allowances(0).unwrap(), 1);
-		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(3)), 0, 42, account(4)));
-	});
-}
-
 #[test]
 fn approval_deadline_works() {
 	new_test_ext().execute_with(|| {
@@ -2259,7 +2015,7 @@ fn approval_deadline_works() {
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(2)),
 			0,
-			Some(42),
+			42,
 			account(3),
 			Some(2)
 		));
@@ -2278,7 +2034,7 @@ fn approval_deadline_works() {
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(4)),
 			0,
-			Some(42),
+			42,
 			account(6),
 			Some(4)
 		));
@@ -2307,31 +2063,26 @@ fn cancel_approval_works_with_admin() {
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(2)),
 			0,
-			Some(42),
+			42,
 			account(3),
 			None
 		));
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 1, Some(42), account(1)),
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 1, 42, account(1)),
 			Error::<Test>::UnknownItem
 		);
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, Some(43), account(1)),
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 43, account(1)),
 			Error::<Test>::UnknownItem
 		);
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, Some(42), account(4)),
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(4)),
 			Error::<Test>::NotDelegate
 		);
 
-		assert_ok!(Nfts::cancel_approval(
-			RuntimeOrigin::signed(account(2)),
-			0,
-			Some(42),
-			account(3)
-		));
+		assert_ok!(Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(3)));
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, Some(42), account(1)),
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(1)),
 			Error::<Test>::NotDelegate
 		);
 	});
@@ -2356,26 +2107,26 @@ fn cancel_approval_works_with_force() {
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(2)),
 			0,
-			Some(42),
+			42,
 			account(3),
 			None
 		));
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::root(), 1, Some(42), account(1)),
+			Nfts::cancel_approval(RuntimeOrigin::root(), 1, 42, account(1)),
 			Error::<Test>::UnknownItem
 		);
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::root(), 0, Some(43), account(1)),
+			Nfts::cancel_approval(RuntimeOrigin::root(), 0, 43, account(1)),
 			Error::<Test>::UnknownItem
 		);
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::root(), 0, Some(42), account(4)),
+			Nfts::cancel_approval(RuntimeOrigin::root(), 0, 42, account(4)),
 			Error::<Test>::NotDelegate
 		);
 
-		assert_ok!(Nfts::cancel_approval(RuntimeOrigin::root(), 0, Some(42), account(3)));
+		assert_ok!(Nfts::cancel_approval(RuntimeOrigin::root(), 0, 42, account(3)));
 		assert_noop!(
-			Nfts::cancel_approval(RuntimeOrigin::root(), 0, Some(42), account(1)),
+			Nfts::cancel_approval(RuntimeOrigin::root(), 0, 42, account(1)),
 			Error::<Test>::NotDelegate
 		);
 	});
@@ -2400,14 +2151,14 @@ fn clear_all_transfer_approvals_works() {
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(2)),
 			0,
-			Some(42),
+			42,
 			account(3),
 			None
 		));
 		assert_ok!(Nfts::approve_transfer(
 			RuntimeOrigin::signed(account(2)),
 			0,
-			Some(42),
+			42,
 			account(4),
 			None
 		));
@@ -2437,36 +2188,6 @@ fn clear_all_transfer_approvals_works() {
 	});
 }
 
-#[test]
-fn total_supply_should_works() {
-	new_test_ext().execute_with(|| {
-		let collection_id = 0;
-		let user_id = account(1);
-		let total_items = 10;
-
-		// no collection.
-		assert_eq!(Nfts::collection_items(collection_id), None);
-
-		assert_ok!(Nfts::force_create(
-			RuntimeOrigin::root(),
-			user_id.clone(),
-			default_collection_config()
-		));
-
-		// mint items and validate the total supply.
-		(0..total_items).into_iter().for_each(|i| {
-			assert_ok!(Nfts::force_mint(
-				RuntimeOrigin::root(),
-				collection_id,
-				i,
-				user_id.clone(),
-				ItemConfig::default()
-			));
-		});
-		assert_eq!(Nfts::collection_items(collection_id), Some(total_items));
-	});
-}
-
 #[test]
 fn max_supply_should_work() {
 	new_test_ext().execute_with(|| {
@@ -2803,7 +2524,6 @@ fn buy_item_should_work() {
 			item_1,
 			price_1 + 1,
 		));
-		assert_eq!(AccountBalance::<Test>::get(collection_id, user_2.clone()), 1);
 
 		// validate the new owner & balances
 		let item = Item::<Test>::get(collection_id, item_1).unwrap();
@@ -3171,8 +2891,6 @@ fn claim_swap_should_work() {
 			default_item_config(),
 		));
 
-		assert_eq!(AccountBalance::<Test>::get(collection_id, user_1.clone()), 2);
-		assert_eq!(AccountBalance::<Test>::get(collection_id, user_2.clone()), 3);
 		assert_ok!(Nfts::create_swap(
 			RuntimeOrigin::signed(user_1.clone()),
 			collection_id,
@@ -3263,8 +2981,6 @@ fn claim_swap_should_work() {
 			item_1,
 			Some(price_with_direction.clone()),
 		));
-		assert_eq!(AccountBalance::<Test>::get(collection_id, user_1.clone()), 2);
-		assert_eq!(AccountBalance::<Test>::get(collection_id, user_2.clone()), 3);
 
 		// validate the new owner
 		let item = Item::<Test>::get(collection_id, item_1).unwrap();
@@ -3453,7 +3169,7 @@ fn pallet_level_feature_flags_should_work() {
 			Nfts::approve_transfer(
 				RuntimeOrigin::signed(user_id.clone()),
 				collection_id,
-				Some(item_id),
+				item_id,
 				account(2),
 				None
 			),
@@ -4154,13 +3870,7 @@ fn clear_collection_metadata_works() {
 		assert_ok!(Nfts::destroy(
 			RuntimeOrigin::signed(account(1)),
 			0,
-			DestroyWitness {
-				item_configs: 0,
-				item_metadatas: 0,
-				attributes: 0,
-				allowances: 0,
-				item_holders: 0
-			}
+			DestroyWitness { item_configs: 0, item_metadatas: 0, attributes: 0 }
 		));
 		assert_eq!(Collection::<Test>::get(0), None);
 		assert_eq!(Balances::reserved_balance(&account(1)), 10);
diff --git a/pallets/nfts/src/types.rs b/pallets/nfts/src/types.rs
index 46148d63..f08f1d09 100644
--- a/pallets/nfts/src/types.rs
+++ b/pallets/nfts/src/types.rs
@@ -94,22 +94,18 @@ pub(super) type PreSignedAttributesOf<T, I = ()> = PreSignedAttributes<
 #[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
 pub struct CollectionDetails<AccountId, DepositBalance> {
 	/// Collection's owner.
-	pub owner: AccountId,
+	pub(super) owner: AccountId,
 	/// The total balance deposited by the owner for all the storage data associated with this
 	/// collection. Used by `destroy`.
-	pub owner_deposit: DepositBalance,
+	pub(super) owner_deposit: DepositBalance,
 	/// The total number of outstanding items of this collection.
-	pub items: u32,
+	pub(super) items: u32,
 	/// The total number of outstanding item metadata of this collection.
-	pub item_metadatas: u32,
+	pub(super) item_metadatas: u32,
 	/// The total number of outstanding item configs of this collection.
-	pub item_configs: u32,
-	/// The total number of accounts that hold items of the collection.
-	pub item_holders: u32,
+	pub(super) item_configs: u32,
 	/// The total number of attributes for this collection.
-	pub attributes: u32,
-	/// The total number of allowances to spend all items within collections.
-	pub allowances: u32,
+	pub(super) attributes: u32,
 }
 
 /// Witness data for the destroy transactions.
@@ -121,15 +117,9 @@ pub struct DestroyWitness {
 	/// The total number of outstanding item configs of this collection.
 	#[codec(compact)]
 	pub item_configs: u32,
-	/// The total number of accounts that hold items of the collection.
-	#[codec(compact)]
-	pub item_holders: u32,
 	/// The total number of attributes for this collection.
 	#[codec(compact)]
 	pub attributes: u32,
-	/// The total number of allowances to spend all items within collections.
-	#[codec(compact)]
-	pub allowances: u32,
 }
 
 impl<AccountId, DepositBalance> CollectionDetails<AccountId, DepositBalance> {
@@ -137,9 +127,7 @@ impl<AccountId, DepositBalance> CollectionDetails<AccountId, DepositBalance> {
 		DestroyWitness {
 			item_metadatas: self.item_metadatas,
 			item_configs: self.item_configs,
-			item_holders: self.item_holders,
 			attributes: self.attributes,
-			allowances: self.allowances,
 		}
 	}
 }
diff --git a/pallets/nfts/src/weights.rs b/pallets/nfts/src/weights.rs
index b3307503..c5fb60a2 100644
--- a/pallets/nfts/src/weights.rs
+++ b/pallets/nfts/src/weights.rs
@@ -1,14 +1,30 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 //! Autogenerated weights for `pallet_nfts`
 //!
-//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 40.0.0
-//! DATE: 2024-11-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2024-04-09, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `R0GUE`, CPU: `<UNKNOWN>`
+//! HOSTNAME: `runner-anb7yjbi-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
 //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
 
 // Executed Command:
-// ./target/release/pop-node
+// ./target/production/substrate-node
 // benchmark
 // pallet
 // --chain=dev
@@ -18,11 +34,12 @@
 // --no-storage-info
 // --no-median-slopes
 // --no-min-squares
+// --extrinsic=*
 // --wasm-execution=compiled
 // --heap-pages=4096
-// --output=./pallets/nfts/src/weights.rs
-// --template=./scripts/pallet-weights-template.hbs
-// --extrinsic=
+// --output=./substrate/frame/nfts/src/weights.rs
+// --header=./substrate/HEADER-APACHE2
+// --template=./substrate/.maintain/frame-weight-template.hbs
 
 #![cfg_attr(rustfmt, rustfmt_skip)]
 #![allow(unused_parens)]
@@ -36,7 +53,7 @@ use core::marker::PhantomData;
 pub trait WeightInfo {
 	fn create() -> Weight;
 	fn force_create() -> Weight;
-	fn destroy(m: u32, c: u32, a: u32, h: u32, l: u32, ) -> Weight;
+	fn destroy(m: u32, c: u32, a: u32, ) -> Weight;
 	fn mint() -> Weight;
 	fn force_mint() -> Weight;
 	fn burn() -> Weight;
@@ -59,8 +76,8 @@ pub trait WeightInfo {
 	fn clear_metadata() -> Weight;
 	fn set_collection_metadata() -> Weight;
 	fn clear_collection_metadata() -> Weight;
-	fn approve_transfer(i: u32, ) -> Weight;
-	fn cancel_approval(i: u32, ) -> Weight;
+	fn approve_transfer() -> Weight;
+	fn cancel_approval() -> Weight;
 	fn clear_all_transfer_approvals() -> Weight;
 	fn set_accept_ownership() -> Weight;
 	fn set_collection_max_supply() -> Weight;
@@ -81,7 +98,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `Nfts::NextCollectionId` (r:1 w:1)
 	/// Proof: `Nfts::NextCollectionId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:0 w:1)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:0 w:1)
@@ -90,17 +107,17 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::CollectionAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
 	fn create() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `105`
-		//  Estimated: `3557`
-		// Minimum execution time: 28_000_000 picoseconds.
-		Weight::from_parts(29_000_000, 3557)
+		//  Measured:  `216`
+		//  Estimated: `3549`
+		// Minimum execution time: 34_863_000 picoseconds.
+		Weight::from_parts(36_679_000, 3549)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Nfts::NextCollectionId` (r:1 w:1)
 	/// Proof: `Nfts::NextCollectionId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:0 w:1)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:0 w:1)
@@ -109,25 +126,21 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::CollectionAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
 	fn force_create() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3`
-		//  Estimated: `3557`
-		// Minimum execution time: 15_000_000 picoseconds.
-		Weight::from_parts(15_000_000, 3557)
+		//  Measured:  `76`
+		//  Estimated: `3549`
+		// Minimum execution time: 19_631_000 picoseconds.
+		Weight::from_parts(20_384_000, 3549)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemMetadataOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemMetadataOf` (`max_values`: None, `max_size`: Some(347), added: 2822, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:1)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:1001 w:1000)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:1 w:0)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Allowances` (r:1 w:0)
-	/// Proof: `Nfts::Allowances` (`max_values`: None, `max_size`: Some(109), added: 2584, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1000 w:1000)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionMetadataOf` (r:0 w:1)
@@ -139,17 +152,15 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `m` is `[0, 1000]`.
 	/// The range of component `c` is `[0, 1000]`.
 	/// The range of component `a` is `[0, 1000]`.
-	/// The range of component `h` is `[0, 1000]`.
-	/// The range of component `l` is `[0, 1000]`.
-	fn destroy(_m: u32, _c: u32, a: u32, _h: u32, _l: u32, ) -> Weight {
+	fn destroy(_m: u32, _c: u32, a: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `32875 + a * (366 ±0)`
+		//  Measured:  `32204 + a * (366 ±0)`
 		//  Estimated: `2523990 + a * (2954 ±0)`
-		// Minimum execution time: 982_000_000 picoseconds.
-		Weight::from_parts(4_613_129_128, 2523990)
-			// Standard Error: 125_087
-			.saturating_add(Weight::from_parts(5_072_767, 0).saturating_mul(a.into()))
-			.saturating_add(T::DbWeight::get().reads(1006_u64))
+		// Minimum execution time: 1_282_083_000 picoseconds.
+		Weight::from_parts(1_249_191_963, 2523990)
+			// Standard Error: 4_719
+			.saturating_add(Weight::from_parts(6_470_227, 0).saturating_mul(a.into()))
+			.saturating_add(T::DbWeight::get().reads(1004_u64))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(a.into())))
 			.saturating_add(T::DbWeight::get().writes(1005_u64))
 			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(a.into())))
@@ -160,78 +171,72 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:1 w:1)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:1)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	fn mint() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `390`
+		//  Measured:  `455`
 		//  Estimated: `4326`
-		// Minimum execution time: 40_000_000 picoseconds.
-		Weight::from_parts(41_000_000, 4326)
-			.saturating_add(T::DbWeight::get().reads(6_u64))
-			.saturating_add(T::DbWeight::get().writes(5_u64))
+		// Minimum execution time: 49_055_000 picoseconds.
+		Weight::from_parts(50_592_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
 	}
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:1 w:1)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:1)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	fn force_mint() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `390`
+		//  Measured:  `455`
 		//  Estimated: `4326`
-		// Minimum execution time: 39_000_000 picoseconds.
-		Weight::from_parts(39_000_000, 4326)
-			.saturating_add(T::DbWeight::get().reads(6_u64))
-			.saturating_add(T::DbWeight::get().writes(5_u64))
+		// Minimum execution time: 47_102_000 picoseconds.
+		Weight::from_parts(48_772_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
 	}
 	/// Storage: `Nfts::Attribute` (r:1 w:0)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemMetadataOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemMetadataOf` (`max_values`: None, `max_size`: Some(347), added: 2822, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:1 w:1)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:1)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemPriceOf` (r:0 w:1)
 	/// Proof: `Nfts::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemAttributesApprovalsOf` (r:0 w:1)
-	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(1001), added: 3476, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(681), added: 3156, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::PendingSwapOf` (r:0 w:1)
 	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
 	fn burn() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `584`
+		//  Measured:  `564`
 		//  Estimated: `4326`
-		// Minimum execution time: 45_000_000 picoseconds.
-		Weight::from_parts(46_000_000, 4326)
-			.saturating_add(T::DbWeight::get().reads(6_u64))
-			.saturating_add(T::DbWeight::get().writes(8_u64))
+		// Minimum execution time: 52_968_000 picoseconds.
+		Weight::from_parts(55_136_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
 	}
-	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Collection` (r:1 w:0)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:1 w:0)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
@@ -240,8 +245,6 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:2 w:2)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:2)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemPriceOf` (r:0 w:1)
@@ -250,15 +253,15 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
 	fn transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `613`
-		//  Estimated: `6068`
-		// Minimum execution time: 38_000_000 picoseconds.
-		Weight::from_parts(38_000_000, 6068)
-			.saturating_add(T::DbWeight::get().reads(7_u64))
-			.saturating_add(T::DbWeight::get().writes(8_u64))
+		//  Measured:  `593`
+		//  Estimated: `4326`
+		// Minimum execution time: 41_140_000 picoseconds.
+		Weight::from_parts(43_288_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:0)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Item` (r:5000 w:5000)
@@ -266,12 +269,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `i` is `[0, 5000]`.
 	fn redeposit(i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `698 + i * (108 ±0)`
-		//  Estimated: `3557 + i * (3336 ±0)`
-		// Minimum execution time: 10_000_000 picoseconds.
-		Weight::from_parts(11_000_000, 3557)
-			// Standard Error: 30_743
-			.saturating_add(Weight::from_parts(15_569_470, 0).saturating_mul(i.into()))
+		//  Measured:  `763 + i * (108 ±0)`
+		//  Estimated: `3549 + i * (3336 ±0)`
+		// Minimum execution time: 14_433_000 picoseconds.
+		Weight::from_parts(14_664_000, 3549)
+			// Standard Error: 23_078
+			.saturating_add(Weight::from_parts(15_911_377, 0).saturating_mul(i.into()))
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(i.into())))
 			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into())))
@@ -283,10 +286,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	fn lock_item_transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `395`
+		//  Measured:  `435`
 		//  Estimated: `3534`
-		// Minimum execution time: 14_000_000 picoseconds.
-		Weight::from_parts(14_000_000, 3534)
+		// Minimum execution time: 18_307_000 picoseconds.
+		Weight::from_parts(18_966_000, 3534)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -296,79 +299,79 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	fn unlock_item_transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `395`
+		//  Measured:  `435`
 		//  Estimated: `3534`
-		// Minimum execution time: 13_000_000 picoseconds.
-		Weight::from_parts(14_000_000, 3534)
+		// Minimum execution time: 18_078_000 picoseconds.
+		Weight::from_parts(18_593_000, 3534)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:0)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	fn lock_collection() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `275`
-		//  Estimated: `3557`
-		// Minimum execution time: 11_000_000 picoseconds.
-		Weight::from_parts(11_000_000, 3557)
+		//  Measured:  `340`
+		//  Estimated: `3549`
+		// Minimum execution time: 15_175_000 picoseconds.
+		Weight::from_parts(15_762_000, 3549)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::OwnershipAcceptance` (r:1 w:1)
 	/// Proof: `Nfts::OwnershipAcceptance` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionAccount` (r:0 w:2)
 	/// Proof: `Nfts::CollectionAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
 	fn transfer_ownership() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `425`
+		//  Measured:  `562`
 		//  Estimated: `3593`
-		// Minimum execution time: 18_000_000 picoseconds.
-		Weight::from_parts(19_000_000, 3593)
+		// Minimum execution time: 26_164_000 picoseconds.
+		Weight::from_parts(27_117_000, 3593)
 			.saturating_add(T::DbWeight::get().reads(3_u64))
 			.saturating_add(T::DbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:2 w:4)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	fn set_team() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `304`
+		//  Measured:  `369`
 		//  Estimated: `6078`
-		// Minimum execution time: 30_000_000 picoseconds.
-		Weight::from_parts(31_000_000, 6078)
+		// Minimum execution time: 38_523_000 picoseconds.
+		Weight::from_parts(39_486_000, 6078)
 			.saturating_add(T::DbWeight::get().reads(3_u64))
 			.saturating_add(T::DbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionAccount` (r:0 w:2)
 	/// Proof: `Nfts::CollectionAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
 	fn force_collection_owner() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `246`
-		//  Estimated: `3557`
-		// Minimum execution time: 11_000_000 picoseconds.
-		Weight::from_parts(12_000_000, 3557)
+		//  Measured:  `311`
+		//  Estimated: `3549`
+		// Minimum execution time: 15_733_000 picoseconds.
+		Weight::from_parts(16_227_000, 3549)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:0)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:0 w:1)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	fn force_collection_config() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `203`
-		//  Estimated: `3557`
-		// Minimum execution time: 9_000_000 picoseconds.
-		Weight::from_parts(9_000_000, 3557)
+		//  Measured:  `276`
+		//  Estimated: `3549`
+		// Minimum execution time: 12_042_000 picoseconds.
+		Weight::from_parts(12_690_000, 3549)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -378,15 +381,15 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	fn lock_item_properties() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `395`
+		//  Measured:  `435`
 		//  Estimated: `3534`
-		// Minimum execution time: 12_000_000 picoseconds.
-		Weight::from_parts(13_000_000, 3534)
+		// Minimum execution time: 17_165_000 picoseconds.
+		Weight::from_parts(17_769_000, 3534)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
@@ -397,23 +400,23 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	fn set_attribute() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `507`
+		//  Measured:  `539`
 		//  Estimated: `3944`
-		// Minimum execution time: 38_000_000 picoseconds.
-		Weight::from_parts(39_000_000, 3944)
+		// Minimum execution time: 48_862_000 picoseconds.
+		Weight::from_parts(50_584_000, 3944)
 			.saturating_add(T::DbWeight::get().reads(5_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:1 w:1)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	fn force_set_attribute() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `279`
+		//  Measured:  `344`
 		//  Estimated: `3944`
-		// Minimum execution time: 19_000_000 picoseconds.
-		Weight::from_parts(19_000_000, 3944)
+		// Minimum execution time: 24_665_000 picoseconds.
+		Weight::from_parts(25_465_000, 3944)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -424,33 +427,33 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	fn clear_attribute() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `951`
+		//  Measured:  `983`
 		//  Estimated: `3944`
-		// Minimum execution time: 35_000_000 picoseconds.
-		Weight::from_parts(37_000_000, 3944)
+		// Minimum execution time: 44_617_000 picoseconds.
+		Weight::from_parts(46_458_000, 3944)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Nfts::Item` (r:1 w:0)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemAttributesApprovalsOf` (r:1 w:1)
-	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(1001), added: 3476, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(681), added: 3156, mode: `MaxEncodedLen`)
 	fn approve_item_attributes() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `308`
-		//  Estimated: `4466`
-		// Minimum execution time: 11_000_000 picoseconds.
-		Weight::from_parts(12_000_000, 4466)
+		//  Measured:  `381`
+		//  Estimated: `4326`
+		// Minimum execution time: 15_710_000 picoseconds.
+		Weight::from_parts(16_191_000, 4326)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::Item` (r:1 w:0)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemAttributesApprovalsOf` (r:1 w:1)
-	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(1001), added: 3476, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(681), added: 3156, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:1001 w:1000)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `System::Account` (r:1 w:1)
@@ -458,12 +461,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `n` is `[0, 1000]`.
 	fn cancel_item_attributes_approval(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `686 + n * (398 ±0)`
-		//  Estimated: `4466 + n * (2954 ±0)`
-		// Minimum execution time: 18_000_000 picoseconds.
-		Weight::from_parts(19_000_000, 4466)
-			// Standard Error: 10_431
-			.saturating_add(Weight::from_parts(4_776_454, 0).saturating_mul(n.into()))
+		//  Measured:  `831 + n * (398 ±0)`
+		//  Estimated: `4326 + n * (2954 ±0)`
+		// Minimum execution time: 24_447_000 picoseconds.
+		Weight::from_parts(25_144_000, 4326)
+			// Standard Error: 4_872
+			.saturating_add(Weight::from_parts(6_523_101, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
@@ -473,7 +476,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
@@ -482,10 +485,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::ItemMetadataOf` (`max_values`: None, `max_size`: Some(347), added: 2822, mode: `MaxEncodedLen`)
 	fn set_metadata() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `507`
+		//  Measured:  `539`
 		//  Estimated: `3812`
-		// Minimum execution time: 30_000_000 picoseconds.
-		Weight::from_parts(31_000_000, 3812)
+		// Minimum execution time: 39_990_000 picoseconds.
+		Weight::from_parts(41_098_000, 3812)
 			.saturating_add(T::DbWeight::get().reads(5_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -494,15 +497,15 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `Nfts::ItemMetadataOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemMetadataOf` (`max_values`: None, `max_size`: Some(347), added: 2822, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	fn clear_metadata() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `817`
+		//  Measured:  `849`
 		//  Estimated: `3812`
-		// Minimum execution time: 29_000_000 picoseconds.
-		Weight::from_parts(30_000_000, 3812)
+		// Minimum execution time: 38_030_000 picoseconds.
+		Weight::from_parts(39_842_000, 3812)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -511,32 +514,32 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionMetadataOf` (r:1 w:1)
 	/// Proof: `Nfts::CollectionMetadataOf` (`max_values`: None, `max_size`: Some(294), added: 2769, mode: `MaxEncodedLen`)
 	fn set_collection_metadata() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `333`
+		//  Measured:  `398`
 		//  Estimated: `3759`
-		// Minimum execution time: 28_000_000 picoseconds.
-		Weight::from_parts(28_000_000, 3759)
+		// Minimum execution time: 36_778_000 picoseconds.
+		Weight::from_parts(38_088_000, 3759)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionMetadataOf` (r:1 w:1)
 	/// Proof: `Nfts::CollectionMetadataOf` (`max_values`: None, `max_size`: Some(294), added: 2769, mode: `MaxEncodedLen`)
 	fn clear_collection_metadata() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `651`
+		//  Measured:  `716`
 		//  Estimated: `3759`
-		// Minimum execution time: 27_000_000 picoseconds.
-		Weight::from_parts(28_000_000, 3759)
+		// Minimum execution time: 36_887_000 picoseconds.
+		Weight::from_parts(38_406_000, 3759)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -544,46 +547,34 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Allowances` (r:1 w:1)
-	/// Proof: `Nfts::Allowances` (`max_values`: None, `max_size`: Some(109), added: 2584, mode: `MaxEncodedLen`)
-	/// The range of component `i` is `[0, 1]`.
-	fn approve_transfer(i: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `308 + i * (29 ±0)`
-		//  Estimated: `3574 + i * (2163 ±0)`
-		// Minimum execution time: 14_000_000 picoseconds.
-		Weight::from_parts(16_969_387, 3574)
-			.saturating_add(T::DbWeight::get().reads(3_u64))
-			.saturating_add(T::DbWeight::get().writes(2_u64))
-			.saturating_add(Weight::from_parts(0, 2163).saturating_mul(i.into()))
+	fn approve_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `410`
+		//  Estimated: `4326`
+		// Minimum execution time: 18_734_000 picoseconds.
+		Weight::from_parts(19_267_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Allowances` (r:0 w:1)
-	/// Proof: `Nfts::Allowances` (`max_values`: None, `max_size`: Some(109), added: 2584, mode: `MaxEncodedLen`)
-	/// The range of component `i` is `[0, 1]`.
-	fn cancel_approval(i: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `312 + i * (33 ±0)`
-		//  Estimated: `3557 + i * (2163 ±0)`
-		// Minimum execution time: 11_000_000 picoseconds.
-		Weight::from_parts(14_000_000, 3557)
+	fn cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `418`
+		//  Estimated: `4326`
+		// Minimum execution time: 16_080_000 picoseconds.
+		Weight::from_parts(16_603_000, 4326)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
-			.saturating_add(T::DbWeight::get().writes(2_u64))
-			.saturating_add(Weight::from_parts(0, 2163).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	fn clear_all_transfer_approvals() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `345`
+		//  Measured:  `418`
 		//  Estimated: `4326`
-		// Minimum execution time: 11_000_000 picoseconds.
-		Weight::from_parts(11_000_000, 4326)
+		// Minimum execution time: 15_013_000 picoseconds.
+		Weight::from_parts(15_607_000, 4326)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -591,23 +582,23 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::OwnershipAcceptance` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
 	fn set_accept_ownership() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3`
+		//  Measured:  `76`
 		//  Estimated: `3517`
-		// Minimum execution time: 9_000_000 picoseconds.
-		Weight::from_parts(9_000_000, 3517)
+		// Minimum execution time: 13_077_000 picoseconds.
+		Weight::from_parts(13_635_000, 3517)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:0)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	fn set_collection_max_supply() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `275`
-		//  Estimated: `3557`
-		// Minimum execution time: 12_000_000 picoseconds.
-		Weight::from_parts(13_000_000, 3557)
+		//  Measured:  `340`
+		//  Estimated: `3549`
+		// Minimum execution time: 17_146_000 picoseconds.
+		Weight::from_parts(17_453_000, 3549)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -617,10 +608,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	fn update_mint_settings() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `250`
+		//  Measured:  `323`
 		//  Estimated: `3538`
-		// Minimum execution time: 12_000_000 picoseconds.
-		Weight::from_parts(12_000_000, 3538)
+		// Minimum execution time: 16_102_000 picoseconds.
+		Weight::from_parts(16_629_000, 3538)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -634,10 +625,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
 	fn set_price() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `478`
+		//  Measured:  `518`
 		//  Estimated: `4326`
-		// Minimum execution time: 15_000_000 picoseconds.
-		Weight::from_parts(16_000_000, 4326)
+		// Minimum execution time: 22_118_000 picoseconds.
+		Weight::from_parts(22_849_000, 4326)
 			.saturating_add(T::DbWeight::get().reads(3_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -645,38 +636,36 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemPriceOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Collection` (r:1 w:0)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:1 w:0)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:2 w:2)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:2)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::PendingSwapOf` (r:0 w:1)
 	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
 	fn buy_item() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `725`
-		//  Estimated: `6068`
-		// Minimum execution time: 43_000_000 picoseconds.
-		Weight::from_parts(44_000_000, 6068)
-			.saturating_add(T::DbWeight::get().reads(8_u64))
-			.saturating_add(T::DbWeight::get().writes(8_u64))
+		//  Measured:  `705`
+		//  Estimated: `4326`
+		// Minimum execution time: 50_369_000 picoseconds.
+		Weight::from_parts(51_816_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
 	}
 	/// The range of component `n` is `[0, 10]`.
 	fn pay_tips(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_000_000 picoseconds.
-		Weight::from_parts(2_101_372, 0)
-			// Standard Error: 5_552
-			.saturating_add(Weight::from_parts(1_704_563, 0).saturating_mul(n.into()))
+		// Minimum execution time: 2_203_000 picoseconds.
+		Weight::from_parts(3_710_869, 0)
+			// Standard Error: 8_094
+			.saturating_add(Weight::from_parts(2_201_869, 0).saturating_mul(n.into()))
 	}
 	/// Storage: `Nfts::Item` (r:2 w:0)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
@@ -684,10 +673,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
 	fn create_swap() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `421`
+		//  Measured:  `494`
 		//  Estimated: `7662`
-		// Minimum execution time: 13_000_000 picoseconds.
-		Weight::from_parts(14_000_000, 7662)
+		// Minimum execution time: 18_893_000 picoseconds.
+		Weight::from_parts(19_506_000, 7662)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -697,10 +686,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	fn cancel_swap() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `440`
+		//  Measured:  `513`
 		//  Estimated: `4326`
-		// Minimum execution time: 13_000_000 picoseconds.
-		Weight::from_parts(14_000_000, 4326)
+		// Minimum execution time: 19_086_000 picoseconds.
+		Weight::from_parts(19_609_000, 4326)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -708,28 +697,26 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::PendingSwapOf` (r:1 w:2)
 	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Collection` (r:1 w:0)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:2 w:0)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:2 w:0)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:2 w:2)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:4)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemPriceOf` (r:0 w:2)
 	/// Proof: `Nfts::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
 	fn claim_swap() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `915`
+		//  Measured:  `834`
 		//  Estimated: `7662`
-		// Minimum execution time: 78_000_000 picoseconds.
-		Weight::from_parts(79_000_000, 7662)
-			.saturating_add(T::DbWeight::get().reads(11_u64))
-			.saturating_add(T::DbWeight::get().writes(13_u64))
+		// Minimum execution time: 84_103_000 picoseconds.
+		Weight::from_parts(85_325_000, 7662)
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(10_u64))
 	}
 	/// Storage: `Nfts::CollectionRoleOf` (r:2 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
@@ -738,9 +725,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:1 w:1)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `System::Account` (r:1 w:1)
@@ -754,26 +739,26 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `n` is `[0, 10]`.
 	fn mint_pre_signed(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `493`
+		//  Measured:  `629`
 		//  Estimated: `6078 + n * (2954 ±0)`
-		// Minimum execution time: 101_000_000 picoseconds.
-		Weight::from_parts(102_689_064, 6078)
-			// Standard Error: 25_175
-			.saturating_add(Weight::from_parts(27_553_304, 0).saturating_mul(n.into()))
-			.saturating_add(T::DbWeight::get().reads(9_u64))
+		// Minimum execution time: 128_363_000 picoseconds.
+		Weight::from_parts(139_474_918, 6078)
+			// Standard Error: 79_252
+			.saturating_add(Weight::from_parts(31_384_027, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
-			.saturating_add(T::DbWeight::get().writes(7_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
 			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
 			.saturating_add(Weight::from_parts(0, 2954).saturating_mul(n.into()))
 	}
 	/// Storage: `Nfts::Item` (r:1 w:0)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemAttributesApprovalsOf` (r:1 w:1)
-	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(1001), added: 3476, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(681), added: 3156, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:10 w:10)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `System::Account` (r:1 w:1)
@@ -781,12 +766,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `n` is `[0, 10]`.
 	fn set_attributes_pre_signed(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `522`
-		//  Estimated: `4466 + n * (2954 ±0)`
-		// Minimum execution time: 50_000_000 picoseconds.
-		Weight::from_parts(55_735_551, 4466)
-			// Standard Error: 34_490
-			.saturating_add(Weight::from_parts(26_799_214, 0).saturating_mul(n.into()))
+		//  Measured:  `659`
+		//  Estimated: `4326 + n * (2954 ±0)`
+		// Minimum execution time: 66_688_000 picoseconds.
+		Weight::from_parts(79_208_379, 4326)
+			// Standard Error: 74_020
+			.saturating_add(Weight::from_parts(31_028_221, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
@@ -800,7 +785,7 @@ impl WeightInfo for () {
 	/// Storage: `Nfts::NextCollectionId` (r:1 w:1)
 	/// Proof: `Nfts::NextCollectionId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:0 w:1)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:0 w:1)
@@ -809,17 +794,17 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::CollectionAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
 	fn create() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `105`
-		//  Estimated: `3557`
-		// Minimum execution time: 28_000_000 picoseconds.
-		Weight::from_parts(29_000_000, 3557)
+		//  Measured:  `216`
+		//  Estimated: `3549`
+		// Minimum execution time: 34_863_000 picoseconds.
+		Weight::from_parts(36_679_000, 3549)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Nfts::NextCollectionId` (r:1 w:1)
 	/// Proof: `Nfts::NextCollectionId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:0 w:1)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:0 w:1)
@@ -828,25 +813,21 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::CollectionAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
 	fn force_create() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3`
-		//  Estimated: `3557`
-		// Minimum execution time: 15_000_000 picoseconds.
-		Weight::from_parts(15_000_000, 3557)
+		//  Measured:  `76`
+		//  Estimated: `3549`
+		// Minimum execution time: 19_631_000 picoseconds.
+		Weight::from_parts(20_384_000, 3549)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemMetadataOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemMetadataOf` (`max_values`: None, `max_size`: Some(347), added: 2822, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:1)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:1001 w:1000)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:1 w:0)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Allowances` (r:1 w:0)
-	/// Proof: `Nfts::Allowances` (`max_values`: None, `max_size`: Some(109), added: 2584, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1000 w:1000)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionMetadataOf` (r:0 w:1)
@@ -858,17 +839,15 @@ impl WeightInfo for () {
 	/// The range of component `m` is `[0, 1000]`.
 	/// The range of component `c` is `[0, 1000]`.
 	/// The range of component `a` is `[0, 1000]`.
-	/// The range of component `h` is `[0, 1000]`.
-	/// The range of component `l` is `[0, 1000]`.
-	fn destroy(_m: u32, _c: u32, a: u32, _h: u32, _l: u32, ) -> Weight {
+	fn destroy(_m: u32, _c: u32, a: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `32875 + a * (366 ±0)`
+		//  Measured:  `32204 + a * (366 ±0)`
 		//  Estimated: `2523990 + a * (2954 ±0)`
-		// Minimum execution time: 982_000_000 picoseconds.
-		Weight::from_parts(4_613_129_128, 2523990)
-			// Standard Error: 125_087
-			.saturating_add(Weight::from_parts(5_072_767, 0).saturating_mul(a.into()))
-			.saturating_add(RocksDbWeight::get().reads(1006_u64))
+		// Minimum execution time: 1_282_083_000 picoseconds.
+		Weight::from_parts(1_249_191_963, 2523990)
+			// Standard Error: 4_719
+			.saturating_add(Weight::from_parts(6_470_227, 0).saturating_mul(a.into()))
+			.saturating_add(RocksDbWeight::get().reads(1004_u64))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(a.into())))
 			.saturating_add(RocksDbWeight::get().writes(1005_u64))
 			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(a.into())))
@@ -879,78 +858,72 @@ impl WeightInfo for () {
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:1 w:1)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:1)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	fn mint() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `390`
+		//  Measured:  `455`
 		//  Estimated: `4326`
-		// Minimum execution time: 40_000_000 picoseconds.
-		Weight::from_parts(41_000_000, 4326)
-			.saturating_add(RocksDbWeight::get().reads(6_u64))
-			.saturating_add(RocksDbWeight::get().writes(5_u64))
+		// Minimum execution time: 49_055_000 picoseconds.
+		Weight::from_parts(50_592_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
 	}
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:1 w:1)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:1)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	fn force_mint() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `390`
+		//  Measured:  `455`
 		//  Estimated: `4326`
-		// Minimum execution time: 39_000_000 picoseconds.
-		Weight::from_parts(39_000_000, 4326)
-			.saturating_add(RocksDbWeight::get().reads(6_u64))
-			.saturating_add(RocksDbWeight::get().writes(5_u64))
+		// Minimum execution time: 47_102_000 picoseconds.
+		Weight::from_parts(48_772_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
 	}
 	/// Storage: `Nfts::Attribute` (r:1 w:0)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemMetadataOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemMetadataOf` (`max_values`: None, `max_size`: Some(347), added: 2822, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:1 w:1)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:1)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemPriceOf` (r:0 w:1)
 	/// Proof: `Nfts::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemAttributesApprovalsOf` (r:0 w:1)
-	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(1001), added: 3476, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(681), added: 3156, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::PendingSwapOf` (r:0 w:1)
 	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
 	fn burn() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `584`
+		//  Measured:  `564`
 		//  Estimated: `4326`
-		// Minimum execution time: 45_000_000 picoseconds.
-		Weight::from_parts(46_000_000, 4326)
-			.saturating_add(RocksDbWeight::get().reads(6_u64))
-			.saturating_add(RocksDbWeight::get().writes(8_u64))
+		// Minimum execution time: 52_968_000 picoseconds.
+		Weight::from_parts(55_136_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
 	}
-	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Collection` (r:1 w:0)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:1 w:0)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
@@ -959,8 +932,6 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:2 w:2)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:2)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemPriceOf` (r:0 w:1)
@@ -969,15 +940,15 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
 	fn transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `613`
-		//  Estimated: `6068`
-		// Minimum execution time: 38_000_000 picoseconds.
-		Weight::from_parts(38_000_000, 6068)
-			.saturating_add(RocksDbWeight::get().reads(7_u64))
-			.saturating_add(RocksDbWeight::get().writes(8_u64))
+		//  Measured:  `593`
+		//  Estimated: `4326`
+		// Minimum execution time: 41_140_000 picoseconds.
+		Weight::from_parts(43_288_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:0)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Item` (r:5000 w:5000)
@@ -985,12 +956,12 @@ impl WeightInfo for () {
 	/// The range of component `i` is `[0, 5000]`.
 	fn redeposit(i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `698 + i * (108 ±0)`
-		//  Estimated: `3557 + i * (3336 ±0)`
-		// Minimum execution time: 10_000_000 picoseconds.
-		Weight::from_parts(11_000_000, 3557)
-			// Standard Error: 30_743
-			.saturating_add(Weight::from_parts(15_569_470, 0).saturating_mul(i.into()))
+		//  Measured:  `763 + i * (108 ±0)`
+		//  Estimated: `3549 + i * (3336 ±0)`
+		// Minimum execution time: 14_433_000 picoseconds.
+		Weight::from_parts(14_664_000, 3549)
+			// Standard Error: 23_078
+			.saturating_add(Weight::from_parts(15_911_377, 0).saturating_mul(i.into()))
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(i.into())))
 			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into())))
@@ -1002,10 +973,10 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	fn lock_item_transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `395`
+		//  Measured:  `435`
 		//  Estimated: `3534`
-		// Minimum execution time: 14_000_000 picoseconds.
-		Weight::from_parts(14_000_000, 3534)
+		// Minimum execution time: 18_307_000 picoseconds.
+		Weight::from_parts(18_966_000, 3534)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1015,79 +986,79 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	fn unlock_item_transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `395`
+		//  Measured:  `435`
 		//  Estimated: `3534`
-		// Minimum execution time: 13_000_000 picoseconds.
-		Weight::from_parts(14_000_000, 3534)
+		// Minimum execution time: 18_078_000 picoseconds.
+		Weight::from_parts(18_593_000, 3534)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:0)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	fn lock_collection() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `275`
-		//  Estimated: `3557`
-		// Minimum execution time: 11_000_000 picoseconds.
-		Weight::from_parts(11_000_000, 3557)
+		//  Measured:  `340`
+		//  Estimated: `3549`
+		// Minimum execution time: 15_175_000 picoseconds.
+		Weight::from_parts(15_762_000, 3549)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::OwnershipAcceptance` (r:1 w:1)
 	/// Proof: `Nfts::OwnershipAcceptance` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionAccount` (r:0 w:2)
 	/// Proof: `Nfts::CollectionAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
 	fn transfer_ownership() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `425`
+		//  Measured:  `562`
 		//  Estimated: `3593`
-		// Minimum execution time: 18_000_000 picoseconds.
-		Weight::from_parts(19_000_000, 3593)
+		// Minimum execution time: 26_164_000 picoseconds.
+		Weight::from_parts(27_117_000, 3593)
 			.saturating_add(RocksDbWeight::get().reads(3_u64))
 			.saturating_add(RocksDbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:2 w:4)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	fn set_team() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `304`
+		//  Measured:  `369`
 		//  Estimated: `6078`
-		// Minimum execution time: 30_000_000 picoseconds.
-		Weight::from_parts(31_000_000, 6078)
+		// Minimum execution time: 38_523_000 picoseconds.
+		Weight::from_parts(39_486_000, 6078)
 			.saturating_add(RocksDbWeight::get().reads(3_u64))
 			.saturating_add(RocksDbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionAccount` (r:0 w:2)
 	/// Proof: `Nfts::CollectionAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
 	fn force_collection_owner() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `246`
-		//  Estimated: `3557`
-		// Minimum execution time: 11_000_000 picoseconds.
-		Weight::from_parts(12_000_000, 3557)
+		//  Measured:  `311`
+		//  Estimated: `3549`
+		// Minimum execution time: 15_733_000 picoseconds.
+		Weight::from_parts(16_227_000, 3549)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:0)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:0 w:1)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	fn force_collection_config() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `203`
-		//  Estimated: `3557`
-		// Minimum execution time: 9_000_000 picoseconds.
-		Weight::from_parts(9_000_000, 3557)
+		//  Measured:  `276`
+		//  Estimated: `3549`
+		// Minimum execution time: 12_042_000 picoseconds.
+		Weight::from_parts(12_690_000, 3549)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1097,15 +1068,15 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	fn lock_item_properties() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `395`
+		//  Measured:  `435`
 		//  Estimated: `3534`
-		// Minimum execution time: 12_000_000 picoseconds.
-		Weight::from_parts(13_000_000, 3534)
+		// Minimum execution time: 17_165_000 picoseconds.
+		Weight::from_parts(17_769_000, 3534)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
@@ -1116,23 +1087,23 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	fn set_attribute() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `507`
+		//  Measured:  `539`
 		//  Estimated: `3944`
-		// Minimum execution time: 38_000_000 picoseconds.
-		Weight::from_parts(39_000_000, 3944)
+		// Minimum execution time: 48_862_000 picoseconds.
+		Weight::from_parts(50_584_000, 3944)
 			.saturating_add(RocksDbWeight::get().reads(5_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:1 w:1)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	fn force_set_attribute() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `279`
+		//  Measured:  `344`
 		//  Estimated: `3944`
-		// Minimum execution time: 19_000_000 picoseconds.
-		Weight::from_parts(19_000_000, 3944)
+		// Minimum execution time: 24_665_000 picoseconds.
+		Weight::from_parts(25_465_000, 3944)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -1143,33 +1114,33 @@ impl WeightInfo for () {
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	fn clear_attribute() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `951`
+		//  Measured:  `983`
 		//  Estimated: `3944`
-		// Minimum execution time: 35_000_000 picoseconds.
-		Weight::from_parts(37_000_000, 3944)
+		// Minimum execution time: 44_617_000 picoseconds.
+		Weight::from_parts(46_458_000, 3944)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Nfts::Item` (r:1 w:0)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemAttributesApprovalsOf` (r:1 w:1)
-	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(1001), added: 3476, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(681), added: 3156, mode: `MaxEncodedLen`)
 	fn approve_item_attributes() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `308`
-		//  Estimated: `4466`
-		// Minimum execution time: 11_000_000 picoseconds.
-		Weight::from_parts(12_000_000, 4466)
+		//  Measured:  `381`
+		//  Estimated: `4326`
+		// Minimum execution time: 15_710_000 picoseconds.
+		Weight::from_parts(16_191_000, 4326)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::Item` (r:1 w:0)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemAttributesApprovalsOf` (r:1 w:1)
-	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(1001), added: 3476, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(681), added: 3156, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:1001 w:1000)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `System::Account` (r:1 w:1)
@@ -1177,12 +1148,12 @@ impl WeightInfo for () {
 	/// The range of component `n` is `[0, 1000]`.
 	fn cancel_item_attributes_approval(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `686 + n * (398 ±0)`
-		//  Estimated: `4466 + n * (2954 ±0)`
-		// Minimum execution time: 18_000_000 picoseconds.
-		Weight::from_parts(19_000_000, 4466)
-			// Standard Error: 10_431
-			.saturating_add(Weight::from_parts(4_776_454, 0).saturating_mul(n.into()))
+		//  Measured:  `831 + n * (398 ±0)`
+		//  Estimated: `4326 + n * (2954 ±0)`
+		// Minimum execution time: 24_447_000 picoseconds.
+		Weight::from_parts(25_144_000, 4326)
+			// Standard Error: 4_872
+			.saturating_add(Weight::from_parts(6_523_101, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
@@ -1192,7 +1163,7 @@ impl WeightInfo for () {
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
@@ -1201,10 +1172,10 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::ItemMetadataOf` (`max_values`: None, `max_size`: Some(347), added: 2822, mode: `MaxEncodedLen`)
 	fn set_metadata() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `507`
+		//  Measured:  `539`
 		//  Estimated: `3812`
-		// Minimum execution time: 30_000_000 picoseconds.
-		Weight::from_parts(31_000_000, 3812)
+		// Minimum execution time: 39_990_000 picoseconds.
+		Weight::from_parts(41_098_000, 3812)
 			.saturating_add(RocksDbWeight::get().reads(5_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -1213,15 +1184,15 @@ impl WeightInfo for () {
 	/// Storage: `Nfts::ItemMetadataOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemMetadataOf` (`max_values`: None, `max_size`: Some(347), added: 2822, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	fn clear_metadata() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `817`
+		//  Measured:  `849`
 		//  Estimated: `3812`
-		// Minimum execution time: 29_000_000 picoseconds.
-		Weight::from_parts(30_000_000, 3812)
+		// Minimum execution time: 38_030_000 picoseconds.
+		Weight::from_parts(39_842_000, 3812)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -1230,32 +1201,32 @@ impl WeightInfo for () {
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionMetadataOf` (r:1 w:1)
 	/// Proof: `Nfts::CollectionMetadataOf` (`max_values`: None, `max_size`: Some(294), added: 2769, mode: `MaxEncodedLen`)
 	fn set_collection_metadata() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `333`
+		//  Measured:  `398`
 		//  Estimated: `3759`
-		// Minimum execution time: 28_000_000 picoseconds.
-		Weight::from_parts(28_000_000, 3759)
+		// Minimum execution time: 36_778_000 picoseconds.
+		Weight::from_parts(38_088_000, 3759)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Nfts::CollectionRoleOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionMetadataOf` (r:1 w:1)
 	/// Proof: `Nfts::CollectionMetadataOf` (`max_values`: None, `max_size`: Some(294), added: 2769, mode: `MaxEncodedLen`)
 	fn clear_collection_metadata() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `651`
+		//  Measured:  `716`
 		//  Estimated: `3759`
-		// Minimum execution time: 27_000_000 picoseconds.
-		Weight::from_parts(28_000_000, 3759)
+		// Minimum execution time: 36_887_000 picoseconds.
+		Weight::from_parts(38_406_000, 3759)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -1263,46 +1234,34 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Allowances` (r:1 w:1)
-	/// Proof: `Nfts::Allowances` (`max_values`: None, `max_size`: Some(109), added: 2584, mode: `MaxEncodedLen`)
-	/// The range of component `i` is `[0, 1]`.
-	fn approve_transfer(i: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `308 + i * (29 ±0)`
-		//  Estimated: `3574 + i * (2163 ±0)`
-		// Minimum execution time: 14_000_000 picoseconds.
-		Weight::from_parts(16_969_387, 3574)
-			.saturating_add(RocksDbWeight::get().reads(3_u64))
-			.saturating_add(RocksDbWeight::get().writes(2_u64))
-			.saturating_add(Weight::from_parts(0, 2163).saturating_mul(i.into()))
+	fn approve_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `410`
+		//  Estimated: `4326`
+		// Minimum execution time: 18_734_000 picoseconds.
+		Weight::from_parts(19_267_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Allowances` (r:0 w:1)
-	/// Proof: `Nfts::Allowances` (`max_values`: None, `max_size`: Some(109), added: 2584, mode: `MaxEncodedLen`)
-	/// The range of component `i` is `[0, 1]`.
-	fn cancel_approval(i: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `312 + i * (33 ±0)`
-		//  Estimated: `3557 + i * (2163 ±0)`
-		// Minimum execution time: 11_000_000 picoseconds.
-		Weight::from_parts(14_000_000, 3557)
+	fn cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `418`
+		//  Estimated: `4326`
+		// Minimum execution time: 16_080_000 picoseconds.
+		Weight::from_parts(16_603_000, 4326)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
-			.saturating_add(RocksDbWeight::get().writes(2_u64))
-			.saturating_add(Weight::from_parts(0, 2163).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	fn clear_all_transfer_approvals() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `345`
+		//  Measured:  `418`
 		//  Estimated: `4326`
-		// Minimum execution time: 11_000_000 picoseconds.
-		Weight::from_parts(11_000_000, 4326)
+		// Minimum execution time: 15_013_000 picoseconds.
+		Weight::from_parts(15_607_000, 4326)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1310,23 +1269,23 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::OwnershipAcceptance` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
 	fn set_accept_ownership() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3`
+		//  Measured:  `76`
 		//  Estimated: `3517`
-		// Minimum execution time: 9_000_000 picoseconds.
-		Weight::from_parts(9_000_000, 3517)
+		// Minimum execution time: 13_077_000 picoseconds.
+		Weight::from_parts(13_635_000, 3517)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:0)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	fn set_collection_max_supply() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `275`
-		//  Estimated: `3557`
-		// Minimum execution time: 12_000_000 picoseconds.
-		Weight::from_parts(13_000_000, 3557)
+		//  Measured:  `340`
+		//  Estimated: `3549`
+		// Minimum execution time: 17_146_000 picoseconds.
+		Weight::from_parts(17_453_000, 3549)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1336,10 +1295,10 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	fn update_mint_settings() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `250`
+		//  Measured:  `323`
 		//  Estimated: `3538`
-		// Minimum execution time: 12_000_000 picoseconds.
-		Weight::from_parts(12_000_000, 3538)
+		// Minimum execution time: 16_102_000 picoseconds.
+		Weight::from_parts(16_629_000, 3538)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1353,10 +1312,10 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
 	fn set_price() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `478`
+		//  Measured:  `518`
 		//  Estimated: `4326`
-		// Minimum execution time: 15_000_000 picoseconds.
-		Weight::from_parts(16_000_000, 4326)
+		// Minimum execution time: 22_118_000 picoseconds.
+		Weight::from_parts(22_849_000, 4326)
 			.saturating_add(RocksDbWeight::get().reads(3_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1364,38 +1323,36 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemPriceOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Collection` (r:1 w:0)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:1 w:0)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:2 w:2)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:2)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::PendingSwapOf` (r:0 w:1)
 	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
 	fn buy_item() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `725`
-		//  Estimated: `6068`
-		// Minimum execution time: 43_000_000 picoseconds.
-		Weight::from_parts(44_000_000, 6068)
-			.saturating_add(RocksDbWeight::get().reads(8_u64))
-			.saturating_add(RocksDbWeight::get().writes(8_u64))
+		//  Measured:  `705`
+		//  Estimated: `4326`
+		// Minimum execution time: 50_369_000 picoseconds.
+		Weight::from_parts(51_816_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
 	}
 	/// The range of component `n` is `[0, 10]`.
 	fn pay_tips(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 1_000_000 picoseconds.
-		Weight::from_parts(2_101_372, 0)
-			// Standard Error: 5_552
-			.saturating_add(Weight::from_parts(1_704_563, 0).saturating_mul(n.into()))
+		// Minimum execution time: 2_203_000 picoseconds.
+		Weight::from_parts(3_710_869, 0)
+			// Standard Error: 8_094
+			.saturating_add(Weight::from_parts(2_201_869, 0).saturating_mul(n.into()))
 	}
 	/// Storage: `Nfts::Item` (r:2 w:0)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
@@ -1403,10 +1360,10 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
 	fn create_swap() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `421`
+		//  Measured:  `494`
 		//  Estimated: `7662`
-		// Minimum execution time: 13_000_000 picoseconds.
-		Weight::from_parts(14_000_000, 7662)
+		// Minimum execution time: 18_893_000 picoseconds.
+		Weight::from_parts(19_506_000, 7662)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1416,10 +1373,10 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	fn cancel_swap() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `440`
+		//  Measured:  `513`
 		//  Estimated: `4326`
-		// Minimum execution time: 13_000_000 picoseconds.
-		Weight::from_parts(14_000_000, 4326)
+		// Minimum execution time: 19_086_000 picoseconds.
+		Weight::from_parts(19_609_000, 4326)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1427,28 +1384,26 @@ impl WeightInfo for () {
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::PendingSwapOf` (r:1 w:2)
 	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Collection` (r:1 w:0)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:2 w:0)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:2 w:0)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:2 w:2)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Account` (r:0 w:4)
 	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemPriceOf` (r:0 w:2)
 	/// Proof: `Nfts::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
 	fn claim_swap() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `915`
+		//  Measured:  `834`
 		//  Estimated: `7662`
-		// Minimum execution time: 78_000_000 picoseconds.
-		Weight::from_parts(79_000_000, 7662)
-			.saturating_add(RocksDbWeight::get().reads(11_u64))
-			.saturating_add(RocksDbWeight::get().writes(13_u64))
+		// Minimum execution time: 84_103_000 picoseconds.
+		Weight::from_parts(85_325_000, 7662)
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(10_u64))
 	}
 	/// Storage: `Nfts::CollectionRoleOf` (r:2 w:0)
 	/// Proof: `Nfts::CollectionRoleOf` (`max_values`: None, `max_size`: Some(69), added: 2544, mode: `MaxEncodedLen`)
@@ -1457,9 +1412,7 @@ impl WeightInfo for () {
 	/// Storage: `Nfts::Item` (r:1 w:1)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
-	/// Storage: `Nfts::AccountBalance` (r:1 w:1)
-	/// Proof: `Nfts::AccountBalance` (`max_values`: None, `max_size`: Some(64), added: 2539, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemConfigOf` (r:1 w:1)
 	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
 	/// Storage: `System::Account` (r:1 w:1)
@@ -1473,26 +1426,26 @@ impl WeightInfo for () {
 	/// The range of component `n` is `[0, 10]`.
 	fn mint_pre_signed(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `493`
+		//  Measured:  `629`
 		//  Estimated: `6078 + n * (2954 ±0)`
-		// Minimum execution time: 101_000_000 picoseconds.
-		Weight::from_parts(102_689_064, 6078)
-			// Standard Error: 25_175
-			.saturating_add(Weight::from_parts(27_553_304, 0).saturating_mul(n.into()))
-			.saturating_add(RocksDbWeight::get().reads(9_u64))
+		// Minimum execution time: 128_363_000 picoseconds.
+		Weight::from_parts(139_474_918, 6078)
+			// Standard Error: 79_252
+			.saturating_add(Weight::from_parts(31_384_027, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
-			.saturating_add(RocksDbWeight::get().writes(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
 			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(n.into())))
 			.saturating_add(Weight::from_parts(0, 2954).saturating_mul(n.into()))
 	}
 	/// Storage: `Nfts::Item` (r:1 w:0)
 	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::ItemAttributesApprovalsOf` (r:1 w:1)
-	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(1001), added: 3476, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::ItemAttributesApprovalsOf` (`max_values`: None, `max_size`: Some(681), added: 3156, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
 	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Collection` (r:1 w:1)
-	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
 	/// Storage: `Nfts::Attribute` (r:10 w:10)
 	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
 	/// Storage: `System::Account` (r:1 w:1)
@@ -1500,12 +1453,12 @@ impl WeightInfo for () {
 	/// The range of component `n` is `[0, 10]`.
 	fn set_attributes_pre_signed(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `522`
-		//  Estimated: `4466 + n * (2954 ±0)`
-		// Minimum execution time: 50_000_000 picoseconds.
-		Weight::from_parts(55_735_551, 4466)
-			// Standard Error: 34_490
-			.saturating_add(Weight::from_parts(26_799_214, 0).saturating_mul(n.into()))
+		//  Measured:  `659`
+		//  Estimated: `4326 + n * (2954 ±0)`
+		// Minimum execution time: 66_688_000 picoseconds.
+		Weight::from_parts(79_208_379, 4326)
+			// Standard Error: 74_020
+			.saturating_add(Weight::from_parts(31_028_221, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))