Contracts: migrate to fungible traits

frame/contracts/src/exec.rs

@@ -28,8 +28,9 @@ use frame_support::{
 	},
 	storage::{with_transaction, TransactionOutcome},
 	traits::{
-		tokens::{Fortitude::Polite, Preservation::Expendable},
-		Contains, Currency, ExistenceRequirement, OriginTrait, Randomness, Time,
+		fungible::{Inspect, Mutate},
+		tokens::{Fortitude::Polite, Preservation},
+		Contains, OriginTrait, Randomness, Time,
 	},
 	weights::Weight,
 	Blake2_128Concat, BoundedVec, StorageHasher,
@@ -1061,12 +1062,12 @@ where
 
 	/// Transfer some funds from `from` to `to`.
 	fn transfer(
-		existence_requirement: ExistenceRequirement,
+		preservation: Preservation,
 		from: &T::AccountId,
 		to: &T::AccountId,
 		value: BalanceOf<T>,
 	) -> DispatchResult {
-		T::Currency::transfer(from, to, value, existence_requirement)
+		T::Currency::transfer(from, to, value, preservation)
 			.map_err(|_| Error::<T>::TransferFailed)?;
 		Ok(())
 	}
@@ -1091,7 +1092,7 @@ where
 			Origin::Root if value.is_zero() => return Ok(()),
 			Origin::Root => return DispatchError::RootNotAllowed.into(),
 		};
-		Self::transfer(ExistenceRequirement::KeepAlive, &caller, &frame.account_id, value)
+		Self::transfer(Preservation::Protect, &caller, &frame.account_id, value)
 	}
 
 	/// Reference to the current (top) frame.
@@ -1239,7 +1240,6 @@ where
 	}
 
 	fn terminate(&mut self, beneficiary: &AccountIdOf<Self::T>) -> Result<(), DispatchError> {
-		use frame_support::traits::fungible::Inspect;
 		if self.is_recursive() {
 			return Err(Error::<T>::TerminatedWhileReentrant.into())
 		}
@@ -1250,8 +1250,8 @@ where
 		T::Currency::transfer(
 			&frame.account_id,
 			beneficiary,
-			T::Currency::reducible_balance(&frame.account_id, Expendable, Polite),
-			ExistenceRequirement::AllowDeath,
+			T::Currency::reducible_balance(&frame.account_id, Preservation::Expendable, Polite),
+			Preservation::Expendable,
 		)?;
 		info.queue_trie_for_deletion();
 		ContractInfoOf::<T>::remove(&frame.account_id);
@@ -1267,7 +1267,7 @@ where
 	}
 
 	fn transfer(&mut self, to: &T::AccountId, value: BalanceOf<T>) -> DispatchResult {
-		Self::transfer(ExistenceRequirement::KeepAlive, &self.top_frame().account_id, to, value)
+		Self::transfer(Preservation::Protect, &self.top_frame().account_id, to, value)
 	}
 
 	fn get_storage(&mut self, key: &Key<T>) -> Option<Vec<u8>> {
@@ -1330,7 +1330,7 @@ where
 	}
 
 	fn balance(&self) -> BalanceOf<T> {
-		T::Currency::free_balance(&self.top_frame().account_id)
+		T::Currency::balance(&self.top_frame().account_id)
 	}
 
 	fn value_transferred(&self) -> BalanceOf<T> {
@@ -1694,7 +1694,7 @@ mod tests {
 			set_balance(&origin, 100);
 			set_balance(&dest, 0);
 
-			MockStack::transfer(ExistenceRequirement::KeepAlive, &origin, &dest, 55).unwrap();
+			MockStack::transfer(Preservation::Protect, &origin, &dest, 55).unwrap();
 
 			assert_eq!(get_balance(&origin), 45);
 			assert_eq!(get_balance(&dest), 55);
@@ -1832,7 +1832,7 @@ mod tests {
 		ExtBuilder::default().build().execute_with(|| {
 			set_balance(&origin, 0);
 
-			let result = MockStack::transfer(ExistenceRequirement::KeepAlive, &origin, &dest, 100);
+			let result = MockStack::transfer(Preservation::Protect, &origin, &dest, 100);
 
 			assert_eq!(result, Err(Error::<Test>::TransferFailed.into()));
 			assert_eq!(get_balance(&origin), 0);

frame/contracts/src/lib.rs

@@ -111,8 +111,8 @@ use frame_support::{
 	ensure,
 	error::BadOrigin,
 	traits::{
-		tokens::fungible::Inspect, ConstU32, Contains, Currency, Get, Randomness,
-		ReservableCurrency, Time,
+		fungible::{Inspect, InspectHold, Mutate, MutateHold},
+		ConstU32, Contains, Get, Randomness, Time,
 	},
 	weights::Weight,
 	BoundedVec, RuntimeDebugNoBound, WeakBoundedVec,
@@ -143,7 +143,7 @@ pub use crate::wasm::api_doc;
 type CodeHash<T> = <T as frame_system::Config>::Hash;
 type TrieId = BoundedVec<u8, ConstU32<128>>;
 type BalanceOf<T> =
-	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+	<<T as Config>::Currency as Inspect<<T as frame_system::Config>::AccountId>>::Balance;
 type CodeVec<T> = BoundedVec<u8, <T as Config>::MaxCodeLen>;
 type RelaxedCodeVec<T> = WeakBoundedVec<u8, <T as Config>::MaxCodeLen>;
 type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
@@ -201,8 +201,9 @@ pub mod pallet {
 		type Randomness: Randomness<Self::Hash, Self::BlockNumber>;
 
 		/// The currency in which fees are paid and contract balances are held.
-		type Currency: ReservableCurrency<Self::AccountId> // TODO: Move to fungible traits
-			+ Inspect<Self::AccountId, Balance = BalanceOf<Self>>;
+		type Currency: Inspect<Self::AccountId>
+			+ Mutate<Self::AccountId>
+			+ MutateHold<Self::AccountId>;
 
 		/// The overarching event type.
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
@@ -311,6 +312,10 @@ pub mod pallet {
 		/// The maximum length of the debug buffer in bytes.
 		#[pallet::constant]
 		type MaxDebugBufferLen: Get<u32>;
+
+		/// The identifier of the hold reason.
+		#[pallet::constant]
+		type HoldReason: Get<<Self::Currency as InspectHold<Self::AccountId>>::Reason>;
 	}
 
 	#[pallet::hooks]
@@ -863,6 +868,14 @@ pub mod pallet {
 		Indeterministic,
 	}
 
+	/// A reason for the pallet contracts placing a hold on funds.
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		/// The Pallet has reserved it for storage deposit.
+		#[codec(index = 0)]
+		StorageDepositReserve,
+	}
+
 	/// A mapping from an original code hash to the original code, untouched by instrumentation.
 	#[pallet::storage]
 	pub(crate) type PristineCode<T: Config> = StorageMap<_, Identity, CodeHash<T>, CodeVec<T>>;

frame/contracts/src/storage/meter.rs

@@ -26,8 +26,9 @@ use frame_support::{
 	dispatch::{fmt::Debug, DispatchError},
 	ensure,
 	traits::{
-		tokens::{Fortitude::Polite, Preservation::Protect, WithdrawConsequence},
-		Currency, ExistenceRequirement, Get,
+		fungible::Mutate,
+		tokens::{Fortitude::Polite, Preservation, WithdrawConsequence},
+		Get,
 	},
 	DefaultNoBound, RuntimeDebugNoBound,
 };
@@ -448,7 +449,7 @@ where
 		System::<T>::inc_consumers(info.deposit_account())?;
 
 		// We also need to make sure that the contract's account itself exists.
-		T::Currency::transfer(origin, contract, ed, ExistenceRequirement::KeepAlive)?;
+		T::Currency::transfer(origin, contract, ed, Preservation::Protect)?;
 		System::<T>::inc_consumers(contract)?;
 
 		Ok(deposit)
@@ -512,7 +513,7 @@ impl<T: Config> Ext<T> for ReservingExt {
 		// We are sending the `min_leftover` and the `min_balance` from the origin
 		// account as part of a contract call. Hence origin needs to have those left over
 		// as free balance after accounting for all deposits.
-		let max = T::Currency::reducible_balance(origin, Protect, Polite)
+		let max = T::Currency::reducible_balance(origin, Preservation::Protect, Polite)
 			.saturating_sub(min_leftover)
 			.saturating_sub(Pallet::<T>::min_balance());
 		let default = max.min(T::DefaultDepositLimit::get());
@@ -532,12 +533,10 @@ impl<T: Config> Ext<T> for ReservingExt {
 		terminated: bool,
 	) -> Result<(), DispatchError> {
 		match amount {
-			Deposit::Charge(amount) => T::Currency::transfer(
-				origin,
-				deposit_account,
-				*amount,
-				ExistenceRequirement::KeepAlive,
-			),
+			Deposit::Charge(amount) => {
+				T::Currency::transfer(origin, deposit_account, *amount, Preservation::Protect)?;
+				Ok(())
+			},
 			Deposit::Refund(amount) => {
 				if terminated {
 					System::<T>::dec_consumers(&deposit_account);
@@ -546,9 +545,11 @@ impl<T: Config> Ext<T> for ReservingExt {
 					deposit_account,
 					origin,
 					*amount,
-					// We can safely use `AllowDeath` because our own consumer prevents an removal.
-					ExistenceRequirement::AllowDeath,
-				)
+					// We can safely make it `Expendable` because our own consumer prevents an
+					// removal.
+					Preservation::Expendable,
+				)?;
+				Ok(())
 			},
 		}
 	}

frame/contracts/src/tests.rs

@@ -31,7 +31,7 @@ use crate::{
 	DefaultAddressGenerator, DeletionQueueCounter, Error, Origin, Pallet, Schedule,
 };
 use assert_matches::assert_matches;
-use codec::Encode;
+use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::{
 	assert_err, assert_err_ignore_postinfo, assert_err_with_weight, assert_noop, assert_ok,
 	dispatch::{DispatchError, DispatchErrorWithPostInfo, PostDispatchInfo},
@@ -45,6 +45,7 @@ use frame_support::{
 };
 use frame_system::{EventRecord, Phase};
 use pretty_assertions::{assert_eq, assert_ne};
+use scale_info::TypeInfo;
 use sp_core::ByteArray;
 use sp_io::hashing::blake2_256;
 use sp_keystore::{testing::MemoryKeystore, KeystoreExt};
@@ -322,8 +323,8 @@ impl pallet_balances::Config for Test {
 	type WeightInfo = ();
 	type FreezeIdentifier = ();
 	type MaxFreezes = ();
-	type HoldIdentifier = ();
-	type MaxHolds = ();
+	type HoldIdentifier = HoldIdentifier;
+	type MaxHolds = ConstU32<1>;
 }
 
 impl pallet_timestamp::Config for Test {
@@ -386,6 +387,13 @@ impl Default for Filters {
 	}
 }
 
+#[derive(
+	Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, MaxEncodedLen, Debug, TypeInfo,
+)]
+pub enum HoldIdentifier {
+	StorageDepositReserve,
+}
+
 parameter_types! {
 	static CallFilter: Filters = Default::default();
 }
@@ -404,6 +412,7 @@ impl Contains<RuntimeCall> for TestFilter {
 
 parameter_types! {
 	pub static UnstableInterface: bool = true;
+	pub const HoldReason: HoldIdentifier = HoldIdentifier::StorageDepositReserve;
 }
 
 impl Config for Test {
@@ -427,6 +436,7 @@ impl Config for Test {
 	type MaxStorageKeyLen = ConstU32<128>;
 	type UnsafeUnstableInterface = UnstableInterface;
 	type MaxDebugBufferLen = ConstU32<{ 2 * 1024 * 1024 }>;
+	type HoldReason = HoldReason;
 }
 
 pub const ALICE: AccountId32 = AccountId32::new([1u8; 32]);
@@ -1298,6 +1308,15 @@ fn self_destruct_works() {
 		pretty_assertions::assert_eq!(
 			System::events(),
 			vec![
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+						from: ALICE,
+						to: addr.clone(),
+						amount: 0,
+					}),
+					topics: vec![],
+				},
 				EventRecord {
 					phase: Phase::Initialization,
 					event: RuntimeEvent::System(frame_system::Event::KilledAccount {

frame/contracts/src/wasm/code_cache.rs

@@ -38,10 +38,10 @@ use crate::{
 use frame_support::{
 	dispatch::{DispatchError, DispatchResult},
 	ensure,
-	traits::{Get, ReservableCurrency},
+	traits::{fungible::MutateHold, tokens::Precision::BestEffort, Get},
 	WeakBoundedVec,
 };
-use sp_runtime::traits::BadOrigin;
+use sp_runtime::{traits::BadOrigin, TokenError};
 use sp_std::vec;
 
 /// Put the instrumented module in storage.
@@ -95,8 +95,17 @@ pub fn store<T: Config>(mut module: PrefabWasmModule<T>, instantiated: bool) ->
 				);
 				// This `None` case happens only in freshly uploaded modules. This means that
 				// the `owner` is always the origin of the current transaction.
-				T::Currency::reserve(&new_owner_info.owner, new_owner_info.deposit)
-					.map_err(|_| <Error<T>>::StorageDepositNotEnoughFunds)?;
+				T::Currency::hold(
+					&T::HoldReason::get(),
+					&new_owner_info.owner,
+					new_owner_info.deposit,
+					// )?;
+				)
+				.map_err(|e| match e {
+					DispatchError::Token(TokenError::FundsUnavailable) =>
+						<Error<T>>::StorageDepositNotEnoughFunds.into(),
+					_ => e,
+				})?;
 				new_owner_info.refcount = if instantiated { 1 } else { 0 };
 				<PristineCode<T>>::insert(&code_hash, orig_code);
 				<CodeStorage<T>>::insert(&code_hash, module);
@@ -144,7 +153,12 @@ pub fn try_remove<T: Config>(origin: &T::AccountId, code_hash: CodeHash<T>) -> D
 		if let Some(owner_info) = existing {
 			ensure!(owner_info.refcount == 0, <Error<T>>::CodeInUse);
 			ensure!(&owner_info.owner == origin, BadOrigin);
-			T::Currency::unreserve(&owner_info.owner, owner_info.deposit);
+			T::Currency::release(
+				&T::HoldReason::get(),
+				&owner_info.owner,
+				owner_info.deposit,
+				BestEffort,
+			)?;
 			*existing = None;
 			<PristineCode<T>>::remove(&code_hash);
 			<CodeStorage<T>>::remove(&code_hash);

frame/support/src/traits/tokens/fungible/hold.rs

@@ -99,7 +99,7 @@ pub trait Inspect<AccountId>: super::Inspect<AccountId> {
 	/// Check to see if some `amount` of funds of `who` may be placed on hold for the given
 	/// `reason`. Reasons why this may not be true:
 	///
-	/// - The implementor supports only a limited number of concurrernt holds on an account which is
+	/// - The implementor supports only a limited number of concurrent holds on an account which is
 	///   the possible values of `reason`;
 	/// - The main balance of the account is less than `amount`;
 	/// - Removing `amount` from the main balance would kill the account and remove the only
@@ -118,7 +118,7 @@ pub trait Inspect<AccountId>: super::Inspect<AccountId> {
 /// **WARNING**
 /// Do not use this directly unless you want trouble, since it allows you to alter account balances
 /// without keeping the issuance up to date. It has no safeguards against accidentally creating
-/// token imbalances in your system leading to accidental imflation or deflation. It's really just
+/// token imbalances in your system leading to accidental inflation or deflation. It's really just
 /// for the underlying datatype to implement so the user gets the much safer `Balanced` trait to
 /// use.
 pub trait Unbalanced<AccountId>: Inspect<AccountId> {
@@ -131,7 +131,7 @@ pub trait Unbalanced<AccountId>: Inspect<AccountId> {
 	/// invariants such as any Existential Deposits needed or overflows/underflows.
 	/// If this cannot be done for some reason (e.g. because the account doesn't exist) then an
 	/// `Err` is returned.
-	// Implmentation note: This should increment the consumer refs if it moves total on hold from
+	// Implementation note: This should increment the consumer refs if it moves total on hold from
 	// zero to non-zero and decrement in the opposite direction.
 	//
 	// Since this was not done in the previous logic, this will need either a migration or a

frame/support/src/traits/tokens/fungible/regular.rs

@@ -58,7 +58,8 @@ pub trait Inspect<AccountId>: Sized {
 	/// The minimum balance any single account may have.
 	fn minimum_balance() -> Self::Balance;
 
-	/// Get the total amount of funds whose ultimate bneficial ownership can be determined as `who`.
+	/// Get the total amount of funds whose ultimate beneficial ownership can be determined as
+	/// `who`.
 	///
 	/// This may include funds which are wholly inaccessible to `who`, either temporarily or even
 	/// indefinitely.

frame/support/src/traits/tokens/fungibles/hold.rs

@@ -133,7 +133,7 @@ pub trait Inspect<AccountId>: super::Inspect<AccountId> {
 /// **WARNING**
 /// Do not use this directly unless you want trouble, since it allows you to alter account balances
 /// without keeping the issuance up to date. It has no safeguards against accidentally creating
-/// token imbalances in your system leading to accidental imflation or deflation. It's really just
+/// token imbalances in your system leading to accidental inflation or deflation. It's really just
 /// for the underlying datatype to implement so the user gets the much safer `Balanced` trait to
 /// use.
 pub trait Unbalanced<AccountId>: Inspect<AccountId> {
@@ -146,7 +146,7 @@ pub trait Unbalanced<AccountId>: Inspect<AccountId> {
 	/// invariants such as any Existential Deposits needed or overflows/underflows.
 	/// If this cannot be done for some reason (e.g. because the account doesn't exist) then an
 	/// `Err` is returned.
-	// Implmentation note: This should increment the consumer refs if it moves total on hold from
+	// Implementation note: This should increment the consumer refs if it moves total on hold from
 	// zero to non-zero and decrement in the opposite direction.
 	//
 	// Since this was not done in the previous logic, this will need either a migration or a