[Uniques V2] Minting options

frame/nfts/src/benchmarking.rs

@@ -20,6 +20,7 @@
 #![cfg(feature = "runtime-benchmarks")]
 
 use super::*;
+use enumflags2::{BitFlag, BitFlags};
 use frame_benchmarking::{
 	account, benchmarks_instance_pallet, whitelist_account, whitelisted_caller,
 };
@@ -46,7 +47,7 @@ fn create_collection<T: Config<I>, I: 'static>(
 	assert_ok!(Nfts::<T, I>::force_create(
 		SystemOrigin::Root.into(),
 		caller_lookup.clone(),
-		CollectionConfig::all_settings_enabled()
+		default_collection_config::<T, I>()
 	));
 	(collection, caller, caller_lookup)
 }
@@ -78,8 +79,7 @@ fn mint_item<T: Config<I>, I: 'static>(
 		SystemOrigin::Signed(caller.clone()).into(),
 		T::Helper::collection(0),
 		item,
-		caller_lookup.clone(),
-		ItemConfig::all_settings_enabled(),
+		None,
 	));
 	(item, caller, caller_lookup)
 }
@@ -128,6 +128,24 @@ fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::
 	assert_eq!(event, &system_event);
 }
 
+fn make_collection_config<T: Config<I>, I: 'static>(
+	disable_settings: BitFlags<CollectionSetting>,
+) -> CollectionConfigFor<T, I> {
+	CollectionConfig {
+		settings: CollectionSettings::from_disabled(disable_settings),
+		max_supply: None,
+		mint_settings: MintSettings::default(),
+	}
+}
+
+fn default_collection_config<T: Config<I>, I: 'static>() -> CollectionConfigFor<T, I> {
+	make_collection_config::<T, I>(CollectionSetting::empty())
+}
+
+fn default_item_config() -> ItemConfig {
+	ItemConfig { settings: ItemSettings::all_enabled() }
+}
+
 benchmarks_instance_pallet! {
 	create {
 		let collection = T::Helper::collection(0);
@@ -136,7 +154,7 @@ benchmarks_instance_pallet! {
 		whitelist_account!(caller);
 		let admin = T::Lookup::unlookup(caller.clone());
 		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
-		let call = Call::<T, I>::create { admin, config: CollectionConfig::all_settings_enabled() };
+		let call = Call::<T, I>::create { admin, config: default_collection_config::<T, I>() };
 	}: { call.dispatch_bypass_filter(origin)? }
 	verify {
 		assert_last_event::<T, I>(Event::Created { collection: T::Helper::collection(0), creator: caller.clone(), owner: caller }.into());
@@ -145,7 +163,7 @@ benchmarks_instance_pallet! {
 	force_create {
 		let caller: T::AccountId = whitelisted_caller();
 		let caller_lookup = T::Lookup::unlookup(caller.clone());
-	}: _(SystemOrigin::Root, caller_lookup, CollectionConfig::all_settings_enabled())
+	}: _(SystemOrigin::Root, caller_lookup, default_collection_config::<T, I>())
 	verify {
 		assert_last_event::<T, I>(Event::ForceCreated { collection: T::Helper::collection(0), owner: caller }.into());
 	}
@@ -169,7 +187,15 @@ benchmarks_instance_pallet! {
 	mint {
 		let (collection, caller, caller_lookup) = create_collection::<T, I>();
 		let item = T::Helper::item(0);
-	}: _(SystemOrigin::Signed(caller.clone()), collection, item, caller_lookup, ItemConfig::all_settings_enabled())
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, None)
+	verify {
+		assert_last_event::<T, I>(Event::Issued { collection, item, owner: caller }.into());
+	}
+
+	force_mint {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let item = T::Helper::item(0);
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, caller_lookup, default_item_config())
 	verify {
 		assert_last_event::<T, I>(Event::Issued { collection, item, owner: caller }.into());
 	}
@@ -188,6 +214,7 @@ benchmarks_instance_pallet! {
 
 		let target: T::AccountId = account("target", 0, SEED);
 		let target_lookup = T::Lookup::unlookup(target.clone());
+		T::Currency::make_free_balance_be(&target, T::Currency::minimum_balance());
 	}: _(SystemOrigin::Signed(caller.clone()), collection, item, target_lookup)
 	verify {
 		assert_last_event::<T, I>(Event::Transferred { collection, item, from: caller, to: target }.into());
@@ -204,7 +231,7 @@ benchmarks_instance_pallet! {
 			caller_lookup.clone(),
 			caller_lookup.clone(),
 			caller_lookup,
-			CollectionConfig(CollectionSetting::DepositRequired.into()),
+			make_collection_config::<T, I>(CollectionSetting::DepositRequired.into()),
 		)?;
 	}: _(SystemOrigin::Signed(caller.clone()), collection, items.clone())
 	verify {
@@ -234,12 +261,13 @@ benchmarks_instance_pallet! {
 
 	lock_collection {
 		let (collection, caller, caller_lookup) = create_collection::<T, I>();
-		let lock_config = CollectionConfig(
+		let lock_settings = CollectionSettings::from_disabled(
 			CollectionSetting::TransferableItems |
 				CollectionSetting::UnlockedMetadata |
-				CollectionSetting::UnlockedAttributes,
+				CollectionSetting::UnlockedAttributes |
+				CollectionSetting::UnlockedMaxSupply,
 		);
-	}: _(SystemOrigin::Signed(caller.clone()), collection, lock_config)
+	}: _(SystemOrigin::Signed(caller.clone()), collection, lock_settings)
 	verify {
 		assert_last_event::<T, I>(Event::CollectionLocked { collection }.into());
 	}
@@ -280,7 +308,7 @@ benchmarks_instance_pallet! {
 			issuer: caller_lookup.clone(),
 			admin: caller_lookup.clone(),
 			freezer: caller_lookup,
-			config: CollectionConfig(CollectionSetting::DepositRequired.into()),
+			config: make_collection_config::<T, I>(CollectionSetting::DepositRequired.into()),
 		};
 	}: { call.dispatch_bypass_filter(origin)? }
 	verify {
@@ -414,6 +442,20 @@ benchmarks_instance_pallet! {
 		}.into());
 	}
 
+	update_mint_settings {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let mint_settings = MintSettings {
+			mint_type: MintType::HolderOf(T::Helper::collection(0)),
+			start_block: Some(One::one()),
+			end_block: Some(One::one()),
+			price: Some(ItemPrice::<T, I>::from(1u32)),
+			default_item_settings: ItemSettings::all_enabled(),
+		};
+	}: _(SystemOrigin::Signed(caller.clone()), collection, mint_settings)
+	verify {
+		assert_last_event::<T, I>(Event::CollectionMintSettingsUpdated { collection }.into());
+	}
+
 	set_price {
 		let (collection, caller, _) = create_collection::<T, I>();
 		let (item, ..) = mint_item::<T, I>(0);
@@ -528,6 +570,7 @@ benchmarks_instance_pallet! {
 		let duration = T::MaxDeadlineDuration::get();
 		let target: T::AccountId = account("target", 0, SEED);
 		let target_lookup = T::Lookup::unlookup(target.clone());
+		T::Currency::make_free_balance_be(&target, T::Currency::minimum_balance());
 		let origin = SystemOrigin::Signed(caller.clone());
 		frame_system::Pallet::<T>::set_block_number(One::one());
 		Nfts::<T, I>::transfer(origin.clone().into(), collection, item2, target_lookup)?;

frame/nfts/src/features/lock.rs

@@ -22,23 +22,21 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	pub(crate) fn do_lock_collection(
 		origin: T::AccountId,
 		collection: T::CollectionId,
-		lock_config: CollectionConfig,
+		lock_settings: CollectionSettings,
 	) -> DispatchResult {
 		ensure!(
 			Self::has_role(&collection, &origin, CollectionRole::Freezer),
 			Error::<T, I>::NoPermission
 		);
+		ensure!(
+			!lock_settings.is_disabled(CollectionSetting::DepositRequired),
+			Error::<T, I>::WrongSetting
+		);
 		CollectionConfigOf::<T, I>::try_mutate(collection, |maybe_config| {
 			let config = maybe_config.as_mut().ok_or(Error::<T, I>::NoConfig)?;
 
-			if lock_config.has_disabled_setting(CollectionSetting::TransferableItems) {
-				config.disable_setting(CollectionSetting::TransferableItems);
-			}
-			if lock_config.has_disabled_setting(CollectionSetting::UnlockedMetadata) {
-				config.disable_setting(CollectionSetting::UnlockedMetadata);
-			}
-			if lock_config.has_disabled_setting(CollectionSetting::UnlockedAttributes) {
-				config.disable_setting(CollectionSetting::UnlockedAttributes);
+			for setting in lock_settings.get_disabled() {
+				config.disable_setting(setting);
 			}
 
 			Self::deposit_event(Event::<T, I>::CollectionLocked { collection });

frame/nfts/src/features/settings.rs

@@ -25,9 +25,9 @@ use frame_support::pallet_prelude::*;
 impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	pub(crate) fn get_collection_config(
 		collection_id: &T::CollectionId,
-	) -> Result<CollectionConfig, DispatchError> {
-		let config = CollectionConfigOf::<T, I>::get(&collection_id)
-			.ok_or(Error::<T, I>::UnknownCollection)?;
+	) -> Result<CollectionConfigFor<T, I>, DispatchError> {
+		let config =
+			CollectionConfigOf::<T, I>::get(&collection_id).ok_or(Error::<T, I>::NoConfig)?;
 		Ok(config)
 	}
 

frame/nfts/src/functions.rs

@@ -54,6 +54,16 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
 		with_details(&collection_details, &mut details)?;
 
+		if details.deposit.account == details.owner {
+			// Move the deposit to the new owner.
+			T::Currency::repatriate_reserved(
+				&details.owner,
+				&dest,
+				details.deposit.amount,
+				Reserved,
+			)?;
+		}
+
 		Account::<T, I>::remove((&details.owner, &collection, &item));
 		Account::<T, I>::insert((&dest, &collection, &item), ());
 		let origin = details.owner;
@@ -81,7 +91,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		collection: T::CollectionId,
 		owner: T::AccountId,
 		admin: T::AccountId,
-		config: CollectionConfig,
+		config: CollectionConfigFor<T, I>,
 		deposit: DepositBalanceOf<T, I>,
 		event: Event<T, I>,
 	) -> DispatchResult {
@@ -138,6 +148,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 			for (item, details) in Item::<T, I>::drain_prefix(&collection) {
 				Account::<T, I>::remove((&details.owner, &collection, &item));
+				T::Currency::unreserve(&details.deposit.account, details.deposit.amount);
 			}
 			#[allow(deprecated)]
 			ItemMetadataOf::<T, I>::remove_prefix(&collection, None);
@@ -151,7 +162,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			Attribute::<T, I>::remove_prefix((&collection,), None);
 			CollectionAccount::<T, I>::remove(&collection_details.owner, &collection);
 			T::Currency::unreserve(&collection_details.owner, collection_details.total_deposit);
-			CollectionMaxSupply::<T, I>::remove(&collection);
 			CollectionConfigOf::<T, I>::remove(&collection);
 			let _ = ItemConfigOf::<T, I>::clear_prefix(&collection, witness.items, None);
 
@@ -169,7 +179,12 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		collection: T::CollectionId,
 		item: T::ItemId,
 		owner: T::AccountId,
-		config: ItemConfig,
+		item_config: ItemConfig,
+		deposit_collection_owner: bool,
+		with_details_and_config: impl FnOnce(
+			&CollectionDetailsFor<T, I>,
+			&CollectionConfigFor<T, I>,
+		) -> DispatchResult,
 	) -> DispatchResult {
 		ensure!(!Item::<T, I>::contains_key(collection, item), Error::<T, I>::AlreadyExists);
 
@@ -179,7 +194,10 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				let collection_details =
 					maybe_collection_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
 
-				if let Ok(max_supply) = CollectionMaxSupply::<T, I>::try_get(&collection) {
+				let collection_config = Self::get_collection_config(&collection)?;
+				with_details_and_config(collection_details, &collection_config)?;
+
+				if let Some(max_supply) = collection_config.max_supply {
 					ensure!(collection_details.items < max_supply, Error::<T, I>::MaxSupplyReached);
 				}
 
@@ -188,24 +206,29 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				collection_details.items = items;
 
 				let collection_config = Self::get_collection_config(&collection)?;
-				let deposit = match collection_config
+				let deposit_amount = match collection_config
 					.is_setting_enabled(CollectionSetting::DepositRequired)
 				{
 					true => T::ItemDeposit::get(),
 					false => Zero::zero(),
 				};
-				T::Currency::reserve(&collection_details.owner, deposit)?;
-				collection_details.total_deposit += deposit;
+				let deposit_account = match deposit_collection_owner {
+					true => collection_details.owner.clone(),
+					false => owner.clone(),
+				};
 
 				let owner = owner.clone();
 				Account::<T, I>::insert((&owner, &collection, &item), ());
 
 				if let Ok(existing_config) = ItemConfigOf::<T, I>::try_get(&collection, &item) {
-					ensure!(existing_config == config, Error::<T, I>::InconsistentItemConfig);
+					ensure!(existing_config == item_config, Error::<T, I>::InconsistentItemConfig);
 				} else {
-					ItemConfigOf::<T, I>::insert(&collection, &item, config);
+					ItemConfigOf::<T, I>::insert(&collection, &item, item_config);
 				}
 
+				T::Currency::reserve(&deposit_account, deposit_amount)?;
+
+				let deposit = ItemDeposit { account: deposit_account, amount: deposit_amount };
 				let details =
 					ItemDetails { owner, approvals: ApprovalsOf::<T, I>::default(), deposit };
 				Item::<T, I>::insert(&collection, &item, details);
@@ -232,8 +255,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				with_details(&details)?;
 
 				// Return the deposit.
-				T::Currency::unreserve(&collection_details.owner, details.deposit);
-				collection_details.total_deposit.saturating_reduce(details.deposit);
+				T::Currency::unreserve(&details.deposit.account, details.deposit.amount);
 				collection_details.items.saturating_dec();
 				Ok(details.owner)
 			},

frame/nfts/src/impl_nonfungibles.rs

@@ -92,15 +92,15 @@ impl<T: Config<I>, I: 'static> Inspect<<T as SystemConfig>::AccountId> for Palle
 	}
 }
 
-impl<T: Config<I>, I: 'static> Create<<T as SystemConfig>::AccountId, CollectionConfig>
+impl<T: Config<I>, I: 'static> Create<<T as SystemConfig>::AccountId, CollectionConfigFor<T, I>>
 	for Pallet<T, I>
 {
 	/// Create a `collection` of nonfungible items to be owned by `who` and managed by `admin`.
 	fn create_collection(
 		collection: &Self::CollectionId,
 		who: &T::AccountId,
 		admin: &T::AccountId,
-		config: &CollectionConfig,
+		config: &CollectionConfigFor<T, I>,
 	) -> DispatchResult {
 		// DepositRequired can be disabled by calling the force_create() only
 		ensure!(
@@ -134,16 +134,22 @@ impl<T: Config<I>, I: 'static> Destroy<<T as SystemConfig>::AccountId> for Palle
 	}
 }
 
-impl<T: Config<I>, I: 'static> Mutate<<T as SystemConfig>::AccountId, ItemSettings>
-	for Pallet<T, I>
-{
+impl<T: Config<I>, I: 'static> Mutate<<T as SystemConfig>::AccountId, ItemConfig> for Pallet<T, I> {
 	fn mint_into(
 		collection: &Self::CollectionId,
 		item: &Self::ItemId,
 		who: &T::AccountId,
-		settings: &ItemSettings,
+		item_config: &ItemConfig,
+		deposit_collection_owner: bool,
 	) -> DispatchResult {
-		Self::do_mint(*collection, *item, who.clone(), ItemConfig(*settings))
+		Self::do_mint(
+			*collection,
+			*item,
+			who.clone(),
+			*item_config,
+			deposit_collection_owner,
+			|_, _| Ok(()),
+		)
 	}
 
 	fn burn(