Allow Creation of Asset Accounts That Don't Exist Yet and Add Blocked Status

frame/assets/src/benchmarking.rs

@@ -277,6 +277,15 @@ benchmarks_instance_pallet! {
 		assert_last_event::<T, I>(Event::Frozen { asset_id: asset_id.into(), who: caller }.into());
 	}
 
+	freeze_creating {
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, 100u32.into());
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, target_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::Frozen { asset_id: asset_id.into(), who: target }.into());
+	}
+
 	thaw {
 		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, 100u32.into());
 		Assets::<T, I>::freeze(
@@ -482,5 +491,61 @@ benchmarks_instance_pallet! {
 		assert_last_event::<T, I>(Event::AssetMinBalanceChanged { asset_id: asset_id.into(), new_min_balance: 50u32.into() }.into());
 	}
 
+	touch {
+		let (asset_id, asset_owner, asset_owner_lookup) = create_default_asset::<T, I>(false);
+		let new_account: T::AccountId = account("newaccount", 1, SEED);
+		T::Currency::make_free_balance_be(&new_account, DepositBalanceOf::<T, I>::max_value());
+		assert_ne!(asset_owner, new_account);
+		assert!(!Account::<T, I>::contains_key(asset_id.into(), &new_account));
+	}: _(SystemOrigin::Signed(new_account.clone()), asset_id)
+	verify {
+		assert!(Account::<T, I>::contains_key(asset_id.into(), &new_account));
+	}
+
+	refund {
+		let (asset_id, asset_owner, asset_owner_lookup) = create_default_asset::<T, I>(false);
+		let new_account: T::AccountId = account("newaccount", 1, SEED);
+		T::Currency::make_free_balance_be(&new_account, DepositBalanceOf::<T, I>::max_value());
+		assert_ne!(asset_owner, new_account);
+		assert!(Assets::<T, I>::touch(
+			SystemOrigin::Signed(new_account.clone()).into(),
+			asset_id
+		).is_ok());
+		// `touch` should reserve some balance of the caller...
+		assert!(!T::Currency::reserved_balance(&new_account).is_zero());
+		// ...and also create an `Account` entry.
+		assert!(Account::<T, I>::contains_key(asset_id.into(), &new_account));
+	}: _(SystemOrigin::Signed(new_account.clone()), asset_id, true)
+	verify {
+		// `refund`ing should of course repatriate the reserve
+		assert!(T::Currency::reserved_balance(&new_account).is_zero());
+	}
+
+	refund_other {
+		let (asset_id, asset_owner, asset_owner_lookup) = create_default_asset::<T, I>(false);
+		let new_account: T::AccountId = account("newaccount", 1, SEED);
+		let new_account_lookup = T::Lookup::unlookup(new_account.clone());
+		T::Currency::make_free_balance_be(&asset_owner, DepositBalanceOf::<T, I>::max_value());
+		assert_ne!(asset_owner, new_account);
+		assert!(Assets::<T, I>::freeze_creating(
+			SystemOrigin::Signed(asset_owner.clone()).into(),
+			asset_id,
+			new_account_lookup.clone()
+		).is_ok());
+		// `freeze_creating` should reserve balance of the freezer
+		assert!(!T::Currency::reserved_balance(&asset_owner).is_zero());
+		assert!(Assets::<T, I>::thaw(
+			SystemOrigin::Signed(asset_owner.clone()).into(),
+			asset_id,
+			new_account_lookup.clone()
+		).is_ok());
+		// the account should still exist, just not be frozen
+		assert!(Account::<T, I>::contains_key(asset_id.into(), &new_account));
+	}: _(SystemOrigin::Signed(asset_owner.clone()), asset_id, new_account.clone(), true)
+	verify {
+		// this should repatriate the reserved balance of the freezer
+		assert!(T::Currency::reserved_balance(&asset_owner).is_zero());
+	}
+
 	impl_benchmark_test_suite!(Assets, crate::mock::new_test_ext(), crate::mock::Test)
 }

frame/assets/src/functions.rs

@@ -66,10 +66,11 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	pub(super) fn new_account(
 		who: &T::AccountId,
 		d: &mut AssetDetails<T::Balance, T::AccountId, DepositBalanceOf<T, I>>,
-		maybe_deposit: Option<DepositBalanceOf<T, I>>,
+		maybe_deposit: Option<(DepositBalanceOf<T, I>, &T::AccountId)>,
 	) -> Result<ExistenceReason<DepositBalanceOf<T, I>>, DispatchError> {
 		let accounts = d.accounts.checked_add(1).ok_or(ArithmeticError::Overflow)?;
-		let reason = if let Some(deposit) = maybe_deposit {
+		let reason = if let Some((deposit, _depositor)) = maybe_deposit {
+			d.deposit = d.deposit.saturating_add(deposit);
 			ExistenceReason::DepositHeld(deposit)
 		} else if d.is_sufficient {
 			frame_system::Pallet::<T>::inc_sufficients(who);
@@ -123,30 +124,39 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		amount: T::Balance,
 		increase_supply: bool,
 	) -> DepositConsequence {
+		use DepositConsequence::*;
 		let details = match Asset::<T, I>::get(id) {
 			Some(details) => details,
-			None => return DepositConsequence::UnknownAsset,
+			None => return UnknownAsset,
 		};
 		if increase_supply && details.supply.checked_add(&amount).is_none() {
-			return DepositConsequence::Overflow
+			return Overflow
+		}
+		// We don't allow freezing of accounts that don't already have an `(AssetId, AccountId)`
+		// entry. The account may have a zero balance provided by a deposit placed by `touch`ing the
+		// account. However, frozen accounts cannot receive more of the `AssetID`.
+		if let Some(a) = Account::<T, I>::get(id, who) {
+			if a.is_frozen {
+				return Frozen
+			}
 		}
 		if let Some(balance) = Self::maybe_balance(id, who) {
 			if balance.checked_add(&amount).is_none() {
-				return DepositConsequence::Overflow
+				return Overflow
 			}
 		} else {
 			if amount < details.min_balance {
-				return DepositConsequence::BelowMinimum
+				return BelowMinimum
 			}
 			if !details.is_sufficient && !frame_system::Pallet::<T>::can_inc_consumer(who) {
-				return DepositConsequence::CannotCreate
+				return CannotCreate
 			}
 			if details.is_sufficient && details.sufficients.checked_add(1).is_none() {
-				return DepositConsequence::Overflow
+				return Overflow
 			}
 		}
 
-		DepositConsequence::Success
+		Success
 	}
 
 	/// Return the consequence of a withdraw.
@@ -302,14 +312,18 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Ok((credit, maybe_burn))
 	}
 
-	/// Creates a account for `who` to hold asset `id` with a zero balance and takes a deposit.
-	pub(super) fn do_touch(id: T::AssetId, who: T::AccountId) -> DispatchResult {
+	/// Creates an account for `who` to hold asset `id` with a zero balance and takes a deposit.
+	pub(super) fn do_touch(
+		id: T::AssetId,
+		who: &T::AccountId,
+		depositor: &T::AccountId,
+	) -> DispatchResult {
 		ensure!(!Account::<T, I>::contains_key(id, &who), Error::<T, I>::AlreadyExists);
 		let deposit = T::AssetAccountDeposit::get();
 		let mut details = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
 		ensure!(details.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
-		let reason = Self::new_account(&who, &mut details, Some(deposit))?;
-		T::Currency::reserve(&who, deposit)?;
+		let reason = Self::new_account(&who, &mut details, Some((deposit, &depositor)))?;
+		T::Currency::reserve(&depositor, deposit)?;
 		Asset::<T, I>::insert(&id, details);
 		Account::<T, I>::insert(
 			id,
@@ -318,6 +332,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 				balance: Zero::zero(),
 				is_frozen: false,
 				reason,
+				depositor: Some(depositor.clone()),
 				extra: T::Extra::default(),
 			},
 		);
@@ -333,7 +348,11 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		ensure!(account.balance.is_zero() || allow_burn, Error::<T, I>::WouldBurn);
 		ensure!(!account.is_frozen, Error::<T, I>::Frozen);
 
-		T::Currency::unreserve(&who, deposit);
+		let mut refund_to: T::AccountId = who.clone();
+		if let Some(depositor) = account.depositor {
+			refund_to = depositor;
+		}
+		T::Currency::unreserve(&refund_to, deposit);
 
 		if let Remove = Self::dead_account(&who, &mut details, &account.reason, false) {
 			Account::<T, I>::remove(id, &who);
@@ -408,6 +427,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 						*maybe_account = Some(AssetAccountOf::<T, I> {
 							balance: amount,
 							reason: Self::new_account(beneficiary, details, None)?,
+							depositor: None,
 							is_frozen: false,
 							extra: T::Extra::default(),
 						});
@@ -604,6 +624,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 							balance: credit,
 							is_frozen: false,
 							reason: Self::new_account(dest, details, None)?,
+							depositor: None,
 							extra: T::Extra::default(),
 						});
 					},
@@ -938,4 +959,32 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			.filter_map(|id| Self::maybe_balance(id, account.clone()).map(|balance| (id, balance)))
 			.collect::<Vec<_>>()
 	}
+
+	/// Freeze an account `who`, preventing further reception or transfer of asset `id`.
+	pub fn do_freeze(
+		origin: T::AccountId,
+		id: T::AssetId,
+		who: T::AccountId,
+		create: bool,
+	) -> DispatchResult {
+		let d = Asset::<T, I>::get(id).ok_or(Error::<T, I>::Unknown)?;
+		ensure!(
+			d.status == AssetStatus::Live || d.status == AssetStatus::Frozen,
+			Error::<T, I>::AssetNotLive
+		);
+		ensure!(origin == d.freezer, Error::<T, I>::NoPermission);
+
+		if create && Account::<T, I>::get(id, &who).is_none() {
+			// we create the account with zero balance, but the freezer must place a deposit
+			let _ = Self::do_touch(id, &who, &origin)?;
+		}
+
+		Account::<T, I>::try_mutate(id, &who, |maybe_account| -> DispatchResult {
+			maybe_account.as_mut().ok_or(Error::<T, I>::NoAccount)?.is_frozen = true;
+			Ok(())
+		})?;
+
+		Self::deposit_event(Event::<T, I>::Frozen { asset_id: id, who });
+		Ok(())
+	}
 }

frame/assets/src/lib.rs

@@ -82,6 +82,9 @@
 //! * `approve_transfer`: Create or increase an delegated transfer.
 //! * `cancel_approval`: Rescind a previous approval.
 //! * `transfer_approved`: Transfer third-party's assets to another account.
+//! * `touch`: Create an asset account for non-provider assets. Caller must place a deposit.
+//! * `refund`: Return the deposit (if any) of the caller's asset account.
+//! * `refund_other`: Return the deposit (if any) of a specified asset account.
 //!
 //! ### Permissioned Functions
 //!
@@ -104,6 +107,8 @@
 //!   Owner.
 //! * `set_metadata`: Set the metadata of an asset class; called by the asset class's Owner.
 //! * `clear_metadata`: Remove the metadata of an asset class; called by the asset class's Owner.
+//! * `freeze_creating`: Same as `freeze`, but creates the account if necessary; called by the asset
+//!   class's Freezer.
 //!
 //! Please refer to the [`Call`] enum and its associated variants for documentation on each
 //! function.
@@ -198,7 +203,7 @@ pub mod pallet {
 	use frame_system::pallet_prelude::*;
 
 	/// The current storage version.
-	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);
 
 	#[pallet::pallet]
 	#[pallet::storage_version(STORAGE_VERSION)]
@@ -531,7 +536,7 @@ pub mod pallet {
 		NoPermission,
 		/// The given asset ID is unknown.
 		Unknown,
-		/// The origin account is frozen.
+		/// The origin or beneficiary account is frozen.
 		Frozen,
 		/// The asset ID is already taken.
 		InUse,
@@ -920,7 +925,9 @@ pub mod pallet {
 			Self::do_transfer(id, &source, &dest, amount, Some(origin), f).map(|_| ())
 		}
 
-		/// Disallow further unprivileged transfers from an account.
+		/// Disallow further unprivileged transfers of an asset `id` to or from an account `who`.
+		/// `who` must already exist as an entry in `Account`s of the asset. If you want to freeze
+		/// an account that does not have an entry, use `freeze_creating` instead.
 		///
 		/// Origin must be Signed and the sender should be the Freezer of the asset `id`.
 		///
@@ -938,23 +945,10 @@ pub mod pallet {
 			who: AccountIdLookupOf<T>,
 		) -> DispatchResult {
 			let origin = ensure_signed(origin)?;
-			let id: T::AssetId = id.into();
-
-			let d = Asset::<T, I>::get(id).ok_or(Error::<T, I>::Unknown)?;
-			ensure!(
-				d.status == AssetStatus::Live || d.status == AssetStatus::Frozen,
-				Error::<T, I>::AssetNotLive
-			);
-			ensure!(origin == d.freezer, Error::<T, I>::NoPermission);
 			let who = T::Lookup::lookup(who)?;
+			let id: T::AssetId = id.into();
 
-			Account::<T, I>::try_mutate(id, &who, |maybe_account| -> DispatchResult {
-				maybe_account.as_mut().ok_or(Error::<T, I>::NoAccount)?.is_frozen = true;
-				Ok(())
-			})?;
-
-			Self::deposit_event(Event::<T, I>::Frozen { asset_id: id, who });
-			Ok(())
+			Self::do_freeze(origin, id, who, false)
 		}
 
 		/// Allow unprivileged transfers from an account again.
@@ -1493,10 +1487,11 @@ pub mod pallet {
 		///
 		/// Emits `Touched` event when successful.
 		#[pallet::call_index(26)]
-		#[pallet::weight(T::WeightInfo::mint())]
+		#[pallet::weight(T::WeightInfo::touch())]
 		pub fn touch(origin: OriginFor<T>, id: T::AssetIdParameter) -> DispatchResult {
+			let who = ensure_signed(origin)?;
 			let id: T::AssetId = id.into();
-			Self::do_touch(id, ensure_signed(origin)?)
+			Self::do_touch(id, &who, &who)
 		}
 
 		/// Return the deposit (if any) of an asset account.
@@ -1508,7 +1503,7 @@ pub mod pallet {
 		///
 		/// Emits `Refunded` event when successful.
 		#[pallet::call_index(27)]
-		#[pallet::weight(T::WeightInfo::mint())]
+		#[pallet::weight(T::WeightInfo::refund())]
 		pub fn refund(
 			origin: OriginFor<T>,
 			id: T::AssetIdParameter,
@@ -1564,6 +1559,53 @@ pub mod pallet {
 			});
 			Ok(())
 		}
+
+		/// Disallow further unprivileged transfers to or from an account. Creates the account and
+		/// takes a deposit if it does not already exist in `Account`.
+		///
+		/// Origin must be Signed and the sender should be the Freezer of the asset `id`.
+		///
+		/// - `id`: The identifier of the asset to be frozen.
+		/// - `who`: The account to be frozen.
+		///
+		/// Emits `Frozen`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(29)]
+		#[pallet::weight(T::WeightInfo::freeze_creating())]
+		pub fn freeze_creating(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			who: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			let id: T::AssetId = id.into();
+
+			Self::do_freeze(origin, id, who, true)
+		}
+
+		/// Return the deposit (if any) of a target asset account. Useful if you are the depositor.
+		///
+		/// The origin must be Signed.
+		///
+		/// - `id`: The identifier of the asset for the account to be created.
+		/// - `who`: The account to refund.
+		/// - `allow_burn`: If `true` then assets may be destroyed in order to complete the refund.
+		///
+		/// Emits `Refunded` event when successful.
+		#[pallet::call_index(30)]
+		#[pallet::weight(T::WeightInfo::refund_other())]
+		pub fn refund_other(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			who: T::AccountId,
+			allow_burn: bool,
+		) -> DispatchResult {
+			let _ = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+			Self::do_refund(id, who, allow_burn)
+		}
 	}
 }