diff --git a/libs/traits/src/liquidity_pools.rs b/libs/traits/src/liquidity_pools.rs
index 0f80787337..5b274599b3 100644
--- a/libs/traits/src/liquidity_pools.rs
+++ b/libs/traits/src/liquidity_pools.rs
@@ -15,11 +15,12 @@ use frame_support::{dispatch::DispatchResult, weights::Weight};
 use sp_runtime::DispatchError;
 use sp_std::vec::Vec;
 
-pub type Proof = [u8; 32];
+/// Type that represents the hash of an LP message.
+pub type MessageHash = [u8; 32];
 
 /// An encoding & decoding trait for the purpose of meeting the
 /// LiquidityPools General Message Passing Format
-pub trait LPEncoding: Sized {
+pub trait LPMessage: Sized {
 	fn serialize(&self) -> Vec<u8>;
 	fn deserialize(input: &[u8]) -> Result<Self, DispatchError>;
 
@@ -34,11 +35,26 @@ pub trait LPEncoding: Sized {
 	/// It's the identity message for composing messages with pack_with
 	fn empty() -> Self;
 
-	/// Retrieves the message proof hash, if the message is a proof type.
-	fn get_proof(&self) -> Option<Proof>;
+	/// Returns whether the message is a proof or not.
+	fn is_proof_message(&self) -> bool;
+
+	/// Retrieves the message hash, if the message is a proof type.
+	fn get_message_hash(&self) -> MessageHash;
 
 	/// Converts the message into a message proof type.
 	fn to_proof_message(&self) -> Self;
+
+	/// Creates a message used for initiating message recovery.
+	///
+	/// Hash - hash of the message that should be recovered.
+	/// Router - the address of the recovery router.
+	fn initiate_recovery_message(hash: [u8; 32], router: [u8; 32]) -> Self;
+
+	/// Creates a message used for disputing message recovery.
+	///
+	/// Hash - hash of the message that should be disputed.
+	/// Router - the address of the recovery router.
+	fn dispute_recovery_message(hash: [u8; 32], router: [u8; 32]) -> Self;
 }
 
 pub trait RouterProvider<Domain>: Sized {
diff --git a/pallets/liquidity-pools-gateway/src/lib.rs b/pallets/liquidity-pools-gateway/src/lib.rs
index ad4ca6f8be..2fd6e75c2f 100644
--- a/pallets/liquidity-pools-gateway/src/lib.rs
+++ b/pallets/liquidity-pools-gateway/src/lib.rs
@@ -30,8 +30,8 @@ use core::fmt::Debug;
 
 use cfg_primitives::LP_DEFENSIVE_WEIGHT;
 use cfg_traits::liquidity_pools::{
-	InboundMessageHandler, LPEncoding, MessageProcessor, MessageQueue, MessageReceiver,
-	MessageSender, OutboundMessageHandler, Proof, RouterProvider,
+	InboundMessageHandler, LPMessage, MessageHash, MessageProcessor, MessageQueue, MessageReceiver,
+	MessageSender, OutboundMessageHandler, RouterProvider,
 };
 use cfg_types::domain_address::{Domain, DomainAddress};
 use frame_support::{dispatch::DispatchResult, pallet_prelude::*};
@@ -44,7 +44,10 @@ use sp_arithmetic::traits::{BaseArithmetic, EnsureAddAssign, One};
 use sp_runtime::SaturatedConversion;
 use sp_std::{convert::TryInto, vec::Vec};
 
-use crate::{message_processing::InboundEntry, weights::WeightInfo};
+use crate::{
+	message_processing::{InboundEntry, ProofEntry},
+	weights::WeightInfo,
+};
 
 mod origin;
 pub use origin::*;
@@ -63,7 +66,6 @@ mod tests;
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
-	use crate::message_processing::ProofEntry;
 
 	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
 
@@ -95,7 +97,7 @@ pub mod pallet {
 		type AdminOrigin: EnsureOrigin<<Self as frame_system::Config>::RuntimeOrigin>;
 
 		/// The Liquidity Pools message type.
-		type Message: LPEncoding
+		type Message: LPMessage
 			+ Clone
 			+ Debug
 			+ PartialEq
@@ -162,11 +164,54 @@ pub mod pallet {
 			hook_address: [u8; 20],
 		},
 
+		/// An inbound message was processed.
+		InboundMessageProcessed {
+			domain_address: DomainAddress,
+			message_hash: MessageHash,
+			router_id: T::RouterId,
+		},
+
+		/// An inbound message proof was processed.
+		InboundProofProcessed {
+			domain_address: DomainAddress,
+			message_hash: MessageHash,
+			router_id: T::RouterId,
+		},
+
+		/// An inbound message was executed.
+		InboundMessageExecuted {
+			domain_address: DomainAddress,
+			message_hash: MessageHash,
+		},
+
+		/// An outbound message was sent.
+		OutboundMessageSent {
+			domain_address: DomainAddress,
+			message_hash: MessageHash,
+			router_id: T::RouterId,
+		},
+
 		/// Message recovery was executed.
 		MessageRecoveryExecuted {
-			proof: Proof,
+			message_hash: MessageHash,
 			router_id: T::RouterId,
 		},
+
+		/// Message recovery was initiated.
+		MessageRecoveryInitiated {
+			domain: Domain,
+			message_hash: MessageHash,
+			recovery_router: [u8; 32],
+			messaging_router: T::RouterId,
+		},
+
+		/// Message recovery was disputed.
+		MessageRecoveryDisputed {
+			domain: Domain,
+			message_hash: MessageHash,
+			recovery_router: [u8; 32],
+			messaging_router: T::RouterId,
+		},
 	}
 
 	/// Storage for routers.
@@ -208,7 +253,7 @@ pub mod pallet {
 	pub type PendingInboundEntries<T: Config> = StorageDoubleMap<
 		_,
 		Blake2_128Concat,
-		Proof,
+		MessageHash,
 		Blake2_128Concat,
 		T::RouterId,
 		InboundEntry<T>,
@@ -249,6 +294,9 @@ pub mod pallet {
 		/// Unknown router.
 		UnknownRouter,
 
+		/// Messaging router not found.
+		MessagingRouterNotFound,
+
 		/// The router that sent the message is not the first one.
 		MessageExpectedFromFirstRouter,
 
@@ -431,7 +479,7 @@ pub mod pallet {
 		pub fn execute_message_recovery(
 			origin: OriginFor<T>,
 			domain_address: DomainAddress,
-			proof: Proof,
+			message_hash: MessageHash,
 			router_id: T::RouterId,
 		) -> DispatchResult {
 			T::AdminOrigin::ensure_origin(origin)?;
@@ -448,8 +496,10 @@ pub mod pallet {
 
 			let session_id = SessionIdStore::<T>::get();
 
-			PendingInboundEntries::<T>::try_mutate(proof, router_id.clone(), |storage_entry| {
-				match storage_entry {
+			PendingInboundEntries::<T>::try_mutate(
+				message_hash,
+				router_id.clone(),
+				|storage_entry| match storage_entry {
 					Some(stored_inbound_entry) => {
 						stored_inbound_entry.increment_proof_count(session_id)
 					}
@@ -461,25 +511,103 @@ pub mod pallet {
 
 						Ok::<(), DispatchError>(())
 					}
-				}
-			})?;
+				},
+			)?;
 
 			let expected_proof_count = Self::get_expected_proof_count(&router_ids)?;
 
 			Self::execute_if_requirements_are_met(
-				proof,
+				message_hash,
 				&router_ids,
 				session_id,
 				expected_proof_count,
 				domain_address,
 			)?;
 
-			Self::deposit_event(Event::<T>::MessageRecoveryExecuted { proof, router_id });
+			Self::deposit_event(Event::<T>::MessageRecoveryExecuted {
+				message_hash,
+				router_id,
+			});
+
+			Ok(())
+		}
+
+		/// Sends a message that initiates a message recovery using the
+		/// messaging router.
+		///
+		/// Can only be called by `AdminOrigin`.
+		#[pallet::weight(T::WeightInfo::initiate_message_recovery())]
+		#[pallet::call_index(12)]
+		pub fn initiate_message_recovery(
+			origin: OriginFor<T>,
+			domain: Domain,
+			message_hash: MessageHash,
+			recovery_router: [u8; 32],
+			messaging_router: T::RouterId,
+		) -> DispatchResult {
+			T::AdminOrigin::ensure_origin(origin)?;
+
+			let message = T::Message::initiate_recovery_message(message_hash, recovery_router);
+
+			Self::send_recovery_message(domain, message, messaging_router.clone())?;
+
+			Self::deposit_event(Event::<T>::MessageRecoveryInitiated {
+				domain,
+				message_hash,
+				recovery_router,
+				messaging_router,
+			});
+
+			Ok(())
+		}
+
+		/// Sends a message that disputes a message recovery using the
+		/// messaging router.
+		///
+		/// Can only be called by `AdminOrigin`.
+		#[pallet::weight(T::WeightInfo::dispute_message_recovery())]
+		#[pallet::call_index(13)]
+		pub fn dispute_message_recovery(
+			origin: OriginFor<T>,
+			domain: Domain,
+			message_hash: MessageHash,
+			recovery_router: [u8; 32],
+			messaging_router: T::RouterId,
+		) -> DispatchResult {
+			T::AdminOrigin::ensure_origin(origin)?;
+
+			let message = T::Message::dispute_recovery_message(message_hash, recovery_router);
+
+			Self::send_recovery_message(domain, message, messaging_router.clone())?;
+
+			Self::deposit_event(Event::<T>::MessageRecoveryDisputed {
+				domain,
+				message_hash,
+				recovery_router,
+				messaging_router,
+			});
 
 			Ok(())
 		}
 	}
 
+	impl<T: Config> Pallet<T> {
+		fn send_recovery_message(
+			domain: Domain,
+			message: T::Message,
+			messaging_router: T::RouterId,
+		) -> DispatchResult {
+			let router_ids = Self::get_router_ids_for_domain(domain)?;
+
+			ensure!(
+				router_ids.iter().any(|x| x == &messaging_router),
+				Error::<T>::MessagingRouterNotFound
+			);
+
+			T::MessageSender::send(messaging_router, T::Sender::get(), message.serialize())
+		}
+	}
+
 	impl<T: Config> OutboundMessageHandler for Pallet<T> {
 		type Destination = Domain;
 		type Message = T::Message;
@@ -534,12 +662,9 @@ pub mod pallet {
 
 					(res, weight)
 				}
-				GatewayMessage::Outbound {
-					sender,
-					message,
-					router_id,
-				} => {
-					let res = T::MessageSender::send(router_id, sender, message.serialize());
+				GatewayMessage::Outbound { message, router_id } => {
+					let res =
+						T::MessageSender::send(router_id, T::Sender::get(), message.serialize());
 
 					(res, LP_DEFENSIVE_WEIGHT)
 				}
diff --git a/pallets/liquidity-pools-gateway/src/message.rs b/pallets/liquidity-pools-gateway/src/message.rs
index 1c604f5d0d..6680179a8a 100644
--- a/pallets/liquidity-pools-gateway/src/message.rs
+++ b/pallets/liquidity-pools-gateway/src/message.rs
@@ -10,7 +10,6 @@ pub enum GatewayMessage<Message, RouterId> {
 		router_id: RouterId,
 	},
 	Outbound {
-		sender: DomainAddress,
 		message: Message,
 		router_id: RouterId,
 	},
diff --git a/pallets/liquidity-pools-gateway/src/message_processing.rs b/pallets/liquidity-pools-gateway/src/message_processing.rs
index 2ea6d0c401..377b6b7a9c 100644
--- a/pallets/liquidity-pools-gateway/src/message_processing.rs
+++ b/pallets/liquidity-pools-gateway/src/message_processing.rs
@@ -1,11 +1,11 @@
 use cfg_traits::liquidity_pools::{
-	InboundMessageHandler, LPEncoding, MessageQueue, Proof, RouterProvider,
+	InboundMessageHandler, LPMessage, MessageHash, MessageQueue, RouterProvider,
 };
 use cfg_types::domain_address::{Domain, DomainAddress};
 use frame_support::{
 	dispatch::DispatchResult,
 	ensure,
-	pallet_prelude::{Decode, Encode, Get, TypeInfo},
+	pallet_prelude::{Decode, Encode, TypeInfo},
 };
 use parity_scale_codec::MaxEncodedLen;
 use sp_arithmetic::traits::{EnsureAddAssign, EnsureSub, SaturatedConversion};
@@ -13,7 +13,8 @@ use sp_runtime::DispatchError;
 use sp_std::vec::Vec;
 
 use crate::{
-	message::GatewayMessage, Config, Error, Pallet, PendingInboundEntries, Routers, SessionIdStore,
+	message::GatewayMessage, Config, Error, Event, Pallet, PendingInboundEntries, Routers,
+	SessionIdStore,
 };
 
 /// Type that holds the information needed for inbound message entries.
@@ -92,17 +93,18 @@ impl<T: Config> InboundEntry<T> {
 		domain_address: DomainAddress,
 		expected_proof_count: u32,
 	) -> Self {
-		match message.get_proof() {
-			None => InboundEntry::Message(MessageEntry {
+		if message.is_proof_message() {
+			InboundEntry::Proof(ProofEntry {
+				session_id,
+				current_count: 1,
+			})
+		} else {
+			InboundEntry::Message(MessageEntry {
 				session_id,
 				domain_address,
 				message,
 				expected_proof_count,
-			}),
-			Some(_) => InboundEntry::Proof(ProofEntry {
-				session_id,
-				current_count: 1,
-			}),
+			})
 		}
 	}
 
@@ -290,25 +292,14 @@ impl<T: Config> Pallet<T> {
 		Ok(expected_proof_count.saturated_into())
 	}
 
-	/// Gets the message proof for a message.
-	pub(crate) fn get_message_proof(message: T::Message) -> Proof {
-		match message.get_proof() {
-			None => message
-				.to_proof_message()
-				.get_proof()
-				.expect("message proof ensured by 'to_message_proof'"),
-			Some(proof) => proof,
-		}
-	}
-
 	/// Upserts an inbound entry for a particular message, increasing the
 	/// relevant counts accordingly.
 	pub(crate) fn upsert_pending_entry(
-		message_proof: Proof,
+		message_hash: MessageHash,
 		router_id: &T::RouterId,
 		new_inbound_entry: InboundEntry<T>,
 	) -> DispatchResult {
-		PendingInboundEntries::<T>::try_mutate(message_proof, router_id, |storage_entry| {
+		PendingInboundEntries::<T>::try_mutate(message_hash, router_id, |storage_entry| {
 			match storage_entry {
 				None => {
 					*storage_entry = Some(new_inbound_entry);
@@ -326,7 +317,7 @@ impl<T: Config> Pallet<T> {
 	/// were received, and if so, decreases the counts accordingly and executes
 	/// the message.
 	pub(crate) fn execute_if_requirements_are_met(
-		message_proof: Proof,
+		message_hash: MessageHash,
 		router_ids: &[T::RouterId],
 		session_id: T::SessionId,
 		expected_proof_count: u32,
@@ -336,7 +327,7 @@ impl<T: Config> Pallet<T> {
 		let mut votes = 0;
 
 		for router_id in router_ids {
-			match PendingInboundEntries::<T>::get(message_proof, router_id) {
+			match PendingInboundEntries::<T>::get(message_hash, router_id) {
 				// We expected one InboundEntry for each router, if that's not the case,
 				// we can return.
 				None => return Ok(()),
@@ -357,9 +348,14 @@ impl<T: Config> Pallet<T> {
 		}
 
 		if let Some(msg) = message {
-			Self::execute_post_voting_dispatch(message_proof, router_ids, expected_proof_count)?;
+			Self::execute_post_voting_dispatch(message_hash, router_ids, expected_proof_count)?;
+
+			T::InboundMessageHandler::handle(domain_address.clone(), msg)?;
 
-			T::InboundMessageHandler::handle(domain_address, msg)?;
+			Self::deposit_event(Event::<T>::InboundMessageExecuted {
+				domain_address,
+				message_hash,
+			})
 		}
 
 		Ok(())
@@ -368,12 +364,12 @@ impl<T: Config> Pallet<T> {
 	/// Decreases the counts for inbound entries and removes them if the
 	/// counts reach 0.
 	pub(crate) fn execute_post_voting_dispatch(
-		message_proof: Proof,
+		message_hash: MessageHash,
 		router_ids: &[T::RouterId],
 		expected_proof_count: u32,
 	) -> DispatchResult {
 		for router_id in router_ids {
-			PendingInboundEntries::<T>::try_mutate(message_proof, router_id, |storage_entry| {
+			PendingInboundEntries::<T>::try_mutate(message_hash, router_id, |storage_entry| {
 				match storage_entry {
 					None => {
 						// This case cannot be reproduced in production since this function is
@@ -413,20 +409,27 @@ impl<T: Config> Pallet<T> {
 		for submessage in message.submessages() {
 			counter.ensure_add_assign(1)?;
 
-			let message_proof = Self::get_message_proof(submessage.clone());
+			let message_hash = submessage.get_message_hash();
 
 			let inbound_entry: InboundEntry<T> = InboundEntry::create(
-				submessage,
+				submessage.clone(),
 				session_id,
 				domain_address.clone(),
 				expected_proof_count,
 			);
 
 			inbound_entry.validate(&router_ids, &router_id.clone())?;
-			Self::upsert_pending_entry(message_proof, &router_id, inbound_entry)?;
+			Self::upsert_pending_entry(message_hash, &router_id, inbound_entry)?;
+
+			Self::deposit_processing_event(
+				domain_address.clone(),
+				submessage,
+				message_hash,
+				router_id.clone(),
+			);
 
 			Self::execute_if_requirements_are_met(
-				message_proof,
+				message_hash,
 				&router_ids,
 				session_id,
 				expected_proof_count,
@@ -437,6 +440,27 @@ impl<T: Config> Pallet<T> {
 		Ok(())
 	}
 
+	fn deposit_processing_event(
+		domain_address: DomainAddress,
+		message: T::Message,
+		message_hash: MessageHash,
+		router_id: T::RouterId,
+	) {
+		if message.is_proof_message() {
+			Self::deposit_event(Event::<T>::InboundProofProcessed {
+				domain_address,
+				message_hash,
+				router_id,
+			})
+		} else {
+			Self::deposit_event(Event::<T>::InboundMessageProcessed {
+				domain_address,
+				message_hash,
+				router_id,
+			})
+		}
+	}
+
 	/// Retrieves the IDs of the routers set for a domain and queues the
 	/// message and proofs accordingly.
 	pub(crate) fn queue_outbound_message(
@@ -445,7 +469,7 @@ impl<T: Config> Pallet<T> {
 	) -> DispatchResult {
 		let router_ids = Self::get_router_ids_for_domain(destination)?;
 
-		let message_proof = message.to_proof_message();
+		let proof_message = message.to_proof_message();
 		let mut message_opt = Some(message);
 
 		for router_id in router_ids {
@@ -453,13 +477,12 @@ impl<T: Config> Pallet<T> {
 			// The remaining routers will send the message proof.
 			let router_msg = match message_opt.take() {
 				Some(m) => m,
-				None => message_proof.clone(),
+				None => proof_message.clone(),
 			};
 
 			// We are using the sender specified in the pallet config so that we can
 			// ensure that the account is funded
 			let gateway_message = GatewayMessage::<T::Message, T::RouterId>::Outbound {
-				sender: T::Sender::get(),
 				message: router_msg,
 				router_id,
 			};
diff --git a/pallets/liquidity-pools-gateway/src/mock.rs b/pallets/liquidity-pools-gateway/src/mock.rs
index 629858220a..acd3d052ce 100644
--- a/pallets/liquidity-pools-gateway/src/mock.rs
+++ b/pallets/liquidity-pools-gateway/src/mock.rs
@@ -1,7 +1,7 @@
 use std::fmt::{Debug, Formatter};
 
 use cfg_mocks::{pallet_mock_liquidity_pools, pallet_mock_liquidity_pools_gateway_queue};
-use cfg_traits::liquidity_pools::{LPEncoding, Proof, RouterProvider};
+use cfg_traits::liquidity_pools::{LPMessage, MessageHash, RouterProvider};
 use cfg_types::{
 	domain_address::{Domain, DomainAddress},
 	EVMChainId,
@@ -17,6 +17,7 @@ use crate::{pallet as pallet_liquidity_pools_gateway, EnsureLocal, GatewayMessag
 
 pub const TEST_SESSION_ID: u32 = 1;
 pub const TEST_EVM_CHAIN: EVMChainId = 1;
+pub const TEST_DOMAIN: Domain = Domain::Evm(TEST_EVM_CHAIN);
 pub const TEST_DOMAIN_ADDRESS: DomainAddress =
 	DomainAddress::Evm(TEST_EVM_CHAIN, H160::repeat_byte(1));
 
@@ -29,13 +30,15 @@ pub const LP_ADMIN_ACCOUNT: AccountId32 = AccountId32::new([u8::MAX; 32]);
 pub const MAX_PACKED_MESSAGES_ERR: &str = "packed limit error";
 pub const MAX_PACKED_MESSAGES: usize = 10;
 
-pub const MESSAGE_PROOF: [u8; 32] = [1; 32];
+pub const MESSAGE_HASH: [u8; 32] = [1; 32];
 
 #[derive(Eq, PartialEq, Clone, Encode, Decode, TypeInfo, Hash)]
 pub enum Message {
 	Simple,
 	Pack(Vec<Message>),
 	Proof([u8; 32]),
+	InitiateMessageRecovery(([u8; 32], [u8; 32])),
+	DisputeMessageRecovery(([u8; 32], [u8; 32])),
 }
 
 impl Debug for Message {
@@ -44,6 +47,7 @@ impl Debug for Message {
 			Message::Simple => write!(f, "Simple"),
 			Message::Pack(p) => write!(f, "Pack - {:?}", p),
 			Message::Proof(_) => write!(f, "Proof"),
+			other => write!(f, "{:?}", other),
 		}
 	}
 }
@@ -55,7 +59,7 @@ impl MaxEncodedLen for Message {
 	}
 }
 
-impl LPEncoding for Message {
+impl LPMessage for Message {
 	fn serialize(&self) -> Vec<u8> {
 		match self {
 			Self::Pack(list) => list.iter().map(|_| 0x42).collect(),
@@ -98,19 +102,28 @@ impl LPEncoding for Message {
 		Self::Pack(vec![])
 	}
 
-	fn get_proof(&self) -> Option<Proof> {
-		match self {
-			Message::Proof(p) => Some(p.clone()),
-			_ => None,
-		}
+	fn is_proof_message(&self) -> bool {
+		matches!(self, Message::Proof(..))
+	}
+
+	fn get_message_hash(&self) -> MessageHash {
+		MESSAGE_HASH
 	}
 
 	fn to_proof_message(&self) -> Self {
 		match self {
 			Message::Proof(_) => self.clone(),
-			_ => Message::Proof(MESSAGE_PROOF),
+			_ => Message::Proof(self.get_message_hash()),
 		}
 	}
+
+	fn initiate_recovery_message(hash: [u8; 32], router: [u8; 32]) -> Self {
+		Self::InitiateMessageRecovery((hash, router))
+	}
+
+	fn dispute_recovery_message(hash: [u8; 32], router: [u8; 32]) -> Self {
+		Self::DisputeMessageRecovery((hash, router))
+	}
 }
 
 #[derive(Default, Debug, Encode, Decode, Clone, PartialEq, Eq, TypeInfo, MaxEncodedLen, Hash)]
diff --git a/pallets/liquidity-pools-gateway/src/tests.rs b/pallets/liquidity-pools-gateway/src/tests.rs
index 69f25c4b0a..b8ca112b5e 100644
--- a/pallets/liquidity-pools-gateway/src/tests.rs
+++ b/pallets/liquidity-pools-gateway/src/tests.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use cfg_primitives::LP_DEFENSIVE_WEIGHT;
-use cfg_traits::liquidity_pools::{LPEncoding, MessageProcessor, OutboundMessageHandler};
+use cfg_traits::liquidity_pools::{LPMessage, MessageProcessor, OutboundMessageHandler};
 use cfg_types::domain_address::*;
 use frame_support::{assert_err, assert_noop, assert_ok};
 use itertools::Itertools;
@@ -664,7 +664,7 @@ mod extrinsics {
 				SessionIdStore::<Runtime>::set(session_id);
 
 				PendingInboundEntries::<Runtime>::insert(
-					MESSAGE_PROOF,
+					MESSAGE_HASH,
 					ROUTER_ID_1,
 					InboundEntry::Message(MessageEntry {
 						session_id,
@@ -685,23 +685,19 @@ mod extrinsics {
 				assert_ok!(LiquidityPoolsGateway::execute_message_recovery(
 					RuntimeOrigin::root(),
 					TEST_DOMAIN_ADDRESS,
-					MESSAGE_PROOF,
+					MESSAGE_HASH,
 					ROUTER_ID_2,
 				));
 
 				event_exists(Event::<Runtime>::MessageRecoveryExecuted {
-					proof: MESSAGE_PROOF,
+					message_hash: MESSAGE_HASH,
 					router_id: ROUTER_ID_2,
 				});
 
 				assert_eq!(handler.times(), 1);
 
-				assert!(
-					PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_1).is_none()
-				);
-				assert!(
-					PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_2).is_none()
-				);
+				assert!(PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_1).is_none());
+				assert!(PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_2).is_none());
 			});
 		}
 
@@ -716,7 +712,7 @@ mod extrinsics {
 				SessionIdStore::<Runtime>::set(session_id);
 
 				PendingInboundEntries::<Runtime>::insert(
-					MESSAGE_PROOF,
+					MESSAGE_HASH,
 					ROUTER_ID_1,
 					InboundEntry::Message(MessageEntry {
 						session_id,
@@ -729,17 +725,17 @@ mod extrinsics {
 				assert_ok!(LiquidityPoolsGateway::execute_message_recovery(
 					RuntimeOrigin::root(),
 					TEST_DOMAIN_ADDRESS,
-					MESSAGE_PROOF,
+					MESSAGE_HASH,
 					ROUTER_ID_2,
 				));
 
 				event_exists(Event::<Runtime>::MessageRecoveryExecuted {
-					proof: MESSAGE_PROOF,
+					message_hash: MESSAGE_HASH,
 					router_id: ROUTER_ID_2,
 				});
 
 				assert_eq!(
-					PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_1),
+					PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_1),
 					Some(
 						MessageEntry {
 							session_id,
@@ -751,7 +747,7 @@ mod extrinsics {
 					)
 				);
 				assert_eq!(
-					PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_2),
+					PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_2),
 					Some(
 						ProofEntry {
 							session_id,
@@ -760,7 +756,7 @@ mod extrinsics {
 						.into()
 					)
 				);
-				assert!(PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_3).is_none())
+				assert!(PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_3).is_none())
 			});
 		}
 
@@ -771,7 +767,7 @@ mod extrinsics {
 					LiquidityPoolsGateway::execute_message_recovery(
 						RuntimeOrigin::root(),
 						TEST_DOMAIN_ADDRESS,
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_1,
 					),
 					Error::<Runtime>::NotEnoughRoutersForDomain
@@ -783,7 +779,7 @@ mod extrinsics {
 					LiquidityPoolsGateway::execute_message_recovery(
 						RuntimeOrigin::root(),
 						TEST_DOMAIN_ADDRESS,
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_1,
 					),
 					Error::<Runtime>::NotEnoughRoutersForDomain
@@ -801,7 +797,7 @@ mod extrinsics {
 					LiquidityPoolsGateway::execute_message_recovery(
 						RuntimeOrigin::root(),
 						TEST_DOMAIN_ADDRESS,
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_2
 					),
 					Error::<Runtime>::UnknownRouter
@@ -819,7 +815,7 @@ mod extrinsics {
 				);
 				SessionIdStore::<Runtime>::set(session_id);
 				PendingInboundEntries::<Runtime>::insert(
-					MESSAGE_PROOF,
+					MESSAGE_HASH,
 					ROUTER_ID_2,
 					InboundEntry::Proof(ProofEntry {
 						session_id,
@@ -831,7 +827,7 @@ mod extrinsics {
 					LiquidityPoolsGateway::execute_message_recovery(
 						RuntimeOrigin::root(),
 						TEST_DOMAIN_ADDRESS,
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_2
 					),
 					Arithmetic(Overflow)
@@ -840,7 +836,7 @@ mod extrinsics {
 		}
 
 		#[test]
-		fn expected_message_proof_type() {
+		fn expected_message_hash_type() {
 			new_test_ext().execute_with(|| {
 				let domain_address = TEST_DOMAIN_ADDRESS;
 				let session_id = 1;
@@ -850,7 +846,7 @@ mod extrinsics {
 				);
 				SessionIdStore::<Runtime>::set(session_id);
 				PendingInboundEntries::<Runtime>::insert(
-					MESSAGE_PROOF,
+					MESSAGE_HASH,
 					ROUTER_ID_2,
 					InboundEntry::Message(MessageEntry {
 						session_id,
@@ -864,7 +860,7 @@ mod extrinsics {
 					LiquidityPoolsGateway::execute_message_recovery(
 						RuntimeOrigin::root(),
 						TEST_DOMAIN_ADDRESS,
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_2
 					),
 					Error::<Runtime>::ExpectedMessageProofType
@@ -872,6 +868,290 @@ mod extrinsics {
 			});
 		}
 	}
+
+	mod initiate_message_recovery {
+		use super::*;
+
+		#[test]
+		fn success() {
+			new_test_ext().execute_with(|| {
+				let recovery_router = [1u8; 32];
+
+				Routers::<Runtime>::set(BoundedVec::try_from(vec![ROUTER_ID_1]).unwrap());
+
+				MockMessageSender::mock_send(move |mock_router_id, mock_sender, mock_message| {
+					assert_eq!(mock_router_id, ROUTER_ID_1);
+					assert_eq!(mock_sender, <Runtime as Config>::Sender::get());
+					assert_eq!(
+						mock_message,
+						Message::InitiateMessageRecovery((MESSAGE_HASH, recovery_router))
+							.serialize()
+					);
+
+					Ok(())
+				});
+
+				assert_ok!(LiquidityPoolsGateway::initiate_message_recovery(
+					RuntimeOrigin::root(),
+					TEST_DOMAIN,
+					MESSAGE_HASH,
+					recovery_router,
+					ROUTER_ID_1,
+				));
+
+				event_exists(Event::<Runtime>::MessageRecoveryInitiated {
+					domain: TEST_DOMAIN,
+					message_hash: MESSAGE_HASH,
+					recovery_router,
+					messaging_router: ROUTER_ID_1,
+				})
+			});
+		}
+
+		#[test]
+		fn bad_origin() {
+			new_test_ext().execute_with(|| {
+				let recovery_router = [1u8; 32];
+
+				assert_noop!(
+					LiquidityPoolsGateway::initiate_message_recovery(
+						RuntimeOrigin::signed(AccountId32::new([0u8; 32])),
+						TEST_DOMAIN,
+						MESSAGE_HASH,
+						recovery_router,
+						ROUTER_ID_1,
+					),
+					BadOrigin
+				);
+			});
+		}
+
+		#[test]
+		fn not_enough_routers_for_domain() {
+			new_test_ext().execute_with(|| {
+				let recovery_router = [1u8; 32];
+
+				assert_noop!(
+					LiquidityPoolsGateway::initiate_message_recovery(
+						RuntimeOrigin::root(),
+						TEST_DOMAIN,
+						MESSAGE_HASH,
+						recovery_router,
+						ROUTER_ID_1,
+					),
+					Error::<Runtime>::NotEnoughRoutersForDomain,
+				);
+			});
+		}
+
+		#[test]
+		fn messaging_router_not_found() {
+			new_test_ext().execute_with(|| {
+				let recovery_router = [1u8; 32];
+
+				Routers::<Runtime>::set(BoundedVec::try_from(vec![ROUTER_ID_1]).unwrap());
+
+				MockMessageSender::mock_send(move |mock_router_id, mock_sender, mock_message| {
+					assert_eq!(mock_router_id, ROUTER_ID_1);
+					assert_eq!(mock_sender, <Runtime as Config>::Sender::get());
+					assert_eq!(
+						mock_message,
+						Message::InitiateMessageRecovery((MESSAGE_HASH, recovery_router))
+							.serialize()
+					);
+
+					Ok(())
+				});
+
+				assert_noop!(
+					LiquidityPoolsGateway::initiate_message_recovery(
+						RuntimeOrigin::root(),
+						TEST_DOMAIN,
+						MESSAGE_HASH,
+						recovery_router,
+						RouterId(4),
+					),
+					Error::<Runtime>::MessagingRouterNotFound,
+				);
+			});
+		}
+
+		#[test]
+		fn message_sender_error() {
+			new_test_ext().execute_with(|| {
+				let recovery_router = [1u8; 32];
+
+				Routers::<Runtime>::set(BoundedVec::try_from(vec![ROUTER_ID_1]).unwrap());
+
+				let err = DispatchError::Unavailable;
+
+				MockMessageSender::mock_send(move |mock_router_id, mock_sender, mock_message| {
+					assert_eq!(mock_router_id, ROUTER_ID_1);
+					assert_eq!(mock_sender, <Runtime as Config>::Sender::get());
+					assert_eq!(
+						mock_message,
+						Message::InitiateMessageRecovery((MESSAGE_HASH, recovery_router))
+							.serialize()
+					);
+
+					Err(err)
+				});
+
+				assert_noop!(
+					LiquidityPoolsGateway::initiate_message_recovery(
+						RuntimeOrigin::root(),
+						TEST_DOMAIN,
+						MESSAGE_HASH,
+						recovery_router,
+						ROUTER_ID_1,
+					),
+					err
+				);
+			});
+		}
+	}
+
+	mod dispute_message_recovery {
+		use super::*;
+
+		#[test]
+		fn success() {
+			new_test_ext().execute_with(|| {
+				let recovery_router = [1u8; 32];
+
+				Routers::<Runtime>::set(BoundedVec::try_from(vec![ROUTER_ID_1]).unwrap());
+
+				MockMessageSender::mock_send(move |mock_router_id, mock_sender, mock_message| {
+					assert_eq!(mock_router_id, ROUTER_ID_1);
+					assert_eq!(mock_sender, <Runtime as Config>::Sender::get());
+					assert_eq!(
+						mock_message,
+						Message::DisputeMessageRecovery((MESSAGE_HASH, recovery_router))
+							.serialize()
+					);
+
+					Ok(())
+				});
+
+				assert_ok!(LiquidityPoolsGateway::dispute_message_recovery(
+					RuntimeOrigin::root(),
+					TEST_DOMAIN,
+					MESSAGE_HASH,
+					recovery_router,
+					ROUTER_ID_1,
+				));
+
+				event_exists(Event::<Runtime>::MessageRecoveryDisputed {
+					domain: TEST_DOMAIN,
+					message_hash: MESSAGE_HASH,
+					recovery_router,
+					messaging_router: ROUTER_ID_1,
+				})
+			});
+		}
+
+		#[test]
+		fn bad_origin() {
+			new_test_ext().execute_with(|| {
+				let recovery_router = [1u8; 32];
+
+				assert_noop!(
+					LiquidityPoolsGateway::dispute_message_recovery(
+						RuntimeOrigin::signed(AccountId32::new([0u8; 32])),
+						TEST_DOMAIN,
+						MESSAGE_HASH,
+						recovery_router,
+						ROUTER_ID_1,
+					),
+					BadOrigin
+				);
+			});
+		}
+
+		#[test]
+		fn not_enough_routers_for_domain() {
+			new_test_ext().execute_with(|| {
+				let recovery_router = [1u8; 32];
+
+				assert_noop!(
+					LiquidityPoolsGateway::dispute_message_recovery(
+						RuntimeOrigin::root(),
+						TEST_DOMAIN,
+						MESSAGE_HASH,
+						recovery_router,
+						ROUTER_ID_1,
+					),
+					Error::<Runtime>::NotEnoughRoutersForDomain,
+				);
+			});
+		}
+
+		#[test]
+		fn messaging_router_not_found() {
+			new_test_ext().execute_with(|| {
+				let recovery_router = [1u8; 32];
+
+				Routers::<Runtime>::set(BoundedVec::try_from(vec![ROUTER_ID_1]).unwrap());
+
+				MockMessageSender::mock_send(move |mock_router_id, mock_sender, mock_message| {
+					assert_eq!(mock_router_id, ROUTER_ID_1);
+					assert_eq!(mock_sender, <Runtime as Config>::Sender::get());
+					assert_eq!(
+						mock_message,
+						Message::DisputeMessageRecovery((MESSAGE_HASH, recovery_router))
+							.serialize()
+					);
+
+					Ok(())
+				});
+
+				assert_noop!(
+					LiquidityPoolsGateway::dispute_message_recovery(
+						RuntimeOrigin::root(),
+						TEST_DOMAIN,
+						MESSAGE_HASH,
+						recovery_router,
+						RouterId(4),
+					),
+					Error::<Runtime>::MessagingRouterNotFound,
+				);
+			});
+		}
+
+		#[test]
+		fn message_sender_error() {
+			new_test_ext().execute_with(|| {
+				let recovery_router = [1u8; 32];
+
+				Routers::<Runtime>::set(BoundedVec::try_from(vec![ROUTER_ID_1]).unwrap());
+
+				let err = DispatchError::Unavailable;
+
+				MockMessageSender::mock_send(move |mock_router_id, mock_sender, mock_message| {
+					assert_eq!(mock_router_id, ROUTER_ID_1);
+					assert_eq!(mock_sender, <Runtime as Config>::Sender::get());
+					assert_eq!(
+						mock_message,
+						Message::DisputeMessageRecovery((MESSAGE_HASH, recovery_router))
+							.serialize()
+					);
+
+					Err(err)
+				});
+
+				assert_noop!(
+					LiquidityPoolsGateway::dispute_message_recovery(
+						RuntimeOrigin::root(),
+						TEST_DOMAIN,
+						MESSAGE_HASH,
+						recovery_router,
+						ROUTER_ID_1,
+					),
+					err
+				);
+			});
+		}
+	}
 }
 
 mod implementations {
@@ -886,7 +1166,7 @@ mod implementations {
 				let domain = Domain::Evm(0);
 				let sender = get_test_account_id();
 				let msg = Message::Simple;
-				let message_proof = msg.to_proof_message().get_proof().unwrap();
+				let message_hash = msg.get_message_hash();
 
 				assert_ok!(LiquidityPoolsGateway::set_routers(
 					RuntimeOrigin::root(),
@@ -898,18 +1178,12 @@ mod implementations {
 						GatewayMessage::Inbound { .. } => {
 							assert!(false, "expected outbound message")
 						}
-						GatewayMessage::Outbound {
-							sender, message, ..
-						} => {
-							assert_eq!(sender, <Runtime as Config>::Sender::get());
-
-							match message {
-								Message::Proof(p) => {
-									assert_eq!(p, message_proof);
-								}
-								_ => {}
+						GatewayMessage::Outbound { message, .. } => match message {
+							Message::Proof(p) => {
+								assert_eq!(p, message_hash);
 							}
-						}
+							_ => {}
+						},
 					}
 
 					Ok(())
@@ -961,7 +1235,6 @@ mod implementations {
 				));
 
 				let gateway_message = GatewayMessage::Outbound {
-					sender: <Runtime as Config>::Sender::get(),
 					message: msg.clone(),
 					router_id: ROUTER_ID_1,
 				};
@@ -1036,7 +1309,7 @@ mod implementations {
 								let expected_inbound_entry = expected_storage_entry.1;
 
 								let storage_entry = PendingInboundEntries::<Runtime>::get(
-									MESSAGE_PROOF, expected_storage_entry_router_id,
+									MESSAGE_HASH, expected_storage_entry_router_id,
 								);
 								assert_eq!(storage_entry, expected_inbound_entry, "Expected inbound entry {expected_inbound_entry:?}, found {storage_entry:?}");
 							}
@@ -1143,7 +1416,7 @@ mod implementations {
 				fn success() {
 					new_test_ext().execute_with(|| {
 						let message = Message::Simple;
-						let message_proof = message.to_proof_message().get_proof().unwrap();
+						let message_hash = message.get_message_hash();
 						let session_id = 1;
 						let domain_address = DomainAddress::Evm(1, H160::repeat_byte(1));
 						let router_id = ROUTER_ID_1;
@@ -1172,7 +1445,7 @@ mod implementations {
 						assert_eq!(handler.times(), 1);
 
 						assert!(
-							PendingInboundEntries::<Runtime>::get(message_proof, router_id)
+							PendingInboundEntries::<Runtime>::get(message_hash, router_id)
 								.is_none()
 						);
 					});
@@ -1221,10 +1494,10 @@ mod implementations {
 				}
 
 				#[test]
-				fn expected_message_proof_type() {
+				fn expected_message_hash_type() {
 					new_test_ext().execute_with(|| {
 						let message = Message::Simple;
-						let message_proof = message.to_proof_message().get_proof().unwrap();
+						let message_hash = message.get_message_hash();
 						let session_id = 1;
 						let domain_address = DomainAddress::Evm(1, H160::repeat_byte(1));
 						let router_id = ROUTER_ID_1;
@@ -1239,7 +1512,7 @@ mod implementations {
 						);
 						SessionIdStore::<Runtime>::set(session_id);
 						PendingInboundEntries::<Runtime>::insert(
-							message_proof,
+							message_hash,
 							router_id,
 							InboundEntry::Proof(ProofEntry {
 								session_id,
@@ -1262,7 +1535,7 @@ mod implementations {
 					lazy_static! {
 						static ref TEST_DATA: Vec<RouterMessage> = vec![
 							(ROUTER_ID_1, Message::Simple),
-							(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+							(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 						];
 					}
 
@@ -1301,8 +1574,8 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 0,
@@ -1324,7 +1597,7 @@ mod implementations {
 									(
 										vec![
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 1,
@@ -1336,7 +1609,7 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 										],
 										ExpectedTestResult {
@@ -1396,9 +1669,9 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 0,
@@ -1421,7 +1694,7 @@ mod implementations {
 										vec![
 											(ROUTER_ID_1, Message::Simple),
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 1,
@@ -1445,7 +1718,7 @@ mod implementations {
 									(
 										vec![
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 										],
 										ExpectedTestResult {
@@ -1470,8 +1743,8 @@ mod implementations {
 									(
 										vec![
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 1,
@@ -1492,7 +1765,7 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 											(ROUTER_ID_1, Message::Simple),
 										],
@@ -1517,9 +1790,9 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 1,
@@ -1540,8 +1813,8 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 										],
 										ExpectedTestResult {
@@ -1611,10 +1884,10 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 0,
@@ -1638,7 +1911,7 @@ mod implementations {
 											(ROUTER_ID_1, Message::Simple),
 											(ROUTER_ID_1, Message::Simple),
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 1,
@@ -1663,7 +1936,7 @@ mod implementations {
 										vec![
 											(ROUTER_ID_1, Message::Simple),
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 										],
 										ExpectedTestResult {
@@ -1688,7 +1961,7 @@ mod implementations {
 									(
 										vec![
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 											(ROUTER_ID_1, Message::Simple),
 										],
@@ -1713,7 +1986,7 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 											(ROUTER_ID_1, Message::Simple),
 											(ROUTER_ID_1, Message::Simple),
@@ -1741,8 +2014,8 @@ mod implementations {
 										vec![
 											(ROUTER_ID_1, Message::Simple),
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 2,
@@ -1754,10 +2027,10 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 2,
@@ -1769,9 +2042,9 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 										],
 										ExpectedTestResult {
@@ -1785,9 +2058,9 @@ mod implementations {
 									(
 										vec![
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 2,
@@ -1800,8 +2073,8 @@ mod implementations {
 									(
 										vec![
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 										],
 										ExpectedTestResult {
@@ -1814,8 +2087,8 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 											(ROUTER_ID_1, Message::Simple),
 										],
@@ -1830,9 +2103,9 @@ mod implementations {
 									(
 										vec![
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 1,
@@ -1853,10 +2126,10 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 1,
@@ -1877,10 +2150,10 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										],
 										ExpectedTestResult {
 											message_submitted_times: 1,
@@ -1901,9 +2174,9 @@ mod implementations {
 									),
 									(
 										vec![
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-											(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+											(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 											(ROUTER_ID_1, Message::Simple),
 										],
 										ExpectedTestResult {
@@ -1975,7 +2248,7 @@ mod implementations {
 
 							let gateway_message = GatewayMessage::Inbound {
 								domain_address: TEST_DOMAIN_ADDRESS,
-								message: Message::Proof(MESSAGE_PROOF),
+								message: Message::Proof(MESSAGE_HASH),
 								router_id: ROUTER_ID_1,
 							};
 
@@ -1992,8 +2265,8 @@ mod implementations {
 				lazy_static! {
 					static ref TEST_DATA: Vec<RouterMessage> = vec![
 						(ROUTER_ID_1, Message::Simple),
-						(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-						(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+						(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+						(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 					];
 				}
 
@@ -2033,8 +2306,8 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2056,8 +2329,8 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2079,8 +2352,8 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2111,8 +2384,8 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2144,7 +2417,7 @@ mod implementations {
 								(
 									vec![
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2178,7 +2451,7 @@ mod implementations {
 								(
 									vec![
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2211,7 +2484,7 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
 									],
 									ExpectedTestResult {
@@ -2245,7 +2518,7 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
 									],
 									ExpectedTestResult {
@@ -2280,7 +2553,7 @@ mod implementations {
 								(
 									vec![
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2361,9 +2634,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2385,9 +2658,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2411,7 +2684,7 @@ mod implementations {
 									vec![
 										(ROUTER_ID_1, Message::Simple),
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2445,7 +2718,7 @@ mod implementations {
 								(
 									vec![
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
 									],
 									ExpectedTestResult {
@@ -2480,8 +2753,8 @@ mod implementations {
 								(
 									vec![
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2515,8 +2788,8 @@ mod implementations {
 								(
 									vec![
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2549,9 +2822,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2584,8 +2857,8 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
 									],
 									ExpectedTestResult {
@@ -2619,9 +2892,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2654,8 +2927,8 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
 									],
 									ExpectedTestResult {
@@ -2691,7 +2964,7 @@ mod implementations {
 									vec![
 										(ROUTER_ID_1, Message::Simple),
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2724,7 +2997,7 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
 										(ROUTER_ID_1, Message::Simple),
 									],
@@ -2760,7 +3033,7 @@ mod implementations {
 								(
 									vec![
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
 									],
 									ExpectedTestResult {
@@ -2794,7 +3067,7 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
 										(ROUTER_ID_1, Message::Simple),
 									],
@@ -2830,8 +3103,8 @@ mod implementations {
 								(
 									vec![
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 1,
@@ -2844,8 +3117,8 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
 									],
 									ExpectedTestResult {
@@ -2860,8 +3133,8 @@ mod implementations {
 								(
 									vec![
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 1,
@@ -2874,9 +3147,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 1,
@@ -2889,8 +3162,8 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
 									],
 									ExpectedTestResult {
@@ -2904,9 +3177,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 										(ROUTER_ID_1, Message::Simple),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 1,
@@ -2919,9 +3192,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2952,9 +3225,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -2985,9 +3258,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -3018,9 +3291,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -3051,9 +3324,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -3084,9 +3357,9 @@ mod implementations {
 								),
 								(
 									vec![
-										(ROUTER_ID_2, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
-										(ROUTER_ID_3, Message::Proof(MESSAGE_PROOF)),
+										(ROUTER_ID_2, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
+										(ROUTER_ID_3, Message::Proof(MESSAGE_HASH)),
 									],
 									ExpectedTestResult {
 										message_submitted_times: 0,
@@ -3167,11 +3440,9 @@ mod implementations {
 			#[test]
 			fn success() {
 				new_test_ext().execute_with(|| {
-					let sender = TEST_DOMAIN_ADDRESS;
 					let message = Message::Simple;
 
 					let gateway_message = GatewayMessage::Outbound {
-						sender: sender.clone(),
 						message: message.clone(),
 						router_id: ROUTER_ID_1,
 					};
@@ -3179,7 +3450,7 @@ mod implementations {
 					let handler = MockMessageSender::mock_send(
 						move |mock_router_id, mock_sender, mock_message| {
 							assert_eq!(mock_router_id, ROUTER_ID_1);
-							assert_eq!(mock_sender, sender);
+							assert_eq!(mock_sender, <Runtime as Config>::Sender::get());
 							assert_eq!(mock_message, message.serialize());
 
 							Ok(())
@@ -3196,11 +3467,9 @@ mod implementations {
 			#[test]
 			fn message_sender_error() {
 				new_test_ext().execute_with(|| {
-					let sender = TEST_DOMAIN_ADDRESS;
 					let message = Message::Simple;
 
 					let gateway_message = GatewayMessage::Outbound {
-						sender: sender.clone(),
 						message: message.clone(),
 						router_id: ROUTER_ID_1,
 					};
@@ -3210,7 +3479,7 @@ mod implementations {
 					MockMessageSender::mock_send(
 						move |mock_router_id, mock_sender, mock_message| {
 							assert_eq!(mock_router_id, ROUTER_ID_1);
-							assert_eq!(mock_sender, sender);
+							assert_eq!(mock_sender, <Runtime as Config>::Sender::get());
 							assert_eq!(mock_message, message.serialize());
 
 							Err(router_err)
@@ -3325,7 +3594,7 @@ mod implementations {
 							.into(),
 						),
 						(
-							Message::Proof(MESSAGE_PROOF),
+							Message::Proof(MESSAGE_HASH),
 							ProofEntry {
 								session_id,
 								current_count: 1,
@@ -3381,13 +3650,13 @@ mod implementations {
 
 					for (test_router_id, test_inbound_entry) in tests {
 						assert_ok!(LiquidityPoolsGateway::upsert_pending_entry(
-							MESSAGE_PROOF,
+							MESSAGE_HASH,
 							&test_router_id.clone(),
 							test_inbound_entry.clone(),
 						));
 
 						let res =
-							PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, test_router_id)
+							PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, test_router_id)
 								.unwrap();
 
 						assert_eq!(res, test_inbound_entry);
@@ -3407,19 +3676,19 @@ mod implementations {
 					.into();
 
 					PendingInboundEntries::<Runtime>::insert(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_1,
 						inbound_entry.clone(),
 					);
 
 					assert_ok!(LiquidityPoolsGateway::upsert_pending_entry(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						&ROUTER_ID_1,
 						inbound_entry,
 					));
 
 					let res =
-						PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_1).unwrap();
+						PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_1).unwrap();
 					assert_eq!(
 						res,
 						MessageEntry {
@@ -3437,7 +3706,7 @@ mod implementations {
 			fn message_entry_new_session() {
 				new_test_ext().execute_with(|| {
 					PendingInboundEntries::<Runtime>::insert(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_1,
 						InboundEntry::Message(MessageEntry {
 							session_id: 1,
@@ -3448,7 +3717,7 @@ mod implementations {
 					);
 
 					assert_ok!(LiquidityPoolsGateway::upsert_pending_entry(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						&ROUTER_ID_1,
 						MessageEntry {
 							session_id: 2,
@@ -3460,7 +3729,7 @@ mod implementations {
 					));
 
 					let res =
-						PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_1).unwrap();
+						PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_1).unwrap();
 					assert_eq!(
 						res,
 						MessageEntry {
@@ -3486,14 +3755,14 @@ mod implementations {
 					.into();
 
 					PendingInboundEntries::<Runtime>::insert(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_1,
 						inbound_entry.clone(),
 					);
 
 					assert_noop!(
 						LiquidityPoolsGateway::upsert_pending_entry(
-							MESSAGE_PROOF,
+							MESSAGE_HASH,
 							&ROUTER_ID_1,
 							InboundEntry::Proof(ProofEntry {
 								session_id: 1,
@@ -3515,19 +3784,19 @@ mod implementations {
 					.into();
 
 					PendingInboundEntries::<Runtime>::insert(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_1,
 						inbound_entry.clone(),
 					);
 
 					assert_ok!(LiquidityPoolsGateway::upsert_pending_entry(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						&ROUTER_ID_1,
 						inbound_entry,
 					));
 
 					let res =
-						PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_1).unwrap();
+						PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_1).unwrap();
 					assert_eq!(
 						res,
 						ProofEntry {
@@ -3543,7 +3812,7 @@ mod implementations {
 			fn proof_entry_new_session() {
 				new_test_ext().execute_with(|| {
 					PendingInboundEntries::<Runtime>::insert(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_1,
 						InboundEntry::Proof(ProofEntry {
 							session_id: 1,
@@ -3552,7 +3821,7 @@ mod implementations {
 					);
 
 					assert_ok!(LiquidityPoolsGateway::upsert_pending_entry(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						&ROUTER_ID_1,
 						ProofEntry {
 							session_id: 2,
@@ -3562,7 +3831,7 @@ mod implementations {
 					));
 
 					let res =
-						PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_1).unwrap();
+						PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_1).unwrap();
 					assert_eq!(
 						res,
 						ProofEntry {
@@ -3575,7 +3844,7 @@ mod implementations {
 			}
 
 			#[test]
-			fn expected_message_proof_type() {
+			fn expected_message_hash_type() {
 				new_test_ext().execute_with(|| {
 					let inbound_entry: InboundEntry<Runtime> = ProofEntry {
 						session_id: 1,
@@ -3584,14 +3853,14 @@ mod implementations {
 					.into();
 
 					PendingInboundEntries::<Runtime>::insert(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_1,
 						inbound_entry.clone(),
 					);
 
 					assert_noop!(
 						LiquidityPoolsGateway::upsert_pending_entry(
-							MESSAGE_PROOF,
+							MESSAGE_HASH,
 							&ROUTER_ID_1,
 							InboundEntry::Message(MessageEntry {
 								session_id: 1,
@@ -3618,7 +3887,7 @@ mod implementations {
 					let expected_proof_count = 2;
 
 					PendingInboundEntries::<Runtime>::insert(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_1,
 						InboundEntry::Message(MessageEntry {
 							session_id: 1,
@@ -3628,7 +3897,7 @@ mod implementations {
 						}),
 					);
 					PendingInboundEntries::<Runtime>::insert(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_2,
 						InboundEntry::Proof(ProofEntry {
 							session_id: 2,
@@ -3636,7 +3905,7 @@ mod implementations {
 						}),
 					);
 					PendingInboundEntries::<Runtime>::insert(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						ROUTER_ID_3,
 						InboundEntry::Proof(ProofEntry {
 							session_id: 3,
@@ -3645,20 +3914,20 @@ mod implementations {
 					);
 
 					assert_ok!(LiquidityPoolsGateway::execute_if_requirements_are_met(
-						MESSAGE_PROOF,
+						MESSAGE_HASH,
 						&router_ids,
 						session_id,
 						expected_proof_count,
 						domain_address,
 					));
 					assert!(
-						PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_1).is_some()
+						PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_1).is_some()
 					);
 					assert!(
-						PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_2).is_some()
+						PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_2).is_some()
 					);
 					assert!(
-						PendingInboundEntries::<Runtime>::get(MESSAGE_PROOF, ROUTER_ID_3).is_some()
+						PendingInboundEntries::<Runtime>::get(MESSAGE_HASH, ROUTER_ID_3).is_some()
 					);
 				});
 			}
@@ -3675,7 +3944,7 @@ mod implementations {
 
 					assert_noop!(
 						LiquidityPoolsGateway::execute_post_voting_dispatch(
-							MESSAGE_PROOF,
+							MESSAGE_HASH,
 							&router_ids,
 							expected_proof_count,
 						),
@@ -3952,7 +4221,7 @@ mod inbound_entry {
 		}
 
 		#[test]
-		fn expected_message_proof_type() {
+		fn expected_message_hash_type() {
 			new_test_ext().execute_with(|| {
 				let mut inbound_entry = InboundEntry::<Runtime>::Message(MessageEntry {
 					session_id: 1,
diff --git a/pallets/liquidity-pools-gateway/src/weights.rs b/pallets/liquidity-pools-gateway/src/weights.rs
index b330d71ac6..a06926a7ba 100644
--- a/pallets/liquidity-pools-gateway/src/weights.rs
+++ b/pallets/liquidity-pools-gateway/src/weights.rs
@@ -23,6 +23,8 @@ pub trait WeightInfo {
 	fn end_batch_message() -> Weight;
 	fn set_domain_hook_address() -> Weight;
 	fn execute_message_recovery() -> Weight;
+	fn initiate_message_recovery() -> Weight;
+	fn dispute_message_recovery() -> Weight;
 }
 
 // NOTE: We use temporary weights here. `execute_epoch` is by far our heaviest
@@ -146,4 +148,26 @@ impl WeightInfo for () {
 			.saturating_add(RocksDbWeight::get().reads(2))
 			.saturating_add(RocksDbWeight::get().writes(2))
 	}
+
+	fn initiate_message_recovery() -> Weight {
+		// TODO: BENCHMARK CORRECTLY
+		//
+		// NOTE: Reasonable weight taken from `PoolSystem::set_max_reserve`
+		//       This one has one read and one write for sure and possible one
+		//       read for `AdminOrigin`
+		Weight::from_parts(30_117_000, 5991)
+			.saturating_add(RocksDbWeight::get().reads(2))
+			.saturating_add(RocksDbWeight::get().writes(2))
+	}
+
+	fn dispute_message_recovery() -> Weight {
+		// TODO: BENCHMARK CORRECTLY
+		//
+		// NOTE: Reasonable weight taken from `PoolSystem::set_max_reserve`
+		//       This one has one read and one write for sure and possible one
+		//       read for `AdminOrigin`
+		Weight::from_parts(30_117_000, 5991)
+			.saturating_add(RocksDbWeight::get().reads(2))
+			.saturating_add(RocksDbWeight::get().writes(2))
+	}
 }
diff --git a/pallets/liquidity-pools/src/message.rs b/pallets/liquidity-pools/src/message.rs
index 8a191a631c..1b52ca3e23 100644
--- a/pallets/liquidity-pools/src/message.rs
+++ b/pallets/liquidity-pools/src/message.rs
@@ -6,7 +6,7 @@
 //! representation for each message variant.
 
 use cfg_traits::{
-	liquidity_pools::{LPEncoding, Proof},
+	liquidity_pools::{LPMessage, MessageHash},
 	Seconds,
 };
 use cfg_types::domain_address::Domain;
@@ -212,7 +212,7 @@ pub enum Message<BatchContent = BatchMessages> {
 	// --- Gateway ---
 	/// Proof a message has been executed.
 	///
-	/// Directionality: Centrifuge -> EVM Domain.
+	/// Directionality: Centrifuge <-> EVM Domain.
 	MessageProof {
 		// Hash of the message for which the proof is provided
 		hash: [u8; 32],
@@ -226,7 +226,7 @@ pub enum Message<BatchContent = BatchMessages> {
 		/// The hash of the message which shall be recovered
 		hash: [u8; 32],
 		/// The address of the router
-		address: Address,
+		router: [u8; 32],
 	},
 	/// Dispute the recovery of a message.
 	///
@@ -235,7 +235,7 @@ pub enum Message<BatchContent = BatchMessages> {
 	/// Directionality: Centrifuge -> EVM Domain.
 	DisputeMessageRecovery {
 		/// The hash of the message which shall be disputed
-		message: [u8; 32],
+		hash: [u8; 32],
 		/// The address of the router
 		router: [u8; 32],
 	},
@@ -532,7 +532,7 @@ pub enum Message<BatchContent = BatchMessages> {
 	},
 }
 
-impl LPEncoding for Message {
+impl LPMessage for Message {
 	fn serialize(&self) -> Vec<u8> {
 		gmpf::to_vec(self).unwrap_or_default()
 	}
@@ -562,17 +562,26 @@ impl LPEncoding for Message {
 		Message::Batch(BatchMessages::default())
 	}
 
-	fn get_proof(&self) -> Option<Proof> {
-		match self {
-			Message::MessageProof { hash } => Some(*hash),
-			_ => None,
-		}
+	fn is_proof_message(&self) -> bool {
+		matches!(self, Message::MessageProof { .. })
+	}
+
+	fn get_message_hash(&self) -> MessageHash {
+		keccak_256(&LPMessage::serialize(self))
 	}
 
 	fn to_proof_message(&self) -> Self {
-		let hash = keccak_256(&LPEncoding::serialize(self));
+		Message::MessageProof {
+			hash: self.get_message_hash(),
+		}
+	}
+
+	fn initiate_recovery_message(hash: [u8; 32], router: [u8; 32]) -> Self {
+		Message::InitiateMessageRecovery { hash, router }
+	}
 
-		Message::MessageProof { hash }
+	fn dispute_recovery_message(hash: [u8; 32], router: [u8; 32]) -> Self {
+		Message::DisputeMessageRecovery { hash, router }
 	}
 }
 
diff --git a/runtime/integration-tests/src/cases/liquidity_pools.rs b/runtime/integration-tests/src/cases/liquidity_pools.rs
index 604d382670..328bb305e4 100644
--- a/runtime/integration-tests/src/cases/liquidity_pools.rs
+++ b/runtime/integration-tests/src/cases/liquidity_pools.rs
@@ -1026,15 +1026,12 @@ mod foreign_investments {
 
 				let nonce = MessageNonceStore::<T>::get();
 
-				let sender = T::Sender::get();
-
 				// Clearing of foreign InvestState should be dispatched
 				assert!(frame_system::Pallet::<T>::events().iter().any(|e| {
 					e.event
 						== pallet_liquidity_pools_gateway_queue::Event::MessageSubmitted {
 							nonce,
 							message: GatewayMessage::Outbound {
-								sender: sender.clone(),
 								router_id: DEFAULT_ROUTER_ID,
 								message: LiquidityPoolMessage::FulfilledDepositRequest {
 									pool_id,
@@ -1130,14 +1127,11 @@ mod foreign_investments {
 
 				let nonce = MessageNonceStore::<T>::get();
 
-				let sender = T::Sender::get();
-
 				assert!(frame_system::Pallet::<T>::events().iter().any(|e| {
 					e.event
 						== pallet_liquidity_pools_gateway_queue::Event::<T>::MessageSubmitted {
 							nonce,
 							message: GatewayMessage::Outbound {
-								sender: sender.clone(),
 								router_id: DEFAULT_ROUTER_ID,
 								message: Message::FulfilledDepositRequest {
 									pool_id,
@@ -1230,7 +1224,6 @@ mod foreign_investments {
 						== pallet_liquidity_pools_gateway_queue::Event::<T>::MessageSubmitted {
 							nonce,
 							message: GatewayMessage::Outbound {
-								sender: sender.clone(),
 								router_id: DEFAULT_ROUTER_ID,
 								message: LiquidityPoolMessage::FulfilledDepositRequest {
 									pool_id,
@@ -1265,12 +1258,11 @@ mod foreign_investments {
 								pallet_liquidity_pools_gateway_queue::Event::MessageSubmitted {
 									message:
 										GatewayMessage::Outbound {
-											sender: event_sender,
 											router_id: event_router_id,
 											message: Message::FulfilledDepositRequest { .. },
 										},
 									..
-								} => event_sender == sender && event_router_id == DEFAULT_ROUTER_ID,
+								} => event_router_id == DEFAULT_ROUTER_ID,
 								_ => false,
 							}
 						} else {
@@ -1502,14 +1494,11 @@ mod foreign_investments {
 
 				let nonce = MessageNonceStore::<T>::get();
 
-				let sender = T::Sender::get();
-
 				assert!(frame_system::Pallet::<T>::events().iter().any(|e| {
 					e.event
 						== pallet_liquidity_pools_gateway_queue::Event::<T>::MessageSubmitted {
 							nonce,
 							message: GatewayMessage::Outbound {
-								sender: sender.clone(),
 								router_id: DEFAULT_ROUTER_ID,
 								message: LiquidityPoolMessage::FulfilledRedeemRequest {
 									pool_id,
@@ -1599,7 +1588,6 @@ mod foreign_investments {
 						== pallet_liquidity_pools_gateway_queue::Event::<T>::MessageSubmitted {
 							nonce,
 							message: GatewayMessage::Outbound {
-								sender: sender.clone(),
 								router_id: DEFAULT_ROUTER_ID,
 								message: LiquidityPoolMessage::FulfilledRedeemRequest {
 									pool_id,
@@ -1940,14 +1928,11 @@ mod foreign_investments {
 
 				let nonce = MessageNonceStore::<T>::get();
 
-				let sender = T::Sender::get();
-
 				assert!(frame_system::Pallet::<T>::events().iter().any(|e| {
 					e.event
 						== pallet_liquidity_pools_gateway_queue::Event::<T>::MessageSubmitted {
 							nonce,
 							message: GatewayMessage::Outbound {
-								sender: sender.clone(),
 								router_id: DEFAULT_ROUTER_ID,
 								message: LiquidityPoolMessage::FulfilledDepositRequest {
 									pool_id,
@@ -2091,14 +2076,11 @@ mod foreign_investments {
 
 				let nonce = MessageNonceStore::<T>::get();
 
-				let sender = <T as pallet_liquidity_pools_gateway::Config>::Sender::get();
-
 				assert!(frame_system::Pallet::<T>::events().iter().any(|e| {
 					e.event
 						== pallet_liquidity_pools_gateway_queue::Event::<T>::MessageSubmitted {
 							nonce,
 							message: GatewayMessage::Outbound {
-								sender: sender.clone(),
 								router_id: DEFAULT_ROUTER_ID,
 								message: LiquidityPoolMessage::FulfilledCancelDepositRequest {
 									pool_id,
@@ -2202,14 +2184,11 @@ mod foreign_investments {
 
 				let nonce = MessageNonceStore::<T>::get();
 
-				let sender = <T as pallet_liquidity_pools_gateway::Config>::Sender::get();
-
 				assert!(frame_system::Pallet::<T>::events().iter().any(|e| {
 					e.event
 						== pallet_liquidity_pools_gateway_queue::Event::<T>::MessageSubmitted {
 							nonce,
 							message: GatewayMessage::Outbound {
-								sender: sender.clone(),
 								router_id: DEFAULT_ROUTER_ID,
 								message: LiquidityPoolMessage::FulfilledCancelDepositRequest {
 									pool_id,
diff --git a/runtime/integration-tests/src/cases/liquidity_pools_gateway_queue.rs b/runtime/integration-tests/src/cases/liquidity_pools_gateway_queue.rs
index 7699fb7052..85573a4581 100644
--- a/runtime/integration-tests/src/cases/liquidity_pools_gateway_queue.rs
+++ b/runtime/integration-tests/src/cases/liquidity_pools_gateway_queue.rs
@@ -1,4 +1,3 @@
-use cfg_primitives::AccountId;
 use cfg_traits::liquidity_pools::MessageQueue;
 use cfg_types::domain_address::DomainAddress;
 use frame_support::{assert_ok, traits::OriginTrait};
@@ -72,7 +71,6 @@ fn outbound<T: Runtime + FudgeSupport>() {
 
 		let nonce = <T as pallet_liquidity_pools_gateway_queue::Config>::MessageNonce::one();
 		let message = GatewayMessage::Outbound {
-			sender: DomainAddress::Centrifuge(AccountId::new([1; 32])),
 			router_id: DEFAULT_ROUTER_ID,
 			message: Message::Invalid,
 		};
diff --git a/runtime/integration-tests/src/cases/lp/utils.rs b/runtime/integration-tests/src/cases/lp/utils.rs
index 8188118c1b..c7d5c72121 100644
--- a/runtime/integration-tests/src/cases/lp/utils.rs
+++ b/runtime/integration-tests/src/cases/lp/utils.rs
@@ -139,15 +139,7 @@ pub fn process_gateway_message<T: Runtime>(
 
 		match msg {
 			GatewayMessage::Inbound { message, .. } => verifier(message),
-			GatewayMessage::Outbound {
-				sender,
-				router_id,
-				message,
-			} => {
-				assert_eq!(
-					sender,
-					<T as pallet_liquidity_pools_gateway::Config>::Sender::get()
-				);
+			GatewayMessage::Outbound { router_id, message } => {
 				assert_eq!(router_id, EVM_ROUTER_ID);
 				verifier(message)
 			}
diff --git a/runtime/integration-tests/src/cases/routers.rs b/runtime/integration-tests/src/cases/routers.rs
index 66a8f21c56..9394b18b1b 100644
--- a/runtime/integration-tests/src/cases/routers.rs
+++ b/runtime/integration-tests/src/cases/routers.rs
@@ -1,5 +1,5 @@
 use cfg_primitives::Balance;
-use cfg_traits::liquidity_pools::{LPEncoding, MessageProcessor};
+use cfg_traits::liquidity_pools::{LPMessage, MessageProcessor};
 use cfg_types::{
 	domain_address::{Domain, DomainAddress},
 	EVMChainId,
@@ -14,7 +14,7 @@ use runtime_common::{
 	account_conversion::AccountConverter, evm::precompile::LP_AXELAR_GATEWAY,
 	gateway::get_gateway_domain_address, routing::RouterId,
 };
-use sp_core::{Get, H160, H256, U256};
+use sp_core::{H160, H256, U256};
 use sp_runtime::traits::{BlakeTwo256, Hash};
 
 use crate::{
@@ -139,7 +139,6 @@ mod axelar_evm {
 			));
 
 			let gateway_message = GatewayMessage::Outbound {
-				sender: T::Sender::get(),
 				router_id: TEST_ROUTER_ID,
 				message: Message::Invalid,
 			};