[NFTs] Offchain mint

frame/democracy/Cargo.toml

@@ -47,6 +47,7 @@ std = [
 	"sp-core/std",
 ]
 runtime-benchmarks = [
+	"sp-core/full_crypto",
 	"frame-benchmarking/runtime-benchmarks",
 	"frame-support/runtime-benchmarks",
 	"frame-system/runtime-benchmarks",

frame/nfts/Cargo.toml

@@ -26,7 +26,6 @@ sp-std = { version = "5.0.0", default-features = false, path = "../../primitives
 
 [dev-dependencies]
 pallet-balances = { version = "4.0.0-dev", path = "../balances" }
-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" }
 

frame/nfts/src/benchmarking.rs

@@ -31,6 +31,7 @@ use frame_support::{
 	BoundedVec,
 };
 use frame_system::RawOrigin as SystemOrigin;
+use sp_core::Pair;
 use sp_runtime::traits::{Bounded, One};
 use sp_std::prelude::*;
 
@@ -714,5 +715,40 @@ benchmarks_instance_pallet! {
 		}.into());
 	}
 
+	mint_pre_signed {
+		let caller_pair = sp_core::sr25519::Pair::from_string("//Alice", None).unwrap();
+		let caller_signer = MultiSigner::Sr25519(caller_pair.public());
+		let caller = Nfts::<T, I>::signer_to_account(caller_signer.clone()).unwrap();
+		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 mint_data = PreSignedMint {
+			collection,
+			item,
+			metadata: metadata.clone(),
+			only_account: None,
+			deadline: One::one(),
+		};
+		let message = Encode::encode(&mint_data);
+		let signature = MultiSignature::Sr25519(caller_pair.sign(&message));
+
+		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, caller_signer)
+	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,9 @@
 
 //! Various pieces of common functionality.
 
-use super::*;
+use crate::*;
+use frame_support::pallet_prelude::*;
+use sp_runtime::traits::IdentifyAccount;
 
 impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// Get the owner of the item, if the item exists.
@@ -30,6 +32,12 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Collection::<T, I>::get(collection).map(|i| i.owner)
 	}
 
+	/// Convert signer into account id.
+	pub fn signer_to_account(signer: MultiSigner) -> Result<T::AccountId, DispatchError> {
+		Ok(T::AccountId::decode(&mut signer.into_account().as_ref())
+			.map_err(|_| Error::<T, I>::WrongPublic)?)
+	}
+
 	#[cfg(any(test, feature = "runtime-benchmarks"))]
 	pub fn set_next_id(id: T::CollectionId) {
 		NextCollectionId::<T, I>::set(Some(id));

frame/nfts/src/features/create_delete_item.rs

@@ -85,6 +85,46 @@ 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, metadata, deadline, only_account } = mint_data;
+		let metadata = Self::construct_metadata(metadata)?;
+
+		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(()),
+		)?;
+		if !metadata.len().is_zero() {
+			Self::do_set_item_metadata(
+				Some(collection_details.owner),
+				collection,
+				item,
+				metadata,
+				Some(mint_to),
+			)?;
+		}
+		Ok(())
+	}
+
 	pub fn do_burn(
 		collection: T::CollectionId,
 		item: T::ItemId,

frame/nfts/src/features/metadata.rs

@@ -60,14 +60,16 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 					.saturating_add(T::MetadataDepositBase::get());
 			}
 
-			// 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)?;
+			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)?;
 			} else if deposit > old_deposit.amount {
-				T::Currency::reserve(&collection_details.owner, deposit - old_deposit.amount)?;
+				T::Currency::reserve(&depositor, deposit - old_deposit.amount)?;
 			} else if deposit < old_deposit.amount {
-				T::Currency::unreserve(&collection_details.owner, old_deposit.amount - deposit);
+				T::Currency::unreserve(&depositor, old_deposit.amount - deposit);
 			}
 
 			if maybe_depositor.is_none() {
@@ -191,4 +193,11 @@ 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)?)
+	}
 }

frame/nfts/src/features/settings.rs

@@ -96,6 +96,13 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Ok(config)
 	}
 
+	pub(crate) fn get_default_item_settings(
+		collection_id: &T::CollectionId,
+	) -> Result<ItemSettings, DispatchError> {
+		let collection_config = Self::get_collection_config(collection_id)?;
+		Ok(collection_config.mint_settings.default_item_settings)
+	}
+
 	pub(crate) fn is_pallet_feature_enabled(feature: PalletFeature) -> bool {
 		let features = T::Features::get();
 		return features.is_enabled(feature)

frame/nfts/src/lib.rs

@@ -52,7 +52,7 @@ use frame_support::traits::{
 use frame_system::Config as SystemConfig;
 use sp_runtime::{
 	traits::{Saturating, StaticLookup, Zero},
-	RuntimeDebug,
+	MultiSignature, MultiSigner, RuntimeDebug,
 };
 use sp_std::prelude::*;
 
@@ -67,6 +67,7 @@ pub mod pallet {
 	use super::*;
 	use frame_support::{pallet_prelude::*, traits::ExistenceRequirement};
 	use frame_system::pallet_prelude::*;
+	use sp_runtime::traits::{IdentifyAccount, Verify};
 
 	#[pallet::pallet]
 	#[pallet::generate_store(pub(super) trait Store)]
@@ -591,6 +592,14 @@ pub mod pallet {
 		AlreadyClaimed,
 		/// The provided data is incorrect.
 		IncorrectData,
+		/// The extrinsic should be sent by another origin.
+		WrongOrigin,
+		/// Unable to get the account id from the provided public key.
+		WrongPublic,
+		/// The provided signature is incorrect.
+		WrongSignature,
+		/// The provided metadata might be too long.
+		IncorrectMetadata,
 	}
 
 	#[pallet::call]
@@ -742,10 +751,8 @@ pub mod pallet {
 		) -> DispatchResult {
 			let caller = ensure_signed(origin)?;
 			let mint_to = T::Lookup::lookup(mint_to)?;
-
-			let collection_config = Self::get_collection_config(&collection)?;
-			let item_settings = collection_config.mint_settings.default_item_settings;
-			let item_config = ItemConfig { settings: item_settings };
+			let item_config =
+				ItemConfig { settings: Self::get_default_item_settings(&collection)? };
 
 			Self::do_mint(
 				collection,
@@ -1768,6 +1775,24 @@ pub mod pallet {
 				witness_price,
 			)
 		}
+
+		#[pallet::call_index(37)]
+		#[pallet::weight(T::WeightInfo::mint_pre_signed())]
+		pub fn mint_pre_signed(
+			origin: OriginFor<T>,
+			data: PreSignedMintOf<T, I>,
+			signature: MultiSignature,
+			signer: MultiSigner,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let msg = Encode::encode(&data);
+			ensure!(
+				signature.verify(&*msg, &signer.clone().into_account()),
+				Error::<T, I>::WrongSignature
+			);
+			let signer_account = Self::signer_to_account(signer)?;
+			Self::do_mint_pre_signed(origin, data, signer_account)
+		}
 	}
 }
 

frame/nfts/src/mock.rs

@@ -28,6 +28,7 @@ use sp_core::H256;
 use sp_runtime::{
 	testing::Header,
 	traits::{BlakeTwo256, IdentityLookup},
+	MultiSignature,
 };
 
 type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
@@ -87,7 +88,7 @@ impl pallet_balances::Config for Test {
 parameter_types! {
 	pub storage Features: PalletFeatures = PalletFeatures::all_enabled();
 }
-
+pub type Signature = MultiSignature;
 impl Config for Test {
 	type RuntimeEvent = RuntimeEvent;
 	type CollectionId = u32;