diff --git a/frame/evm-balances/src/impl_currency.rs b/frame/evm-balances/src/impl_currency.rs
new file mode 100644
index 0000000000..9bb70f92e3
--- /dev/null
+++ b/frame/evm-balances/src/impl_currency.rs
@@ -0,0 +1,300 @@
+//! Currency trait implementation.
+
+use frame_support::traits::Currency;
+
+use super::*;
+
+impl<T: Config<I>, I: 'static> Currency<<T as Config<I>>::AccountId> for Pallet<T, I>
+where
+	T::Balance: MaybeSerializeDeserialize + Debug,
+{
+	type Balance = T::Balance;
+	type PositiveImbalance = PositiveImbalance<T, I>;
+	type NegativeImbalance = NegativeImbalance<T, I>;
+
+	fn total_balance(who: &<T as Config<I>>::AccountId) -> Self::Balance {
+		Self::account(who).total()
+	}
+
+	fn can_slash(who: &<T as Config<I>>::AccountId, value: Self::Balance) -> bool {
+		if value.is_zero() {
+			return true;
+		}
+		Self::free_balance(who) >= value
+	}
+
+	fn total_issuance() -> Self::Balance {
+		TotalIssuance::<T, I>::get()
+	}
+
+	fn active_issuance() -> Self::Balance {
+		<Self as fungible::Inspect<_>>::active_issuance()
+	}
+
+	fn deactivate(amount: Self::Balance) {
+		<Self as fungible::Unbalanced<_>>::deactivate(amount);
+	}
+
+	fn reactivate(amount: Self::Balance) {
+		<Self as fungible::Unbalanced<_>>::reactivate(amount);
+	}
+
+	fn minimum_balance() -> Self::Balance {
+		T::ExistentialDeposit::get()
+	}
+
+	// Burn funds from the total issuance, returning a positive imbalance for the amount burned.
+	// Is a no-op if amount to be burned is zero.
+	fn burn(mut amount: Self::Balance) -> Self::PositiveImbalance {
+		if amount.is_zero() {
+			return PositiveImbalance::zero();
+		}
+		<TotalIssuance<T, I>>::mutate(|issued| {
+			*issued = issued.checked_sub(&amount).unwrap_or_else(|| {
+				amount = *issued;
+				Zero::zero()
+			});
+		});
+		PositiveImbalance::new(amount)
+	}
+
+	// Create new funds into the total issuance, returning a negative imbalance
+	// for the amount issued.
+	// Is a no-op if amount to be issued it zero.
+	fn issue(mut amount: Self::Balance) -> Self::NegativeImbalance {
+		if amount.is_zero() {
+			return NegativeImbalance::zero();
+		}
+		<TotalIssuance<T, I>>::mutate(|issued| {
+			*issued = issued.checked_add(&amount).unwrap_or_else(|| {
+				amount = Self::Balance::max_value() - *issued;
+				Self::Balance::max_value()
+			})
+		});
+		NegativeImbalance::new(amount)
+	}
+
+	fn free_balance(who: &<T as Config<I>>::AccountId) -> Self::Balance {
+		Self::account(who).free
+	}
+
+	// We don't have any existing withdrawal restrictions like locked and reserved balance.
+	// Is a no-op if amount to be withdrawn is zero.
+	fn ensure_can_withdraw(
+		_who: &<T as Config<I>>::AccountId,
+		_amount: T::Balance,
+		_reasons: WithdrawReasons,
+		_new_balance: T::Balance,
+	) -> DispatchResult {
+		Ok(())
+	}
+
+	// Transfer some free balance from `transactor` to `dest`, respecting existence requirements.
+	// Is a no-op if value to be transferred is zero or the `transactor` is the same as `dest`.
+	fn transfer(
+		transactor: &<T as Config<I>>::AccountId,
+		dest: &<T as Config<I>>::AccountId,
+		value: Self::Balance,
+		existence_requirement: ExistenceRequirement,
+	) -> DispatchResult {
+		if value.is_zero() || transactor == dest {
+			return Ok(());
+		}
+		let keep_alive = match existence_requirement {
+			ExistenceRequirement::KeepAlive => Preservation::Preserve,
+			ExistenceRequirement::AllowDeath => Preservation::Expendable,
+		};
+		<Self as fungible::Mutate<_>>::transfer(transactor, dest, value, keep_alive)?;
+		Ok(())
+	}
+
+	/// Slash a target account `who`, returning the negative imbalance created and any left over
+	/// amount that could not be slashed.
+	///
+	/// Is a no-op if `value` to be slashed is zero or the account does not exist.
+	///
+	/// NOTE: `slash()` prefers free balance, but assumes that reserve balance can be drawn
+	/// from in extreme circumstances. `can_slash()` should be used prior to `slash()` to avoid
+	/// having to draw from reserved funds, however we err on the side of punishment if things are
+	/// inconsistent or `can_slash` wasn't used appropriately.
+	fn slash(
+		who: &<T as Config<I>>::AccountId,
+		value: Self::Balance,
+	) -> (Self::NegativeImbalance, Self::Balance) {
+		if value.is_zero() {
+			return (NegativeImbalance::zero(), Zero::zero());
+		}
+
+		if Self::total_balance(who).is_zero() {
+			return (NegativeImbalance::zero(), value);
+		}
+
+		let result = match Self::try_mutate_account_handling_dust(
+			who,
+			|account, _is_new| -> Result<(Self::NegativeImbalance, Self::Balance), DispatchError> {
+				// Best value is the most amount we can slash following liveness rules.
+				let actual = value.min(account.free);
+				account.free.saturating_reduce(actual);
+				let remaining = value.saturating_sub(actual);
+				Ok((NegativeImbalance::new(actual), remaining))
+			},
+		) {
+			Ok((imbalance, remaining)) => {
+				Self::deposit_event(Event::Slashed {
+					who: who.clone(),
+					amount: value.saturating_sub(remaining),
+				});
+				(imbalance, remaining)
+			}
+			Err(_) => (Self::NegativeImbalance::zero(), value),
+		};
+		result
+	}
+
+	/// Deposit some `value` into the free balance of an existing target account `who`.
+	///
+	/// Is a no-op if the `value` to be deposited is zero.
+	fn deposit_into_existing(
+		who: &<T as Config<I>>::AccountId,
+		value: Self::Balance,
+	) -> Result<Self::PositiveImbalance, DispatchError> {
+		if value.is_zero() {
+			return Ok(PositiveImbalance::zero());
+		}
+
+		Self::try_mutate_account_handling_dust(
+			who,
+			|account, is_new| -> Result<Self::PositiveImbalance, DispatchError> {
+				ensure!(!is_new, Error::<T, I>::DeadAccount);
+				account.free = account
+					.free
+					.checked_add(&value)
+					.ok_or(ArithmeticError::Overflow)?;
+				Self::deposit_event(Event::Deposit {
+					who: who.clone(),
+					amount: value,
+				});
+				Ok(PositiveImbalance::new(value))
+			},
+		)
+	}
+
+	/// Deposit some `value` into the free balance of `who`, possibly creating a new account.
+	///
+	/// This function is a no-op if:
+	/// - the `value` to be deposited is zero; or
+	/// - the `value` to be deposited is less than the required ED and the account does not yet
+	///   exist; or
+	/// - the deposit would necessitate the account to exist and there are no provider references;
+	///   or
+	/// - `value` is so large it would cause the balance of `who` to overflow.
+	fn deposit_creating(
+		who: &<T as Config<I>>::AccountId,
+		value: Self::Balance,
+	) -> Self::PositiveImbalance {
+		if value.is_zero() {
+			return Self::PositiveImbalance::zero();
+		}
+
+		Self::try_mutate_account_handling_dust(
+			who,
+			|account, is_new| -> Result<Self::PositiveImbalance, DispatchError> {
+				let ed = T::ExistentialDeposit::get();
+				ensure!(value >= ed || !is_new, Error::<T, I>::ExistentialDeposit);
+
+				// defensive only: overflow should never happen, however in case it does, then this
+				// operation is a no-op.
+				account.free = match account.free.checked_add(&value) {
+					Some(x) => x,
+					None => return Ok(Self::PositiveImbalance::zero()),
+				};
+
+				Self::deposit_event(Event::Deposit {
+					who: who.clone(),
+					amount: value,
+				});
+				Ok(PositiveImbalance::new(value))
+			},
+		)
+		.unwrap_or_else(|_| Self::PositiveImbalance::zero())
+	}
+
+	/// Withdraw some free balance from an account, respecting existence requirements.
+	///
+	/// Is a no-op if value to be withdrawn is zero.
+	fn withdraw(
+		who: &<T as Config<I>>::AccountId,
+		value: Self::Balance,
+		reasons: WithdrawReasons,
+		liveness: ExistenceRequirement,
+	) -> result::Result<Self::NegativeImbalance, DispatchError> {
+		if value.is_zero() {
+			return Ok(NegativeImbalance::zero());
+		}
+
+		Self::try_mutate_account_handling_dust(
+			who,
+			|account, _| -> Result<Self::NegativeImbalance, DispatchError> {
+				let new_free_account = account
+					.free
+					.checked_sub(&value)
+					.ok_or(Error::<T, I>::InsufficientBalance)?;
+
+				// bail if we need to keep the account alive and this would kill it.
+				let ed = T::ExistentialDeposit::get();
+				let would_be_dead = new_free_account < ed;
+				let would_kill = would_be_dead && account.free >= ed;
+				ensure!(
+					liveness == ExistenceRequirement::AllowDeath || !would_kill,
+					Error::<T, I>::Expendability
+				);
+
+				Self::ensure_can_withdraw(who, value, reasons, new_free_account)?;
+
+				account.free = new_free_account;
+
+				Self::deposit_event(Event::Withdraw {
+					who: who.clone(),
+					amount: value,
+				});
+				Ok(NegativeImbalance::new(value))
+			},
+		)
+	}
+
+	/// Force the new free balance of a target account `who` to some new value `balance`.
+	fn make_free_balance_be(
+		who: &<T as Config<I>>::AccountId,
+		value: Self::Balance,
+	) -> SignedImbalance<Self::Balance, Self::PositiveImbalance> {
+		Self::try_mutate_account_handling_dust(
+			who,
+			|account,
+			 is_new|
+			 -> Result<SignedImbalance<Self::Balance, Self::PositiveImbalance>, DispatchError> {
+				let ed = T::ExistentialDeposit::get();
+				// If we're attempting to set an existing account to less than ED, then
+				// bypass the entire operation. It's a no-op if you follow it through, but
+				// since this is an instance where we might account for a negative imbalance
+				// (in the dust cleaner of set_account) before we account for its actual
+				// equal and opposite cause (returned as an Imbalance), then in the
+				// instance that there's no other accounts on the system at all, we might
+				// underflow the issuance and our arithmetic will be off.
+				ensure!(value >= ed || !is_new, Error::<T, I>::ExistentialDeposit);
+
+				let imbalance = if account.free <= value {
+					SignedImbalance::Positive(PositiveImbalance::new(value - account.free))
+				} else {
+					SignedImbalance::Negative(NegativeImbalance::new(account.free - value))
+				};
+				account.free = value;
+				Self::deposit_event(Event::BalanceSet {
+					who: who.clone(),
+					free: account.free,
+				});
+				Ok(imbalance)
+			},
+		)
+		.unwrap_or_else(|_| SignedImbalance::Positive(Self::PositiveImbalance::zero()))
+	}
+}
diff --git a/frame/evm-balances/src/impl_fungible.rs b/frame/evm-balances/src/impl_fungible.rs
new file mode 100644
index 0000000000..5c86426e39
--- /dev/null
+++ b/frame/evm-balances/src/impl_fungible.rs
@@ -0,0 +1,209 @@
+//! Fungible related traits implementation.
+
+use super::*;
+
+impl<T: Config<I>, I: 'static> fungible::Inspect<<T as Config<I>>::AccountId> for Pallet<T, I> {
+	type Balance = T::Balance;
+
+	fn total_issuance() -> Self::Balance {
+		TotalIssuance::<T, I>::get()
+	}
+
+	fn active_issuance() -> Self::Balance {
+		TotalIssuance::<T, I>::get().saturating_sub(InactiveIssuance::<T, I>::get())
+	}
+
+	fn minimum_balance() -> Self::Balance {
+		T::ExistentialDeposit::get()
+	}
+
+	fn total_balance(who: &<T as Config<I>>::AccountId) -> Self::Balance {
+		Self::account(who).total()
+	}
+
+	fn balance(who: &<T as Config<I>>::AccountId) -> Self::Balance {
+		Self::account(who).free
+	}
+
+	fn reducible_balance(
+		who: &<T as Config<I>>::AccountId,
+		preservation: Preservation,
+		_force: Fortitude,
+	) -> Self::Balance {
+		let a = Self::account(who);
+		let untouchable = match preservation {
+			Preservation::Expendable => Zero::zero(),
+			_ => T::ExistentialDeposit::get(),
+		};
+		a.free.saturating_sub(untouchable)
+	}
+
+	fn can_deposit(
+		who: &<T as Config<I>>::AccountId,
+		amount: Self::Balance,
+		provenance: Provenance,
+	) -> DepositConsequence {
+		if amount.is_zero() {
+			return DepositConsequence::Success;
+		}
+
+		if provenance == Provenance::Minted
+			&& TotalIssuance::<T, I>::get().checked_add(&amount).is_none()
+		{
+			return DepositConsequence::Overflow;
+		}
+
+		let account = Self::account(who);
+		match account.free.checked_add(&amount) {
+			None => return DepositConsequence::Overflow,
+			Some(x) if x < T::ExistentialDeposit::get() => return DepositConsequence::BelowMinimum,
+			Some(x) => x,
+		};
+
+		// NOTE: We assume that we are a provider, so don't need to do any checks in the
+		// case of account creation.
+
+		DepositConsequence::Success
+	}
+
+	fn can_withdraw(
+		who: &<T as Config<I>>::AccountId,
+		amount: Self::Balance,
+	) -> WithdrawConsequence<Self::Balance> {
+		if amount.is_zero() {
+			return WithdrawConsequence::Success;
+		}
+
+		if TotalIssuance::<T, I>::get().checked_sub(&amount).is_none() {
+			return WithdrawConsequence::Underflow;
+		}
+
+		let account = Self::account(who);
+		let new_free_balance = match account.free.checked_sub(&amount) {
+			Some(x) => x,
+			None => return WithdrawConsequence::BalanceLow,
+		};
+
+		// Provider restriction - total account balance cannot be reduced to zero if it cannot
+		// sustain the loss of a provider reference.
+		// NOTE: This assumes that the pallet is a provider (which is true). Is this ever changes,
+		// then this will need to adapt accordingly.
+		let ed = T::ExistentialDeposit::get();
+		if new_free_balance < ed {
+			return WithdrawConsequence::ReducedToZero(new_free_balance);
+		}
+
+		WithdrawConsequence::Success
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungible::Unbalanced<<T as Config<I>>::AccountId> for Pallet<T, I> {
+	fn handle_dust(dust: fungible::Dust<<T as Config<I>>::AccountId, Self>) {
+		T::DustRemoval::on_unbalanced(NegativeImbalance::new(dust.0));
+	}
+
+	fn write_balance(
+		who: &<T as Config<I>>::AccountId,
+		amount: Self::Balance,
+	) -> Result<Option<Self::Balance>, DispatchError> {
+		let max_reduction = <Self as fungible::Inspect<_>>::reducible_balance(
+			who,
+			Preservation::Expendable,
+			Fortitude::Force,
+		);
+		let (result, maybe_dust) = Self::mutate_account(who, |account| -> DispatchResult {
+			// Make sure the reduction (if there is one) is no more than the maximum allowed.
+			let reduction = account.free.saturating_sub(amount);
+			ensure!(
+				reduction <= max_reduction,
+				Error::<T, I>::InsufficientBalance
+			);
+
+			account.free = amount;
+			Ok(())
+		})?;
+		result?;
+		Ok(maybe_dust)
+	}
+
+	fn set_total_issuance(amount: Self::Balance) {
+		TotalIssuance::<T, I>::mutate(|t| *t = amount);
+	}
+
+	fn deactivate(amount: Self::Balance) {
+		InactiveIssuance::<T, I>::mutate(|b| b.saturating_accrue(amount));
+	}
+
+	fn reactivate(amount: Self::Balance) {
+		InactiveIssuance::<T, I>::mutate(|b| b.saturating_reduce(amount));
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungible::Mutate<<T as Config<I>>::AccountId> for Pallet<T, I> {
+	fn done_mint_into(who: &<T as Config<I>>::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::Minted {
+			who: who.clone(),
+			amount,
+		});
+	}
+
+	fn done_burn_from(who: &<T as Config<I>>::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::Burned {
+			who: who.clone(),
+			amount,
+		});
+	}
+
+	fn done_shelve(who: &<T as Config<I>>::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::Suspended {
+			who: who.clone(),
+			amount,
+		});
+	}
+
+	fn done_restore(who: &<T as Config<I>>::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::Restored {
+			who: who.clone(),
+			amount,
+		});
+	}
+
+	fn done_transfer(
+		source: &<T as Config<I>>::AccountId,
+		dest: &<T as Config<I>>::AccountId,
+		amount: Self::Balance,
+	) {
+		Self::deposit_event(Event::Transfer {
+			from: source.clone(),
+			to: dest.clone(),
+			amount,
+		});
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungible::Balanced<<T as Config<I>>::AccountId> for Pallet<T, I> {
+	type OnDropCredit = fungible::DecreaseIssuance<<T as Config<I>>::AccountId, Self>;
+	type OnDropDebt = fungible::IncreaseIssuance<<T as Config<I>>::AccountId, Self>;
+
+	fn done_deposit(who: &<T as Config<I>>::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::Deposit {
+			who: who.clone(),
+			amount,
+		});
+	}
+
+	fn done_withdraw(who: &<T as Config<I>>::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::Withdraw {
+			who: who.clone(),
+			amount,
+		});
+	}
+
+	fn done_issue(amount: Self::Balance) {
+		Self::deposit_event(Event::Issued { amount });
+	}
+
+	fn done_rescind(amount: Self::Balance) {
+		Self::deposit_event(Event::Rescinded { amount });
+	}
+}
diff --git a/frame/evm-balances/src/lib.rs b/frame/evm-balances/src/lib.rs
index dbd5c744b0..5cdee7374e 100644
--- a/frame/evm-balances/src/lib.rs
+++ b/frame/evm-balances/src/lib.rs
@@ -9,10 +9,9 @@ use frame_support::{
 	ensure,
 	traits::{
 		fungible,
-		tokens::{DepositConsequence, WithdrawConsequence, Preservation, Fortitude, Provenance},
-		Currency, ExistenceRequirement,
-		ExistenceRequirement::AllowDeath,
-		Get, Imbalance, OnUnbalanced, SignedImbalance, StorageVersion, StoredMap, WithdrawReasons,
+		tokens::{DepositConsequence, Fortitude, Preservation, Provenance, WithdrawConsequence},
+		ExistenceRequirement, Get, Imbalance, OnUnbalanced, SignedImbalance, StorageVersion,
+		StoredMap, WithdrawReasons,
 	},
 };
 use scale_codec::{Codec, Decode, Encode, MaxEncodedLen};
@@ -21,7 +20,10 @@ use sp_runtime::{
 	traits::{Bounded, CheckedAdd, CheckedSub, MaybeSerializeDeserialize, Zero},
 	ArithmeticError, DispatchError, DispatchResult, RuntimeDebug, Saturating,
 };
-use sp_std::{cmp, fmt::Debug, result};
+use sp_std::{fmt::Debug, result};
+
+mod impl_currency;
+mod impl_fungible;
 
 mod account_data;
 pub use account_data::{AccountData, Reasons};
@@ -143,40 +145,47 @@ pub mod pallet {
 			who: <T as Config<I>>::AccountId,
 			amount: T::Balance,
 		},
+		/// Some amount was minted into an account.
+		Minted {
+			who: <T as Config<I>>::AccountId,
+			amount: T::Balance,
+		},
+		/// Some amount was burned from an account.
+		Burned {
+			who: <T as Config<I>>::AccountId,
+			amount: T::Balance,
+		},
+		/// Some amount was suspended from an account (it can be restored later).
+		Suspended {
+			who: <T as Config<I>>::AccountId,
+			amount: T::Balance,
+		},
+		/// Some amount was restored into an account.
+		Restored {
+			who: <T as Config<I>>::AccountId,
+			amount: T::Balance,
+		},
+		/// Total issuance was increased by `amount`, creating a credit to be balanced.
+		Issued { amount: T::Balance },
+		/// Total issuance was decreased by `amount`, creating a debt to be balanced.
+		Rescinded { amount: T::Balance },
 	}
 
 	#[pallet::error]
 	pub enum Error<T, I = ()> {
-		/// Account liquidity restrictions prevent withdrawal
+		/// Account liquidity restrictions prevent withdrawal.
 		LiquidityRestrictions,
 		/// Balance too low to send value.
 		InsufficientBalance,
-		/// Value too low to create account due to existential deposit
+		/// Value too low to create account due to existential deposit.
 		ExistentialDeposit,
-		/// Transfer/payment would kill account
-		KeepAlive,
-		/// Beneficiary account must pre-exist
+		/// Transfer/payment would kill account.
+		Expendability,
+		/// Beneficiary account must pre-exist.
 		DeadAccount,
 	}
 }
 
-/// Removes a dust account whose balance was non-zero but below `ExistentialDeposit`.
-pub struct DustCleaner<T: Config<I>, I: 'static = ()>(
-	Option<(<T as Config<I>>::AccountId, NegativeImbalance<T, I>)>,
-);
-
-impl<T: Config<I>, I: 'static> Drop for DustCleaner<T, I> {
-	fn drop(&mut self) {
-		if let Some((who, dust)) = self.0.take() {
-			Pallet::<T, I>::deposit_event(Event::DustLost {
-				account: who,
-				amount: dust.peek(),
-			});
-			T::DustRemoval::on_unbalanced(dust);
-		}
-	}
-}
-
 impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// Get the free balance of an account.
 	pub fn free_balance(
@@ -191,49 +200,93 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	}
 
 	/// Mutate an account to some new value, or delete it entirely with `None`. Will enforce
-	/// `ExistentialDeposit` law, annulling the account as needed. This will do nothing if the
-	/// result of `f` is an `Err`.
+	/// `ExistentialDeposit` law, annulling the account as needed.
+	///
+	/// It returns the result from the closure. Any dust is handled through the low-level
+	/// `fungible::Unbalanced` trap-door for legacy dust management.
 	///
 	/// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used
 	/// when it is known that the account already exists.
 	///
 	/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
 	/// the caller will do this.
-	fn try_mutate_account<R, E: From<DispatchError>>(
+	pub(crate) fn try_mutate_account_handling_dust<R, E: From<DispatchError>>(
 		who: &<T as Config<I>>::AccountId,
 		f: impl FnOnce(&mut AccountData<T::Balance>, bool) -> Result<R, E>,
 	) -> Result<R, E> {
-		Self::try_mutate_account_with_dust(who, f).map(|(result, dust_cleaner)| {
-			drop(dust_cleaner);
-			result
-		})
+		let (r, maybe_dust) = Self::try_mutate_account(who, f)?;
+		if let Some(dust) = maybe_dust {
+			<Self as fungible::Unbalanced<_>>::handle_raw_dust(dust);
+		}
+		Ok(r)
+	}
+
+	/// Mutate an account to some new value, or delete it entirely with `None`. Will enforce
+	/// `ExistentialDeposit` law, annulling the account as needed.
+	///
+	/// It returns both the result from the closure, and an optional amount of dust
+	/// which should be handled once it is known that all nested mutates that could affect
+	/// storage items what the dust handler touches have completed.
+	///
+	/// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used
+	/// when it is known that the account already exists.
+	///
+	/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
+	/// the caller will do this.
+	pub(crate) fn mutate_account<R>(
+		who: &<T as Config<I>>::AccountId,
+		f: impl FnOnce(&mut AccountData<T::Balance>) -> R,
+	) -> Result<(R, Option<T::Balance>), DispatchError> {
+		Self::try_mutate_account(who, |a, _| -> Result<R, DispatchError> { Ok(f(a)) })
 	}
 
 	/// Mutate an account to some new value, or delete it entirely with `None`. Will enforce
 	/// `ExistentialDeposit` law, annulling the account as needed. This will do nothing if the
 	/// result of `f` is an `Err`.
 	///
-	/// It returns both the result from the closure, and an optional `DustCleaner` instance which
-	/// should be dropped once it is known that all nested mutates that could affect storage items
-	/// what the dust handler touches have completed.
+	/// It returns both the result from the closure, and an optional amount of dust
+	/// which should be handled once it is known that all nested mutates that could affect
+	/// storage items what the dust handler touches have completed.
 	///
 	/// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used
 	/// when it is known that the account already exists.
 	///
 	/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
 	/// the caller will do this.
-	fn try_mutate_account_with_dust<R, E: From<DispatchError>>(
+	fn try_mutate_account<R, E: From<DispatchError>>(
 		who: &<T as Config<I>>::AccountId,
 		f: impl FnOnce(&mut AccountData<T::Balance>, bool) -> Result<R, E>,
-	) -> Result<(R, DustCleaner<T, I>), E> {
+	) -> Result<(R, Option<T::Balance>), E> {
 		let result = T::AccountStore::try_mutate_exists(who, |maybe_account| {
 			let is_new = maybe_account.is_none();
 			let mut account = maybe_account.take().unwrap_or_default();
 			f(&mut account, is_new).map(move |result| {
 				let maybe_endowed = if is_new { Some(account.free) } else { None };
-				let maybe_account_maybe_dust = Self::post_mutation(who, account);
-				*maybe_account = maybe_account_maybe_dust.0;
-				(maybe_endowed, maybe_account_maybe_dust.1, result)
+
+				// Handle any steps needed after mutating an account.
+				//
+				// This includes DustRemoval unbalancing, in the case than the `new` account's total
+				// balance is non-zero but below ED.
+				//
+				// Updates `maybe_account` to `Some` iff the account has sufficient balance.
+				// Evaluates `maybe_dust`, which is `Some` containing the dust to be dropped, iff
+				// some dust should be dropped.
+				//
+				// We should never be dropping if reserved is non-zero. Reserved being non-zero
+				// should imply that we have a consumer ref, so this is economically safe.
+				let maybe_dust = if account.free < T::ExistentialDeposit::get() {
+					if account.free.is_zero() {
+						None
+					} else {
+						Some(account.free)
+					}
+				} else {
+					assert!(account.free.is_zero() || account.free >= T::ExistentialDeposit::get());
+					*maybe_account = Some(account);
+					None
+				};
+
+				(maybe_endowed, maybe_dust, result)
 			})
 		});
 		result.map(|(maybe_endowed, maybe_dust, result)| {
@@ -243,505 +296,13 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 					free_balance: endowed,
 				});
 			}
-			let dust_cleaner = DustCleaner(maybe_dust.map(|dust| (who.clone(), dust)));
-			(result, dust_cleaner)
-		})
-	}
-
-	/// Handles any steps needed after mutating an account.
-	///
-	/// This includes `DustRemoval` unbalancing, in the case than the `new` account's total balance
-	/// is non-zero but below ED.
-	///
-	/// Returns two values:
-	/// - `Some` containing the the `new` account, iff the account has sufficient balance.
-	/// - `Some` containing the dust to be dropped, iff some dust should be dropped.
-	fn post_mutation(
-		_who: &<T as Config<I>>::AccountId,
-		new: AccountData<T::Balance>,
-	) -> (
-		Option<AccountData<T::Balance>>,
-		Option<NegativeImbalance<T, I>>,
-	) {
-		let total = new.total();
-		if total < T::ExistentialDeposit::get() {
-			if total.is_zero() {
-				(None, None)
-			} else {
-				(None, Some(NegativeImbalance::new(total)))
-			}
-		} else {
-			(Some(new), None)
-		}
-	}
-
-	fn deposit_consequence(
-		who: &<T as Config<I>>::AccountId,
-		amount: T::Balance,
-		provenance: Provenance,
-	) -> DepositConsequence {
-		if amount.is_zero() {
-			return DepositConsequence::Success;
-		}
-
-		if provenance == Provenance::Minted && TotalIssuance::<T, I>::get().checked_add(&amount).is_none() {
-			return DepositConsequence::Overflow;
-		}
-
-		let account = Self::account(who);
-		let new_total_balance = match account.total().checked_add(&amount) {
-			Some(x) => x,
-			None => return DepositConsequence::Overflow,
-		};
-
-		if new_total_balance < T::ExistentialDeposit::get() {
-			return DepositConsequence::BelowMinimum;
-		}
-
-		// NOTE: We assume that we are a provider, so don't need to do any checks in the
-		// case of account creation.
-
-		DepositConsequence::Success
-	}
-
-	fn withdraw_consequence(
-		who: &<T as Config<I>>::AccountId,
-		amount: T::Balance,
-	) -> WithdrawConsequence<T::Balance> {
-		if amount.is_zero() {
-			return WithdrawConsequence::Success;
-		}
-
-		if TotalIssuance::<T, I>::get().checked_sub(&amount).is_none() {
-			return WithdrawConsequence::Underflow;
-		}
-
-		let account = Self::account(who);
-		let new_total_balance = match account.total().checked_sub(&amount) {
-			Some(x) => x,
-			None => return WithdrawConsequence::BalanceLow,
-		};
-
-		// Provider restriction - total account balance cannot be reduced to zero if it cannot
-		// sustain the loss of a provider reference.
-		// NOTE: This assumes that the pallet is a provider (which is true). Is this ever changes,
-		// then this will need to adapt accordingly.
-		let ed = T::ExistentialDeposit::get();
-		if new_total_balance < ed {
-			return WithdrawConsequence::WouldDie;
-		}
-
-		// Enough free funds to have them be reduced.
-		match account.free.checked_sub(&amount) {
-			Some(_) => WithdrawConsequence::Success,
-			None => WithdrawConsequence::BalanceLow,
-		}
-	}
-}
-
-impl<T: Config<I>, I: 'static> Currency<<T as Config<I>>::AccountId> for Pallet<T, I>
-where
-	T::Balance: MaybeSerializeDeserialize + Debug,
-{
-	type Balance = T::Balance;
-	type PositiveImbalance = PositiveImbalance<T, I>;
-	type NegativeImbalance = NegativeImbalance<T, I>;
-
-	fn total_balance(who: &<T as Config<I>>::AccountId) -> Self::Balance {
-		Self::account(who).total()
-	}
-
-	fn can_slash(who: &<T as Config<I>>::AccountId, value: Self::Balance) -> bool {
-		if value.is_zero() {
-			return true;
-		}
-		Self::free_balance(who) >= value
-	}
-
-	fn total_issuance() -> Self::Balance {
-		TotalIssuance::<T, I>::get()
-	}
-
-	fn active_issuance() -> Self::Balance {
-		<Self as fungible::Inspect<<T as Config<I>>::AccountId>>::active_issuance()
-	}
-
-	fn deactivate(amount: Self::Balance) {
-		InactiveIssuance::<T, I>::mutate(|b| b.saturating_accrue(amount));
-	}
-
-	fn reactivate(amount: Self::Balance) {
-		InactiveIssuance::<T, I>::mutate(|b| b.saturating_reduce(amount));
-	}
-
-	fn minimum_balance() -> Self::Balance {
-		T::ExistentialDeposit::get()
-	}
-
-	fn burn(mut amount: Self::Balance) -> Self::PositiveImbalance {
-		if amount.is_zero() {
-			return PositiveImbalance::zero();
-		}
-		<TotalIssuance<T, I>>::mutate(|issued| {
-			*issued = issued.checked_sub(&amount).unwrap_or_else(|| {
-				amount = *issued;
-				Zero::zero()
-			});
-		});
-		PositiveImbalance::new(amount)
-	}
-
-	fn issue(mut amount: Self::Balance) -> Self::NegativeImbalance {
-		if amount.is_zero() {
-			return NegativeImbalance::zero();
-		}
-		<TotalIssuance<T, I>>::mutate(|issued| {
-			*issued = issued.checked_add(&amount).unwrap_or_else(|| {
-				amount = Self::Balance::max_value() - *issued;
-				Self::Balance::max_value()
-			})
-		});
-		NegativeImbalance::new(amount)
-	}
-
-	fn free_balance(who: &<T as Config<I>>::AccountId) -> Self::Balance {
-		Self::account(who).free
-	}
-
-	// We don't have any existing withdrawal restrictions like locked and reserved balance.
-	fn ensure_can_withdraw(
-		_who: &<T as Config<I>>::AccountId,
-		_amount: T::Balance,
-		_reasons: WithdrawReasons,
-		_new_balance: T::Balance,
-	) -> DispatchResult {
-		Ok(())
-	}
-
-	fn transfer(
-		transactor: &<T as Config<I>>::AccountId,
-		dest: &<T as Config<I>>::AccountId,
-		value: Self::Balance,
-		existence_requirement: ExistenceRequirement,
-	) -> DispatchResult {
-		if value.is_zero() || transactor == dest {
-			return Ok(());
-		}
-
-		Self::try_mutate_account_with_dust(
-			dest,
-			|to_account, _| -> Result<DustCleaner<T, I>, DispatchError> {
-				Self::try_mutate_account_with_dust(
-					transactor,
-					|from_account, _| -> DispatchResult {
-						from_account.free = from_account
-							.free
-							.checked_sub(&value)
-							.ok_or(Error::<T, I>::InsufficientBalance)?;
-
-						to_account.free = to_account
-							.free
-							.checked_add(&value)
-							.ok_or(ArithmeticError::Overflow)?;
-
-						let ed = T::ExistentialDeposit::get();
-						ensure!(to_account.total() >= ed, Error::<T, I>::ExistentialDeposit);
-
-						Self::ensure_can_withdraw(
-							transactor,
-							value,
-							WithdrawReasons::TRANSFER,
-							from_account.free,
-						)
-						.map_err(|_| Error::<T, I>::LiquidityRestrictions)?;
-
-						let allow_death = existence_requirement == ExistenceRequirement::AllowDeath;
-						ensure!(
-							allow_death || from_account.total() >= ed,
-							Error::<T, I>::KeepAlive
-						);
-
-						Ok(())
-					},
-				)
-				.map(|(_, maybe_dust_cleaner)| maybe_dust_cleaner)
-			},
-		)?;
-
-		// Emit transfer event.
-		Self::deposit_event(Event::Transfer {
-			from: transactor.clone(),
-			to: dest.clone(),
-			amount: value,
-		});
-
-		Ok(())
-	}
-
-	/// Slash a target account `who`, returning the negative imbalance created and any left over
-	/// amount that could not be slashed.
-	///
-	/// Is a no-op if `value` to be slashed is zero or the account does not exist.
-	///
-	/// NOTE: `slash()` prefers free balance, but assumes that reserve balance can be drawn
-	/// from in extreme circumstances. `can_slash()` should be used prior to `slash()` to avoid
-	/// having to draw from reserved funds, however we err on the side of punishment if things are
-	/// inconsistent or `can_slash` wasn't used appropriately.
-	fn slash(
-		who: &<T as Config<I>>::AccountId,
-		value: Self::Balance,
-	) -> (Self::NegativeImbalance, Self::Balance) {
-		if value.is_zero() {
-			return (NegativeImbalance::zero(), Zero::zero());
-		}
-		if Self::total_balance(who).is_zero() {
-			return (NegativeImbalance::zero(), value);
-		}
-
-		for attempt in 0..2 {
-			match Self::try_mutate_account(
-				who,
-				|account,
-				 _is_new|
-				 -> Result<(Self::NegativeImbalance, Self::Balance), DispatchError> {
-					// Best value is the most amount we can slash following liveness rules.
-					let best_value = match attempt {
-						// First attempt we try to slash the full amount, and see if liveness issues
-						// happen.
-						0 => value,
-						// If acting as a critical provider (i.e. first attempt failed), then slash
-						// as much as possible while leaving at least at ED.
-						_ => value.min(account.free.saturating_sub(T::ExistentialDeposit::get())),
-					};
-
-					let free_slash = cmp::min(account.free, best_value);
-					account.free -= free_slash; // Safe because of above check
-
-					Ok((
-						NegativeImbalance::new(free_slash),
-						value - free_slash, // Safe because value is gt or eq to total slashed
-					))
-				},
-			) {
-				Ok((imbalance, not_slashed)) => {
-					Self::deposit_event(Event::Slashed {
-						who: who.clone(),
-						amount: value.saturating_sub(not_slashed),
-					});
-					return (imbalance, not_slashed);
-				}
-				Err(_) => (),
-			}
-		}
-
-		// Should never get here. But we'll be defensive anyway.
-		(Self::NegativeImbalance::zero(), value)
-	}
-
-	/// Deposit some `value` into the free balance of an existing target account `who`.
-	///
-	/// Is a no-op if the `value` to be deposited is zero.
-	fn deposit_into_existing(
-		who: &<T as Config<I>>::AccountId,
-		value: Self::Balance,
-	) -> Result<Self::PositiveImbalance, DispatchError> {
-		if value.is_zero() {
-			return Ok(PositiveImbalance::zero());
-		}
-
-		Self::try_mutate_account(
-			who,
-			|account, is_new| -> Result<Self::PositiveImbalance, DispatchError> {
-				ensure!(!is_new, Error::<T, I>::DeadAccount);
-				account.free = account
-					.free
-					.checked_add(&value)
-					.ok_or(ArithmeticError::Overflow)?;
-				Self::deposit_event(Event::Deposit {
-					who: who.clone(),
-					amount: value,
-				});
-				Ok(PositiveImbalance::new(value))
-			},
-		)
-	}
-
-	/// Deposit some `value` into the free balance of `who`, possibly creating a new account.
-	///
-	/// This function is a no-op if:
-	/// - the `value` to be deposited is zero; or
-	/// - the `value` to be deposited is less than the required ED and the account does not yet
-	///   exist; or
-	/// - the deposit would necessitate the account to exist and there are no provider references;
-	///   or
-	/// - `value` is so large it would cause the balance of `who` to overflow.
-	fn deposit_creating(
-		who: &<T as Config<I>>::AccountId,
-		value: Self::Balance,
-	) -> Self::PositiveImbalance {
-		if value.is_zero() {
-			return Self::PositiveImbalance::zero();
-		}
-
-		Self::try_mutate_account(
-			who,
-			|account, is_new| -> Result<Self::PositiveImbalance, DispatchError> {
-				let ed = T::ExistentialDeposit::get();
-				ensure!(value >= ed || !is_new, Error::<T, I>::ExistentialDeposit);
-
-				// defensive only: overflow should never happen, however in case it does, then this
-				// operation is a no-op.
-				account.free = match account.free.checked_add(&value) {
-					Some(x) => x,
-					None => return Ok(Self::PositiveImbalance::zero()),
-				};
-
-				Self::deposit_event(Event::Deposit {
-					who: who.clone(),
-					amount: value,
-				});
-				Ok(PositiveImbalance::new(value))
-			},
-		)
-		.unwrap_or_else(|_| Self::PositiveImbalance::zero())
-	}
-
-	/// Withdraw some free balance from an account, respecting existence requirements.
-	///
-	/// Is a no-op if value to be withdrawn is zero.
-	fn withdraw(
-		who: &<T as Config<I>>::AccountId,
-		value: Self::Balance,
-		reasons: WithdrawReasons,
-		liveness: ExistenceRequirement,
-	) -> result::Result<Self::NegativeImbalance, DispatchError> {
-		if value.is_zero() {
-			return Ok(NegativeImbalance::zero());
-		}
-
-		Self::try_mutate_account(
-			who,
-			|account, _| -> Result<Self::NegativeImbalance, DispatchError> {
-				let new_free_account = account
-					.free
-					.checked_sub(&value)
-					.ok_or(Error::<T, I>::InsufficientBalance)?;
-
-				// bail if we need to keep the account alive and this would kill it.
-				let ed = T::ExistentialDeposit::get();
-				let would_be_dead = new_free_account < ed;
-				let would_kill = would_be_dead && account.free >= ed;
-				ensure!(
-					liveness == AllowDeath || !would_kill,
-					Error::<T, I>::KeepAlive
-				);
-
-				Self::ensure_can_withdraw(who, value, reasons, new_free_account)?;
-
-				account.free = new_free_account;
-
-				Self::deposit_event(Event::Withdraw {
-					who: who.clone(),
-					amount: value,
-				});
-				Ok(NegativeImbalance::new(value))
-			},
-		)
-	}
-
-	/// Force the new free balance of a target account `who` to some new value `balance`.
-	fn make_free_balance_be(
-		who: &<T as Config<I>>::AccountId,
-		value: Self::Balance,
-	) -> SignedImbalance<Self::Balance, Self::PositiveImbalance> {
-		Self::try_mutate_account(
-			who,
-			|account,
-			 is_new|
-			 -> Result<SignedImbalance<Self::Balance, Self::PositiveImbalance>, DispatchError> {
-				let ed = T::ExistentialDeposit::get();
-				let total = value;
-				// If we're attempting to set an existing account to less than ED, then
-				// bypass the entire operation. It's a no-op if you follow it through, but
-				// since this is an instance where we might account for a negative imbalance
-				// (in the dust cleaner of set_account) before we account for its actual
-				// equal and opposite cause (returned as an Imbalance), then in the
-				// instance that there's no other accounts on the system at all, we might
-				// underflow the issuance and our arithmetic will be off.
-				ensure!(total >= ed || !is_new, Error::<T, I>::ExistentialDeposit);
-
-				let imbalance = if account.free <= value {
-					SignedImbalance::Positive(PositiveImbalance::new(value - account.free))
-				} else {
-					SignedImbalance::Negative(NegativeImbalance::new(account.free - value))
-				};
-				account.free = value;
-				Self::deposit_event(Event::BalanceSet {
-					who: who.clone(),
-					free: account.free,
+			if let Some(amount) = maybe_dust {
+				Pallet::<T, I>::deposit_event(Event::DustLost {
+					account: who.clone(),
+					amount,
 				});
-				Ok(imbalance)
-			},
-		)
-		.unwrap_or_else(|_| SignedImbalance::Positive(Self::PositiveImbalance::zero()))
-	}
-}
-
-impl<T: Config<I>, I: 'static> fungible::Inspect<<T as Config<I>>::AccountId> for Pallet<T, I> {
-	type Balance = T::Balance;
-
-	fn total_issuance() -> Self::Balance {
-		TotalIssuance::<T, I>::get()
-	}
-
-	fn active_issuance() -> Self::Balance {
-		TotalIssuance::<T, I>::get().saturating_sub(InactiveIssuance::<T, I>::get())
-	}
-
-	fn minimum_balance() -> Self::Balance {
-		T::ExistentialDeposit::get()
-	}
-
-	fn total_balance(who: &<T as Config<I>>::AccountId) -> Self::Balance {
-		Self::account(who).total()
-	}
-
-	fn balance(who: &<T as Config<I>>::AccountId) -> Self::Balance {
-		Self::account(who).total()
-	}
-
-	fn reducible_balance(
-		who: &<T as Config<I>>::AccountId,
-		preservation: Preservation,
-		_force: Fortitude,
-	) -> Self::Balance {
-		let a = Self::account(who);
-		// Liquid balance is what is neither reserved nor locked/frozen.
-		let liquid = a.free;
-		match preservation {
-			Preservation::Expendable => liquid,
-			_ => {
-				// `must_remain_to_exist` is the part of liquid balance which must remain
-				// to keep total over ED.
-				let must_remain_to_exist =
-					T::ExistentialDeposit::get().saturating_sub(a.total() - liquid);
-				liquid.saturating_sub(must_remain_to_exist)
 			}
-		}
-	}
-
-	fn can_deposit(
-		who: &<T as Config<I>>::AccountId,
-		amount: Self::Balance,
-		provenance: Provenance,
-	) -> DepositConsequence {
-		Self::deposit_consequence(who, amount, provenance)
-	}
-
-	fn can_withdraw(
-		who: &<T as Config<I>>::AccountId,
-		amount: Self::Balance,
-	) -> WithdrawConsequence<Self::Balance> {
-		Self::withdraw_consequence(who, amount)
+			(result, maybe_dust)
+		})
 	}
 }
diff --git a/frame/evm-balances/src/tests.rs b/frame/evm-balances/src/tests/currency.rs
similarity index 51%
rename from frame/evm-balances/src/tests.rs
rename to frame/evm-balances/src/tests/currency.rs
index 4466176420..80e1052d19 100644
--- a/frame/evm-balances/src/tests.rs
+++ b/frame/evm-balances/src/tests/currency.rs
@@ -1,33 +1,22 @@
-//! Unit tests.
+//! Tests regarding the functionality of the `Currency` trait set implementations.
 
-use frame_support::{assert_noop, assert_ok, weights::Weight};
-use pallet_evm::{FeeCalculator, Runner, FixedGasWeightMapping, GasWeightMapping};
-use sp_core::{H160, U256};
-use sp_runtime::traits::UniqueSaturatedInto;
+use frame_support::{assert_noop, assert_ok, traits::Currency};
+use sp_core::H160;
+use sp_runtime::TokenError;
 use sp_std::str::FromStr;
 
 use crate::{mock::*, *};
 
 #[test]
-fn basic_setup_works() {
+fn total_issuance_works() {
 	new_test_ext().execute_with_ext(|_| {
-		// Check the accounts.
-		assert_eq!(
-			<EvmBalances>::account(&alice()),
-			account_data::AccountData { free: INIT_BALANCE }
-		);
-		assert_eq!(
-			<EvmBalances>::account(&bob()),
-			account_data::AccountData { free: INIT_BALANCE }
-		);
-
-		// Check the total balance value.
+		// Check the total issuance value.
 		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
 	});
 }
 
 #[test]
-fn currency_total_balance_works() {
+fn total_balance_works() {
 	new_test_ext().execute_with_ext(|_| {
 		// Check the total balance value.
 		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
@@ -35,23 +24,29 @@ fn currency_total_balance_works() {
 }
 
 #[test]
-fn currency_can_slash_works() {
+fn free_balance_works() {
 	new_test_ext().execute_with_ext(|_| {
-		// Check possible slashing.
-		assert!(EvmBalances::can_slash(&alice(), 100));
+		// Check the free balance value.
+		assert_eq!(EvmBalances::free_balance(&alice()), INIT_BALANCE);
 	});
 }
 
 #[test]
-fn currency_total_issuance_works() {
+fn can_slash_works() {
 	new_test_ext().execute_with_ext(|_| {
-		// Check the total issuance value.
-		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+		// Check possible slashing if slashing value is less than current balance.
+		assert!(EvmBalances::can_slash(&alice(), 100));
+
+		// Check possible slashing if slashing value is equal to current balance.
+		assert!(EvmBalances::can_slash(&alice(), INIT_BALANCE));
+
+		// Check slashing restriction if slashing value that is greater than current balance.
+		assert!(!EvmBalances::can_slash(&alice(), INIT_BALANCE + 1));
 	});
 }
 
 #[test]
-fn currency_active_issuance_works() {
+fn active_issuance_works() {
 	new_test_ext().execute_with_ext(|_| {
 		// Check the active issuance value.
 		assert_eq!(EvmBalances::active_issuance(), 2 * INIT_BALANCE);
@@ -59,7 +54,7 @@ fn currency_active_issuance_works() {
 }
 
 #[test]
-fn currency_deactivate_reactivate_works() {
+fn deactivate_reactivate_works() {
 	new_test_ext().execute_with_ext(|_| {
 		// Check test preconditions.
 		assert_eq!(<InactiveIssuance<Test>>::get(), 0);
@@ -68,6 +63,7 @@ fn currency_deactivate_reactivate_works() {
 		EvmBalances::deactivate(100);
 		// Assert state changes.
 		assert_eq!(<InactiveIssuance<Test>>::get(), 100);
+
 		// Reactivate some balance.
 		EvmBalances::reactivate(40);
 		// Assert state changes.
@@ -76,7 +72,15 @@ fn currency_deactivate_reactivate_works() {
 }
 
 #[test]
-fn currency_burn_works() {
+fn minimum_balance_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check the minimum balance value.
+		assert_eq!(EvmBalances::minimum_balance(), 1);
+	});
+}
+
+#[test]
+fn burn_works() {
 	new_test_ext().execute_with_ext(|_| {
 		// Check test preconditions.
 		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
@@ -92,7 +96,7 @@ fn currency_burn_works() {
 }
 
 #[test]
-fn currency_issue_works() {
+fn issue_works() {
 	new_test_ext().execute_with_ext(|_| {
 		// Check test preconditions.
 		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
@@ -108,7 +112,7 @@ fn currency_issue_works() {
 }
 
 #[test]
-fn currency_transfer_works() {
+fn transfer_works() {
 	new_test_ext().execute_with_ext(|_| {
 		// Check test preconditions.
 		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
@@ -144,7 +148,95 @@ fn currency_transfer_works() {
 }
 
 #[test]
-fn currency_slash_works() {
+fn transfer_works_full_balance() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let transfered_amount = INIT_BALANCE;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::transfer(
+			&alice(),
+			&bob(),
+			transfered_amount,
+			ExistenceRequirement::AllowDeath
+		));
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE - transfered_amount
+		);
+		assert_eq!(
+			EvmBalances::total_balance(&bob()),
+			INIT_BALANCE + transfered_amount
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(crate::Event::Transfer {
+			from: alice(),
+			to: bob(),
+			amount: transfered_amount,
+		}));
+		assert!(!EvmSystem::account_exists(&alice()));
+		System::assert_has_event(RuntimeEvent::EvmSystem(
+			pallet_evm_system::Event::KilledAccount { account: alice() },
+		));
+	});
+}
+
+#[test]
+fn transfer_fails_funds_unavailable() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let transfered_amount = INIT_BALANCE + 1;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::transfer(
+				&alice(),
+				&bob(),
+				transfered_amount,
+				ExistenceRequirement::KeepAlive
+			),
+			TokenError::FundsUnavailable
+		);
+	});
+}
+
+#[test]
+fn transfer_fails_not_expendable() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let transfered_amount = INIT_BALANCE;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::transfer(
+				&alice(),
+				&bob(),
+				transfered_amount,
+				ExistenceRequirement::KeepAlive
+			),
+			TokenError::NotExpendable
+		);
+	});
+}
+
+#[test]
+fn slash_works() {
 	new_test_ext().execute_with_ext(|_| {
 		// Check test preconditions.
 		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
@@ -155,7 +247,7 @@ fn currency_slash_works() {
 		System::set_block_number(1);
 
 		// Invoke the function under test.
-		assert!(EvmBalances::slash(&alice(), 1000).1.is_zero());
+		assert!(EvmBalances::slash(&alice(), slashed_amount).1.is_zero());
 
 		// Assert state changes.
 		assert_eq!(
@@ -170,7 +262,37 @@ fn currency_slash_works() {
 }
 
 #[test]
-fn currency_deposit_into_existing_works() {
+fn slash_works_full_balance() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let slashed_amount = INIT_BALANCE;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		assert!(EvmBalances::slash(&alice(), slashed_amount).1.is_zero());
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE - slashed_amount
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(crate::Event::Slashed {
+			who: alice(),
+			amount: slashed_amount,
+		}));
+		assert!(!EvmSystem::account_exists(&alice()));
+		System::assert_has_event(RuntimeEvent::EvmSystem(
+			pallet_evm_system::Event::KilledAccount { account: alice() },
+		));
+	});
+}
+
+#[test]
+fn deposit_into_existing_works() {
 	new_test_ext().execute_with_ext(|_| {
 		// Check test preconditions.
 		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
@@ -199,7 +321,41 @@ fn currency_deposit_into_existing_works() {
 }
 
 #[test]
-fn currency_deposit_creating_works() {
+fn deposit_into_existing_fails_overflow() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let deposited_amount = u64::MAX;
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::deposit_into_existing(&alice(), deposited_amount),
+			ArithmeticError::Overflow
+		);
+	});
+}
+
+#[test]
+fn deposit_into_existing_fails_dead_account() {
+	new_test_ext().execute_with_ext(|_| {
+		let charlie = H160::from_str("1000000000000000000000000000000000000003").unwrap();
+
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&charlie), 0);
+
+		let deposited_amount = 10;
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::deposit_into_existing(&charlie, deposited_amount),
+			Error::<Test>::DeadAccount
+		);
+	});
+}
+
+#[test]
+fn deposit_creating_works() {
 	new_test_ext().execute_with_ext(|_| {
 		// Prepare test preconditions.
 		let charlie = H160::from_str("1000000000000000000000000000000000000003").unwrap();
@@ -226,7 +382,7 @@ fn currency_deposit_creating_works() {
 }
 
 #[test]
-fn currency_withdraw_works() {
+fn withdraw_works() {
 	new_test_ext().execute_with_ext(|_| {
 		// Check test preconditions.
 		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
@@ -239,7 +395,7 @@ fn currency_withdraw_works() {
 		// Invoke the function under test.
 		assert_ok!(EvmBalances::withdraw(
 			&alice(),
-			1000,
+			withdrawed_amount,
 			WithdrawReasons::FEE,
 			ExistenceRequirement::KeepAlive
 		));
@@ -257,8 +413,85 @@ fn currency_withdraw_works() {
 }
 
 #[test]
-fn currency_make_free_balance_be_works() {
-	new_test_ext().execute_with(|| {
+fn withdraw_works_full_balance() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let withdrawed_amount = INIT_BALANCE;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::withdraw(
+			&alice(),
+			withdrawed_amount,
+			WithdrawReasons::TRANSFER,
+			ExistenceRequirement::AllowDeath
+		));
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE - withdrawed_amount
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(crate::Event::Withdraw {
+			who: alice(),
+			amount: withdrawed_amount,
+		}));
+		assert!(!EvmSystem::account_exists(&alice()));
+		System::assert_has_event(RuntimeEvent::EvmSystem(
+			pallet_evm_system::Event::KilledAccount { account: alice() },
+		));
+	});
+}
+
+#[test]
+fn withdraw_fails_insufficient_balance() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let withdrawed_amount = INIT_BALANCE + 1;
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::withdraw(
+				&alice(),
+				withdrawed_amount,
+				WithdrawReasons::TRANSFER,
+				ExistenceRequirement::AllowDeath
+			),
+			Error::<Test>::InsufficientBalance
+		);
+	});
+}
+
+#[test]
+fn withdraw_fails_expendability() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let withdrawed_amount = INIT_BALANCE;
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::withdraw(
+				&alice(),
+				withdrawed_amount,
+				WithdrawReasons::TRANSFER,
+				ExistenceRequirement::KeepAlive
+			),
+			Error::<Test>::Expendability
+		);
+	});
+}
+
+#[test]
+fn make_free_balance_be_works() {
+	new_test_ext().execute_with_ext(|_| {
 		// Prepare test preconditions.
 		let charlie = H160::from_str("1000000000000000000000000000000000000003").unwrap();
 		let made_free_balance = 100;
@@ -301,8 +534,8 @@ fn evm_system_account_should_be_reaped() {
 }
 
 #[test]
-fn evm_balances_transferring_too_high_value_should_not_panic() {
-	new_test_ext().execute_with(|| {
+fn transferring_too_high_value_should_not_panic() {
+	new_test_ext().execute_with_ext(|_| {
 		// Prepare test preconditions.
 		let charlie = H160::from_str("1000000000000000000000000000000000000003").unwrap();
 		let eve = H160::from_str("1000000000000000000000000000000000000004").unwrap();
@@ -316,201 +549,3 @@ fn evm_balances_transferring_too_high_value_should_not_panic() {
 		);
 	});
 }
-
-#[test]
-fn evm_fee_deduction() {
-	new_test_ext().execute_with(|| {
-		let charlie = H160::from_str("1000000000000000000000000000000000000003").unwrap();
-
-		// Seed account
-		let _ = <Test as pallet_evm::Config>::Currency::deposit_creating(&charlie, 100);
-		assert_eq!(EvmBalances::free_balance(&charlie), 100);
-
-		// Deduct fees as 10 units
-		let imbalance =
-			<<Test as pallet_evm::Config>::OnChargeTransaction as pallet_evm::OnChargeEVMTransaction<Test>>::withdraw_fee(
-				&charlie,
-				U256::from(10),
-			)
-			.unwrap();
-		assert_eq!(EvmBalances::free_balance(&charlie), 90);
-
-		// Refund fees as 5 units
-		<<Test as pallet_evm::Config>::OnChargeTransaction as pallet_evm::OnChargeEVMTransaction<Test>>::correct_and_deposit_fee(&charlie, U256::from(5), U256::from(5), imbalance);
-		assert_eq!(EvmBalances::free_balance(&charlie), 95);
-	});
-}
-
-#[test]
-fn evm_issuance_after_tip() {
-	new_test_ext().execute_with(|| {
-		let before_tip = <Test as pallet_evm::Config>::Currency::total_issuance();
-
-		let gas_limit: u64 = 1_000_000;
- 		let weight_limit = FixedGasWeightMapping::<Test>::gas_to_weight(gas_limit, true);
-
-		assert_ok!(<Test as pallet_evm::Config>::Runner::call(
-			alice(),
-			bob(),
-			Vec::new(),
-			U256::from(1),
-			gas_limit,
-			Some(U256::from(2_000_000_000)),
-			None,
-			None,
-			Vec::new(),
-			true,
-			true,
-			Some(weight_limit),
-			Some(0),
-			<Test as pallet_evm::Config>::config(),
-		));
-
-		// Only base fee is burned
-		let base_fee: u64 = <Test as pallet_evm::Config>::FeeCalculator::min_gas_price()
-			.0
-			.unique_saturated_into();
-
-		let after_tip = <Test as pallet_evm::Config>::Currency::total_issuance();
-
-		assert_eq!(after_tip, (before_tip - (base_fee * 21_000)));
-	});
-}
-
-#[test]
-fn evm_refunds_should_work() {
-	new_test_ext().execute_with(|| {
-		let before_call = EVM::account_basic(&alice()).0.balance;
-		// Gas price is not part of the actual fee calculations anymore, only the base fee.
-		//
-		// Because we first deduct max_fee_per_gas * gas_limit (2_000_000_000 * 1000000) we need
-		// to ensure that the difference (max fee VS base fee) is refunded.
-
-		let gas_limit: u64 = 1_000_000;
- 		let weight_limit = FixedGasWeightMapping::<Test>::gas_to_weight(gas_limit, true);
-
-		let _ = <Test as pallet_evm::Config>::Runner::call(
-			alice(),
-			bob(),
-			Vec::new(),
-			U256::from(1),
-			gas_limit,
-			Some(U256::from(2_000_000_000)),
-			None,
-			None,
-			Vec::new(),
-			true,
-			true,
-			Some(weight_limit),
- 			Some(0),
-			<Test as pallet_evm::Config>::config(),
-		);
-
-		let (base_fee, _) = <Test as pallet_evm::Config>::FeeCalculator::min_gas_price();
-		let total_cost = (U256::from(21_000) * base_fee) + U256::from(1);
-		let after_call = EVM::account_basic(&alice()).0.balance;
-		assert_eq!(after_call, before_call - total_cost);
-	});
-}
-
-#[test]
-fn evm_refunds_and_priority_should_work() {
-	new_test_ext().execute_with(|| {
-		let before_call = EVM::account_basic(&alice()).0.balance;
-		// We deliberately set a base fee + max tip > max fee.
-		// The effective priority tip will be 1GWEI instead 1.5GWEI:
-		// 		(max_fee_per_gas - base_fee).min(max_priority_fee)
-		//		(2 - 1).min(1.5)
-		let tip = U256::from(1_500_000_000);
-		let max_fee_per_gas = U256::from(2_000_000_000);
-		let used_gas = U256::from(21_000);
-
-		let gas_limit: u64 = 1_000_000;
- 		let weight_limit = FixedGasWeightMapping::<Test>::gas_to_weight(gas_limit, true);
-
-		let _ = <Test as pallet_evm::Config>::Runner::call(
-			alice(),
-			bob(),
-			Vec::new(),
-			U256::from(1),
-			gas_limit,
-			Some(max_fee_per_gas),
-			Some(tip),
-			None,
-			Vec::new(),
-			true,
-			true,
-			Some(weight_limit),
- 			Some(0),
-			<Test as pallet_evm::Config>::config(),
-		);
-
-		let (base_fee, _) = <Test as pallet_evm::Config>::FeeCalculator::min_gas_price();
-		let actual_tip = (max_fee_per_gas - base_fee).min(tip) * used_gas;
-		let total_cost = (used_gas * base_fee) + U256::from(actual_tip) + U256::from(1);
-		let after_call = EVM::account_basic(&alice()).0.balance;
-		// The tip is deducted but never refunded to the caller.
-		assert_eq!(after_call, before_call - total_cost);
-	});
-}
-
-#[test]
-fn evm_call_should_fail_with_priority_greater_than_max_fee() {
-	new_test_ext().execute_with(|| {
-		// Max priority greater than max fee should fail.
-		let tip: u128 = 1_100_000_000;
-
-		let gas_limit: u64 = 1_000_000;
- 		let weight_limit = FixedGasWeightMapping::<Test>::gas_to_weight(gas_limit, true);
-
-		let result = <Test as pallet_evm::Config>::Runner::call(
-			alice(),
-			bob(),
-			Vec::new(),
-			U256::from(1),
-			gas_limit,
-			Some(U256::from(1_000_000_000)),
-			Some(U256::from(tip)),
-			None,
-			Vec::new(),
-			true,
-			true,
-			Some(weight_limit),
- 			Some(0),
-			<Test as pallet_evm::Config>::config(),
-		);
-		assert!(result.is_err());
-		// Some used weight is returned as part of the error.
-		assert_eq!(result.unwrap_err().weight, Weight::from_parts(7, 0));
-	});
-}
-
-#[test]
-fn evm_call_should_succeed_with_priority_equal_to_max_fee() {
-	new_test_ext().execute_with(|| {
-		let tip: u128 = 1_000_000_000;
-
-		let gas_limit: u64 = 1_000_000;
- 		let weight_limit = FixedGasWeightMapping::<Test>::gas_to_weight(gas_limit, true);
-
-		// Mimics the input for pre-eip-1559 transaction types where `gas_price`
-		// is used for both `max_fee_per_gas` and `max_priority_fee_per_gas`.
-		let result = <Test as pallet_evm::Config>::Runner::call(
-			alice(),
-			bob(),
-			Vec::new(),
-			U256::from(1),
-			gas_limit,
-			Some(U256::from(1_000_000_000)),
-			Some(U256::from(tip)),
-			None,
-			Vec::new(),
-			true,
-			true,
-			Some(weight_limit),
- 			Some(0),
-			<Test as pallet_evm::Config>::config(),
-		);
-		assert!(result.is_ok());
-	});
-}
diff --git a/frame/evm-balances/src/tests/fungible.rs b/frame/evm-balances/src/tests/fungible.rs
new file mode 100644
index 0000000000..6241c6322d
--- /dev/null
+++ b/frame/evm-balances/src/tests/fungible.rs
@@ -0,0 +1,986 @@
+//! Tests regarding the functionality of the fungible trait set implementations.
+
+use frame_support::{
+	assert_noop, assert_ok,
+	traits::{
+		fungible::{Balanced, Inspect, Mutate, Unbalanced},
+		tokens::Precision,
+	},
+};
+use sp_core::H160;
+use sp_runtime::TokenError;
+use sp_std::str::FromStr;
+
+use crate::{mock::*, *};
+
+#[test]
+fn total_issuance_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check the total issuance value.
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+	});
+}
+
+#[test]
+fn active_issuance_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check the active issuance value.
+		assert_eq!(EvmBalances::active_issuance(), 2 * INIT_BALANCE);
+	});
+}
+
+#[test]
+fn minimum_balance_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check the minimum balance value.
+		assert_eq!(EvmBalances::minimum_balance(), 1);
+	});
+}
+
+#[test]
+fn total_balance_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check the total balance value.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+	});
+}
+
+#[test]
+fn balance_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check the balance value.
+		assert_eq!(EvmBalances::balance(&alice()), INIT_BALANCE);
+	});
+}
+
+#[test]
+fn reducable_balance_works() {
+	new_test_ext().execute_with_ext(|_| {
+		assert_eq!(
+			EvmBalances::reducible_balance(&alice(), Preservation::Expendable, Fortitude::Polite),
+			INIT_BALANCE
+		);
+
+		assert_eq!(
+			EvmBalances::reducible_balance(&alice(), Preservation::Expendable, Fortitude::Force),
+			INIT_BALANCE
+		);
+
+		assert_eq!(
+			EvmBalances::reducible_balance(&alice(), Preservation::Preserve, Fortitude::Polite),
+			INIT_BALANCE - 1
+		);
+
+		assert_eq!(
+			EvmBalances::reducible_balance(&alice(), Preservation::Preserve, Fortitude::Force),
+			INIT_BALANCE - 1
+		);
+
+		assert_eq!(
+			EvmBalances::reducible_balance(&alice(), Preservation::Protect, Fortitude::Polite),
+			INIT_BALANCE - 1
+		);
+
+		assert_eq!(
+			EvmBalances::reducible_balance(&alice(), Preservation::Protect, Fortitude::Force),
+			INIT_BALANCE - 1
+		);
+	});
+}
+
+#[test]
+fn can_deposit_works_success() {
+	new_test_ext().execute_with_ext(|_| {
+		assert_eq!(
+			EvmBalances::can_deposit(&alice(), 10, Provenance::Minted),
+			DepositConsequence::Success
+		);
+	});
+}
+
+#[test]
+fn can_deposit_works_overflow() {
+	new_test_ext().execute_with_ext(|_| {
+		assert_eq!(
+			EvmBalances::can_deposit(&alice(), u64::MAX, Provenance::Minted),
+			DepositConsequence::Overflow
+		);
+	});
+}
+
+#[test]
+fn can_withdraw_works_success() {
+	new_test_ext().execute_with_ext(|_| {
+		assert_eq!(
+			EvmBalances::can_withdraw(&alice(), 10),
+			WithdrawConsequence::Success
+		);
+	});
+}
+
+#[test]
+fn can_withdraw_works_underflow() {
+	new_test_ext().execute_with_ext(|_| {
+		assert_eq!(
+			EvmBalances::can_withdraw(&alice(), u64::MAX),
+			WithdrawConsequence::Underflow
+		);
+	});
+}
+
+#[test]
+fn can_withdraw_works_balance_low() {
+	new_test_ext().execute_with_ext(|_| {
+		assert_eq!(
+			EvmBalances::can_withdraw(&alice(), INIT_BALANCE + 1),
+			WithdrawConsequence::BalanceLow
+		);
+	});
+}
+
+#[test]
+fn can_withdraw_works_reduced_to_zero() {
+	new_test_ext().execute_with_ext(|_| {
+		assert_eq!(
+			EvmBalances::can_withdraw(&alice(), INIT_BALANCE),
+			WithdrawConsequence::ReducedToZero(0)
+		);
+	});
+}
+
+#[test]
+fn write_balance_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let write_balance = 10;
+
+		// Invoke the function under test.
+		assert_eq!(
+			EvmBalances::write_balance(&alice(), write_balance),
+			Ok(None)
+		);
+
+		// Assert state changes.
+		assert_eq!(EvmBalances::total_balance(&alice()), write_balance);
+	});
+}
+
+#[test]
+fn set_total_issuance_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		let set_total_issuance_balance = 100;
+
+		// Invoke the function under test.
+		EvmBalances::set_total_issuance(set_total_issuance_balance);
+
+		// Assert state changes.
+		assert_eq!(EvmBalances::total_issuance(), set_total_issuance_balance);
+	});
+}
+
+#[test]
+fn decrease_balance_works_exact_expendable() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let decreased_balance = 100;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::decrease_balance(
+			&alice(),
+			decreased_balance,
+			Precision::Exact,
+			Preservation::Expendable,
+			Fortitude::Polite
+		));
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE - decreased_balance
+		);
+	});
+}
+
+#[test]
+fn decrease_balance_works_best_effort_preserve() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let decreased_balance = INIT_BALANCE + 1;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::decrease_balance(
+			&alice(),
+			decreased_balance,
+			Precision::BestEffort,
+			Preservation::Preserve,
+			Fortitude::Polite
+		));
+
+		// Assert state changes.
+		assert_eq!(EvmBalances::total_balance(&alice()), 1);
+	});
+}
+
+#[test]
+fn decrease_balance_works_full_balance() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let decreased_balance = INIT_BALANCE;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::decrease_balance(
+			&alice(),
+			decreased_balance,
+			Precision::Exact,
+			Preservation::Expendable,
+			Fortitude::Polite
+		));
+
+		// Assert state changes.
+		assert_eq!(EvmBalances::total_balance(&alice()), 0);
+		assert!(!EvmSystem::account_exists(&alice()));
+		System::assert_has_event(RuntimeEvent::EvmSystem(
+			pallet_evm_system::Event::KilledAccount { account: alice() },
+		));
+	});
+}
+
+#[test]
+fn decrease_balance_fails_funds_unavailable() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let decreased_balance = INIT_BALANCE + 1;
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::decrease_balance(
+				&alice(),
+				decreased_balance,
+				Precision::Exact,
+				Preservation::Preserve,
+				Fortitude::Polite
+			),
+			TokenError::FundsUnavailable
+		);
+	});
+}
+
+#[test]
+fn increase_balance_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let increased_balance = 100;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::increase_balance(
+			&alice(),
+			increased_balance,
+			Precision::Exact,
+		));
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE + increased_balance
+		);
+	});
+}
+
+#[test]
+fn increase_balance_works_best_effort() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let increased_balance = u64::MAX;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::increase_balance(
+			&alice(),
+			increased_balance,
+			Precision::BestEffort,
+		));
+
+		// Assert state changes.
+		assert_eq!(EvmBalances::total_balance(&alice()), u64::MAX);
+	});
+}
+
+#[test]
+fn increase_balance_fails_overflow() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let increased_balance = u64::MAX;
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::increase_balance(&alice(), increased_balance, Precision::Exact),
+			ArithmeticError::Overflow
+		);
+	});
+}
+
+#[test]
+fn deactivate_reactivate_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(<InactiveIssuance<Test>>::get(), 0);
+
+		// Deactivate some balance.
+		EvmBalances::deactivate(100);
+		// Assert state changes.
+		assert_eq!(<InactiveIssuance<Test>>::get(), 100);
+
+		// Reactivate some balance.
+		EvmBalances::reactivate(40);
+		// Assert state changes.
+		assert_eq!(<InactiveIssuance<Test>>::get(), 60);
+	});
+}
+
+#[test]
+fn mint_into_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let minted_balance = 10;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::mint_into(&alice(), minted_balance));
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE + minted_balance
+		);
+		assert_eq!(
+			EvmBalances::total_issuance(),
+			2 * INIT_BALANCE + minted_balance
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Minted {
+			who: alice(),
+			amount: minted_balance,
+		}));
+	});
+}
+
+#[test]
+fn mint_into_fails_overflow() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let minted_balance = u64::MAX;
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::mint_into(&alice(), minted_balance),
+			ArithmeticError::Overflow
+		);
+	});
+}
+
+#[test]
+fn burn_from_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let burned_balance = 10;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::burn_from(
+			&alice(),
+			burned_balance,
+			Precision::Exact,
+			Fortitude::Polite
+		));
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE - burned_balance
+		);
+		assert_eq!(
+			EvmBalances::total_issuance(),
+			2 * INIT_BALANCE - burned_balance
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Burned {
+			who: alice(),
+			amount: burned_balance,
+		}));
+	});
+}
+
+#[test]
+fn burn_from_works_best_effort() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let burned_balance = INIT_BALANCE + 1;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::burn_from(
+			&alice(),
+			burned_balance,
+			Precision::BestEffort,
+			Fortitude::Polite
+		));
+
+		// Assert state changes.
+		assert_eq!(EvmBalances::total_balance(&alice()), 0);
+		assert_eq!(EvmBalances::total_issuance(), INIT_BALANCE);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Burned {
+			who: alice(),
+			amount: INIT_BALANCE,
+		}));
+		assert!(!EvmSystem::account_exists(&alice()));
+		System::assert_has_event(RuntimeEvent::EvmSystem(
+			pallet_evm_system::Event::KilledAccount { account: alice() },
+		));
+	});
+}
+
+#[test]
+fn burn_from_works_exact_full_balance() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let burned_balance = INIT_BALANCE;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::burn_from(
+			&alice(),
+			burned_balance,
+			Precision::Exact,
+			Fortitude::Polite
+		));
+
+		// Assert state changes.
+		assert_eq!(EvmBalances::total_balance(&alice()), 0);
+		assert_eq!(EvmBalances::total_issuance(), INIT_BALANCE);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Burned {
+			who: alice(),
+			amount: INIT_BALANCE,
+		}));
+		assert!(!EvmSystem::account_exists(&alice()));
+		System::assert_has_event(RuntimeEvent::EvmSystem(
+			pallet_evm_system::Event::KilledAccount { account: alice() },
+		));
+	});
+}
+
+#[test]
+fn burn_from_fails_funds_unavailable() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let burned_balance = INIT_BALANCE + 1;
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::burn_from(
+				&alice(),
+				burned_balance,
+				Precision::Exact,
+				Fortitude::Polite
+			),
+			TokenError::FundsUnavailable
+		);
+	});
+}
+
+#[test]
+fn shelve_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let shelved_balance = 10;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::shelve(&alice(), shelved_balance));
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE - shelved_balance
+		);
+		assert_eq!(
+			EvmBalances::total_issuance(),
+			2 * INIT_BALANCE - shelved_balance
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Suspended {
+			who: alice(),
+			amount: shelved_balance,
+		}));
+	});
+}
+
+#[test]
+fn shelve_works_exact_full_balance() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let shelved_balance = INIT_BALANCE;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::shelve(&alice(), shelved_balance));
+
+		// Assert state changes.
+		assert_eq!(EvmBalances::total_balance(&alice()), 0);
+		assert_eq!(EvmBalances::total_issuance(), INIT_BALANCE);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Suspended {
+			who: alice(),
+			amount: INIT_BALANCE,
+		}));
+		assert!(!EvmSystem::account_exists(&alice()));
+		System::assert_has_event(RuntimeEvent::EvmSystem(
+			pallet_evm_system::Event::KilledAccount { account: alice() },
+		));
+	});
+}
+
+#[test]
+fn shelve_fails_funds_unavailable() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let shelved_balance = INIT_BALANCE + 1;
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::shelve(&alice(), shelved_balance),
+			TokenError::FundsUnavailable
+		);
+	});
+}
+
+#[test]
+fn restore_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let restored_balance = 10;
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::restore(&alice(), restored_balance));
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE + restored_balance
+		);
+		assert_eq!(
+			EvmBalances::total_issuance(),
+			2 * INIT_BALANCE + restored_balance
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Restored {
+			who: alice(),
+			amount: restored_balance,
+		}));
+	});
+}
+
+#[test]
+fn restore_fails_overflow() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let restored_balance = u64::MAX;
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::restore(&alice(), restored_balance),
+			ArithmeticError::Overflow
+		);
+	});
+}
+
+#[test]
+fn transfer_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let transfered_amount = 100;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::transfer(
+			&alice(),
+			&bob(),
+			transfered_amount,
+			Preservation::Preserve
+		));
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE - transfered_amount
+		);
+		assert_eq!(
+			EvmBalances::total_balance(&bob()),
+			INIT_BALANCE + transfered_amount
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Transfer {
+			from: alice(),
+			to: bob(),
+			amount: transfered_amount,
+		}));
+	});
+}
+
+#[test]
+fn transfer_works_full_balance() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let transfered_amount = INIT_BALANCE;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		assert_ok!(EvmBalances::transfer(
+			&alice(),
+			&bob(),
+			transfered_amount,
+			Preservation::Expendable
+		));
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE - transfered_amount
+		);
+		assert_eq!(
+			EvmBalances::total_balance(&bob()),
+			INIT_BALANCE + transfered_amount
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Transfer {
+			from: alice(),
+			to: bob(),
+			amount: transfered_amount,
+		}));
+		assert!(!EvmSystem::account_exists(&alice()));
+		System::assert_has_event(RuntimeEvent::EvmSystem(
+			pallet_evm_system::Event::KilledAccount { account: alice() },
+		));
+	});
+}
+
+#[test]
+fn transfer_fails_funds_unavailable() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let transfered_amount = INIT_BALANCE + 1;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::transfer(&alice(), &bob(), transfered_amount, Preservation::Preserve),
+			TokenError::FundsUnavailable
+		);
+	});
+}
+
+#[test]
+fn transfer_fails_not_expendable() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let transfered_amount = INIT_BALANCE;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::transfer(&alice(), &bob(), transfered_amount, Preservation::Preserve),
+			TokenError::NotExpendable
+		);
+	});
+}
+
+#[test]
+fn transfer_fails_underflow() {
+	new_test_ext().execute_with_ext(|_| {
+		// Prepare test preconditions.
+		let charlie = H160::from_str("1000000000000000000000000000000000000003").unwrap();
+		let eve = H160::from_str("1000000000000000000000000000000000000004").unwrap();
+		EvmBalances::set_balance(&charlie, u64::MAX);
+		EvmBalances::set_balance(&eve, 1);
+
+		// Invoke the function under test.
+		assert_noop!(
+			EvmBalances::transfer(&charlie, &eve, u64::MAX, Preservation::Expendable),
+			// Withdraw consequence is checked first by reducing total issuance.
+			ArithmeticError::Underflow,
+		);
+	});
+}
+
+#[test]
+fn rescind_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let rescinded_balance = 100;
+
+		// Burn some balance.
+		let imbalance = EvmBalances::rescind(rescinded_balance);
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_issuance(),
+			2 * INIT_BALANCE - rescinded_balance
+		);
+		drop(imbalance);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Rescinded {
+			amount: rescinded_balance,
+		}));
+	});
+}
+
+#[test]
+fn issue_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		let issued_balance = 100;
+
+		// Burn some balance.
+		let imbalance = EvmBalances::issue(issued_balance);
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_issuance(),
+			2 * INIT_BALANCE + issued_balance
+		);
+		drop(imbalance);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Issued {
+			amount: issued_balance,
+		}));
+	});
+}
+
+#[test]
+fn deposit_flow_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let deposited_amount = 10;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		let debt = EvmBalances::deposit(&alice(), deposited_amount, Precision::Exact).unwrap();
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE + deposited_amount
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Deposit {
+			who: alice(),
+			amount: deposited_amount,
+		}));
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+
+		let _ = EvmBalances::settle(&bob(), debt, Preservation::Expendable);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+	});
+}
+
+#[test]
+fn deposit_works_new_account() {
+	new_test_ext().execute_with_ext(|_| {
+		let charlie = H160::from_str("1000000000000000000000000000000000000003").unwrap();
+
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&charlie), 0);
+
+		let deposited_amount = 10;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		let debt = EvmBalances::deposit(&charlie, deposited_amount, Precision::Exact).unwrap();
+
+		// Assert state changes.
+		assert_eq!(EvmBalances::total_balance(&charlie), deposited_amount);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Deposit {
+			who: charlie,
+			amount: deposited_amount,
+		}));
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+		let _ = EvmBalances::settle(&bob(), debt, Preservation::Expendable);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+		assert!(EvmSystem::account_exists(&charlie));
+		System::assert_has_event(RuntimeEvent::EvmSystem(
+			pallet_evm_system::Event::NewAccount { account: charlie },
+		));
+	});
+}
+
+#[test]
+fn withdraw_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let withdrawed_amount = 1000;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		let credit = EvmBalances::withdraw(
+			&alice(),
+			withdrawed_amount,
+			Precision::Exact,
+			Preservation::Preserve,
+			Fortitude::Polite,
+		)
+		.unwrap();
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE - withdrawed_amount
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(Event::Withdraw {
+			who: alice(),
+			amount: withdrawed_amount,
+		}));
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+		let _ = EvmBalances::resolve(&bob(), credit);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+	});
+}
+
+#[test]
+fn withdraw_works_full_balance() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check test preconditions.
+		assert_eq!(EvmBalances::total_balance(&alice()), INIT_BALANCE);
+
+		let withdrawed_amount = INIT_BALANCE;
+
+		// Set block number to enable events.
+		System::set_block_number(1);
+
+		// Invoke the function under test.
+		let credit = EvmBalances::withdraw(
+			&alice(),
+			withdrawed_amount,
+			Precision::Exact,
+			Preservation::Expendable,
+			Fortitude::Polite,
+		)
+		.unwrap();
+
+		// Assert state changes.
+		assert_eq!(
+			EvmBalances::total_balance(&alice()),
+			INIT_BALANCE - withdrawed_amount
+		);
+		System::assert_has_event(RuntimeEvent::EvmBalances(crate::Event::Withdraw {
+			who: alice(),
+			amount: withdrawed_amount,
+		}));
+		assert!(!EvmSystem::account_exists(&alice()));
+		System::assert_has_event(RuntimeEvent::EvmSystem(
+			pallet_evm_system::Event::KilledAccount { account: alice() },
+		));
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+		let _ = EvmBalances::resolve(&bob(), credit);
+		assert_eq!(EvmBalances::total_issuance(), 2 * INIT_BALANCE);
+	});
+}
diff --git a/frame/evm-balances/src/tests/mod.rs b/frame/evm-balances/src/tests/mod.rs
new file mode 100644
index 0000000000..a87abdd238
--- /dev/null
+++ b/frame/evm-balances/src/tests/mod.rs
@@ -0,0 +1,225 @@
+//! Unit tests.
+
+use frame_support::{assert_ok, traits::Currency, weights::Weight};
+use pallet_evm::{FeeCalculator, FixedGasWeightMapping, GasWeightMapping, Runner};
+use sp_core::{H160, U256};
+use sp_runtime::traits::UniqueSaturatedInto;
+use sp_std::str::FromStr;
+
+use crate::{mock::*, *};
+
+mod currency;
+mod fungible;
+
+#[test]
+fn basic_setup_works() {
+	new_test_ext().execute_with_ext(|_| {
+		// Check the accounts.
+		assert_eq!(
+			<EvmBalances>::account(&alice()),
+			account_data::AccountData { free: INIT_BALANCE }
+		);
+		assert_eq!(
+			<EvmBalances>::account(&bob()),
+			account_data::AccountData { free: INIT_BALANCE }
+		);
+	});
+}
+
+#[test]
+fn evm_fee_deduction() {
+	new_test_ext().execute_with_ext(|_| {
+		let charlie = H160::from_str("1000000000000000000000000000000000000003").unwrap();
+
+		// Seed account
+		let _ = <Test as pallet_evm::Config>::Currency::deposit_creating(&charlie, 100);
+		assert_eq!(EvmBalances::free_balance(&charlie), 100);
+
+		// Deduct fees as 10 units
+		let imbalance =
+			<<Test as pallet_evm::Config>::OnChargeTransaction as pallet_evm::OnChargeEVMTransaction<Test>>::withdraw_fee(
+				&charlie,
+				U256::from(10),
+			)
+			.unwrap();
+		assert_eq!(EvmBalances::free_balance(&charlie), 90);
+
+		// Refund fees as 5 units
+		<<Test as pallet_evm::Config>::OnChargeTransaction as pallet_evm::OnChargeEVMTransaction<Test>>::correct_and_deposit_fee(&charlie, U256::from(5), U256::from(5), imbalance);
+		assert_eq!(EvmBalances::free_balance(&charlie), 95);
+	});
+}
+
+#[test]
+fn evm_issuance_after_tip() {
+	new_test_ext().execute_with_ext(|_| {
+		let before_tip = <Test as pallet_evm::Config>::Currency::total_issuance();
+
+		let gas_limit: u64 = 1_000_000;
+		let weight_limit = FixedGasWeightMapping::<Test>::gas_to_weight(gas_limit, true);
+
+		assert_ok!(<Test as pallet_evm::Config>::Runner::call(
+			alice(),
+			bob(),
+			Vec::new(),
+			U256::from(1),
+			gas_limit,
+			Some(U256::from(2_000_000_000)),
+			None,
+			None,
+			Vec::new(),
+			true,
+			true,
+			Some(weight_limit),
+			Some(0),
+			<Test as pallet_evm::Config>::config(),
+		));
+
+		// Only base fee is burned
+		let base_fee: u64 = <Test as pallet_evm::Config>::FeeCalculator::min_gas_price()
+			.0
+			.unique_saturated_into();
+
+		let after_tip = <Test as pallet_evm::Config>::Currency::total_issuance();
+
+		assert_eq!(after_tip, (before_tip - (base_fee * 21_000)));
+	});
+}
+
+#[test]
+fn evm_refunds_should_work() {
+	new_test_ext().execute_with_ext(|_| {
+		let before_call = EVM::account_basic(&alice()).0.balance;
+		// Gas price is not part of the actual fee calculations anymore, only the base fee.
+		//
+		// Because we first deduct max_fee_per_gas * gas_limit (2_000_000_000 * 1000000) we need
+		// to ensure that the difference (max fee VS base fee) is refunded.
+
+		let gas_limit: u64 = 1_000_000;
+		let weight_limit = FixedGasWeightMapping::<Test>::gas_to_weight(gas_limit, true);
+
+		let _ = <Test as pallet_evm::Config>::Runner::call(
+			alice(),
+			bob(),
+			Vec::new(),
+			U256::from(1),
+			gas_limit,
+			Some(U256::from(2_000_000_000)),
+			None,
+			None,
+			Vec::new(),
+			true,
+			true,
+			Some(weight_limit),
+			Some(0),
+			<Test as pallet_evm::Config>::config(),
+		);
+
+		let (base_fee, _) = <Test as pallet_evm::Config>::FeeCalculator::min_gas_price();
+		let total_cost = (U256::from(21_000) * base_fee) + U256::from(1);
+		let after_call = EVM::account_basic(&alice()).0.balance;
+		assert_eq!(after_call, before_call - total_cost);
+	});
+}
+
+#[test]
+fn evm_refunds_and_priority_should_work() {
+	new_test_ext().execute_with_ext(|_| {
+		let before_call = EVM::account_basic(&alice()).0.balance;
+		// We deliberately set a base fee + max tip > max fee.
+		// The effective priority tip will be 1GWEI instead 1.5GWEI:
+		// 		(max_fee_per_gas - base_fee).min(max_priority_fee)
+		//		(2 - 1).min(1.5)
+		let tip = U256::from(1_500_000_000);
+		let max_fee_per_gas = U256::from(2_000_000_000);
+		let used_gas = U256::from(21_000);
+
+		let gas_limit: u64 = 1_000_000;
+		let weight_limit = FixedGasWeightMapping::<Test>::gas_to_weight(gas_limit, true);
+
+		let _ = <Test as pallet_evm::Config>::Runner::call(
+			alice(),
+			bob(),
+			Vec::new(),
+			U256::from(1),
+			gas_limit,
+			Some(max_fee_per_gas),
+			Some(tip),
+			None,
+			Vec::new(),
+			true,
+			true,
+			Some(weight_limit),
+			Some(0),
+			<Test as pallet_evm::Config>::config(),
+		);
+
+		let (base_fee, _) = <Test as pallet_evm::Config>::FeeCalculator::min_gas_price();
+		let actual_tip = (max_fee_per_gas - base_fee).min(tip) * used_gas;
+		let total_cost = (used_gas * base_fee) + U256::from(actual_tip) + U256::from(1);
+		let after_call = EVM::account_basic(&alice()).0.balance;
+		// The tip is deducted but never refunded to the caller.
+		assert_eq!(after_call, before_call - total_cost);
+	});
+}
+
+#[test]
+fn evm_call_should_fail_with_priority_greater_than_max_fee() {
+	new_test_ext().execute_with_ext(|_| {
+		// Max priority greater than max fee should fail.
+		let tip: u128 = 1_100_000_000;
+
+		let gas_limit: u64 = 1_000_000;
+		let weight_limit = FixedGasWeightMapping::<Test>::gas_to_weight(gas_limit, true);
+
+		let result = <Test as pallet_evm::Config>::Runner::call(
+			alice(),
+			bob(),
+			Vec::new(),
+			U256::from(1),
+			gas_limit,
+			Some(U256::from(1_000_000_000)),
+			Some(U256::from(tip)),
+			None,
+			Vec::new(),
+			true,
+			true,
+			Some(weight_limit),
+			Some(0),
+			<Test as pallet_evm::Config>::config(),
+		);
+		assert!(result.is_err());
+		// Some used weight is returned as part of the error.
+		assert_eq!(result.unwrap_err().weight, Weight::from_parts(7, 0));
+	});
+}
+
+#[test]
+fn evm_call_should_succeed_with_priority_equal_to_max_fee() {
+	new_test_ext().execute_with_ext(|_| {
+		let tip: u128 = 1_000_000_000;
+
+		let gas_limit: u64 = 1_000_000;
+		let weight_limit = FixedGasWeightMapping::<Test>::gas_to_weight(gas_limit, true);
+
+		// Mimics the input for pre-eip-1559 transaction types where `gas_price`
+		// is used for both `max_fee_per_gas` and `max_priority_fee_per_gas`.
+		let result = <Test as pallet_evm::Config>::Runner::call(
+			alice(),
+			bob(),
+			Vec::new(),
+			U256::from(1),
+			gas_limit,
+			Some(U256::from(1_000_000_000)),
+			Some(U256::from(tip)),
+			None,
+			Vec::new(),
+			true,
+			true,
+			Some(weight_limit),
+			Some(0),
+			<Test as pallet_evm::Config>::config(),
+		);
+		assert!(result.is_ok());
+	});
+}