Jg/13643 contracts migrate to fungible traits (#14020)

* contracts: refactor currency to use fungible traits * contracts: refactor currency to use fungible traits * contracts: add minor improvements * contracts: max holds config set * contracts: fix some typos * contracts: map token errors * fix typo * contracts: add 0 balance transfer to test * contracts: not transfer if value is zero * contracts: [WIP] add StorageDepositHold * contracts: add storage deposit held event * contracts: clean up some code and comments * contracts: add deposit storage released event * contracts: update comment * contracts: update slash cannot kill account test * contracts: fix tests * contracts: add some comments to the slashing test * contracts: add some comments to the slashing test * contracts: remove references to Currency * contracts: do not transfer if from equals to * bound BalanceOf<T> * added FixedPointOperand to Balance trait * move migrate sequence to config * remove commented out code * Update frame/contracts/src/lib.rs Co-authored-by: PG Herveou <pgherveou@gmail.com> * remove Migrations generic * make runtime use noop migrations * restrict is_upgrade_supported * undo is_upgrade_supported change * Update bin/node/runtime/src/lib.rs Co-authored-by: PG Herveou <pgherveou@gmail.com> * add rust doc example for `Migrations` * feature gate NoopMigration * fix example code * improve example * wip * remove FixedPointOperand from trait * trait bound BalanceOf * more trait bound BalanceOf * update to use RuntimeHoldReason * replace Fungible for Currency * update runtime * WIP * make v10 benchmark generic over currency * solve merge conflicts * make v12 migration benchmarking generic over DepositPerItem and DepositPerByte * give some format * fix tests and old migrations * add migration v13 placholder * wip * wip * add benchmarking * add weights * wip * [pallet_collective] Enforce prime is a valid member of collective in set_members extrinsic (#14354) * Updated set_members extrinsic to enforce prime is valid member of collective * Added additional tests for set_members extrinsic * applied the code review suggestions * update to docify 0.2.0 / crate-relative embed paths (#14570) * Fix Society v2 migration (#14421) * fix society v2 migration * Update frame/society/src/migrations.rs * Update frame/society/src/migrations.rs Co-authored-by: Bastian Köcher <git@kchr.de> * Update frame/society/src/migrations.rs Co-authored-by: Bastian Köcher <git@kchr.de> * update for versioned upgrade * fix society v2 migration * remove references to members being sorted from commnets * fix type * fix can_migrate check * add sanity log * fix sanity check * kick ci * kick ci * run tests with --experimental flag * versioned migration cleanup * revert pipeline change * use defensive! * semicolons * defensive and doc comment * address pr comment * feature gate the versioned migration * defensive_unwrap_or * fix test * fix doc comment * change defensive to a log warning * remove can_migrate anti-pattern * Update frame/society/Cargo.toml Co-authored-by: Bastian Köcher <git@kchr.de> * add experimental feature warning to doc comment * update doc comment * bump ci * kick ci * kick ci * kick ci --------- Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com> Co-authored-by: Bastian Köcher <git@kchr.de> * Moves `Block` to `frame_system` instead of `construct_runtime` and removes `Header` and `BlockNumber` (#14437) * Initial setup * Adds node block * Uses UncheckedExtrinsic and removes Where section * Updates frame_system to use Block * Adds deprecation warning * Fixes pallet-timestamp * Removes Header and BlockNumber * Addresses review comments * Addresses review comments * Adds comment about compiler bug * Removes where clause * Refactors code * Fixes errors in cargo check * Fixes errors in cargo check * Fixes warnings in cargo check * Formatting * Fixes construct_runtime tests * Uses import instead of full path for BlockNumber * Uses import instead of full path for Header * Formatting * Fixes construct_runtime tests * Fixes imports in benchmarks * Formatting * Fixes construct_runtime tests * Formatting * Minor updates * Fixes construct_runtime ui tests * Fixes construct_runtime ui tests with 1.70 * Fixes docs * Fixes docs * Adds u128 mock block type * Fixes split example * fixes for cumulus * ".git/.scripts/commands/fmt/fmt.sh" * Updates new tests * Fixes fully-qualified path in few places * Formatting * Update frame/examples/default-config/src/lib.rs Co-authored-by: Juan <juangirini@gmail.com> * Update frame/support/procedural/src/construct_runtime/mod.rs Co-authored-by: Juan <juangirini@gmail.com> * ".git/.scripts/commands/fmt/fmt.sh" * Addresses some review comments * Fixes build * ".git/.scripts/commands/fmt/fmt.sh" * Update frame/democracy/src/lib.rs Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> * Update frame/democracy/src/lib.rs Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> * Update frame/support/procedural/src/construct_runtime/mod.rs Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> * Update frame/support/procedural/src/construct_runtime/mod.rs Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> * Addresses review comments * Updates trait bounds * Minor fix * ".git/.scripts/commands/fmt/fmt.sh" * Removes unnecessary bound * ".git/.scripts/commands/fmt/fmt.sh" * Updates test * Fixes build * Adds a bound for header * ".git/.scripts/commands/fmt/fmt.sh" * Removes where block * Minor fix * Minor fix * Fixes tests * ".git/.scripts/commands/update-ui/update-ui.sh" 1.70 * Updates test * Update primitives/runtime/src/traits.rs Co-authored-by: Bastian Köcher <git@kchr.de> * Update primitives/runtime/src/traits.rs Co-authored-by: Bastian Köcher <git@kchr.de> * Updates doc * Updates doc --------- Co-authored-by: command-bot <> Co-authored-by: Juan <juangirini@gmail.com> Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> Co-authored-by: Bastian Köcher <git@kchr.de> * Refactor the asset-conversion-tx-payment pallet (#14558) * Code refactoring * Fix imports * Typo * Update frame/asset-conversion/src/types.rs Co-authored-by: joe petrowski <25483142+joepetrowski@users.noreply.github.com> * Sync docs --------- Co-authored-by: parity-processbot <> Co-authored-by: joe petrowski <25483142+joepetrowski@users.noreply.github.com> * wip * wip * wip * improve try-runtime imports * fix benchmark test * improved rustdocs * improved rustdocs * remove log * ignore variable * reduce caller funding * move v13 out * update v13 migration * v13 migration * benchmark v13_migration * fix broken compilation * ".git/.scripts/commands/bench/bench.sh" --subcommand=pallet --runtime=dev --target_dir=substrate --pallet=pallet_contracts * remove all the `where BalanceOf` * add Balance to Config * improve docs * add new deposit storage error * remove todo message * rename migration v13 pre rebase * fix tests * add missing migration; * bump storage version * apply review suggestions * improved comment * remove unnecessary code * simplify migrations * mock balance * mock more for benchmarks * fix benchmarking tests * fix benchmarking tests with caller * improve cargo toml * solve nit * Update frame/contracts/src/lib.rs Co-authored-by: Alexander Theißen <alex.theissen@me.com> * Update frame/contracts/src/exec.rs Co-authored-by: Alexander Theißen <alex.theissen@me.com> * Update frame/contracts/src/exec.rs Co-authored-by: Alexander Theißen <alex.theissen@me.com> * Update frame/contracts/src/storage/meter.rs Co-authored-by: Alexander Theißen <alex.theissen@me.com> * review improvements * remove extra events * update cargo * undo update cargo * review updates * remove type Balance * add extra fields to events * fix zepter ci --------- Co-authored-by: PG Herveou <pgherveou@gmail.com> Co-authored-by: Toufeeq Pasha <47236805+ToufeeqP@users.noreply.github.com> Co-authored-by: Sam Johnson <sam@durosoft.com> Co-authored-by: Liam Aharon <liam.aharon@hotmail.com> Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com> Co-authored-by: Bastian Köcher <git@kchr.de> Co-authored-by: gupnik <17176722+gupnik@users.noreply.github.com> Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io> Co-authored-by: Jegor Sidorenko <5252494+jsidorenko@users.noreply.github.com> Co-authored-by: joe petrowski <25483142+joepetrowski@users.noreply.github.com> Co-authored-by: command-bot <> Co-authored-by: Alexander Theißen <alex.theissen@me.com>
2026-04-25 23:27:56 +00:00 · 2023-08-02 15:51:31 +02:00
parent 3fef703e30
commit fef9723d65
17 changed files with 797 additions and 371 deletions
@@ -1251,6 +1251,7 @@ impl pallet_contracts::Config for Runtime {
 	type MaxStorageKeyLen = ConstU32<128>;
 	type UnsafeUnstableInterface = ConstBool<false>;
 	type MaxDebugBufferLen = ConstU32<{ 2 * 1024 * 1024 }>;
+	type RuntimeHoldReason = RuntimeHoldReason;
 	#[cfg(not(feature = "runtime-benchmarks"))]
 	type Migrations = ();
 	#[cfg(feature = "runtime-benchmarks")]
@@ -39,6 +39,7 @@ environmental = { version = "1.1.4", default-features = false }
 frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../benchmarking", optional = true }
 frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
 frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances", optional = true, default-features = false }
 pallet-contracts-primitives = { version = "24.0.0", default-features = false, path = "primitives" }
 pallet-contracts-proc-macro = { version = "4.0.0-dev", path = "proc-macro" }
 sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api" }
@@ -82,7 +83,7 @@ std = [
 	"log/std",
 	"rand/std",
 	"environmental/std",
-	"pallet-balances/std",
+	"pallet-balances?/std",
 	"pallet-insecure-randomness-collective-flip/std",
 	"pallet-proxy/std",
 	"pallet-timestamp/std",
@@ -95,9 +96,9 @@ runtime-benchmarks = [
 	"rand",
 	"rand_pcg",
 	"wasm-instrument",
+	"pallet-balances/runtime-benchmarks",
 	"frame-support/runtime-benchmarks",
 	"frame-system/runtime-benchmarks",
-	"pallet-balances/runtime-benchmarks",
 	"pallet-proxy/runtime-benchmarks",
 	"pallet-timestamp/runtime-benchmarks",
 	"pallet-utility/runtime-benchmarks",
@@ -9,8 +9,8 @@ The Contracts module provides functionality for the runtime to deploy and execut

 ## Overview

-This module extends accounts based on the `Currency` trait to have smart-contract functionality. It can
-be used with other modules that implement accounts based on `Currency`. These "smart-contract accounts"
+This module extends accounts based on the [`frame_support::traits::fungible`] traits to have smart-contract functionality. It can
+be used with other modules that implement accounts based on [`frame_support::traits::fungible`]. These "smart-contract accounts"
 have the ability to instantiate smart-contracts and make calls to other contract and non-contract accounts.

 The smart-contract code is stored once, and later retrievable via its `code_hash`.
@@ -30,14 +30,20 @@ use self::{
 };
 use crate::{
 	exec::{AccountIdOf, Key},
-	migration::{codegen::LATEST_MIGRATION_VERSION, v09, v10, v11, v12, v13, MigrationStep},
+	migration::{codegen::LATEST_MIGRATION_VERSION, v09, v10, v11, v12, v13, v14, MigrationStep},
 	wasm::CallFlags,
 	Pallet as Contracts, *,
 };
 use codec::{Encode, MaxEncodedLen};
 use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller};
-use frame_support::{pallet_prelude::StorageVersion, weights::Weight};
+use frame_support::{
+	self,
+	pallet_prelude::StorageVersion,
+	traits::{fungible::InspectHold, Currency},
+	weights::Weight,
+};
 use frame_system::RawOrigin;
+use pallet_balances;
 use sp_runtime::traits::{Bounded, Hash};
 use sp_std::prelude::*;
 use wasm_instrument::parity_wasm::elements::{BlockType, Instruction, ValueType};
@@ -63,8 +69,9 @@ struct Contract<T: Config> {
 	value: BalanceOf<T>,
 }

-impl<T: Config> Contract<T>
+impl<T> Contract<T>
 where
+	T: Config + pallet_balances::Config,
 	<BalanceOf<T> as HasCompact>::Type: Clone + Eq + PartialEq + Debug + TypeInfo + Encode,
 {
 	/// Create new contract and use a default account id as instantiator.
@@ -88,7 +95,7 @@ where
 		data: Vec<u8>,
 	) -> Result<Contract<T>, &'static str> {
 		let value = Pallet::<T>::min_balance();
-		T::Currency::make_free_balance_be(&caller, caller_funding::<T>());
+		T::Currency::set_balance(&caller, caller_funding::<T>());
 		let salt = vec![0xff];
 		let addr = Contracts::<T>::contract_address(&caller, &module.hash, &data, &salt);

@@ -154,7 +161,7 @@ where

 	/// Set the balance of the contract to the supplied amount.
 	fn set_balance(&self, balance: BalanceOf<T>) {
-		T::Currency::make_free_balance_be(&self.account_id, balance);
+		T::Currency::set_balance(&self.account_id, balance);
 	}

 	/// Returns `true` iff all storage entries related to code storage exist.
@@ -170,7 +177,9 @@ where

 /// The funding that each account that either calls or instantiates contracts is funded with.
 fn caller_funding<T: Config>() -> BalanceOf<T> {
-	BalanceOf::<T>::max_value() / 2u32.into()
+	// Minting can overflow, so we can't abuse of the funding. This value happens to be big enough,
+	// but not too big to make the total supply overflow.
+	BalanceOf::<T>::max_value() / 10_000u32.into()
 }

 /// Load the specified contract file from disk by including it into the runtime.
@@ -194,6 +203,9 @@ macro_rules! load_benchmark {
 benchmarks! {
 	where_clause { where
 		<BalanceOf<T> as codec::HasCompact>::Type: Clone + Eq + PartialEq + sp_std::fmt::Debug + scale_info::TypeInfo + codec::Encode,
+		T: Config + pallet_balances::Config,
+		BalanceOf<T>: From<<pallet_balances::Pallet<T> as Currency<T::AccountId>>::Balance>,
+		<pallet_balances::Pallet<T> as Currency<T::AccountId>>::Balance: From<BalanceOf<T>>,
 	}

 	// The base weight consumed on processing contracts deletion queue.
@@ -229,8 +241,8 @@ benchmarks! {
 			whitelisted_caller(), WasmModule::dummy(), vec![],
 		)?;

-		v10::store_old_contract_info::<T>(contract.account_id.clone(), contract.info()?);
-		let mut m = v10::Migration::<T>::default();
+		v10::store_old_contract_info::<T, pallet_balances::Pallet<T>>(contract.account_id.clone(), contract.info()?);
+		let mut m = v10::Migration::<T, pallet_balances::Pallet<T>>::default();
 	}: {
 		m.step();
 	}
@@ -251,8 +263,11 @@ benchmarks! {
 	#[pov_mode = Measured]
 	v12_migration_step {
 		let c in 0 .. T::MaxCodeLen::get();
-		v12::store_old_dummy_code::<T>(c as usize, account::<T::AccountId>("account", 0, 0));
-		let mut m = v12::Migration::<T>::default();
+		v12::store_old_dummy_code::<
+			T,
+			pallet_balances::Pallet<T>
+		>(c as usize, account::<T::AccountId>("account", 0, 0));
+		let mut m = v12::Migration::<T, pallet_balances::Pallet<T>>::default();
 	}: {
 		m.step();
 	}
@@ -270,6 +285,17 @@ benchmarks! {
 		m.step();
 	}

+	// This benchmarks the v14 migration step (Move code owners' reserved balance to be held instead).
+	#[pov_mode = Measured]
+	v14_migration_step {
+		let account = account::<T::AccountId>("account", 0, 0);
+		T::Currency::set_balance(&account, caller_funding::<T>());
+		v14::store_dummy_code::<T, pallet_balances::Pallet<T>>(account);
+		let mut m = v14::Migration::<T, pallet_balances::Pallet<T>>::default();
+	}: {
+		m.step();
+	}
+
 	// This benchmarks the weight of executing Migration::migrate to execute a noop migration.
 	#[pov_mode = Measured]
 	migration_noop {
@@ -365,22 +391,22 @@ benchmarks! {
 		let salt = vec![42u8; s as usize];
 		let value = Pallet::<T>::min_balance();
 		let caller = whitelisted_caller();
-		T::Currency::make_free_balance_be(&caller, caller_funding::<T>());
+		T::Currency::set_balance(&caller, caller_funding::<T>());
 		let WasmModule { code, hash, .. } = WasmModule::<T>::sized(c, Location::Call);
 		let origin = RawOrigin::Signed(caller.clone());
 		let addr = Contracts::<T>::contract_address(&caller, &hash, &input, &salt);
 	}: _(origin, value, Weight::MAX, None, code, input, salt)
 	verify {
 		let deposit_account = Contract::<T>::address_info(&addr)?.deposit_account().clone();
-		let deposit = T::Currency::free_balance(&deposit_account);
+		let deposit = T::Currency::balance(&deposit_account);
 		// uploading the code reserves some balance in the callers account
-		let code_deposit = T::Currency::reserved_balance(&caller);
+		let code_deposit = T::Currency::total_balance_on_hold(&caller);
 		assert_eq!(
-			T::Currency::free_balance(&caller),
+			T::Currency::balance(&caller),
 			caller_funding::<T>() - value - deposit - code_deposit - Pallet::<T>::min_balance(),
 		);
 		// contract has the full value
-		assert_eq!(T::Currency::free_balance(&addr), value + Pallet::<T>::min_balance());
+		assert_eq!(T::Currency::balance(&addr), value + Pallet::<T>::min_balance());
 	}

 	// Instantiate uses a dummy contract constructor to measure the overhead of the instantiate.
@@ -394,7 +420,7 @@ benchmarks! {
 		let salt = vec![42u8; s as usize];
 		let value = Pallet::<T>::min_balance();
 		let caller = whitelisted_caller();
-		T::Currency::make_free_balance_be(&caller, caller_funding::<T>());
+		T::Currency::set_balance(&caller, caller_funding::<T>());
 		let WasmModule { code, hash, .. } = WasmModule::<T>::dummy();
 		let origin = RawOrigin::Signed(caller.clone());
 		let addr = Contracts::<T>::contract_address(&caller, &hash, &input, &salt);
@@ -402,14 +428,14 @@ benchmarks! {
 	}: _(origin, value, Weight::MAX, None, hash, input, salt)
 	verify {
 		let deposit_account = Contract::<T>::address_info(&addr)?.deposit_account().clone();
-		let deposit = T::Currency::free_balance(&deposit_account);
+		let deposit = T::Currency::balance(&deposit_account);
 		// value was removed from the caller
 		assert_eq!(
-			T::Currency::free_balance(&caller),
+			T::Currency::balance(&caller),
 			caller_funding::<T>() - value - deposit - Pallet::<T>::min_balance(),
 		);
 		// contract has the full value
-		assert_eq!(T::Currency::free_balance(&addr), value + Pallet::<T>::min_balance());
+		assert_eq!(T::Currency::balance(&addr), value + Pallet::<T>::min_balance());
 	}

 	// We just call a dummy contract to measure the overhead of the call extrinsic.
@@ -429,18 +455,18 @@ benchmarks! {
 		let value = Pallet::<T>::min_balance();
 		let origin = RawOrigin::Signed(instance.caller.clone());
 		let callee = instance.addr.clone();
-		let before = T::Currency::free_balance(&instance.account_id);
-		let before_deposit = T::Currency::free_balance(&deposit_account);
+		let before = T::Currency::balance(&instance.account_id);
+		let before_deposit = T::Currency::balance(&deposit_account);
 	}: _(origin, callee, value, Weight::MAX, None, data)
 	verify {
-		let deposit = T::Currency::free_balance(&deposit_account);
+		let deposit = T::Currency::balance(&deposit_account);
 		// value and value transferred via call should be removed from the caller
 		assert_eq!(
-			T::Currency::free_balance(&instance.caller),
+			T::Currency::balance(&instance.caller),
 			caller_funding::<T>() - instance.value - value - deposit - Pallet::<T>::min_balance(),
 		);
 		// contract should have received the value
-		assert_eq!(T::Currency::free_balance(&instance.account_id), before + value);
+		assert_eq!(T::Currency::balance(&instance.account_id), before + value);
 		// contract should still exist
 		instance.info()?;
 	}
@@ -452,13 +478,13 @@ benchmarks! {
 	upload_code {
 		let c in 0 .. T::MaxCodeLen::get();
 		let caller = whitelisted_caller();
-		T::Currency::make_free_balance_be(&caller, caller_funding::<T>());
+		T::Currency::set_balance(&caller, caller_funding::<T>());
 		let WasmModule { code, hash, .. } = WasmModule::<T>::sized(c, Location::Call);
 		let origin = RawOrigin::Signed(caller.clone());
 	}: _(origin, code, None, Determinism::Enforced)
 	verify {
 		// uploading the code reserves some balance in the callers account
-		assert!(T::Currency::reserved_balance(&caller) > 0u32.into());
+		assert!(T::Currency::total_balance_on_hold(&caller) > 0u32.into());
 		assert!(<Contract<T>>::code_exists(&hash));
 	}

@@ -468,17 +494,17 @@ benchmarks! {
 	#[pov_mode = Measured]
 	remove_code {
 		let caller = whitelisted_caller();
-		T::Currency::make_free_balance_be(&caller, caller_funding::<T>());
+		T::Currency::set_balance(&caller, caller_funding::<T>());
 		let WasmModule { code, hash, .. } = WasmModule::<T>::dummy();
 		let origin = RawOrigin::Signed(caller.clone());
 		let uploaded = <Contracts<T>>::bare_upload_code(caller.clone(), code, None, Determinism::Enforced)?;
 		assert_eq!(uploaded.code_hash, hash);
-		assert_eq!(uploaded.deposit, T::Currency::reserved_balance(&caller));
+		assert_eq!(uploaded.deposit, T::Currency::total_balance_on_hold(&caller));
 		assert!(<Contract<T>>::code_exists(&hash));
 	}: _(origin, hash)
 	verify {
 		// removing the code should have unreserved the deposit
-		assert_eq!(T::Currency::reserved_balance(&caller), 0u32.into());
+		assert_eq!(T::Currency::total_balance_on_hold(&caller), 0u32.into());
 		assert!(<Contract<T>>::code_removed(&hash));
 	}

@@ -850,12 +876,15 @@ benchmarks! {
 		let beneficiary = account::<T::AccountId>("beneficiary", 0, 0);
 		let beneficiary_bytes = beneficiary.encode();
 		let beneficiary_len = beneficiary_bytes.len();
+		let caller = whitelisted_caller();
+
+		T::Currency::set_balance(&caller, caller_funding::<T>());

 		// Maximize the delegate_dependencies to account for the worst-case scenario.
 		let code_hashes = (0..T::MaxDelegateDependencies::get())
 			.map(|i| {
 				let new_code = WasmModule::<T>::dummy_with_bytes(65 + i);
-				Contracts::<T>::store_code_raw(new_code.code, whitelisted_caller())?;
+				Contracts::<T>::store_code_raw(new_code.code, caller.clone())?;
 				Ok(new_code.hash)
 			})
 			.collect::<Result<Vec<_>, &'static str>>()?;
@@ -902,15 +931,15 @@ benchmarks! {
 		let instance = Contract::<T>::new(code, vec![])?;
 		let origin = RawOrigin::Signed(instance.caller.clone());
 		let deposit_account = instance.info()?.deposit_account().clone();
-		assert_eq!(<T::Currency as Currency<_>>::total_balance(&beneficiary), 0u32.into());
-		assert_eq!(T::Currency::free_balance(&instance.account_id), Pallet::<T>::min_balance() * 2u32.into());
-		assert_ne!(T::Currency::free_balance(&deposit_account), 0u32.into());
+		assert_eq!(T::Currency::total_balance(&beneficiary), 0u32.into());
+		assert_eq!(T::Currency::balance(&instance.account_id), Pallet::<T>::min_balance() * 2u32.into());
+		assert_ne!(T::Currency::balance(&deposit_account), 0u32.into());
 	}: call(origin, instance.addr.clone(), 0u32.into(), Weight::MAX, None, vec![])
 	verify {
 		if r > 0 {
-			assert_eq!(<T::Currency as Currency<_>>::total_balance(&instance.account_id), 0u32.into());
-			assert_eq!(<T::Currency as Currency<_>>::total_balance(&deposit_account), 0u32.into());
-			assert_eq!(<T::Currency as Currency<_>>::total_balance(&beneficiary), Pallet::<T>::min_balance() * 2u32.into());
+			assert_eq!(T::Currency::total_balance(&instance.account_id), 0u32.into());
+			assert_eq!(T::Currency::total_balance(&deposit_account), 0u32.into());
+			assert_eq!(T::Currency::total_balance(&beneficiary), Pallet::<T>::min_balance() * 2u32.into());
 		}
 	}

@@ -1679,12 +1708,12 @@ benchmarks! {
 		instance.set_balance(value * (r + 1).into());
 		let origin = RawOrigin::Signed(instance.caller.clone());
 		for account in &accounts {
-			assert_eq!(<T::Currency as Currency<_>>::total_balance(account), 0u32.into());
+			assert_eq!(T::Currency::total_balance(account), 0u32.into());
 		}
 	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
 	verify {
 		for account in &accounts {
-			assert_eq!(<T::Currency as Currency<_>>::total_balance(account), value);
+			assert_eq!(T::Currency::total_balance(account), value);
 		}
 	}

@@ -1763,7 +1792,7 @@ benchmarks! {
 		});
 		let instance = Contract::<T>::new(code, vec![])?;
 		let origin = RawOrigin::Signed(instance.caller.clone());
-	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, Some(BalanceOf::<T>::from(u32::MAX).into()), vec![])
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, Some(BalanceOf::<T>::from(u32::MAX.into()).into()), vec![])

 	// This is a slow call: We redeuce the number of runs.
 	#[pov_mode = Measured]
@@ -1772,7 +1801,9 @@ benchmarks! {
 		let hashes = (0..r)
 			.map(|i| {
 				let code = WasmModule::<T>::dummy_with_bytes(i);
-				Contracts::<T>::store_code_raw(code.code, whitelisted_caller())?;
+				let caller = whitelisted_caller();
+				T::Currency::set_balance(&caller, caller_funding::<T>());
+				Contracts::<T>::store_code_raw(code.code, caller)?;
 				Ok(code.hash)
 			})
 			.collect::<Result<Vec<_>, &'static str>>()?;
@@ -1892,7 +1923,9 @@ benchmarks! {
 					])),
 					.. Default::default()
 				});
-				Contracts::<T>::store_code_raw(code.code, whitelisted_caller())?;
+				let caller = whitelisted_caller();
+				T::Currency::set_balance(&caller, caller_funding::<T>());
+				Contracts::<T>::store_code_raw(code.code, caller)?;
 				Ok(code.hash)
 			})
 			.collect::<Result<Vec<_>, &'static str>>()?;
@@ -1996,7 +2029,9 @@ benchmarks! {
 		let hash = callee_code.hash;
 		let hash_bytes = callee_code.hash.encode();
 		let hash_len = hash_bytes.len();
-		Contracts::<T>::store_code_raw(callee_code.code, whitelisted_caller())?;
+		let caller = whitelisted_caller();
+		T::Currency::set_balance(&caller, caller_funding::<T>());
+		Contracts::<T>::store_code_raw(callee_code.code, caller)?;
 		let value: BalanceOf<T> =  t.into();
 		let value_bytes = value.encode();

@@ -2338,7 +2373,9 @@ benchmarks! {
 		let code_hashes = (0..r)
 			.map(|i| {
 				let new_code = WasmModule::<T>::dummy_with_bytes(i);
-				Contracts::<T>::store_code_raw(new_code.code, whitelisted_caller())?;
+				let caller = whitelisted_caller();
+				T::Currency::set_balance(&caller, caller_funding::<T>());
+				Contracts::<T>::store_code_raw(new_code.code, caller)?;
 				Ok(new_code.hash)
 			})
 			.collect::<Result<Vec<_>, &'static str>>()?;
@@ -2379,7 +2416,9 @@ benchmarks! {
 		let code_hashes = (0..r)
 			.map(|i| {
 				let new_code = WasmModule::<T>::dummy_with_bytes(65 + i);
-				Contracts::<T>::store_code_raw(new_code.code, whitelisted_caller())?;
+				let caller = whitelisted_caller();
+				T::Currency::set_balance(&caller, caller_funding::<T>());
+				Contracts::<T>::store_code_raw(new_code.code, caller)?;
 				Ok(new_code.hash)
 			})
 			.collect::<Result<Vec<_>, &'static str>>()?;
@@ -2415,7 +2454,9 @@ benchmarks! {
 		let code_hashes = (0..r)
 			.map(|i| {
 				let new_code = WasmModule::<T>::dummy_with_bytes(65 + i);
-				Contracts::<T>::store_code_raw(new_code.code, whitelisted_caller())?;
+				let caller = whitelisted_caller();
+				T::Currency::set_balance(&caller, caller_funding::<T>());
+				Contracts::<T>::store_code_raw(new_code.code, caller)?;
 				Ok(new_code.hash)
 			})
 			.collect::<Result<Vec<_>, &'static str>>()?;
@@ -30,8 +30,9 @@ use frame_support::{
 	ensure,
 	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,
@@ -1100,13 +1101,15 @@ 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)
-			.map_err(|_| Error::<T>::TransferFailed)?;
+		if !value.is_zero() && from != to {
+			T::Currency::transfer(from, to, value, preservation)
+				.map_err(|_| Error::<T>::TransferFailed)?;
+		}
 		Ok(())
 	}

@@ -1130,7 +1133,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::Preserve, &caller, &frame.account_id, value)
 	}

 	/// Reference to the current (top) frame.
@@ -1278,7 +1281,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())
 		}
@@ -1286,11 +1288,11 @@ where
 		let info = frame.terminate();
 		frame.nested_storage.terminate(&info);
 		System::<T>::dec_consumers(&frame.account_id);
-		T::Currency::transfer(
+		Self::transfer(
+			Preservation::Expendable,
 			&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),
 		)?;
 		info.queue_trie_for_deletion();
 		ContractInfoOf::<T>::remove(&frame.account_id);
@@ -1314,7 +1316,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::Preserve, &self.top_frame().account_id, to, value)
 	}

 	fn get_storage(&mut self, key: &Key<T>) -> Option<Vec<u8>> {
@@ -1377,7 +1379,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> {
@@ -1808,7 +1810,7 @@ mod tests {
 			set_balance(&origin, 100);
 			set_balance(&dest, 0);

-			MockStack::transfer(ExistenceRequirement::KeepAlive, &origin, &dest, 55).unwrap();
+			MockStack::transfer(Preservation::Preserve, &origin, &dest, 55).unwrap();

 			assert_eq!(get_balance(&origin), 45);
 			assert_eq!(get_balance(&dest), 55);
@@ -1946,7 +1948,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::Preserve, &origin, &dest, 100);

 			assert_eq!(result, Err(Error::<Test>::TransferFailed.into()));
 			assert_eq!(get_balance(&origin), 0);
@@ -25,10 +25,10 @@
 //!
 //! ## Overview
 //!
-//! This module extends accounts based on the [`Currency`] trait to have smart-contract
-//! functionality. It can be used with other modules that implement accounts based on [`Currency`].
-//! These "smart-contract accounts" have the ability to instantiate smart-contracts and make calls
-//! to other contract and non-contract accounts.
+//! This module extends accounts based on the [`frame_support::traits::fungible`] traits to have
+//! smart-contract functionality. It can be used with other modules that implement accounts based on
+//! the [`frame_support::traits::fungible`] traits. These "smart-contract accounts" have the ability
+//! to instantiate smart-contracts and make calls to other contract and non-contract accounts.
 //!
 //! The smart-contract code is stored once, and later retrievable via its hash.
 //! This means that multiple smart-contracts can be instantiated from the same hash, without
@@ -117,8 +117,8 @@ use frame_support::{
 	ensure,
 	error::BadOrigin,
 	traits::{
-		tokens::fungible::Inspect, ConstU32, Contains, Currency, Get, Randomness,
-		ReservableCurrency, Time,
+		fungible::{Inspect, Mutate, MutateHold},
+		ConstU32, Contains, Get, Randomness, Time,
 	},
 	weights::Weight,
 	BoundedVec, RuntimeDebugNoBound,
@@ -133,7 +133,6 @@ use scale_info::TypeInfo;
 use smallvec::Array;
 use sp_runtime::traits::{Convert, Hash, Saturating, StaticLookup, Zero};
 use sp_std::{fmt::Debug, prelude::*};
-pub use weights::WeightInfo;

 pub use crate::{
 	address::{AddressGenerator, DefaultAddressGenerator},
@@ -143,6 +142,7 @@ pub use crate::{
 	schedule::{HostFnWeights, InstructionWeights, Limits, Schedule},
 	wasm::Determinism,
 };
+pub use weights::WeightInfo;

 #[cfg(doc)]
 pub use crate::wasm::api_doc;
@@ -150,7 +150,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 AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
 type DebugBufferVec<T> = BoundedVec<u8, <T as Config>::MaxDebugBufferLen>;
@@ -186,7 +186,7 @@ pub mod pallet {
 	use sp_runtime::Perbill;

 	/// The current storage version.
-	pub(crate) const STORAGE_VERSION: StorageVersion = StorageVersion::new(13);
+	pub(crate) const STORAGE_VERSION: StorageVersion = StorageVersion::new(14);

 	#[pallet::pallet]
 	#[pallet::storage_version(STORAGE_VERSION)]
@@ -207,9 +207,10 @@ pub mod pallet {
 		/// to supply a dummy implementation for this type (because it is never used).
 		type Randomness: Randomness<Self::Hash, BlockNumberFor<Self>>;

-		/// 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>>;
+		/// The fungible in which fees are paid and contract balances are held.
+		type Currency: Inspect<Self::AccountId>
+			+ Mutate<Self::AccountId>
+			+ MutateHold<Self::AccountId, Reason = Self::RuntimeHoldReason>;

 		/// The overarching event type.
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
@@ -329,20 +330,25 @@ pub mod pallet {
 		#[pallet::constant]
 		type MaxDebugBufferLen: Get<u32>;

+		/// Overarching hold reason.
+		type RuntimeHoldReason: From<HoldReason>;
+
 		/// The sequence of migration steps that will be applied during a migration.
 		///
 		/// # Examples
 		/// ```
 		/// use pallet_contracts::migration::{v10, v11};
 		/// # struct Runtime {};
-		/// type Migrations = (v10::Migration<Runtime>, v11::Migration<Runtime>);
+		/// # struct Currency {};
+		/// type Migrations = (v10::Migration<Runtime, Currency>, v11::Migration<Runtime>);
 		/// ```
 		///
 		/// If you have a single migration step, you can use a tuple with a single element:
 		/// ```
 		/// use pallet_contracts::migration::v10;
 		/// # struct Runtime {};
-		/// type Migrations = (v10::Migration<Runtime>,);
+		/// # struct Currency {};
+		/// type Migrations = (v10::Migration<Runtime, Currency>,);
 		/// ```
 		type Migrations: MigrateSequence;
 	}
@@ -832,7 +838,7 @@ pub mod pallet {
 		},

 		/// Code with the specified hash has been stored.
-		CodeStored { code_hash: T::Hash },
+		CodeStored { code_hash: T::Hash, deposit_held: BalanceOf<T>, uploader: T::AccountId },

 		/// A custom event emitted by the contract.
 		ContractEmitted {
@@ -844,7 +850,7 @@ pub mod pallet {
 		},

 		/// A code with the specified hash was removed.
-		CodeRemoved { code_hash: T::Hash },
+		CodeRemoved { code_hash: T::Hash, deposit_released: BalanceOf<T>, remover: T::AccountId },

 		/// A contract's code was updated.
 		ContractCodeUpdated {
@@ -979,6 +985,13 @@ pub mod pallet {
 		CannotAddSelfAsDelegateDependency,
 	}

+	/// A reason for the pallet contracts placing a hold on funds.
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		/// The Pallet has reserved it for storing code on-chain.
+		CodeUploadDepositReserve,
+	}
+
 	/// A mapping from a contract's code hash to its code.
 	#[pallet::storage]
 	pub(crate) type PristineCode<T: Config> = StorageMap<_, Identity, CodeHash<T>, CodeVec<T>>;
@@ -33,7 +33,8 @@
 //! ```
 //! use pallet_contracts::migration::{v10, v11};
 //! # pub enum Runtime {};
-//! type Migrations = (v10::Migration<Runtime>, v11::Migration<Runtime>);
+//! # struct Currency;
+//! type Migrations = (v10::Migration<Runtime, Currency>, v11::Migration<Runtime>);
 //! ```
 //!
 //! ## Notes:
@@ -61,6 +62,7 @@ pub mod v10;
 pub mod v11;
 pub mod v12;
 pub mod v13;
+pub mod v14;
 include!(concat!(env!("OUT_DIR"), "/migration_codegen.rs"));

 use crate::{weights::WeightInfo, Config, Error, MigrationInProgress, Pallet, Weight, LOG_TARGET};
@@ -23,7 +23,7 @@ use crate::{
 	exec::AccountIdOf,
 	migration::{IsFinished, MigrationStep},
 	weights::WeightInfo,
-	BalanceOf, CodeHash, Config, Pallet, TrieId, Weight, LOG_TARGET,
+	CodeHash, Config, Pallet, TrieId, Weight, LOG_TARGET,
 };
 use codec::{Decode, Encode};
 use core::cmp::{max, min};
@@ -32,9 +32,8 @@ use frame_support::{
 	pallet_prelude::*,
 	storage_alias,
 	traits::{
-		fungible::Inspect,
-		tokens::{Fortitude::Polite, Preservation::Preserve},
-		Currency, ExistenceRequirement, ReservableCurrency,
+		tokens::{fungible::Inspect, Fortitude::Polite, Preservation::Preserve},
+		ExistenceRequirement, ReservableCurrency,
 	},
 	DefaultNoBound,
 };
@@ -47,29 +46,41 @@ use sp_std::{ops::Deref, prelude::*};
 mod old {
 	use super::*;

+	pub type BalanceOf<T, OldCurrency> = <OldCurrency as frame_support::traits::Currency<
+		<T as frame_system::Config>::AccountId,
+	>>::Balance;
+
 	#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
-	#[scale_info(skip_type_params(T))]
-	pub struct ContractInfo<T: Config> {
+	#[scale_info(skip_type_params(T, OldCurrency))]
+	pub struct ContractInfo<T: Config, OldCurrency>
+	where
+		OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+	{
 		pub trie_id: TrieId,
 		pub code_hash: CodeHash<T>,
 		pub storage_bytes: u32,
 		pub storage_items: u32,
-		pub storage_byte_deposit: BalanceOf<T>,
-		pub storage_item_deposit: BalanceOf<T>,
-		pub storage_base_deposit: BalanceOf<T>,
+		pub storage_byte_deposit: BalanceOf<T, OldCurrency>,
+		pub storage_item_deposit: BalanceOf<T, OldCurrency>,
+		pub storage_base_deposit: BalanceOf<T, OldCurrency>,
 	}

 	#[storage_alias]
-	pub type ContractInfoOf<T: Config> = StorageMap<
+	pub type ContractInfoOf<T: Config, OldCurrency> = StorageMap<
 		Pallet<T>,
 		Twox64Concat,
 		<T as frame_system::Config>::AccountId,
-		ContractInfo<T>,
+		ContractInfo<T, OldCurrency>,
 	>;
 }

 #[cfg(feature = "runtime-benchmarks")]
-pub fn store_old_contract_info<T: Config>(account: T::AccountId, info: crate::ContractInfo<T>) {
+pub fn store_old_contract_info<T: Config, OldCurrency>(
+	account: T::AccountId,
+	info: crate::ContractInfo<T>,
+) where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId> + 'static,
+{
 	let info = old::ContractInfo {
 		trie_id: info.trie_id,
 		code_hash: info.code_hash,
@@ -79,7 +90,7 @@ pub fn store_old_contract_info<T: Config>(account: T::AccountId, info: crate::Co
 		storage_item_deposit: Default::default(),
 		storage_base_deposit: Default::default(),
 	};
-	old::ContractInfoOf::<T>::insert(account, info);
+	old::ContractInfoOf::<T, OldCurrency>::insert(account, info);
 }

 #[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebugNoBound, TypeInfo, MaxEncodedLen)]
@@ -95,28 +106,40 @@ impl<T: Config> Deref for DepositAccount<T> {
 }

 #[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
-#[scale_info(skip_type_params(T))]
-pub struct ContractInfo<T: Config> {
+#[scale_info(skip_type_params(T, OldCurrency))]
+pub struct ContractInfo<T: Config, OldCurrency>
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+{
 	pub trie_id: TrieId,
 	deposit_account: DepositAccount<T>,
 	pub code_hash: CodeHash<T>,
 	storage_bytes: u32,
 	storage_items: u32,
-	pub storage_byte_deposit: BalanceOf<T>,
-	storage_item_deposit: BalanceOf<T>,
-	storage_base_deposit: BalanceOf<T>,
+	pub storage_byte_deposit: old::BalanceOf<T, OldCurrency>,
+	storage_item_deposit: old::BalanceOf<T, OldCurrency>,
+	storage_base_deposit: old::BalanceOf<T, OldCurrency>,
 }

 #[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)]
-pub struct Migration<T: Config> {
+pub struct Migration<T: Config, OldCurrency = ()> {
 	last_account: Option<T::AccountId>,
+	_phantom: PhantomData<(T, OldCurrency)>,
 }

 #[storage_alias]
-type ContractInfoOf<T: Config> =
-	StorageMap<Pallet<T>, Twox64Concat, <T as frame_system::Config>::AccountId, ContractInfo<T>>;
+type ContractInfoOf<T: Config, OldCurrency> = StorageMap<
+	Pallet<T>,
+	Twox64Concat,
+	<T as frame_system::Config>::AccountId,
+	ContractInfo<T, OldCurrency>,
+>;

-impl<T: Config> MigrationStep for Migration<T> {
+impl<T: Config, OldCurrency: 'static> MigrationStep for Migration<T, OldCurrency>
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>
+		+ Inspect<<T as frame_system::Config>::AccountId, Balance = old::BalanceOf<T, OldCurrency>>,
+{
 	const VERSION: u16 = 10;

 	fn max_step_weight() -> Weight {
@@ -125,15 +148,17 @@ impl<T: Config> MigrationStep for Migration<T> {

 	fn step(&mut self) -> (IsFinished, Weight) {
 		let mut iter = if let Some(last_account) = self.last_account.take() {
-			old::ContractInfoOf::<T>::iter_from(old::ContractInfoOf::<T>::hashed_key_for(
-				last_account,
-			))
+			old::ContractInfoOf::<T, OldCurrency>::iter_from(
+				old::ContractInfoOf::<T, OldCurrency>::hashed_key_for(last_account),
+			)
 		} else {
-			old::ContractInfoOf::<T>::iter()
+			old::ContractInfoOf::<T, OldCurrency>::iter()
 		};

 		if let Some((account, contract)) = iter.next() {
-			let min_balance = Pallet::<T>::min_balance();
+			let min_balance = <OldCurrency as frame_support::traits::Currency<
+				<T as frame_system::Config>::AccountId,
+			>>::minimum_balance();
 			log::debug!(target: LOG_TARGET, "Account: 0x{} ", HexDisplay::from(&account.encode()));

 			// Get the new deposit account address
@@ -148,7 +173,7 @@ impl<T: Config> MigrationStep for Migration<T> {

 			// Unreserve the existing deposit
 			// Note we can't use repatriate_reserve, because it only works with existing accounts
-			let remaining = T::Currency::unreserve(&account, old_deposit);
+			let remaining = OldCurrency::unreserve(&account, old_deposit);
 			if !remaining.is_zero() {
 				log::warn!(
 					target: LOG_TARGET,
@@ -161,9 +186,9 @@ impl<T: Config> MigrationStep for Migration<T> {
 			// Attempt to transfer the old deposit to the deposit account.
 			let amount = old_deposit
 				.saturating_sub(min_balance)
-				.min(T::Currency::reducible_balance(&account, Preserve, Polite));
+				.min(OldCurrency::reducible_balance(&account, Preserve, Polite));

-			let new_deposit = T::Currency::transfer(
+			let new_deposit = OldCurrency::transfer(
 				&account,
 				&deposit_account,
 				amount,
@@ -184,7 +209,7 @@ impl<T: Config> MigrationStep for Migration<T> {
 					"Failed to transfer the base deposit, reason: {:?}",
 					err
 				);
-				T::Currency::deposit_creating(&deposit_account, min_balance);
+				OldCurrency::deposit_creating(&deposit_account, min_balance);
 				min_balance
 			});

@@ -224,7 +249,7 @@ impl<T: Config> MigrationStep for Migration<T> {
 				storage_base_deposit,
 			};

-			ContractInfoOf::<T>::insert(&account, new_contract_info);
+			ContractInfoOf::<T, OldCurrency>::insert(&account, new_contract_info);

 			// Store last key for next migration step
 			self.last_account = Some(account);
@@ -238,7 +263,7 @@ impl<T: Config> MigrationStep for Migration<T> {

 	#[cfg(feature = "try-runtime")]
 	fn pre_upgrade_step() -> Result<Vec<u8>, TryRuntimeError> {
-		let sample: Vec<_> = old::ContractInfoOf::<T>::iter().take(10).collect();
+		let sample: Vec<_> = old::ContractInfoOf::<T, OldCurrency>::iter().take(10).collect();

 		log::debug!(target: LOG_TARGET, "Taking sample of {} contracts", sample.len());
 		Ok(sample.encode())
@@ -246,23 +271,24 @@ impl<T: Config> MigrationStep for Migration<T> {

 	#[cfg(feature = "try-runtime")]
 	fn post_upgrade_step(state: Vec<u8>) -> Result<(), TryRuntimeError> {
-		let sample = <Vec<(T::AccountId, old::ContractInfo<T>)> as Decode>::decode(&mut &state[..])
-			.expect("pre_upgrade_step provides a valid state; qed");
+		let sample = <Vec<(T::AccountId, old::ContractInfo<T, OldCurrency>)> as Decode>::decode(
+			&mut &state[..],
+		)
+		.expect("pre_upgrade_step provides a valid state; qed");

 		log::debug!(target: LOG_TARGET, "Validating sample of {} contracts", sample.len());
 		for (account, old_contract) in sample {
 			log::debug!(target: LOG_TARGET, "===");
 			log::debug!(target: LOG_TARGET, "Account: 0x{} ", HexDisplay::from(&account.encode()));
-			let contract = ContractInfoOf::<T>::get(&account).unwrap();
+			let contract = ContractInfoOf::<T, OldCurrency>::get(&account).unwrap();
 			ensure!(old_contract.trie_id == contract.trie_id, "invalid trie_id");
 			ensure!(old_contract.code_hash == contract.code_hash, "invalid code_hash");
 			ensure!(old_contract.storage_bytes == contract.storage_bytes, "invalid storage_bytes");
 			ensure!(old_contract.storage_items == contract.storage_items, "invalid storage_items");

-			let deposit =
-				<<T as Config>::Currency as frame_support::traits::Currency<_>>::total_balance(
-					&contract.deposit_account,
-				);
+			let deposit = <OldCurrency as frame_support::traits::Currency<_>>::total_balance(
+				&contract.deposit_account,
+			);
 			ensure!(
 				deposit ==
 					contract
@@ -37,13 +37,20 @@ use sp_std::prelude::*;
 mod old {
 	use super::*;

+	pub type BalanceOf<T, OldCurrency> = <OldCurrency as frame_support::traits::Currency<
+		<T as frame_system::Config>::AccountId,
+	>>::Balance;
+
 	#[derive(Encode, Decode, scale_info::TypeInfo, MaxEncodedLen)]
 	#[codec(mel_bound())]
-	#[scale_info(skip_type_params(T))]
-	pub struct OwnerInfo<T: Config> {
+	#[scale_info(skip_type_params(T, OldCurrency))]
+	pub struct OwnerInfo<T: Config, OldCurrency>
+	where
+		OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+	{
 		pub owner: AccountIdOf<T>,
 		#[codec(compact)]
-		pub deposit: BalanceOf<T>,
+		pub deposit: BalanceOf<T, OldCurrency>,
 		#[codec(compact)]
 		pub refcount: u64,
 	}
@@ -63,7 +70,8 @@ mod old {
 	}

 	#[storage_alias]
-	pub type OwnerInfoOf<T: Config> = StorageMap<Pallet<T>, Identity, CodeHash<T>, OwnerInfo<T>>;
+	pub type OwnerInfoOf<T: Config, OldCurrency> =
+		StorageMap<Pallet<T>, Identity, CodeHash<T>, OwnerInfo<T, OldCurrency>>;

 	#[storage_alias]
 	pub type CodeStorage<T: Config> =
@@ -72,11 +80,14 @@ mod old {

 #[derive(Encode, Decode, scale_info::TypeInfo, MaxEncodedLen)]
 #[codec(mel_bound())]
-#[scale_info(skip_type_params(T))]
-pub struct CodeInfo<T: Config> {
+#[scale_info(skip_type_params(T, OldCurrency))]
+pub struct CodeInfo<T: Config, OldCurrency>
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+{
 	owner: AccountIdOf<T>,
 	#[codec(compact)]
-	deposit: BalanceOf<T>,
+	deposit: old::BalanceOf<T, OldCurrency>,
 	#[codec(compact)]
 	refcount: u64,
 	determinism: Determinism,
@@ -84,13 +95,17 @@ pub struct CodeInfo<T: Config> {
 }

 #[storage_alias]
-pub type CodeInfoOf<T: Config> = StorageMap<Pallet<T>, Twox64Concat, CodeHash<T>, CodeInfo<T>>;
+pub type CodeInfoOf<T: Config, OldCurrency> =
+	StorageMap<Pallet<T>, Twox64Concat, CodeHash<T>, CodeInfo<T, OldCurrency>>;

 #[storage_alias]
 pub type PristineCode<T: Config> = StorageMap<Pallet<T>, Identity, CodeHash<T>, Vec<u8>>;

 #[cfg(feature = "runtime-benchmarks")]
-pub fn store_old_dummy_code<T: Config>(len: usize, account: T::AccountId) {
+pub fn store_old_dummy_code<T: Config, OldCurrency>(len: usize, account: T::AccountId)
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId> + 'static,
+{
 	use sp_runtime::traits::Hash;

 	let code = vec![42u8; len];
@@ -107,15 +122,24 @@ pub fn store_old_dummy_code<T: Config>(len: usize, account: T::AccountId) {
 	old::CodeStorage::<T>::insert(hash, module);

 	let info = old::OwnerInfo { owner: account, deposit: u32::MAX.into(), refcount: u64::MAX };
-	old::OwnerInfoOf::<T>::insert(hash, info);
+	old::OwnerInfoOf::<T, OldCurrency>::insert(hash, info);
 }

 #[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)]
-pub struct Migration<T: Config> {
+pub struct Migration<T: Config, OldCurrency>
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+	OldCurrency::Balance: From<BalanceOf<T>>,
+{
 	last_code_hash: Option<CodeHash<T>>,
+	_phantom: PhantomData<OldCurrency>,
 }

-impl<T: Config> MigrationStep for Migration<T> {
+impl<T: Config, OldCurrency> MigrationStep for Migration<T, OldCurrency>
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId> + 'static,
+	OldCurrency::Balance: From<BalanceOf<T>>,
+{
 	const VERSION: u16 = 12;

 	fn max_step_weight() -> Weight {
@@ -124,9 +148,11 @@ impl<T: Config> MigrationStep for Migration<T> {

 	fn step(&mut self) -> (IsFinished, Weight) {
 		let mut iter = if let Some(last_key) = self.last_code_hash.take() {
-			old::OwnerInfoOf::<T>::iter_from(old::OwnerInfoOf::<T>::hashed_key_for(last_key))
+			old::OwnerInfoOf::<T, OldCurrency>::iter_from(
+				old::OwnerInfoOf::<T, OldCurrency>::hashed_key_for(last_key),
+			)
 		} else {
-			old::OwnerInfoOf::<T>::iter()
+			old::OwnerInfoOf::<T, OldCurrency>::iter()
 		};
 		if let Some((hash, old_info)) = iter.next() {
 			log::debug!(target: LOG_TARGET, "Migrating OwnerInfo for code_hash {:?}", hash);
@@ -158,7 +184,8 @@ impl<T: Config> MigrationStep for Migration<T> {
 			let bytes_before = module
 				.encoded_size()
 				.saturating_add(code_len)
-				.saturating_add(old::OwnerInfo::<T>::max_encoded_len()) as u32;
+				.saturating_add(old::OwnerInfo::<T, OldCurrency>::max_encoded_len())
+				as u32;
 			let items_before = 3u32;
 			let deposit_expected_before = price_per_byte
 				.saturating_mul(bytes_before.into())
@@ -166,24 +193,25 @@ impl<T: Config> MigrationStep for Migration<T> {
 			let ratio = FixedU128::checked_from_rational(old_info.deposit, deposit_expected_before)
 				.unwrap_or_default()
 				.min(FixedU128::from_u32(1));
-			let bytes_after = code_len.saturating_add(CodeInfo::<T>::max_encoded_len()) as u32;
+			let bytes_after =
+				code_len.saturating_add(CodeInfo::<T, OldCurrency>::max_encoded_len()) as u32;
 			let items_after = 2u32;
 			let deposit_expected_after = price_per_byte
 				.saturating_mul(bytes_after.into())
 				.saturating_add(price_per_item.saturating_mul(items_after.into()));
 			let deposit = ratio.saturating_mul_int(deposit_expected_after);

-			let info = CodeInfo::<T> {
+			let info = CodeInfo::<T, OldCurrency> {
 				determinism: module.determinism,
 				owner: old_info.owner,
-				deposit,
+				deposit: deposit.into(),
 				refcount: old_info.refcount,
 				code_len: code_len as u32,
 			};

 			let amount = old_info.deposit.saturating_sub(info.deposit);
 			if !amount.is_zero() {
-				T::Currency::unreserve(&info.owner, amount);
+				OldCurrency::unreserve(&info.owner, amount);
 				log::debug!(
 					target: LOG_TARGET,
 					"Deposit refunded: {:?} Balance, to: {:?}",
@@ -198,7 +226,7 @@ impl<T: Config> MigrationStep for Migration<T> {
 					&old_info.deposit
 				);
 			}
-			CodeInfoOf::<T>::insert(hash, info);
+			CodeInfoOf::<T, OldCurrency>::insert(hash, info);

 			self.last_code_hash = Some(hash);

@@ -213,12 +241,12 @@ impl<T: Config> MigrationStep for Migration<T> {
 	fn pre_upgrade_step() -> Result<Vec<u8>, TryRuntimeError> {
 		let len = 100;
 		log::debug!(target: LOG_TARGET, "Taking sample of {} OwnerInfo(s)", len);
-		let sample: Vec<_> = old::OwnerInfoOf::<T>::iter()
+		let sample: Vec<_> = old::OwnerInfoOf::<T, OldCurrency>::iter()
 			.take(len)
 			.map(|(k, v)| {
 				let module = old::CodeStorage::<T>::get(k)
 					.expect("No PrefabWasmModule found for code_hash: {:?}");
-				let info: CodeInfo<T> = CodeInfo {
+				let info: CodeInfo<T, OldCurrency> = CodeInfo {
 					determinism: module.determinism,
 					deposit: v.deposit,
 					refcount: v.refcount,
@@ -231,22 +259,24 @@ impl<T: Config> MigrationStep for Migration<T> {

 		let storage: u32 =
 			old::CodeStorage::<T>::iter().map(|(_k, v)| v.encoded_size() as u32).sum();
-		let mut deposit: BalanceOf<T> = Default::default();
-		old::OwnerInfoOf::<T>::iter().for_each(|(_k, v)| deposit += v.deposit);
+		let mut deposit: old::BalanceOf<T, OldCurrency> = Default::default();
+		old::OwnerInfoOf::<T, OldCurrency>::iter().for_each(|(_k, v)| deposit += v.deposit);

 		Ok((sample, deposit, storage).encode())
 	}

 	#[cfg(feature = "try-runtime")]
 	fn post_upgrade_step(state: Vec<u8>) -> Result<(), TryRuntimeError> {
-		let state = <(Vec<(CodeHash<T>, CodeInfo<T>)>, BalanceOf<T>, u32) as Decode>::decode(
-			&mut &state[..],
-		)
+		let state = <(
+			Vec<(CodeHash<T>, CodeInfo<T, OldCurrency>)>,
+			old::BalanceOf<T, OldCurrency>,
+			u32,
+		) as Decode>::decode(&mut &state[..])
 		.unwrap();

 		log::debug!(target: LOG_TARGET, "Validating state of {} Codeinfo(s)", state.0.len());
 		for (hash, old) in state.0 {
-			let info = CodeInfoOf::<T>::get(&hash)
+			let info = CodeInfoOf::<T, OldCurrency>::get(&hash)
 				.expect(format!("CodeInfo for code_hash {:?} not found!", hash).as_str());
 			ensure!(info.determinism == old.determinism, "invalid determinism");
 			ensure!(info.owner == old.owner, "invalid owner");
@@ -262,7 +292,7 @@ impl<T: Config> MigrationStep for Migration<T> {
 		} else {
 			log::debug!(target: LOG_TARGET, "CodeStorage is empty.");
 		}
-		if let Some((k, _)) = old::OwnerInfoOf::<T>::iter().next() {
+		if let Some((k, _)) = old::OwnerInfoOf::<T, OldCurrency>::iter().next() {
 			log::warn!(
 				target: LOG_TARGET,
 				"OwnerInfoOf is still NOT empty, found code_hash: {:?}",
@@ -272,10 +302,10 @@ impl<T: Config> MigrationStep for Migration<T> {
 			log::debug!(target: LOG_TARGET, "OwnerInfoOf is empty.");
 		}

-		let mut deposit: BalanceOf<T> = Default::default();
+		let mut deposit: old::BalanceOf<T, OldCurrency> = Default::default();
 		let mut items = 0u32;
 		let mut storage_info = 0u32;
-		CodeInfoOf::<T>::iter().for_each(|(_k, v)| {
+		CodeInfoOf::<T, OldCurrency>::iter().for_each(|(_k, v)| {
 			deposit += v.deposit;
 			items += 1;
 			storage_info += v.encoded_size() as u32;
@@ -0,0 +1,269 @@
+// This file is part of Substrate.
+
+// Copyright (C) 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.
+
+//! Update the code owner balance, make the storage deposit reserved balance to be held instead.
+
+use crate::{
+	exec::AccountIdOf,
+	migration::{IsFinished, MigrationStep},
+	weights::WeightInfo,
+	BalanceOf, CodeHash, Config, Determinism, HoldReason, Pallet, Weight, LOG_TARGET,
+};
+use codec::{Decode, Encode};
+#[cfg(feature = "try-runtime")]
+use environmental::Vec;
+#[cfg(feature = "try-runtime")]
+use frame_support::traits::fungible::{Inspect, InspectHold};
+use frame_support::{
+	codec,
+	pallet_prelude::*,
+	storage_alias,
+	traits::{fungible::MutateHold, ReservableCurrency},
+	DefaultNoBound,
+};
+use sp_core::hexdisplay::HexDisplay;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+use sp_runtime::{traits::Zero, Saturating};
+#[cfg(feature = "try-runtime")]
+use sp_std::collections::btree_map::BTreeMap;
+
+mod old {
+	use super::*;
+
+	pub type BalanceOf<T, OldCurrency> = <OldCurrency as frame_support::traits::Currency<
+		<T as frame_system::Config>::AccountId,
+	>>::Balance;
+
+	#[derive(Encode, Decode, scale_info::TypeInfo, MaxEncodedLen)]
+	#[codec(mel_bound())]
+	#[scale_info(skip_type_params(T, OldCurrency))]
+	pub struct CodeInfo<T, OldCurrency>
+	where
+		T: Config,
+		OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+	{
+		pub owner: AccountIdOf<T>,
+		#[codec(compact)]
+		pub deposit: old::BalanceOf<T, OldCurrency>,
+		#[codec(compact)]
+		pub refcount: u64,
+		pub determinism: Determinism,
+		pub code_len: u32,
+	}
+
+	#[storage_alias]
+	pub type CodeInfoOf<T: Config, OldCurrency> =
+		StorageMap<Pallet<T>, Twox64Concat, CodeHash<T>, CodeInfo<T, OldCurrency>>;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub fn store_dummy_code<T: Config, OldCurrency>(account: T::AccountId)
+where
+	T: Config,
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId> + 'static,
+{
+	use sp_runtime::traits::Hash;
+	use sp_std::vec;
+
+	let len = T::MaxCodeLen::get();
+	let code = vec![42u8; len as usize];
+	let hash = T::Hashing::hash(&code);
+
+	let info = old::CodeInfo {
+		owner: account,
+		deposit: 10_000u32.into(),
+		refcount: u64::MAX,
+		determinism: Determinism::Enforced,
+		code_len: len,
+	};
+	old::CodeInfoOf::<T, OldCurrency>::insert(hash, info);
+}
+
+#[cfg(feature = "try-runtime")]
+#[derive(Encode, Decode)]
+/// Accounts for the balance allocation of a code owner.
+struct BalanceAllocation<T, OldCurrency>
+where
+	T: Config,
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+{
+	/// Total reserved balance as storage deposit for the owner.
+	reserved: old::BalanceOf<T, OldCurrency>,
+	/// Total balance of the owner.
+	total: old::BalanceOf<T, OldCurrency>,
+}
+
+#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)]
+pub struct Migration<T, OldCurrency>
+where
+	T: Config,
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+{
+	last_code_hash: Option<CodeHash<T>>,
+	_phantom: PhantomData<(T, OldCurrency)>,
+}
+
+impl<T, OldCurrency> MigrationStep for Migration<T, OldCurrency>
+where
+	T: Config,
+	OldCurrency: 'static + ReservableCurrency<<T as frame_system::Config>::AccountId>,
+	BalanceOf<T>: From<OldCurrency::Balance>,
+{
+	const VERSION: u16 = 14;
+
+	fn max_step_weight() -> Weight {
+		T::WeightInfo::v14_migration_step()
+	}
+
+	fn step(&mut self) -> (IsFinished, Weight) {
+		let mut iter = if let Some(last_hash) = self.last_code_hash.take() {
+			old::CodeInfoOf::<T, OldCurrency>::iter_from(
+				old::CodeInfoOf::<T, OldCurrency>::hashed_key_for(last_hash),
+			)
+		} else {
+			old::CodeInfoOf::<T, OldCurrency>::iter()
+		};
+
+		if let Some((hash, code_info)) = iter.next() {
+			log::debug!(target: LOG_TARGET, "Migrating storage deposit for 0x{:?}", HexDisplay::from(&code_info.owner.encode()));
+
+			let remaining = OldCurrency::unreserve(&code_info.owner, code_info.deposit);
+
+			if remaining > Zero::zero() {
+				log::warn!(
+					target: LOG_TARGET,
+					"Code owner's account 0x{:?} for code {:?} has some non-unreservable deposit {:?} from a total of {:?} that will remain in reserved.",
+					HexDisplay::from(&code_info.owner.encode()),
+					hash,
+					remaining,
+					code_info.deposit
+				);
+			}
+
+			let unreserved = code_info.deposit.saturating_sub(remaining);
+			let amount = BalanceOf::<T>::from(unreserved);
+
+			log::debug!(
+				target: LOG_TARGET,
+				"Holding {:?} on the code owner's account 0x{:?} for code {:?}.",
+				amount,
+				HexDisplay::from(&code_info.owner.encode()),
+				hash,
+			);
+
+			T::Currency::hold(
+				&HoldReason::CodeUploadDepositReserve.into(),
+				&code_info.owner,
+				amount,
+			)
+			.unwrap_or_else(|err| {
+				log::error!(
+					target: LOG_TARGET,
+					"Failed to hold {:?} from the code owner's account 0x{:?} for code {:?}, reason: {:?}.",
+					amount,
+					HexDisplay::from(&code_info.owner.encode()),
+					hash,
+					err
+				);
+			});
+
+			self.last_code_hash = Some(hash);
+			(IsFinished::No, T::WeightInfo::v14_migration_step())
+		} else {
+			log::debug!(target: LOG_TARGET, "No more storage deposit to migrate");
+			(IsFinished::Yes, T::WeightInfo::v14_migration_step())
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade_step() -> Result<Vec<u8>, TryRuntimeError> {
+		let info: Vec<_> = old::CodeInfoOf::<T, OldCurrency>::iter().collect();
+
+		let mut owner_balance_allocation =
+			BTreeMap::<AccountIdOf<T>, BalanceAllocation<T, OldCurrency>>::new();
+
+		// Calculates the balance allocation by accumulating the storage deposits of all codes owned
+		// by an owner.
+		for (_, code_info) in info {
+			owner_balance_allocation
+				.entry(code_info.owner.clone())
+				.and_modify(|alloc| {
+					alloc.reserved = alloc.reserved.saturating_add(code_info.deposit);
+				})
+				.or_insert(BalanceAllocation {
+					reserved: code_info.deposit,
+					total: OldCurrency::total_balance(&code_info.owner),
+				});
+		}
+
+		Ok(owner_balance_allocation.encode())
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade_step(state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		let owner_balance_allocation =
+			<BTreeMap<AccountIdOf<T>, BalanceAllocation<T, OldCurrency>> as Decode>::decode(
+				&mut &state[..],
+			)
+			.expect("pre_upgrade_step provides a valid state; qed");
+
+		let mut total_held: BalanceOf<T> = Zero::zero();
+		let count = owner_balance_allocation.len();
+		for (owner, old_balance_allocation) in owner_balance_allocation {
+			let held =
+				T::Currency::balance_on_hold(&HoldReason::CodeUploadDepositReserve.into(), &owner);
+			log::debug!(
+				target: LOG_TARGET,
+				"Validating storage deposit for owner 0x{:?}, reserved: {:?}, held: {:?}",
+				HexDisplay::from(&owner.encode()),
+				old_balance_allocation.reserved,
+				held
+			);
+			ensure!(held == old_balance_allocation.reserved.into(), "Held amount mismatch");
+
+			log::debug!(
+				target: LOG_TARGET,
+				"Validating total balance for owner 0x{:?}, new: {:?}, old: {:?}",
+				HexDisplay::from(&owner.encode()),
+				T::Currency::total_balance(&owner),
+				old_balance_allocation.total
+			);
+			ensure!(
+				T::Currency::total_balance(&owner) ==
+					BalanceOf::<T>::decode(&mut &old_balance_allocation.total.encode()[..])
+						.unwrap(),
+				"Balance mismatch "
+			);
+			total_held += held;
+		}
+
+		log::info!(
+			target: LOG_TARGET,
+			"Code owners processed: {:?}.",
+			count
+		);
+
+		log::info!(
+			target: LOG_TARGET,
+			"Total held amount for storage deposit: {:?}",
+			total_held
+		);
+
+		Ok(())
+	}
+}
@@ -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,
 };
@@ -37,7 +38,7 @@ use sp_runtime::{
 };
 use sp_std::{marker::PhantomData, vec::Vec};

-/// Deposit that uses the native currency's balance type.
+/// Deposit that uses the native fungible's balance type.
 pub type DepositOf<T> = Deposit<BalanceOf<T>>;

 /// A production root storage meter that actually charges from its origin.
@@ -89,7 +90,7 @@ pub trait Ext<T: Config> {

 /// This [`Ext`] is used for actual on-chain execution when balance needs to be charged.
 ///
-/// It uses [`frame_support::traits::ReservableCurrency`] in order to do accomplish the reserves.
+/// It uses [`frame_support::traits::fungible::Mutate`] in order to do accomplish the reserves.
 pub enum ReservingExt {}

 /// Used to implement a type state pattern for the meter.
@@ -453,7 +454,7 @@ where
 		System::<T>::inc_consumers(contract_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::Preserve)?;
 		System::<T>::inc_consumers(contract)?;

 		Ok(deposit)
@@ -517,7 +518,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::Preserve, Polite)
 			.saturating_sub(min_leftover)
 			.saturating_sub(Pallet::<T>::min_balance());
 		let default = max.min(T::DefaultDepositLimit::get());
@@ -537,12 +538,11 @@ 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) | Deposit::Refund(amount) if amount.is_zero() => return Ok(()),
+			Deposit::Charge(amount) => {
+				T::Currency::transfer(origin, deposit_account, *amount, Preservation::Preserve)?;
+				Ok(())
+			},
 			Deposit::Refund(amount) => {
 				if terminated {
 					System::<T>::dec_consumers(&deposit_account);
@@ -551,9 +551,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 a
+					// removal.
+					Preservation::Expendable,
+				)?;
+				Ok(())
 			},
 		}
 	}
@@ -37,14 +37,14 @@ use crate::{
 	gas::{GasMeter, Token},
 	wasm::prepare::LoadedModule,
 	weights::WeightInfo,
-	AccountIdOf, BadOrigin, BalanceOf, CodeHash, CodeInfoOf, CodeVec, Config, Error, Event, Pallet,
-	PristineCode, Schedule, Weight, LOG_TARGET,
+	AccountIdOf, BadOrigin, BalanceOf, CodeHash, CodeInfoOf, CodeVec, Config, Error, Event,
+	HoldReason, Pallet, PristineCode, Schedule, Weight, LOG_TARGET,
 };
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::{
 	dispatch::{DispatchError, DispatchResult},
 	ensure,
-	traits::ReservableCurrency,
+	traits::{fungible::MutateHold, tokens::Precision::BestEffort},
 };
 use sp_core::Get;
 use sp_runtime::RuntimeDebug;
@@ -237,12 +237,24 @@ impl<T: Config> WasmBlob<T> {
 				// the `owner` is always the origin of the current transaction.
 				None => {
 					let deposit = self.code_info.deposit;
-					T::Currency::reserve(&self.code_info.owner, deposit)
-						.map_err(|_| <Error<T>>::StorageDepositNotEnoughFunds)?;
+					T::Currency::hold(
+						&HoldReason::CodeUploadDepositReserve.into(),
+						&self.code_info.owner,
+						deposit,
+					)
+					.map_err(|_| <Error<T>>::StorageDepositNotEnoughFunds)?;
+
 					self.code_info.refcount = 0;
 					<PristineCode<T>>::insert(code_hash, &self.code);
 					*stored_code_info = Some(self.code_info.clone());
-					<Pallet<T>>::deposit_event(vec![code_hash], Event::CodeStored { code_hash });
+					<Pallet<T>>::deposit_event(
+						vec![code_hash],
+						Event::CodeStored {
+							code_hash,
+							deposit_held: deposit,
+							uploader: self.code_info.owner.clone(),
+						},
+					);
 					Ok(deposit)
 				},
 			}
@@ -255,10 +267,21 @@ impl<T: Config> WasmBlob<T> {
 			if let Some(code_info) = existing {
 				ensure!(code_info.refcount == 0, <Error<T>>::CodeInUse);
 				ensure!(&code_info.owner == origin, BadOrigin);
-				T::Currency::unreserve(&code_info.owner, code_info.deposit);
+				let _ = T::Currency::release(
+					&HoldReason::CodeUploadDepositReserve.into(),
+					&code_info.owner,
+					code_info.deposit,
+					BestEffort,
+				);
+				let deposit_released = code_info.deposit;
+				let remover = code_info.owner.clone();
+
 				*existing = None;
 				<PristineCode<T>>::remove(&code_hash);
-				<Pallet<T>>::deposit_event(vec![code_hash], Event::CodeRemoved { code_hash });
+				<Pallet<T>>::deposit_event(
+					vec![code_hash],
+					Event::CodeRemoved { code_hash, deposit_released, remover },
+				);
 				Ok(())
 			} else {
 				Err(<Error<T>>::CodeNotFound.into())
@@ -56,6 +56,7 @@ pub trait WeightInfo {
 	fn v11_migration_step(k: u32, ) -> Weight;
 	fn v12_migration_step(c: u32, ) -> Weight;
 	fn v13_migration_step() -> Weight;
+	fn v14_migration_step() -> Weight;
 	fn migration_noop() -> Weight;
 	fn migrate() -> Weight;
 	fn on_runtime_upgrade_noop() -> Weight;
@@ -240,6 +241,20 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:1)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:2 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	fn v14_migration_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `260`
+		//  Estimated: `6200`
+		// Minimum execution time: 27_995_000 picoseconds.
+		Weight::from_parts(28_661_000, 6200)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:1)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
 	fn migration_noop() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
@@ -2096,6 +2111,20 @@ impl WeightInfo for () {
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:1)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:2 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	fn v14_migration_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `260`
+		//  Estimated: `6200`
+		// Minimum execution time: 27_995_000 picoseconds.
+		Weight::from_parts(28_661_000, 6200)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:1)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
 	fn migration_noop() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
@@ -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
@@ -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
@@ -136,7 +136,7 @@ impl<A, T: Balanced<A>> Dust<A, T> {
 /// **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> {