diff --git a/asset-registry/src/mock/para.rs b/asset-registry/src/mock/para.rs
index 585f29280..e8900a634 100644
--- a/asset-registry/src/mock/para.rs
+++ b/asset-registry/src/mock/para.rs
@@ -92,16 +92,11 @@ impl orml_tokens::Config for Runtime {
 	type CurrencyId = CurrencyId;
 	type WeightInfo = ();
 	type ExistentialDeposits = ExistentialDeposits;
-	type OnDust = ();
-	type OnSlash = ();
-	type OnDeposit = ();
-	type OnTransfer = ();
+	type CurrencyHooks = ();
 	type ReserveIdentifier = [u8; 8];
 	type MaxReserves = ();
 	type MaxLocks = ConstU32<50>;
 	type DustRemovalWhitelist = Nothing;
-	type OnNewTokenAccount = ();
-	type OnKilledTokenAccount = ();
 }
 
 #[derive(scale_info::TypeInfo, Encode, Decode, Clone, Eq, PartialEq, Debug)]
diff --git a/currencies/src/mock.rs b/currencies/src/mock.rs
index 62bd4da68..cb837a4dd 100644
--- a/currencies/src/mock.rs
+++ b/currencies/src/mock.rs
@@ -8,7 +8,7 @@ use frame_support::{
 	traits::{ConstU32, ConstU64, Everything, Nothing},
 	PalletId,
 };
-use orml_traits::parameter_type_with_key;
+use orml_traits::{currency::MutationHooks, parameter_type_with_key};
 use sp_core::H256;
 use sp_runtime::{
 	testing::Header,
@@ -73,6 +73,21 @@ parameter_types! {
 	pub DustAccount: AccountId = PalletId(*b"orml/dst").into_account_truncating();
 }
 
+pub struct CurrencyHooks<T>(marker::PhantomData<T>);
+impl<T: orml_tokens::Config> MutationHooks<T::AccountId, T::CurrencyId, T::Balance> for CurrencyHooks<T>
+where
+	T::AccountId: From<AccountId32>,
+{
+	type OnDust = orml_tokens::TransferDust<T, DustAccount>;
+	type OnSlash = ();
+	type PreDeposit = ();
+	type PostDeposit = ();
+	type PreTransfer = ();
+	type PostTransfer = ();
+	type OnNewTokenAccount = ();
+	type OnKilledTokenAccount = ();
+}
+
 impl orml_tokens::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type Balance = Balance;
@@ -80,16 +95,11 @@ impl orml_tokens::Config for Runtime {
 	type CurrencyId = CurrencyId;
 	type WeightInfo = ();
 	type ExistentialDeposits = ExistentialDeposits;
-	type OnDust = orml_tokens::TransferDust<Runtime, DustAccount>;
-	type OnSlash = ();
-	type OnDeposit = ();
-	type OnTransfer = ();
+	type CurrencyHooks = CurrencyHooks<Runtime>;
 	type MaxLocks = ConstU32<100_000>;
 	type MaxReserves = ConstU32<100_000>;
 	type ReserveIdentifier = ReserveIdentifier;
 	type DustRemovalWhitelist = Nothing;
-	type OnNewTokenAccount = ();
-	type OnKilledTokenAccount = ();
 }
 
 pub const NATIVE_CURRENCY_ID: CurrencyId = 1;
diff --git a/payments/src/mock.rs b/payments/src/mock.rs
index ac32214ba..53bc87e3c 100644
--- a/payments/src/mock.rs
+++ b/payments/src/mock.rs
@@ -98,17 +98,12 @@ impl orml_tokens::Config for Test {
 	type CurrencyId = u32;
 	type RuntimeEvent = RuntimeEvent;
 	type ExistentialDeposits = ExistentialDeposits;
-	type OnDust = ();
-	type OnSlash = ();
-	type OnDeposit = ();
-	type OnTransfer = ();
+	type CurrencyHooks = ();
 	type WeightInfo = ();
 	type MaxLocks = MaxLocks;
 	type DustRemovalWhitelist = MockDustRemovalWhitelist;
 	type MaxReserves = ConstU32<2>;
 	type ReserveIdentifier = ReserveIdentifier;
-	type OnNewTokenAccount = ();
-	type OnKilledTokenAccount = ();
 }
 
 pub struct MockDisputeResolver;
diff --git a/tokens/src/lib.rs b/tokens/src/lib.rs
index b9ab40860..59be2f68b 100644
--- a/tokens/src/lib.rs
+++ b/tokens/src/lib.rs
@@ -66,9 +66,9 @@ use sp_std::{cmp, convert::Infallible, marker, prelude::*, vec::Vec};
 
 use orml_traits::{
 	arithmetic::{self, Signed},
-	currency::{OnDeposit, OnSlash, OnTransfer, TransferAll},
+	currency::{MutationHooks, OnDeposit, OnDust, OnSlash, OnTransfer, TransferAll},
 	BalanceStatus, GetByKey, Happened, LockIdentifier, MultiCurrency, MultiCurrencyExtended, MultiLockableCurrency,
-	MultiReservableCurrency, NamedMultiReservableCurrency, OnDust,
+	MultiReservableCurrency, NamedMultiReservableCurrency,
 };
 
 mod imbalances;
@@ -173,7 +173,7 @@ pub use module::*;
 
 #[frame_support::pallet]
 pub mod module {
-	use orml_traits::currency::{OnDeposit, OnSlash, OnTransfer};
+	use orml_traits::currency::MutationHooks;
 
 	use super::*;
 
@@ -216,23 +216,9 @@ pub mod module {
 		/// System::AccountInfo, zero ED may cause some problems.
 		type ExistentialDeposits: GetByKey<Self::CurrencyId, Self::Balance>;
 
-		/// Handler to burn or transfer account's dust
-		type OnDust: OnDust<Self::AccountId, Self::CurrencyId, Self::Balance>;
-
-		/// Hook to run before slashing an account.
-		type OnSlash: OnSlash<Self::AccountId, Self::CurrencyId, Self::Balance>;
-
-		/// Hook to run before depositing into an account.
-		type OnDeposit: OnDeposit<Self::AccountId, Self::CurrencyId, Self::Balance>;
-
-		/// Hook to run before transferring from an account to another.
-		type OnTransfer: OnTransfer<Self::AccountId, Self::CurrencyId, Self::Balance>;
-
-		/// Handler for when an account was created
-		type OnNewTokenAccount: Happened<(Self::AccountId, Self::CurrencyId)>;
-
-		/// Handler for when an account was created
-		type OnKilledTokenAccount: Happened<(Self::AccountId, Self::CurrencyId)>;
+		/// Hooks are actions that are executed on certain events.
+		/// For example: OnDust, OnNewTokenAccount
+		type CurrencyHooks: MutationHooks<Self::AccountId, Self::CurrencyId, Self::Balance>;
 
 		#[pallet::constant]
 		type MaxLocks: Get<u32>;
@@ -765,11 +751,11 @@ impl<T: Config> Pallet<T> {
 				// Ignore the result, because if it failed then there are remaining consumers,
 				// and the account storage in frame_system shouldn't be reaped.
 				let _ = frame_system::Pallet::<T>::dec_providers(who);
-				T::OnKilledTokenAccount::happened(&(who.clone(), currency_id));
+				<T::CurrencyHooks as MutationHooks<T::AccountId, T::CurrencyId, T::Balance>>::OnKilledTokenAccount::happened(&(who.clone(), currency_id));
 			} else if !existed && exists {
 				// if new, increase account provider
 				frame_system::Pallet::<T>::inc_providers(who);
-				T::OnNewTokenAccount::happened(&(who.clone(), currency_id));
+				<T::CurrencyHooks as MutationHooks<T::AccountId, T::CurrencyId, T::Balance>>::OnNewTokenAccount::happened(&(who.clone(), currency_id));
 			}
 
 			if let Some(endowed) = maybe_endowed {
@@ -783,7 +769,7 @@ impl<T: Config> Pallet<T> {
 			if let Some(dust_amount) = maybe_dust {
 				// `OnDust` maybe get/set storage `Accounts` of `who`, trigger handler here
 				// to avoid some unexpected errors.
-				T::OnDust::on_dust(who, currency_id, dust_amount);
+				<T::CurrencyHooks as MutationHooks<T::AccountId, T::CurrencyId, T::Balance>>::OnDust::on_dust(who, currency_id, dust_amount);
 
 				Self::deposit_event(Event::DustLost {
 					currency_id,
@@ -906,7 +892,12 @@ impl<T: Config> Pallet<T> {
 			return Ok(());
 		}
 
-		T::OnTransfer::on_transfer(currency_id, from, to, amount)?;
+		<T::CurrencyHooks as MutationHooks<T::AccountId, T::CurrencyId, T::Balance>>::PreTransfer::on_transfer(
+			currency_id,
+			from,
+			to,
+			amount,
+		)?;
 		Self::try_mutate_account(to, currency_id, |to_account, _existed| -> DispatchResult {
 			Self::try_mutate_account(from, currency_id, |from_account, _existed| -> DispatchResult {
 				from_account.free = from_account
@@ -946,6 +937,12 @@ impl<T: Config> Pallet<T> {
 			Ok(())
 		})?;
 
+		<T::CurrencyHooks as MutationHooks<T::AccountId, T::CurrencyId, T::Balance>>::PostTransfer::on_transfer(
+			currency_id,
+			from,
+			to,
+			amount,
+		)?;
 		Self::deposit_event(Event::Transfer {
 			currency_id,
 			from: from.clone(),
@@ -1032,7 +1029,11 @@ impl<T: Config> Pallet<T> {
 			return Ok(());
 		}
 
-		T::OnDeposit::on_deposit(currency_id, who, amount)?;
+		<T::CurrencyHooks as MutationHooks<T::AccountId, T::CurrencyId, T::Balance>>::PreDeposit::on_deposit(
+			currency_id,
+			who,
+			amount,
+		)?;
 		Self::try_mutate_account(who, currency_id, |account, existed| -> DispatchResult {
 			if require_existed {
 				ensure!(existed, Error::<T>::DeadAccount);
@@ -1054,6 +1055,11 @@ impl<T: Config> Pallet<T> {
 			}
 			account.free = account.free.defensive_saturating_add(amount);
 
+			<T::CurrencyHooks as MutationHooks<T::AccountId, T::CurrencyId, T::Balance>>::PostDeposit::on_deposit(
+				currency_id,
+				who,
+				amount,
+			)?;
 			Self::deposit_event(Event::Deposited {
 				currency_id,
 				who: who.clone(),
@@ -1128,7 +1134,11 @@ impl<T: Config> MultiCurrency<T::AccountId> for Pallet<T> {
 			return amount;
 		}
 
-		T::OnSlash::on_slash(currency_id, who, amount);
+		<T::CurrencyHooks as MutationHooks<T::AccountId, T::CurrencyId, T::Balance>>::OnSlash::on_slash(
+			currency_id,
+			who,
+			amount,
+		);
 		let account = Self::accounts(who, currency_id);
 		let free_slashed_amount = account.free.min(amount);
 		// Cannot underflow because free_slashed_amount can never be greater than amount
@@ -1306,7 +1316,11 @@ impl<T: Config> MultiReservableCurrency<T::AccountId> for Pallet<T> {
 			return value;
 		}
 
-		T::OnSlash::on_slash(currency_id, who, value);
+		<T::CurrencyHooks as MutationHooks<T::AccountId, T::CurrencyId, T::Balance>>::OnSlash::on_slash(
+			currency_id,
+			who,
+			value,
+		);
 		let reserved_balance = Self::reserved_balance(currency_id, who);
 		let actual = reserved_balance.min(value);
 		Self::mutate_account(who, currency_id, |account, _| {
diff --git a/tokens/src/mock.rs b/tokens/src/mock.rs
index 74e962d86..ca5592c89 100644
--- a/tokens/src/mock.rs
+++ b/tokens/src/mock.rs
@@ -228,10 +228,18 @@ thread_local! {
 	pub static KILLED: RefCell<Vec<(AccountId, CurrencyId)>> = RefCell::new(vec![]);
 }
 
-pub struct TrackCreatedAccounts;
-impl TrackCreatedAccounts {
-	pub fn accounts() -> Vec<(AccountId, CurrencyId)> {
-		CREATED.with(|accounts| accounts.borrow().clone())
+pub struct TrackCreatedAccounts<T>(marker::PhantomData<T>);
+impl<T: Config> TrackCreatedAccounts<T>
+where
+	T::AccountId: From<AccountId32> + Into<AccountId32>,
+	T::CurrencyId: From<u32> + Into<u32>,
+{
+	pub fn accounts() -> Vec<(T::AccountId, T::CurrencyId)> {
+		CREATED
+			.with(|accounts| accounts.borrow().clone())
+			.iter()
+			.map(|account| (account.0.clone().into(), account.1.clone().into()))
+			.collect()
 	}
 
 	pub fn reset() {
@@ -240,18 +248,30 @@ impl TrackCreatedAccounts {
 		});
 	}
 }
-impl Happened<(AccountId, CurrencyId)> for TrackCreatedAccounts {
-	fn happened((who, currency): &(AccountId, CurrencyId)) {
+impl<T: Config> Happened<(T::AccountId, T::CurrencyId)> for TrackCreatedAccounts<T>
+where
+	T::AccountId: From<AccountId32> + Into<AccountId32>,
+	T::CurrencyId: From<u32> + Into<u32>,
+{
+	fn happened((who, currency): &(T::AccountId, T::CurrencyId)) {
 		CREATED.with(|accounts| {
-			accounts.borrow_mut().push((who.clone(), *currency));
+			accounts.borrow_mut().push((who.clone().into(), (*currency).into()));
 		});
 	}
 }
 
-pub struct TrackKilledAccounts;
-impl TrackKilledAccounts {
-	pub fn accounts() -> Vec<(AccountId, CurrencyId)> {
-		KILLED.with(|accounts| accounts.borrow().clone())
+pub struct TrackKilledAccounts<T>(marker::PhantomData<T>);
+impl<T: Config> TrackKilledAccounts<T>
+where
+	T::AccountId: From<AccountId32> + Into<AccountId32>,
+	T::CurrencyId: From<u32> + Into<u32>,
+{
+	pub fn accounts() -> Vec<(T::AccountId, T::CurrencyId)> {
+		KILLED
+			.with(|accounts| accounts.borrow().clone())
+			.iter()
+			.map(|account| (account.0.clone().into(), account.1.clone().into()))
+			.collect()
 	}
 
 	pub fn reset() {
@@ -260,23 +280,29 @@ impl TrackKilledAccounts {
 		});
 	}
 }
-impl Happened<(AccountId, CurrencyId)> for TrackKilledAccounts {
-	fn happened((who, currency): &(AccountId, CurrencyId)) {
+impl<T: Config> Happened<(T::AccountId, T::CurrencyId)> for TrackKilledAccounts<T>
+where
+	T::AccountId: From<AccountId32> + Into<AccountId32>,
+	T::CurrencyId: From<u32> + Into<u32>,
+{
+	fn happened((who, currency): &(T::AccountId, T::CurrencyId)) {
 		KILLED.with(|accounts| {
-			accounts.borrow_mut().push((who.clone(), *currency));
+			accounts.borrow_mut().push((who.clone().into(), (*currency).into()));
 		});
 	}
 }
 
 thread_local! {
 	pub static ON_SLASH_CALLS: RefCell<u32> = RefCell::new(0);
-	pub static ON_DEPOSIT_CALLS: RefCell<u32> = RefCell::new(0);
-	pub static ON_TRANSFER_CALLS: RefCell<u32> = RefCell::new(0);
+	pub static ON_DEPOSIT_PREHOOK_CALLS: RefCell<u32> = RefCell::new(0);
+	pub static ON_DEPOSIT_POSTHOOK_CALLS: RefCell<u32> = RefCell::new(0);
+	pub static ON_TRANSFER_PREHOOK_CALLS: RefCell<u32> = RefCell::new(0);
+	pub static ON_TRANSFER_POSTHOOK_CALLS: RefCell<u32> = RefCell::new(0);
 }
 
 pub struct OnSlashHook<T>(marker::PhantomData<T>);
-impl<T: Config> OnSlash<T::AccountId, CurrencyId, Balance> for OnSlashHook<T> {
-	fn on_slash(_currency_id: CurrencyId, _account_id: &T::AccountId, _amount: Balance) {
+impl<T: Config> OnSlash<T::AccountId, T::CurrencyId, T::Balance> for OnSlashHook<T> {
+	fn on_slash(_currency_id: T::CurrencyId, _account_id: &T::AccountId, _amount: T::Balance) {
 		ON_SLASH_CALLS.with(|cell| *cell.borrow_mut() += 1);
 	}
 }
@@ -286,34 +312,65 @@ impl<T: Config> OnSlashHook<T> {
 	}
 }
 
-pub struct OnDepositHook<T>(marker::PhantomData<T>);
-impl<T: Config> OnDeposit<T::AccountId, CurrencyId, Balance> for OnDepositHook<T> {
-	fn on_deposit(_currency_id: CurrencyId, _account_id: &T::AccountId, _amount: Balance) -> DispatchResult {
-		ON_DEPOSIT_CALLS.with(|cell| *cell.borrow_mut() += 1);
+pub struct PreDeposit<T>(marker::PhantomData<T>);
+impl<T: Config> OnDeposit<T::AccountId, T::CurrencyId, T::Balance> for PreDeposit<T> {
+	fn on_deposit(_currency_id: T::CurrencyId, _account_id: &T::AccountId, _amount: T::Balance) -> DispatchResult {
+		ON_DEPOSIT_PREHOOK_CALLS.with(|cell| *cell.borrow_mut() += 1);
 		Ok(())
 	}
 }
-impl<T: Config> OnDepositHook<T> {
+impl<T: Config> PreDeposit<T> {
 	pub fn calls() -> u32 {
-		ON_DEPOSIT_CALLS.with(|accounts| *accounts.borrow())
+		ON_DEPOSIT_PREHOOK_CALLS.with(|accounts| accounts.borrow().clone())
 	}
 }
 
-pub struct OnTransferHook<T>(marker::PhantomData<T>);
-impl<T: Config> OnTransfer<T::AccountId, CurrencyId, Balance> for OnTransferHook<T> {
+pub struct PostDeposit<T>(marker::PhantomData<T>);
+impl<T: Config> OnDeposit<T::AccountId, T::CurrencyId, T::Balance> for PostDeposit<T> {
+	fn on_deposit(_currency_id: T::CurrencyId, _account_id: &T::AccountId, _amount: T::Balance) -> DispatchResult {
+		ON_DEPOSIT_POSTHOOK_CALLS.with(|cell| *cell.borrow_mut() += 1);
+		Ok(())
+	}
+}
+impl<T: Config> PostDeposit<T> {
+	pub fn calls() -> u32 {
+		ON_DEPOSIT_POSTHOOK_CALLS.with(|accounts| accounts.borrow().clone())
+	}
+}
+
+pub struct PreTransfer<T>(marker::PhantomData<T>);
+impl<T: Config> OnTransfer<T::AccountId, T::CurrencyId, T::Balance> for PreTransfer<T> {
+	fn on_transfer(
+		_currency_id: T::CurrencyId,
+		_from: &T::AccountId,
+		_to: &T::AccountId,
+		_amount: T::Balance,
+	) -> DispatchResult {
+		ON_TRANSFER_PREHOOK_CALLS.with(|cell| *cell.borrow_mut() += 1);
+		Ok(())
+	}
+}
+impl<T: Config> PreTransfer<T> {
+	pub fn calls() -> u32 {
+		ON_TRANSFER_PREHOOK_CALLS.with(|accounts| accounts.borrow().clone())
+	}
+}
+
+pub struct PostTransfer<T>(marker::PhantomData<T>);
+impl<T: Config> OnTransfer<T::AccountId, T::CurrencyId, T::Balance> for PostTransfer<T> {
 	fn on_transfer(
-		_currency_id: CurrencyId,
+		_currency_id: T::CurrencyId,
 		_from: &T::AccountId,
 		_to: &T::AccountId,
-		_amount: Balance,
+		_amount: T::Balance,
 	) -> DispatchResult {
-		ON_TRANSFER_CALLS.with(|cell| *cell.borrow_mut() += 1);
+		ON_TRANSFER_POSTHOOK_CALLS.with(|cell| *cell.borrow_mut() += 1);
 		Ok(())
 	}
 }
-impl<T: Config> OnTransferHook<T> {
+impl<T: Config> PostTransfer<T> {
 	pub fn calls() -> u32 {
-		ON_TRANSFER_CALLS.with(|accounts| *accounts.borrow())
+		ON_TRANSFER_POSTHOOK_CALLS.with(|accounts| accounts.borrow().clone())
 	}
 }
 
@@ -321,6 +378,22 @@ parameter_types! {
 	pub DustReceiver: AccountId = PalletId(*b"orml/dst").into_account_truncating();
 }
 
+pub struct CurrencyHooks<T>(marker::PhantomData<T>);
+impl<T: Config> MutationHooks<T::AccountId, T::CurrencyId, T::Balance> for CurrencyHooks<T>
+where
+	T::AccountId: From<AccountId32> + Into<AccountId32>,
+	T::CurrencyId: From<u32> + Into<u32>,
+{
+	type OnDust = TransferDust<T, DustReceiver>;
+	type OnSlash = OnSlashHook<T>;
+	type PreDeposit = PreDeposit<T>;
+	type PostDeposit = PostDeposit<T>;
+	type PreTransfer = PreTransfer<T>;
+	type PostTransfer = PostTransfer<T>;
+	type OnNewTokenAccount = TrackCreatedAccounts<T>;
+	type OnKilledTokenAccount = TrackKilledAccounts<T>;
+}
+
 impl Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type Balance = Balance;
@@ -328,12 +401,7 @@ impl Config for Runtime {
 	type CurrencyId = CurrencyId;
 	type WeightInfo = ();
 	type ExistentialDeposits = ExistentialDeposits;
-	type OnDust = TransferDust<Runtime, DustReceiver>;
-	type OnSlash = OnSlashHook<Runtime>;
-	type OnDeposit = OnDepositHook<Runtime>;
-	type OnTransfer = OnTransferHook<Runtime>;
-	type OnNewTokenAccount = TrackCreatedAccounts;
-	type OnKilledTokenAccount = TrackKilledAccounts;
+	type CurrencyHooks = CurrencyHooks<Runtime>;
 	type MaxLocks = ConstU32<2>;
 	type MaxReserves = ConstU32<2>;
 	type ReserveIdentifier = ReserveIdentifier;
@@ -390,8 +458,8 @@ impl ExtBuilder {
 			.unwrap();
 		}
 
-		TrackCreatedAccounts::reset();
-		TrackKilledAccounts::reset();
+		TrackCreatedAccounts::<Runtime>::reset();
+		TrackKilledAccounts::<Runtime>::reset();
 
 		let mut ext = sp_io::TestExternalities::new(t);
 		ext.execute_with(|| System::set_block_number(1));
diff --git a/tokens/src/tests.rs b/tokens/src/tests.rs
index 12feb02ea..baa96dd69 100644
--- a/tokens/src/tests.rs
+++ b/tokens/src/tests.rs
@@ -55,7 +55,7 @@ fn transfer_should_work() {
 				Error::<Runtime>::ExistentialDeposit,
 			);
 			assert_ok!(Tokens::transfer(Some(ALICE).into(), CHARLIE, DOT, 2));
-			assert_eq!(TrackCreatedAccounts::accounts(), vec![(CHARLIE, DOT)]);
+			assert_eq!(TrackCreatedAccounts::<Runtime>::accounts(), vec![(CHARLIE, DOT)]);
 
 			// imply AllowDeath
 			assert!(Accounts::<Runtime>::contains_key(ALICE, DOT));
@@ -132,7 +132,7 @@ fn transfer_all_allow_death_should_work() {
 			assert!(Accounts::<Runtime>::contains_key(ALICE, DOT));
 			assert_eq!(Tokens::free_balance(DOT, &ALICE), 100);
 			assert_ok!(Tokens::transfer_all(Some(ALICE).into(), CHARLIE, DOT, false));
-			assert_eq!(TrackCreatedAccounts::accounts(), vec![(CHARLIE, DOT)]);
+			assert_eq!(TrackCreatedAccounts::<Runtime>::accounts(), vec![(CHARLIE, DOT)]);
 			System::assert_last_event(RuntimeEvent::Tokens(crate::Event::Transfer {
 				currency_id: DOT,
 				from: ALICE,
@@ -141,7 +141,7 @@ fn transfer_all_allow_death_should_work() {
 			}));
 			assert!(!Accounts::<Runtime>::contains_key(ALICE, DOT));
 			assert_eq!(Tokens::free_balance(DOT, &ALICE), 0);
-			assert_eq!(TrackKilledAccounts::accounts(), vec![(ALICE, DOT)]);
+			assert_eq!(TrackKilledAccounts::<Runtime>::accounts(), vec![(ALICE, DOT)]);
 
 			assert_ok!(Tokens::set_lock(ID_1, DOT, &BOB, 50));
 			assert_eq!(Tokens::accounts(&BOB, DOT).frozen, 50);
@@ -179,7 +179,7 @@ fn force_transfer_should_work() {
 				amount: 100,
 			}));
 			assert!(!Accounts::<Runtime>::contains_key(ALICE, DOT));
-			assert_eq!(TrackKilledAccounts::accounts(), vec![(ALICE, DOT)]);
+			assert_eq!(TrackKilledAccounts::<Runtime>::accounts(), vec![(ALICE, DOT)]);
 			assert_eq!(Tokens::free_balance(DOT, &ALICE), 0);
 			assert_eq!(Tokens::free_balance(DOT, &BOB), 200);
 		});
@@ -1154,17 +1154,20 @@ fn exceeding_max_reserves_should_fail() {
 fn lifecycle_callbacks_are_activated() {
 	ExtBuilder::default().build().execute_with(|| {
 		assert_ok!(Tokens::set_balance(RawOrigin::Root.into(), ALICE, DOT, 200, 0));
-		assert_eq!(TrackCreatedAccounts::accounts(), vec![(ALICE, DOT)]);
+		assert_eq!(TrackCreatedAccounts::<Runtime>::accounts(), vec![(ALICE, DOT)]);
 
 		assert_ok!(Tokens::set_balance(RawOrigin::Root.into(), ALICE, BTC, 200, 0));
-		assert_eq!(TrackCreatedAccounts::accounts(), vec![(ALICE, DOT), (ALICE, BTC)]);
+		assert_eq!(
+			TrackCreatedAccounts::<Runtime>::accounts(),
+			vec![(ALICE, DOT), (ALICE, BTC)]
+		);
 
 		assert_ok!(Tokens::transfer_all(Some(ALICE).into(), CHARLIE, BTC, false));
 		assert_eq!(
-			TrackCreatedAccounts::accounts(),
+			TrackCreatedAccounts::<Runtime>::accounts(),
 			vec![(ALICE, DOT), (ALICE, BTC), (CHARLIE, BTC)]
 		);
-		assert_eq!(TrackKilledAccounts::accounts(), vec![(ALICE, BTC)]);
+		assert_eq!(TrackKilledAccounts::<Runtime>::accounts(), vec![(ALICE, BTC)]);
 	})
 }
 
@@ -1174,31 +1177,37 @@ fn lifecycle_callbacks_are_activated() {
 // *************************************************
 
 #[test]
-fn deposit_hook_works() {
+fn deposit_hooks_work() {
 	ExtBuilder::default().build().execute_with(|| {
-		let initial_hook_calls = OnDepositHook::<Runtime>::calls();
+		let initial_prehook_calls = PreDeposit::<Runtime>::calls();
+		let initial_posthook_calls = PostDeposit::<Runtime>::calls();
 		assert_ok!(Tokens::do_deposit(DOT, &CHARLIE, 0, false, true),);
-		assert_eq!(OnDepositHook::<Runtime>::calls(), initial_hook_calls);
+		assert_eq!(PreDeposit::<Runtime>::calls(), initial_prehook_calls);
+		assert_eq!(PostDeposit::<Runtime>::calls(), initial_posthook_calls);
 
 		assert_ok!(Tokens::do_deposit(DOT, &CHARLIE, 100, false, true),);
-		assert_eq!(OnDepositHook::<Runtime>::calls(), initial_hook_calls + 1);
+		assert_eq!(PreDeposit::<Runtime>::calls(), initial_prehook_calls + 1);
+		assert_eq!(PostDeposit::<Runtime>::calls(), initial_posthook_calls + 1);
 
-		// The hook must be called even if the actual deposit ends up failing
 		assert_noop!(
 			Tokens::do_deposit(DOT, &BOB, 1, false, true),
 			Error::<Runtime>::ExistentialDeposit
 		);
-		assert_eq!(OnDepositHook::<Runtime>::calls(), initial_hook_calls + 2);
+		// The prehook is called
+		assert_eq!(PreDeposit::<Runtime>::calls(), initial_prehook_calls + 2);
+		// The posthook is not called
+		assert_eq!(PostDeposit::<Runtime>::calls(), initial_posthook_calls + 1);
 	});
 }
 
 #[test]
-fn transfer_hook_works() {
+fn transfer_hooks_work() {
 	ExtBuilder::default()
 		.balances(vec![(ALICE, DOT, 100)])
 		.build()
 		.execute_with(|| {
-			let initial_hook_calls = OnTransferHook::<Runtime>::calls();
+			let initial_prehook_calls = PreTransfer::<Runtime>::calls();
+			let initial_posthook_calls = PostTransfer::<Runtime>::calls();
 			assert_ok!(Tokens::do_transfer(
 				DOT,
 				&ALICE,
@@ -1206,7 +1215,8 @@ fn transfer_hook_works() {
 				0,
 				ExistenceRequirement::AllowDeath
 			),);
-			assert_eq!(OnTransferHook::<Runtime>::calls(), initial_hook_calls);
+			assert_eq!(PreTransfer::<Runtime>::calls(), initial_prehook_calls);
+			assert_eq!(PostTransfer::<Runtime>::calls(), initial_posthook_calls);
 
 			assert_ok!(Tokens::do_transfer(
 				DOT,
@@ -1215,13 +1225,16 @@ fn transfer_hook_works() {
 				10,
 				ExistenceRequirement::AllowDeath
 			));
-			assert_eq!(OnTransferHook::<Runtime>::calls(), initial_hook_calls + 1);
+			assert_eq!(PreTransfer::<Runtime>::calls(), initial_prehook_calls + 1);
+			assert_eq!(PostTransfer::<Runtime>::calls(), initial_posthook_calls + 1);
 
-			// The hook must be called even if the actual transfer ends up failing
 			assert_noop!(
 				Tokens::do_transfer(DOT, &ALICE, &BOB, 1, ExistenceRequirement::AllowDeath),
 				Error::<Runtime>::ExistentialDeposit
 			);
-			assert_eq!(OnTransferHook::<Runtime>::calls(), initial_hook_calls + 2);
+			// The prehook is called
+			assert_eq!(PreTransfer::<Runtime>::calls(), initial_prehook_calls + 2);
+			// The posthook is not called
+			assert_eq!(PostTransfer::<Runtime>::calls(), initial_posthook_calls + 1);
 		});
 }
diff --git a/traits/src/currency.rs b/traits/src/currency.rs
index eaaf5b4d1..8c391f604 100644
--- a/traits/src/currency.rs
+++ b/traits/src/currency.rs
@@ -1,4 +1,4 @@
-use crate::arithmetic;
+use crate::{arithmetic, Happened};
 use codec::{Codec, FullCodec, MaxEncodedLen};
 pub use frame_support::{
 	traits::{BalanceStatus, DefensiveSaturating, LockIdentifier},
@@ -690,3 +690,40 @@ impl<AccountId, CurrencyId, Balance> OnTransfer<AccountId, CurrencyId, Balance>
 		Ok(())
 	}
 }
+
+pub trait MutationHooks<AccountId, CurrencyId, Balance> {
+	/// Handler to burn or transfer account's dust
+	type OnDust: OnDust<AccountId, CurrencyId, Balance>;
+
+	/// Hook to run before slashing an account.
+	type OnSlash: OnSlash<AccountId, CurrencyId, Balance>;
+
+	/// Hook to run before depositing into an account.
+	type PreDeposit: OnDeposit<AccountId, CurrencyId, Balance>;
+
+	/// Hook to run after depositing into an account.
+	type PostDeposit: OnDeposit<AccountId, CurrencyId, Balance>;
+
+	/// Hook to run before transferring from an account to another.
+	type PreTransfer: OnTransfer<AccountId, CurrencyId, Balance>;
+
+	/// Hook to run after transferring from an account to another.
+	type PostTransfer: OnTransfer<AccountId, CurrencyId, Balance>;
+
+	/// Handler for when an account was created
+	type OnNewTokenAccount: Happened<(AccountId, CurrencyId)>;
+
+	/// Handler for when an account was created
+	type OnKilledTokenAccount: Happened<(AccountId, CurrencyId)>;
+}
+
+impl<AccountId, CurrencyId, Balance> MutationHooks<AccountId, CurrencyId, Balance> for () {
+	type OnDust = ();
+	type OnSlash = ();
+	type PreDeposit = ();
+	type PostDeposit = ();
+	type PreTransfer = ();
+	type PostTransfer = ();
+	type OnNewTokenAccount = ();
+	type OnKilledTokenAccount = ();
+}
diff --git a/traits/src/lib.rs b/traits/src/lib.rs
index 818d51251..a5894d218 100644
--- a/traits/src/lib.rs
+++ b/traits/src/lib.rs
@@ -16,7 +16,7 @@ pub use auction::{Auction, AuctionHandler, AuctionInfo, OnNewBidResult};
 pub use currency::{
 	BalanceStatus, BasicCurrency, BasicCurrencyExtended, BasicLockableCurrency, BasicReservableCurrency,
 	LockIdentifier, MultiCurrency, MultiCurrencyExtended, MultiLockableCurrency, MultiReservableCurrency,
-	NamedBasicReservableCurrency, NamedMultiReservableCurrency, OnDust,
+	NamedBasicReservableCurrency, NamedMultiReservableCurrency,
 };
 pub use data_provider::{DataFeeder, DataProvider, DataProviderExtended};
 pub use get_by_key::GetByKey;
diff --git a/xtokens/src/mock/para.rs b/xtokens/src/mock/para.rs
index 830ad48f4..6a91b6185 100644
--- a/xtokens/src/mock/para.rs
+++ b/xtokens/src/mock/para.rs
@@ -83,16 +83,11 @@ impl orml_tokens::Config for Runtime {
 	type CurrencyId = CurrencyId;
 	type WeightInfo = ();
 	type ExistentialDeposits = ExistentialDeposits;
-	type OnDust = ();
-	type OnSlash = ();
-	type OnDeposit = ();
-	type OnTransfer = ();
+	type CurrencyHooks = ();
 	type MaxLocks = ConstU32<50>;
 	type MaxReserves = ConstU32<50>;
 	type ReserveIdentifier = [u8; 8];
 	type DustRemovalWhitelist = Everything;
-	type OnNewTokenAccount = ();
-	type OnKilledTokenAccount = ();
 }
 
 parameter_types! {
diff --git a/xtokens/src/mock/para_relative_view.rs b/xtokens/src/mock/para_relative_view.rs
index 064cdb0db..357e5cd07 100644
--- a/xtokens/src/mock/para_relative_view.rs
+++ b/xtokens/src/mock/para_relative_view.rs
@@ -86,16 +86,11 @@ impl orml_tokens::Config for Runtime {
 	type CurrencyId = CurrencyId;
 	type WeightInfo = ();
 	type ExistentialDeposits = ExistentialDeposits;
-	type OnDust = ();
-	type OnSlash = ();
-	type OnDeposit = ();
-	type OnTransfer = ();
+	type CurrencyHooks = ();
 	type MaxLocks = ConstU32<50>;
 	type MaxReserves = ConstU32<50>;
 	type ReserveIdentifier = [u8; 8];
 	type DustRemovalWhitelist = Everything;
-	type OnNewTokenAccount = ();
-	type OnKilledTokenAccount = ();
 }
 
 parameter_types! {
diff --git a/xtokens/src/mock/para_teleport.rs b/xtokens/src/mock/para_teleport.rs
index a9660e07f..01bc013e5 100644
--- a/xtokens/src/mock/para_teleport.rs
+++ b/xtokens/src/mock/para_teleport.rs
@@ -84,16 +84,11 @@ impl orml_tokens::Config for Runtime {
 	type CurrencyId = CurrencyId;
 	type WeightInfo = ();
 	type ExistentialDeposits = ExistentialDeposits;
-	type OnDust = ();
-	type OnSlash = ();
-	type OnDeposit = ();
-	type OnTransfer = ();
+	type CurrencyHooks = ();
 	type MaxLocks = ConstU32<50>;
 	type MaxReserves = ConstU32<50>;
 	type ReserveIdentifier = [u8; 8];
 	type DustRemovalWhitelist = Everything;
-	type OnNewTokenAccount = ();
-	type OnKilledTokenAccount = ();
 }
 
 parameter_types! {