Revert "[NFTs] Offchain mint (#13158)"

This reverts commit 187cda6.

bin/node/runtime/src/lib.rs

@@ -1566,7 +1566,6 @@ impl pallet_uniques::Config for Runtime {
 
 parameter_types! {
 	pub Features: PalletFeatures = PalletFeatures::all_enabled();
-	pub const MaxAttributesPerCall: u32 = 10;
 }
 
 impl pallet_nfts::Config for Runtime {
@@ -1587,10 +1586,7 @@ impl pallet_nfts::Config for Runtime {
 	type ItemAttributesApprovalsLimit = ItemAttributesApprovalsLimit;
 	type MaxTips = MaxTips;
 	type MaxDeadlineDuration = MaxDeadlineDuration;
-	type MaxAttributesPerCall = MaxAttributesPerCall;
 	type Features = Features;
-	type OffchainSignature = Signature;
-	type OffchainPublic = <Signature as traits::Verify>::Signer;
 	type WeightInfo = pallet_nfts::weights::SubstrateWeight<Runtime>;
 	#[cfg(feature = "runtime-benchmarks")]
 	type Helper = ();

frame/nfts/Cargo.toml

@@ -21,13 +21,14 @@ frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional
 frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
 frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
 sp-core = { version = "7.0.0", default-features = false, path = "../../primitives/core" }
-sp-io = { version = "7.0.0", default-features = false, path = "../../primitives/io" }
 sp-runtime = { version = "7.0.0", default-features = false, path = "../../primitives/runtime" }
 sp-std = { version = "5.0.0", default-features = false, path = "../../primitives/std" }
 
 [dev-dependencies]
 pallet-balances = { version = "4.0.0-dev", path = "../balances" }
-sp-keystore = { version = "0.13.0", path = "../../primitives/keystore" }
+sp-core = { version = "7.0.0", path = "../../primitives/core" }
+sp-io = { version = "7.0.0", path = "../../primitives/io" }
+sp-std = { version = "5.0.0", path = "../../primitives/std" }
 
 [features]
 default = ["std"]
@@ -39,7 +40,6 @@ std = [
 	"log/std",
 	"scale-info/std",
 	"sp-core/std",
-	"sp-io/std",
 	"sp-runtime/std",
 	"sp-std/std",
 ]

frame/nfts/src/benchmarking.rs

@@ -31,11 +31,7 @@ use frame_support::{
 	BoundedVec,
 };
 use frame_system::RawOrigin as SystemOrigin;
-use sp_io::crypto::{sr25519_generate, sr25519_sign};
-use sp_runtime::{
-	traits::{Bounded, IdentifyAccount, One},
-	AccountId32, MultiSignature, MultiSigner,
-};
+use sp_runtime::traits::{Bounded, One};
 use sp_std::prelude::*;
 
 use crate::Pallet as Nfts;
@@ -152,21 +148,7 @@ fn default_item_config() -> ItemConfig {
 	ItemConfig { settings: ItemSettings::all_enabled() }
 }
 
-fn make_filled_vec(value: u16, length: usize) -> Vec<u8> {
-	let mut vec = vec![0u8; length];
-	let mut s = Vec::from(value.to_be_bytes());
-	vec.truncate(length - s.len());
-	vec.append(&mut s);
-	vec
-}
-
 benchmarks_instance_pallet! {
-	where_clause {
-		where
-			T::OffchainSignature: From<MultiSignature>,
-			T::AccountId: From<AccountId32>,
-	}
-
 	create {
 		let collection = T::Helper::collection(0);
 		let origin = T::CreateOrigin::try_successful_origin(&collection)
@@ -457,7 +439,11 @@ benchmarks_instance_pallet! {
 		T::Currency::make_free_balance_be(&target, DepositBalanceOf::<T, I>::max_value());
 		let value: BoundedVec<_, _> = vec![0u8; T::ValueLimit::get() as usize].try_into().unwrap();
 		for i in 0..n {
-			let key = make_filled_vec(i as u16, T::KeyLimit::get() as usize);
+			let mut key = vec![0u8; T::KeyLimit::get() as usize];
+			let mut s = Vec::from((i as u16).to_be_bytes());
+			key.truncate(s.len());
+			key.append(&mut s);
+
 			Nfts::<T, I>::set_attribute(
 				SystemOrigin::Signed(target.clone()).into(),
 				T::Helper::collection(0),
@@ -731,47 +717,5 @@ benchmarks_instance_pallet! {
 		}.into());
 	}
 
-	mint_pre_signed {
-		let n in 0 .. T::MaxAttributesPerCall::get() as u32;
-		let caller_public = sr25519_generate(0.into(), None);
-		let caller = MultiSigner::Sr25519(caller_public).into_account().into();
-		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
-		let caller_lookup = T::Lookup::unlookup(caller.clone());
-
-		let collection = T::Helper::collection(0);
-		let item = T::Helper::item(0);
-		assert_ok!(Nfts::<T, I>::force_create(
-			SystemOrigin::Root.into(),
-			caller_lookup.clone(),
-			default_collection_config::<T, I>()
-		));
-
-		let metadata = vec![0u8; T::StringLimit::get() as usize];
-		let mut attributes = vec![];
-		let attribute_value = vec![0u8; T::ValueLimit::get() as usize];
-		for i in 0..n {
-			let attribute_key = make_filled_vec(i as u16, T::KeyLimit::get() as usize);
-			attributes.push((attribute_key, attribute_value.clone()));
-		}
-		let mint_data = PreSignedMint {
-			collection,
-			item,
-			attributes,
-			metadata: metadata.clone(),
-			only_account: None,
-			deadline: One::one(),
-		};
-		let message = Encode::encode(&mint_data);
-		let signature = MultiSignature::Sr25519(sr25519_sign(0.into(), &caller_public, &message).unwrap());
-
-		let target: T::AccountId = account("target", 0, SEED);
-		T::Currency::make_free_balance_be(&target, DepositBalanceOf::<T, I>::max_value());
-		frame_system::Pallet::<T>::set_block_number(One::one());
-	}: _(SystemOrigin::Signed(target.clone()), mint_data, signature.into(), caller)
-	verify {
-		let metadata: BoundedVec<_, _> = metadata.try_into().unwrap();
-		assert_last_event::<T, I>(Event::ItemMetadataSet { collection, item, data: metadata }.into());
-	}
-
 	impl_benchmark_test_suite!(Nfts, crate::mock::new_test_ext(), crate::mock::Test);
 }

frame/nfts/src/common_functions.rs

@@ -17,7 +17,7 @@
 
 //! Various pieces of common functionality.
 
-use crate::*;
+use super::*;
 
 impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// Get the owner of the item, if the item exists.

frame/nfts/src/features/attributes.rs

@@ -26,7 +26,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		namespace: AttributeNamespace<T::AccountId>,
 		key: BoundedVec<u8, T::KeyLimit>,
 		value: BoundedVec<u8, T::ValueLimit>,
-		depositor: T::AccountId,
 	) -> DispatchResult {
 		ensure!(
 			Self::is_pallet_feature_enabled(PalletFeature::Attributes),
@@ -67,16 +66,14 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		}
 
 		let attribute = Attribute::<T, I>::get((collection, maybe_item, &namespace, &key));
-		let attribute_exists = attribute.is_some();
-		if !attribute_exists {
+		if attribute.is_none() {
 			collection_details.attributes.saturating_inc();
 		}
 
 		let old_deposit =
 			attribute.map_or(AttributeDeposit { account: None, amount: Zero::zero() }, |m| m.1);
 
 		let mut deposit = Zero::zero();
-		// disabled DepositRequired setting only affects the CollectionOwner namespace
 		if collection_config.is_setting_enabled(CollectionSetting::DepositRequired) ||
 			namespace != AttributeNamespace::CollectionOwner
 		{
@@ -85,50 +82,33 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				.saturating_add(T::AttributeDepositBase::get());
 		}
 
-		let is_collection_owner_namespace = namespace == AttributeNamespace::CollectionOwner;
-		let is_depositor_collection_owner =
-			is_collection_owner_namespace && collection_details.owner == depositor;
-
-		// NOTE: in the CollectionOwner namespace if the depositor is `None` that means the deposit
-		// was paid by the collection's owner.
-		let old_depositor =
-			if is_collection_owner_namespace && old_deposit.account.is_none() && attribute_exists {
-				Some(collection_details.owner.clone())
-			} else {
-				old_deposit.account
-			};
-		let depositor_has_changed = old_depositor != Some(depositor.clone());
-
 		// NOTE: when we transfer an item, we don't move attributes in the ItemOwner namespace.
 		// When the new owner updates the same attribute, we will update the depositor record
 		// and return the deposit to the previous owner.
-		if depositor_has_changed {
-			if let Some(old_depositor) = old_depositor {
-				T::Currency::unreserve(&old_depositor, old_deposit.amount);
-			}
-			T::Currency::reserve(&depositor, deposit)?;
+		if old_deposit.account.is_some() && old_deposit.account != Some(origin.clone()) {
+			T::Currency::unreserve(&old_deposit.account.unwrap(), old_deposit.amount);
+			T::Currency::reserve(&origin, deposit)?;
 		} else if deposit > old_deposit.amount {
-			T::Currency::reserve(&depositor, deposit - old_deposit.amount)?;
+			T::Currency::reserve(&origin, deposit - old_deposit.amount)?;
 		} else if deposit < old_deposit.amount {
-			T::Currency::unreserve(&depositor, old_deposit.amount - deposit);
+			T::Currency::unreserve(&origin, old_deposit.amount - deposit);
 		}
 
-		if is_depositor_collection_owner {
-			if !depositor_has_changed {
+		// NOTE: we don't track the depositor in the CollectionOwner namespace as it's always a
+		// collection's owner. This simplifies the collection's transfer to another owner.
+		let deposit_owner = match namespace {
+			AttributeNamespace::CollectionOwner => {
+				collection_details.owner_deposit.saturating_accrue(deposit);
 				collection_details.owner_deposit.saturating_reduce(old_deposit.amount);
-			}
-			collection_details.owner_deposit.saturating_accrue(deposit);
-		}
-
-		let new_deposit_owner = match is_depositor_collection_owner {
-			true => None,
-			false => Some(depositor),
+				None
+			},
+			_ => Some(origin),
 		};
+
 		Attribute::<T, I>::insert(
 			(&collection, maybe_item, &namespace, &key),
-			(&value, AttributeDeposit { account: new_deposit_owner, amount: deposit }),
+			(&value, AttributeDeposit { account: deposit_owner, amount: deposit }),
 		);
-
 		Collection::<T, I>::insert(collection, &collection_details);
 		Self::deposit_event(Event::AttributeSet { collection, maybe_item, key, value, namespace });
 		Ok(())
@@ -208,38 +188,27 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 						// NOTE: if the item was previously burned, the ItemConfigOf record
 						// might not exist. In that case, we allow to clear the attribute.
 						let maybe_is_locked = Self::get_item_config(&collection, &item)
-							.map_or(None, |c| {
-								Some(c.has_disabled_setting(ItemSetting::UnlockedAttributes))
+							.map_or(false, |c| {
+								c.has_disabled_setting(ItemSetting::UnlockedAttributes)
 							});
-						match maybe_is_locked {
-							Some(is_locked) => {
-								// when item exists, then only the collection's owner can clear that
-								// attribute
-								ensure!(
-									check_owner == &collection_details.owner,
-									Error::<T, I>::NoPermission
-								);
-								ensure!(!is_locked, Error::<T, I>::LockedItemAttributes);
-							},
-							None => (),
-						}
+						ensure!(!maybe_is_locked, Error::<T, I>::LockedItemAttributes);
 					},
 				},
 				_ => (),
 			};
 		}
 
 		collection_details.attributes.saturating_dec();
-
-		match deposit.account {
-			Some(deposit_account) => {
-				T::Currency::unreserve(&deposit_account, deposit.amount);
-			},
-			None if namespace == AttributeNamespace::CollectionOwner => {
+		match namespace {
+			AttributeNamespace::CollectionOwner => {
 				collection_details.owner_deposit.saturating_reduce(deposit.amount);
 				T::Currency::unreserve(&collection_details.owner, deposit.amount);
 			},
 			_ => (),
+		};
+
+		if let Some(deposit_account) = deposit.account {
+			T::Currency::unreserve(&deposit_account, deposit.amount);
 		}
 
 		Collection::<T, I>::insert(collection, &collection_details);

frame/nfts/src/features/create_delete_item.rs

@@ -85,62 +85,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Ok(())
 	}
 
-	pub(crate) fn do_mint_pre_signed(
-		mint_to: T::AccountId,
-		mint_data: PreSignedMintOf<T, I>,
-		signer: T::AccountId,
-	) -> DispatchResult {
-		let PreSignedMint { collection, item, attributes, metadata, deadline, only_account } =
-			mint_data;
-		let metadata = Self::construct_metadata(metadata)?;
-
-		ensure!(
-			attributes.len() <= T::MaxAttributesPerCall::get() as usize,
-			Error::<T, I>::MaxAttributesLimitReached
-		);
-		if let Some(account) = only_account {
-			ensure!(account == mint_to, Error::<T, I>::WrongOrigin);
-		}
-
-		let now = frame_system::Pallet::<T>::block_number();
-		ensure!(deadline >= now, Error::<T, I>::DeadlineExpired);
-
-		let collection_details =
-			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
-		ensure!(collection_details.owner == signer, Error::<T, I>::NoPermission);
-
-		let item_config = ItemConfig { settings: Self::get_default_item_settings(&collection)? };
-		Self::do_mint(
-			collection,
-			item,
-			Some(mint_to.clone()),
-			mint_to.clone(),
-			item_config,
-			|_, _| Ok(()),
-		)?;
-		for (key, value) in attributes {
-			Self::do_set_attribute(
-				collection_details.owner.clone(),
-				collection,
-				Some(item),
-				AttributeNamespace::CollectionOwner,
-				Self::construct_attribute_key(key)?,
-				Self::construct_attribute_value(value)?,
-				mint_to.clone(),
-			)?;
-		}
-		if !metadata.len().is_zero() {
-			Self::do_set_item_metadata(
-				Some(collection_details.owner.clone()),
-				collection,
-				item,
-				metadata,
-				Some(mint_to.clone()),
-			)?;
-		}
-		Ok(())
-	}
-
 	pub fn do_burn(
 		collection: T::CollectionId,
 		item: T::ItemId,

frame/nfts/src/features/metadata.rs

@@ -60,16 +60,14 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 					.saturating_add(T::MetadataDepositBase::get());
 			}
 
-			let depositor = maybe_depositor.clone().unwrap_or(collection_details.owner.clone());
-			let old_depositor = old_deposit.account.unwrap_or(collection_details.owner.clone());
-
-			if depositor != old_depositor {
-				T::Currency::unreserve(&old_depositor, old_deposit.amount);
-				T::Currency::reserve(&depositor, deposit)?;
+			// the previous deposit was taken from the item's owner
+			if old_deposit.account.is_some() && maybe_depositor.is_none() {
+				T::Currency::unreserve(&old_deposit.account.unwrap(), old_deposit.amount);
+				T::Currency::reserve(&collection_details.owner, deposit)?;
 			} else if deposit > old_deposit.amount {
-				T::Currency::reserve(&depositor, deposit - old_deposit.amount)?;
+				T::Currency::reserve(&collection_details.owner, deposit - old_deposit.amount)?;
 			} else if deposit < old_deposit.amount {
-				T::Currency::unreserve(&depositor, old_deposit.amount - deposit);
+				T::Currency::unreserve(&collection_details.owner, old_deposit.amount - deposit);
 			}
 
 			if maybe_depositor.is_none() {
@@ -193,11 +191,4 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			Ok(())
 		})
 	}
-
-	/// A helper method to construct metadata.
-	pub fn construct_metadata(
-		metadata: Vec<u8>,
-	) -> Result<BoundedVec<u8, T::StringLimit>, DispatchError> {
-		Ok(BoundedVec::try_from(metadata).map_err(|_| Error::<T, I>::IncorrectMetadata)?)
-	}
 }