feat(nfts): add CollectionApprovals and AccountBalance storages, and general improvements

pallets/nfts/src/benchmarking.rs

@@ -17,7 +17,7 @@
 
 //! Nfts pallet benchmarking.
 
 #![cfg(feature = "runtime-benchmarks")]
 
 use enumflags2::{BitFlag, BitFlags};
 use frame_benchmarking::v1::{
@@ -64,6 +64,27 @@
 	(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>) {
@@ -74,10 +95,10 @@
 		whitelist_account!(caller);
 	}
 	let caller_lookup = T::Lookup::unlookup(caller.clone());
 	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(),
@@ -250,6 +271,8 @@
 		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>();
@@ -267,6 +290,13 @@
 		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 {
@@ -573,27 +603,45 @@
 	}
 
 	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 deadline = BlockNumberFor::<T>::max_value();
-	}: _(SystemOrigin::Signed(caller.clone()), collection, item, delegate_lookup, Some(deadline))
+		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)
 	verify {
-		assert_last_event::<T, I>(Event::TransferApproved { collection, item, owner: caller, delegate, deadline: Some(deadline) }.into());
+		assert_last_event::<T, I>(Event::TransferApproved { collection, item: maybe_item, owner: caller, delegate, deadline: maybe_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();
-		Nfts::<T, I>::approve_transfer(origin, collection, item, delegate_lookup.clone(), Some(deadline))?;
-	}: _(SystemOrigin::Signed(caller.clone()), collection, item, delegate_lookup)
+		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)
 	verify {
-		assert_last_event::<T, I>(Event::ApprovalCancelled { collection, item, owner: caller, delegate }.into());
+		assert_last_event::<T, I>(Event::ApprovalCancelled { collection, item: maybe_item, owner: caller, delegate }.into());
 	}
 
 	clear_all_transfer_approvals {
@@ -603,7 +651,7 @@
 		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, item, delegate_lookup.clone(), Some(deadline))?;
+		Nfts::<T, I>::approve_transfer(origin, collection, Some(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());
@@ -682,7 +730,7 @@
 	}
 
 	pay_tips {
 		let n in 0 .. T::MaxTips::get() as u32;
 		let amount = BalanceOf::<T, I>::from(100u32);
 		let caller: T::AccountId = whitelisted_caller();
 		let collection = T::Helper::collection(0);
@@ -788,7 +836,7 @@
 	}
 
 	mint_pre_signed {
 		let n in 0 .. T::MaxAttributesPerCall::get() as u32;
 		let (caller_public, caller) = T::Helper::signer();
 		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
 		let caller_lookup = T::Lookup::unlookup(caller.clone());
@@ -823,14 +871,14 @@
 		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()), Box::new(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());
 	}
 
 	set_attributes_pre_signed {
 		let n in 0 .. T::MaxAttributesPerCall::get() as u32;
 		let (collection, _, _) = create_collection::<T, I>();
 
 		let item_owner: T::AccountId = account("item_owner", 0, SEED);
@@ -866,7 +914,7 @@
 		let signature = T::Helper::sign(&signer_public, &message);
 
 		frame_system::Pallet::<T>::set_block_number(One::one());
 	}: _(SystemOrigin::Signed(item_owner.clone()), pre_signed_data, signature.into(), signer.clone())
 	verify {
 		assert_last_event::<T, I>(
 			Event::PreSignedAttributesSet {

pallets/nfts/src/common_functions.rs

@@ -34,6 +34,24 @@
 		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
@@ -45,8 +63,8 @@
 		signature: &T::OffchainSignature,
 		signer: &T::AccountId,
 	) -> DispatchResult {
 		if signature.verify(&**data, &signer) {
-			return Ok(())
+			return Ok(());
 		}
 
 		// NOTE: for security reasons modern UIs implicitly wrap the data requested to sign into
@@ -58,7 +76,7 @@
 		wrapped.extend(data);
 		wrapped.extend(suffix);
 
 		ensure!(signature.verify(&*wrapped, &signer), Error::<T, I>::WrongSignature);
 
 		Ok(())
 	}
@@ -70,7 +88,7 @@
 	}
 
 	#[cfg(any(test, feature = "runtime-benchmarks"))]
 	pub fn set_next_id(id: T::CollectionId) {
 		NextCollectionId::<T, I>::set(Some(id));
 	}
 

pallets/nfts/src/features/approvals.rs

@@ -54,7 +54,7 @@
 			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!(
@@ -65,7 +65,6 @@
 		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));
 
@@ -73,16 +72,14 @@
 			.approvals
 			.try_insert(delegate.clone(), deadline)
 			.map_err(|_| Error::<T, I>::ReachedApprovalLimit)?;
 		Item::<T, I>::insert(&collection, &item, &details);
-
 		Self::deposit_event(Event::TransferApproved {
 			collection,
-			item,
+			item: Some(item),
 			owner: details.owner,
 			delegate,
 			deadline,
 		});
-
 		Ok(())
 	}
 
@@ -107,7 +104,7 @@
 		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)?;
 
@@ -125,11 +122,11 @@
 		}
 
 		details.approvals.remove(&delegate);
 		Item::<T, I>::insert(&collection, &item, &details);
 
 		Self::deposit_event(Event::ApprovalCancelled {
 			collection,
-			item,
+			item: Some(item),
 			owner: details.owner,
 			delegate,
 		});
@@ -156,14 +153,14 @@
 		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 {
 			ensure!(check_origin == details.owner, Error::<T, I>::NoPermission);
 		}
 
 		details.approvals.clear();
 		Item::<T, I>::insert(&collection, &item, &details);
 
 		Self::deposit_event(Event::AllApprovalsCancelled {
 			collection,
@@ -173,4 +170,102 @@
 
 		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())
+	}
 }

pallets/nfts/src/features/create_delete_collection.rs

@@ -54,7 +54,9 @@
 				items: 0,
 				item_metadatas: 0,
 				item_configs: 0,
+				item_holders: 0,
 				attributes: 0,
+				allowances: 0,
 			},
 		);
 		CollectionRoleOf::<T, I>::insert(
@@ -65,8 +67,8 @@
 			),
 		);
 
 		CollectionConfigOf::<T, I>::insert(&collection, config);
 		CollectionAccount::<T, I>::insert(&owner, &collection, ());
 
 		Self::deposit_event(event);
 
@@ -119,14 +121,19 @@
 				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 {
 					T::Currency::unreserve(&depositor, metadata.deposit.amount);
 				}
 			}
 
 			CollectionMetadataOf::<T, I>::remove(&collection);
 			Self::clear_roles(&collection)?;
 
 			for (_, (_, deposit)) in Attribute::<T, I>::drain_prefix((&collection,)) {
@@ -137,17 +144,22 @@
 				}
 			}
 
+			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);
 			let _ = ItemConfigOf::<T, I>::clear_prefix(&collection, witness.item_configs, None);
 
 			Self::deposit_event(Event::Destroyed { collection });
 
 			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,
 			})
 		})
 	}

pallets/nfts/src/features/create_delete_item.rs

@@ -56,7 +56,7 @@
 		ensure!(!Item::<T, I>::contains_key(collection, item), Error::<T, I>::AlreadyExists);
 
 		Collection::<T, I>::try_mutate(
 			&collection,
 			|maybe_collection_details| -> DispatchResult {
 				let collection_details =
 					maybe_collection_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
@@ -70,6 +70,15 @@
 
 				collection_details.items.saturating_inc();
 
+				let account_balance =
+					AccountBalance::<T, I>::mutate(collection, &mint_to, |balance| -> u32 {
+						balance.saturating_inc();
+						*balance
+					});
+				if account_balance == 1 {
+					collection_details.item_holders.saturating_inc();
+				}
+
 				let collection_config = Self::get_collection_config(&collection)?;
 				let deposit_amount = match collection_config
 					.is_setting_enabled(CollectionSetting::DepositRequired)
@@ -85,10 +94,10 @@
 				let item_owner = mint_to.clone();
 				Account::<T, I>::insert((&item_owner, &collection, &item), ());
 
 				if let Ok(existing_config) = ItemConfigOf::<T, I>::try_get(&collection, &item) {
 					ensure!(existing_config == item_config, Error::<T, I>::InconsistentItemConfig);
 				} else {
 					ItemConfigOf::<T, I>::insert(&collection, &item, item_config);
 					collection_details.item_configs.saturating_inc();
 				}
 
@@ -100,7 +109,7 @@
 					approvals: ApprovalsOf::<T, I>::default(),
 					deposit,
 				};
 				Item::<T, I>::insert(&collection, &item, details);
 				Ok(())
 			},
 		)?;
@@ -221,11 +230,11 @@
 		// then we keep the config record and don't remove it
 		let remove_config = !item_config.has_disabled_settings();
 		let owner = Collection::<T, I>::try_mutate(
 			&collection,
 			|maybe_collection_details| -> Result<T::AccountId, DispatchError> {
 				let collection_details =
 					maybe_collection_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
 				let details = Item::<T, I>::get(&collection, &item)
 					.ok_or(Error::<T, I>::UnknownCollection)?;
 				with_details(&details)?;
 
@@ -239,7 +248,7 @@
 
 				// Clear the metadata if it's not locked.
 				if item_config.is_setting_enabled(ItemSetting::UnlockedMetadata) {
 					if let Some(metadata) = ItemMetadataOf::<T, I>::take(&collection, &item) {
 						let depositor_account =
 							metadata.deposit.account.unwrap_or(collection_details.owner.clone());
 
@@ -254,18 +263,25 @@
 					}
 				}
 
+				if AccountBalance::<T, I>::get(collection, &details.owner) == 1 {
+					collection_details.item_holders.saturating_dec();
+				}
+
 				Ok(details.owner)
 			},
 		)?;
 
 		Item::<T, I>::remove(&collection, &item);
 		Account::<T, I>::remove((&owner, &collection, &item));
 		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);
 		}
 
 		Self::deposit_event(Event::Burned { collection, item, owner });