[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());
 	}
@@ -271,20 +299,28 @@ benchmarks_instance_pallet! {
 		}.into());
 	}
 
-	force_collection_status {
+	force_collection_owner {
 		let (collection, caller, caller_lookup) = create_collection::<T, I>();
 		let origin = T::ForceOrigin::successful_origin();
 		let call = Call::<T, I>::force_collection_status {
 			collection,
 			owner: caller_lookup.clone(),
-			issuer: caller_lookup.clone(),
-			admin: caller_lookup.clone(),
-			freezer: caller_lookup,
-			config: CollectionConfig(CollectionSetting::DepositRequired.into()),
 		};
 	}: { call.dispatch_bypass_filter(origin)? }
 	verify {
-		assert_last_event::<T, I>(Event::CollectionStatusChanged { collection }.into());
+		assert_last_event::<T, I>(Event::OwnerChanged { collection }.into());
+	}
+
+	force_collection_config {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let origin = T::ForceOrigin::successful_origin();
+		let call = Call::<T, I>::force_collection_status {
+			collection,
+			config: make_collection_config::<T, I>(CollectionSetting::DepositRequired.into()),
+		};
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_last_event::<T, I>(Event::CollectionConfigChanged { collection }.into());
 	}
 
 	lock_item_properties {
@@ -414,6 +450,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 +578,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/common_functions.rs

@@ -0,0 +1,42 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-2022 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.
+
+//! Various pieces of common functionality.
+
+use super::*;
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Get the owner of the item, if the item exists.
+	pub fn owner(collection: T::CollectionId, item: T::ItemId) -> Option<T::AccountId> {
+		Item::<T, I>::get(collection, item).map(|i| i.owner)
+	}
+
+	/// Get the owner of the item, if the item exists.
+	pub fn collection_owner(collection: T::CollectionId) -> Option<T::AccountId> {
+		Collection::<T, I>::get(collection).map(|i| i.owner)
+	}
+
+	#[cfg(any(test, feature = "runtime-benchmarks"))]
+	pub fn set_next_id(id: T::CollectionId) {
+		NextCollectionId::<T, I>::set(Some(id));
+	}
+
+	#[cfg(test)]
+	pub fn get_next_id() -> T::CollectionId {
+		NextCollectionId::<T, I>::get().unwrap_or(T::CollectionId::initial_value())
+	}
+}

frame/nfts/src/features/approvals.rs

@@ -0,0 +1,132 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 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 crate::*;
+use frame_support::pallet_prelude::*;
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	pub(crate) fn do_approve_transfer(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		item: T::ItemId,
+		delegate: T::AccountId,
+		maybe_deadline: Option<<T as SystemConfig>::BlockNumber>,
+	) -> DispatchResult {
+		ensure!(
+			Self::is_pallet_feature_enabled(PalletFeature::Approvals),
+			Error::<T, I>::MethodDisabled
+		);
+		let mut details =
+			Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+
+		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 {
+			let is_admin = Self::has_role(&collection, &check_origin, CollectionRole::Admin);
+			let permitted = is_admin || check_origin == details.owner;
+			ensure!(permitted, Error::<T, I>::NoPermission);
+		}
+
+		let now = frame_system::Pallet::<T>::block_number();
+		let deadline = maybe_deadline.map(|d| d.saturating_add(now));
+
+		details
+			.approvals
+			.try_insert(delegate.clone(), deadline)
+			.map_err(|_| Error::<T, I>::ReachedApprovalLimit)?;
+		Item::<T, I>::insert(&collection, &item, &details);
+
+		Self::deposit_event(Event::ApprovedTransfer {
+			collection,
+			item,
+			owner: details.owner,
+			delegate,
+			deadline,
+		});
+
+		Ok(())
+	}
+
+	pub(crate) fn do_cancel_approval(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		item: T::ItemId,
+		delegate: T::AccountId,
+	) -> DispatchResult {
+		let mut details =
+			Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+
+		let maybe_deadline = details.approvals.get(&delegate).ok_or(Error::<T, I>::NotDelegate)?;
+
+		let is_past_deadline = if let Some(deadline) = maybe_deadline {
+			let now = frame_system::Pallet::<T>::block_number();
+			now > *deadline
+		} else {
+			false
+		};
+
+		if !is_past_deadline {
+			if let Some(check_origin) = maybe_check_origin {
+				let is_admin = Self::has_role(&collection, &check_origin, CollectionRole::Admin);
+				let permitted = is_admin || check_origin == details.owner;
+				ensure!(permitted, Error::<T, I>::NoPermission);
+			}
+		}
+
+		details.approvals.remove(&delegate);
+		Item::<T, I>::insert(&collection, &item, &details);
+
+		Self::deposit_event(Event::ApprovalCancelled {
+			collection,
+			item,
+			owner: details.owner,
+			delegate,
+		});
+
+		Ok(())
+	}
+
+	pub(crate) fn do_clear_all_transfer_approvals(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		item: T::ItemId,
+	) -> DispatchResult {
+		let mut details =
+			Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownCollection)?;
+
+		if let Some(check_origin) = maybe_check_origin {
+			let is_admin = Self::has_role(&collection, &check_origin, CollectionRole::Admin);
+			let permitted = is_admin || check_origin == details.owner;
+			ensure!(permitted, Error::<T, I>::NoPermission);
+		}
+
+		details.approvals.clear();
+		Item::<T, I>::insert(&collection, &item, &details);
+
+		Self::deposit_event(Event::AllApprovalsCancelled {
+			collection,
+			item,
+			owner: details.owner,
+		});
+
+		Ok(())
+	}
+}