Merge commit '392447f5c8f986ded2559a78457f4cd87942f393' into update-bridges-subtree-r/w

2026-05-31 09:51:02 +00:00 · 2021-12-01 09:46:14 +01:00
parent e16f71b7b6 392447f5c8
commit 5228731ae8
321 changed files with 28385 additions and 10466 deletions
@@ -22,123 +22,139 @@
 //! a successful dispatch an event is emitted.

 #![cfg_attr(not(feature = "std"), no_std)]
-#![warn(missing_docs)]
 // Generated by `decl_event!`
 #![allow(clippy::unused_unit)]

-use bp_message_dispatch::{CallOrigin, MessageDispatch, MessagePayload, SpecVersion, Weight};
+use bp_message_dispatch::{CallOrigin, MessageDispatch, MessagePayload, SpecVersion};
 use bp_runtime::{
 	derive_account_id,
 	messages::{DispatchFeePayment, MessageDispatchResult},
 	ChainId, SourceAccount,
 };
-use codec::{Decode, Encode};
+use codec::Encode;
 use frame_support::{
-	decl_event, decl_module, decl_storage,
-	dispatch::{Dispatchable, Parameter},
+	dispatch::Dispatchable,
 	ensure,
 	traits::{Contains, Get},
 	weights::{extract_actual_weight, GetDispatchInfo},
 };
 use frame_system::RawOrigin;
-use sp_runtime::{
-	traits::{BadOrigin, Convert, IdentifyAccount, MaybeDisplay, MaybeSerializeDeserialize, Member, Verify},
-	DispatchResult,
-};
-use sp_std::{fmt::Debug, marker::PhantomData, prelude::*};
+use sp_runtime::traits::{BadOrigin, Convert, IdentifyAccount, MaybeDisplay, Verify};
+use sp_std::{fmt::Debug, prelude::*};

-/// The module configuration trait.
-pub trait Config<I = DefaultInstance>: frame_system::Config {
-	/// The overarching event type.
-	type Event: From<Event<Self, I>> + Into<<Self as frame_system::Config>::Event>;
-	/// Id of the message. Whenever message is passed to the dispatch module, it emits
-	/// event with this id + dispatch result. Could be e.g. (`LaneId`, `MessageNonce`) if
-	/// it comes from the messages module.
-	type MessageId: Parameter;
-	/// Type of account ID on source chain.
-	type SourceChainAccountId: Parameter + Member + MaybeSerializeDeserialize + Debug + MaybeDisplay + Ord + Default;
-	/// Type of account public key on target chain.
-	type TargetChainAccountPublic: Parameter + IdentifyAccount<AccountId = Self::AccountId>;
-	/// Type of signature that may prove that the message has been signed by
-	/// owner of `TargetChainAccountPublic`.
-	type TargetChainSignature: Parameter + Verify<Signer = Self::TargetChainAccountPublic>;
-	/// The overarching dispatch call type.
-	type Call: Parameter
-		+ GetDispatchInfo
-		+ Dispatchable<
-			Origin = <Self as frame_system::Config>::Origin,
-			PostInfo = frame_support::dispatch::PostDispatchInfo,
-		>;
-	/// Pre-dispatch filter for incoming calls.
-	///
-	/// The pallet will filter all incoming calls right before they're dispatched. If this filter
-	/// rejects the call, special event (`Event::MessageCallRejected`) is emitted.
-	type CallFilter: Contains<<Self as Config<I>>::Call>;
-	/// The type that is used to wrap the `Self::Call` when it is moved over bridge.
-	///
-	/// The idea behind this is to avoid `Call` conversion/decoding until we'll be sure
-	/// that all other stuff (like `spec_version`) is OK. If we would try to decode
-	/// `Call` which has been encoded using previous `spec_version`, then we might end
-	/// up with decoding error, instead of `MessageVersionSpecMismatch`.
-	type EncodedCall: Decode + Encode + Into<Result<<Self as Config<I>>::Call, ()>>;
-	/// A type which can be turned into an `AccountId` from a 256-bit hash.
-	///
-	/// Used when deriving target chain `AccountId`s from source chain `AccountId`s.
-	type AccountIdConverter: sp_runtime::traits::Convert<sp_core::hash::H256, Self::AccountId>;
-}
+pub use pallet::*;

-decl_storage! {
-	trait Store for Pallet<T: Config<I>, I: Instance = DefaultInstance> as Dispatch {}
-}
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;

-decl_event!(
-	pub enum Event<T, I = DefaultInstance> where
-		<T as Config<I>>::MessageId,
-		AccountId = <T as frame_system::Config>::AccountId,
-	{
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The overarching event type.
+		type Event: From<Event<Self, I>> + IsType<<Self as frame_system::Config>::Event>;
+		/// Id of the message. Whenever message is passed to the dispatch module, it emits
+		/// event with this id + dispatch result. Could be e.g. (LaneId, MessageNonce) if
+		/// it comes from the messages module.
+		type BridgeMessageId: Parameter;
+		/// Type of account ID on source chain.
+		type SourceChainAccountId: Parameter
+			+ Member
+			+ MaybeSerializeDeserialize
+			+ Debug
+			+ MaybeDisplay
+			+ Ord
+			+ Default;
+		/// Type of account public key on target chain.
+		type TargetChainAccountPublic: Parameter + IdentifyAccount<AccountId = Self::AccountId>;
+		/// Type of signature that may prove that the message has been signed by
+		/// owner of `TargetChainAccountPublic`.
+		type TargetChainSignature: Parameter + Verify<Signer = Self::TargetChainAccountPublic>;
+		/// The overarching dispatch call type.
+		type Call: Parameter
+			+ GetDispatchInfo
+			+ Dispatchable<
+				Origin = <Self as frame_system::Config>::Origin,
+				PostInfo = frame_support::dispatch::PostDispatchInfo,
+			>;
+		/// Pre-dispatch filter for incoming calls.
+		///
+		/// The pallet will filter all incoming calls right before they're dispatched. If this
+		/// filter rejects the call, special event (`Event::MessageCallRejected`) is emitted.
+		type CallFilter: Contains<<Self as Config<I>>::Call>;
+		/// The type that is used to wrap the `Self::Call` when it is moved over bridge.
+		///
+		/// The idea behind this is to avoid `Call` conversion/decoding until we'll be sure
+		/// that all other stuff (like `spec_version`) is ok. If we would try to decode
+		/// `Call` which has been encoded using previous `spec_version`, then we might end
+		/// up with decoding error, instead of `MessageVersionSpecMismatch`.
+		type EncodedCall: Decode + Encode + Into<Result<<Self as Config<I>>::Call, ()>>;
+		/// A type which can be turned into an AccountId from a 256-bit hash.
+		///
+		/// Used when deriving target chain AccountIds from source chain AccountIds.
+		type AccountIdConverter: sp_runtime::traits::Convert<sp_core::hash::H256, Self::AccountId>;
+	}
+
+	type BridgeMessageIdOf<T, I> = <T as Config<I>>::BridgeMessageId;
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
 		/// Message has been rejected before reaching dispatch.
-		MessageRejected(ChainId, MessageId),
+		MessageRejected(ChainId, BridgeMessageIdOf<T, I>),
 		/// Message has been rejected by dispatcher because of spec version mismatch.
 		/// Last two arguments are: expected and passed spec version.
-		MessageVersionSpecMismatch(ChainId, MessageId, SpecVersion, SpecVersion),
+		MessageVersionSpecMismatch(ChainId, BridgeMessageIdOf<T, I>, SpecVersion, SpecVersion),
 		/// Message has been rejected by dispatcher because of weight mismatch.
 		/// Last two arguments are: expected and passed call weight.
-		MessageWeightMismatch(ChainId, MessageId, Weight, Weight),
+		MessageWeightMismatch(ChainId, BridgeMessageIdOf<T, I>, Weight, Weight),
 		/// Message signature mismatch.
-		MessageSignatureMismatch(ChainId, MessageId),
+		MessageSignatureMismatch(ChainId, BridgeMessageIdOf<T, I>),
 		/// We have failed to decode Call from the message.
-		MessageCallDecodeFailed(ChainId, MessageId),
+		MessageCallDecodeFailed(ChainId, BridgeMessageIdOf<T, I>),
 		/// The call from the message has been rejected by the call filter.
-		MessageCallRejected(ChainId, MessageId),
+		MessageCallRejected(ChainId, BridgeMessageIdOf<T, I>),
 		/// The origin account has failed to pay fee for dispatching the message.
-		MessageDispatchPaymentFailed(ChainId, MessageId, AccountId, Weight),
+		MessageDispatchPaymentFailed(
+			ChainId,
+			BridgeMessageIdOf<T, I>,
+			<T as frame_system::Config>::AccountId,
+			Weight,
+		),
 		/// Message has been dispatched with given result.
-		MessageDispatched(ChainId, MessageId, DispatchResult),
+		MessageDispatched(ChainId, BridgeMessageIdOf<T, I>, DispatchResult),
 		/// Phantom member, never used. Needed to handle multiple pallet instances.
 		_Dummy(PhantomData<I>),
 	}
-);
-
-decl_module! {
-	/// Call Dispatch FRAME Pallet.
-	pub struct Module<T: Config<I>, I: Instance = DefaultInstance> for enum Call where origin: T::Origin {
-		/// Deposit one of this module's events by using the default implementation.
-		fn deposit_event() = default;
-	}
 }

-impl<T: Config<I>, I: Instance> MessageDispatch<T::AccountId, T::MessageId> for Pallet<T, I> {
-	type Message =
-		MessagePayload<T::SourceChainAccountId, T::TargetChainAccountPublic, T::TargetChainSignature, T::EncodedCall>;
+impl<T: Config<I>, I: 'static> MessageDispatch<T::AccountId, T::BridgeMessageId> for Pallet<T, I> {
+	type Message = MessagePayload<
+		T::SourceChainAccountId,
+		T::TargetChainAccountPublic,
+		T::TargetChainSignature,
+		T::EncodedCall,
+	>;

-	fn dispatch_weight(message: &Self::Message) -> Weight {
+	fn dispatch_weight(message: &Self::Message) -> bp_message_dispatch::Weight {
 		message.weight
 	}

-	fn dispatch<P: FnOnce(&T::AccountId, Weight) -> Result<(), ()>>(
+	fn dispatch<P: FnOnce(&T::AccountId, bp_message_dispatch::Weight) -> Result<(), ()>>(
 		source_chain: ChainId,
 		target_chain: ChainId,
-		id: T::MessageId,
+		id: T::BridgeMessageId,
 		message: Result<Self::Message, ()>,
 		pay_dispatch_fee: P,
 	) -> MessageDispatchResult {
@@ -152,13 +168,13 @@ impl<T: Config<I>, I: Instance> MessageDispatch<T::AccountId, T::MessageId> for
 					source_chain,
 					id,
 				);
-				Self::deposit_event(RawEvent::MessageRejected(source_chain, id));
+				Self::deposit_event(Event::MessageRejected(source_chain, id));
 				return MessageDispatchResult {
 					dispatch_result: false,
 					unspent_weight: 0,
 					dispatch_fee_paid_during_dispatch: false,
-				};
-			}
+				}
+			},
 		};

 		// verify spec version
@@ -177,13 +193,13 @@ impl<T: Config<I>, I: Instance> MessageDispatch<T::AccountId, T::MessageId> for
 				expected_version,
 				message.spec_version,
 			);
-			Self::deposit_event(RawEvent::MessageVersionSpecMismatch(
+			Self::deposit_event(Event::MessageVersionSpecMismatch(
 				source_chain,
 				id,
 				expected_version,
 				message.spec_version,
 			));
-			return dispatch_result;
+			return dispatch_result
 		}

 		// now that we have spec version checked, let's decode the call
@@ -196,19 +212,20 @@ impl<T: Config<I>, I: Instance> MessageDispatch<T::AccountId, T::MessageId> for
 					source_chain,
 					id,
 				);
-				Self::deposit_event(RawEvent::MessageCallDecodeFailed(source_chain, id));
-				return dispatch_result;
-			}
+				Self::deposit_event(Event::MessageCallDecodeFailed(source_chain, id));
+				return dispatch_result
+			},
 		};

 		// prepare dispatch origin
 		let origin_account = match message.origin {
 			CallOrigin::SourceRoot => {
-				let hex_id = derive_account_id::<T::SourceChainAccountId>(source_chain, SourceAccount::Root);
+				let hex_id =
+					derive_account_id::<T::SourceChainAccountId>(source_chain, SourceAccount::Root);
 				let target_id = T::AccountIdConverter::convert(hex_id);
 				log::trace!(target: "runtime::bridge-dispatch", "Root Account: {:?}", &target_id);
 				target_id
-			}
+			},
 			CallOrigin::TargetAccount(source_account_id, target_public, target_signature) => {
 				let digest = account_ownership_digest(
 					&call,
@@ -228,19 +245,20 @@ impl<T: Config<I>, I: Instance> MessageDispatch<T::AccountId, T::MessageId> for
 						target_account,
 						target_signature,
 					);
-					Self::deposit_event(RawEvent::MessageSignatureMismatch(source_chain, id));
-					return dispatch_result;
+					Self::deposit_event(Event::MessageSignatureMismatch(source_chain, id));
+					return dispatch_result
 				}

 				log::trace!(target: "runtime::bridge-dispatch", "Target Account: {:?}", &target_account);
 				target_account
-			}
+			},
 			CallOrigin::SourceAccount(source_account_id) => {
-				let hex_id = derive_account_id(source_chain, SourceAccount::Account(source_account_id));
+				let hex_id =
+					derive_account_id(source_chain, SourceAccount::Account(source_account_id));
 				let target_id = T::AccountIdConverter::convert(hex_id);
 				log::trace!(target: "runtime::bridge-dispatch", "Source Account: {:?}", &target_id);
 				target_id
-			}
+			},
 		};

 		// filter the call
@@ -252,8 +270,8 @@ impl<T: Config<I>, I: Instance> MessageDispatch<T::AccountId, T::MessageId> for
 				id,
 				call,
 			);
-			Self::deposit_event(RawEvent::MessageCallRejected(source_chain, id));
-			return dispatch_result;
+			Self::deposit_event(Event::MessageCallRejected(source_chain, id));
+			return dispatch_result
 		}

 		// verify weight
@@ -270,18 +288,21 @@ impl<T: Config<I>, I: Instance> MessageDispatch<T::AccountId, T::MessageId> for
 				expected_weight,
 				message.weight,
 			);
-			Self::deposit_event(RawEvent::MessageWeightMismatch(
+			Self::deposit_event(Event::MessageWeightMismatch(
 				source_chain,
 				id,
 				expected_weight,
 				message.weight,
 			));
-			return dispatch_result;
+			return dispatch_result
 		}

 		// pay dispatch fee right before dispatch
-		let pay_dispatch_fee_at_target_chain = message.dispatch_fee_payment == DispatchFeePayment::AtTargetChain;
-		if pay_dispatch_fee_at_target_chain && pay_dispatch_fee(&origin_account, message.weight).is_err() {
+		let pay_dispatch_fee_at_target_chain =
+			message.dispatch_fee_payment == DispatchFeePayment::AtTargetChain;
+		if pay_dispatch_fee_at_target_chain &&
+			pay_dispatch_fee(&origin_account, message.weight).is_err()
+		{
 			log::trace!(
 				target: "runtime::bridge-dispatch",
 				"Failed to pay dispatch fee for dispatching message {:?}/{:?} with weight {}",
@@ -289,13 +310,13 @@ impl<T: Config<I>, I: Instance> MessageDispatch<T::AccountId, T::MessageId> for
 				id,
 				message.weight,
 			);
-			Self::deposit_event(RawEvent::MessageDispatchPaymentFailed(
+			Self::deposit_event(Event::MessageDispatchPaymentFailed(
 				source_chain,
 				id,
 				origin_account,
 				message.weight,
 			));
-			return dispatch_result;
+			return dispatch_result
 		}
 		dispatch_result.dispatch_fee_paid_during_dispatch = pay_dispatch_fee_at_target_chain;

@@ -313,13 +334,13 @@ impl<T: Config<I>, I: Instance> MessageDispatch<T::AccountId, T::MessageId> for
 			"Message {:?}/{:?} has been dispatched. Weight: {} of {}. Result: {:?}. Call dispatch result: {:?}",
 			source_chain,
 			id,
-			dispatch_result.unspent_weight,
+			actual_call_weight,
 			message.weight,
 			dispatch_result,
 			result,
 		);

-		Self::deposit_event(RawEvent::MessageDispatched(
+		Self::deposit_event(Event::MessageDispatched(
 			source_chain,
 			id,
 			result.map(drop).map_err(|e| e.error),
@@ -335,9 +356,19 @@ impl<T: Config<I>, I: Instance> MessageDispatch<T::AccountId, T::MessageId> for
 /// For example, if a message is sent from a "regular" account on the source chain it will not be
 /// allowed to be dispatched as Root on the target chain. This is a useful check to do on the source
 /// chain _before_ sending a message whose dispatch will be rejected on the target chain.
-pub fn verify_message_origin<SourceChainAccountId, TargetChainAccountPublic, TargetChainSignature, Call>(
+pub fn verify_message_origin<
+	SourceChainAccountId,
+	TargetChainAccountPublic,
+	TargetChainSignature,
+	Call,
+>(
 	sender_origin: &RawOrigin<SourceChainAccountId>,
-	message: &MessagePayload<SourceChainAccountId, TargetChainAccountPublic, TargetChainSignature, Call>,
+	message: &MessagePayload<
+		SourceChainAccountId,
+		TargetChainAccountPublic,
+		TargetChainSignature,
+		Call,
+	>,
 ) -> Result<Option<SourceChainAccountId>, BadOrigin>
 where
 	SourceChainAccountId: PartialEq + Clone,
@@ -346,21 +377,19 @@ where
 		CallOrigin::SourceRoot => {
 			ensure!(sender_origin == &RawOrigin::Root, BadOrigin);
 			Ok(None)
-		}
+		},
 		CallOrigin::TargetAccount(ref source_account_id, _, _) => {
-			ensure!(
-				sender_origin == &RawOrigin::Signed(source_account_id.clone()),
-				BadOrigin
-			);
+			ensure!(sender_origin == &RawOrigin::Signed(source_account_id.clone()), BadOrigin);
 			Ok(Some(source_account_id.clone()))
-		}
+		},
 		CallOrigin::SourceAccount(ref source_account_id) => {
 			ensure!(
-				sender_origin == &RawOrigin::Signed(source_account_id.clone()) || sender_origin == &RawOrigin::Root,
+				sender_origin == &RawOrigin::Signed(source_account_id.clone()) ||
+					sender_origin == &RawOrigin::Root,
 				BadOrigin
 			);
 			Ok(Some(source_account_id.clone()))
-		}
+		},
 	}
 }

@@ -397,7 +426,8 @@ mod tests {
 	#![allow(clippy::from_over_into)]

 	use super::*;
-	use frame_support::{dispatch::GetDispatchInfo, parameter_types, weights::Weight};
+	use codec::Decode;
+	use frame_support::{parameter_types, weights::Weight};
 	use frame_system::{EventRecord, Phase};
 	use scale_info::TypeInfo;
 	use sp_core::H256;
@@ -408,7 +438,7 @@ mod tests {
 	};

 	type AccountId = u64;
-	type MessageId = [u8; 4];
+	type BridgeMessageId = [u8; 4];

 	const SOURCE_CHAIN_ID: ChainId = *b"srce";
 	const TARGET_CHAIN_ID: ChainId = *b"trgt";
@@ -494,7 +524,7 @@ mod tests {

 	impl Config for TestRuntime {
 		type Event = Event;
-		type MessageId = MessageId;
+		type BridgeMessageId = BridgeMessageId;
 		type SourceChainAccountId = AccountId;
 		type TargetChainAccountPublic = TestAccountPublic;
 		type TargetChainSignature = TestSignature;
@@ -525,16 +555,17 @@ mod tests {
 	const TEST_WEIGHT: Weight = 1_000_000_000;

 	fn new_test_ext() -> sp_io::TestExternalities {
-		let t = frame_system::GenesisConfig::default()
-			.build_storage::<TestRuntime>()
-			.unwrap();
+		let t = frame_system::GenesisConfig::default().build_storage::<TestRuntime>().unwrap();
 		sp_io::TestExternalities::new(t)
 	}

 	fn prepare_message(
 		origin: CallOrigin<AccountId, TestAccountPublic, TestSignature>,
 		call: Call,
-	) -> <Pallet<TestRuntime> as MessageDispatch<AccountId, <TestRuntime as Config>::MessageId>>::Message {
+	) -> <Pallet<TestRuntime> as MessageDispatch<
+		AccountId,
+		<TestRuntime as Config>::BridgeMessageId,
+	>>::Message {
 		MessagePayload {
 			spec_version: TEST_SPEC_VERSION,
 			weight: TEST_WEIGHT,
@@ -546,20 +577,29 @@ mod tests {

 	fn prepare_root_message(
 		call: Call,
-	) -> <Pallet<TestRuntime> as MessageDispatch<AccountId, <TestRuntime as Config>::MessageId>>::Message {
+	) -> <Pallet<TestRuntime> as MessageDispatch<
+		AccountId,
+		<TestRuntime as Config>::BridgeMessageId,
+	>>::Message {
 		prepare_message(CallOrigin::SourceRoot, call)
 	}

 	fn prepare_target_message(
 		call: Call,
-	) -> <Pallet<TestRuntime> as MessageDispatch<AccountId, <TestRuntime as Config>::MessageId>>::Message {
+	) -> <Pallet<TestRuntime> as MessageDispatch<
+		AccountId,
+		<TestRuntime as Config>::BridgeMessageId,
+	>>::Message {
 		let origin = CallOrigin::TargetAccount(1, TestAccountPublic(1), TestSignature(1));
 		prepare_message(origin, call)
 	}

 	fn prepare_source_message(
 		call: Call,
-	) -> <Pallet<TestRuntime> as MessageDispatch<AccountId, <TestRuntime as Config>::MessageId>>::Message {
+	) -> <Pallet<TestRuntime> as MessageDispatch<
+		AccountId,
+		<TestRuntime as Config>::BridgeMessageId,
+	>>::Message {
 		let origin = CallOrigin::SourceAccount(1);
 		prepare_message(origin, call)
 	}
@@ -570,14 +610,20 @@ mod tests {
 			let id = [0; 4];

 			const BAD_SPEC_VERSION: SpecVersion = 99;
-			let mut message = prepare_root_message(Call::System(frame_system::Call::<TestRuntime>::remark {
+			let mut message = prepare_root_message(Call::System(frame_system::Call::remark {
 				remark: vec![1, 2, 3],
 			}));
 			let weight = message.weight;
 			message.spec_version = BAD_SPEC_VERSION;

 			System::set_block_number(1);
-			let result = Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| unreachable!());
+			let result = Dispatch::dispatch(
+				SOURCE_CHAIN_ID,
+				TARGET_CHAIN_ID,
+				id,
+				Ok(message),
+				|_, _| unreachable!(),
+			);
 			assert_eq!(result.unspent_weight, weight);
 			assert!(!result.dispatch_result);

@@ -585,12 +631,14 @@ mod tests {
 				System::events(),
 				vec![EventRecord {
 					phase: Phase::Initialization,
-					event: Event::Dispatch(call_dispatch::Event::<TestRuntime>::MessageVersionSpecMismatch(
-						SOURCE_CHAIN_ID,
-						id,
-						TEST_SPEC_VERSION,
-						BAD_SPEC_VERSION
-					)),
+					event: Event::Dispatch(
+						call_dispatch::Event::<TestRuntime>::MessageVersionSpecMismatch(
+							SOURCE_CHAIN_ID,
+							id,
+							TEST_SPEC_VERSION,
+							BAD_SPEC_VERSION
+						)
+					),
 					topics: vec![],
 				}],
 			);
@@ -601,17 +649,20 @@ mod tests {
 	fn should_fail_on_weight_mismatch() {
 		new_test_ext().execute_with(|| {
 			let id = [0; 4];
-			let call = Call::System(frame_system::Call::<TestRuntime>::remark { remark: vec![1, 2, 3] });
+			let call = Call::System(frame_system::Call::remark { remark: vec![1, 2, 3] });
 			let call_weight = call.get_dispatch_info().weight;
 			let mut message = prepare_root_message(call);
 			message.weight = 7;
-			assert!(
-				call_weight != 7,
-				"needed for test to actually trigger a weight mismatch"
-			);
+			assert!(call_weight != 7, "needed for test to actually trigger a weight mismatch");

 			System::set_block_number(1);
-			let result = Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| unreachable!());
+			let result = Dispatch::dispatch(
+				SOURCE_CHAIN_ID,
+				TARGET_CHAIN_ID,
+				id,
+				Ok(message),
+				|_, _| unreachable!(),
+			);
 			assert_eq!(result.unspent_weight, 7);
 			assert!(!result.dispatch_result);

@@ -619,12 +670,14 @@ mod tests {
 				System::events(),
 				vec![EventRecord {
 					phase: Phase::Initialization,
-					event: Event::Dispatch(call_dispatch::Event::<TestRuntime>::MessageWeightMismatch(
-						SOURCE_CHAIN_ID,
-						id,
-						call_weight,
-						7,
-					)),
+					event: Event::Dispatch(
+						call_dispatch::Event::<TestRuntime>::MessageWeightMismatch(
+							SOURCE_CHAIN_ID,
+							id,
+							call_weight,
+							7,
+						)
+					),
 					topics: vec![],
 				}],
 			);
@@ -639,12 +692,18 @@ mod tests {
 			let call_origin = CallOrigin::TargetAccount(1, TestAccountPublic(1), TestSignature(99));
 			let message = prepare_message(
 				call_origin,
-				Call::System(frame_system::Call::<TestRuntime>::remark { remark: vec![1, 2, 3] }),
+				Call::System(frame_system::Call::remark { remark: vec![1, 2, 3] }),
 			);
 			let weight = message.weight;

 			System::set_block_number(1);
-			let result = Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| unreachable!());
+			let result = Dispatch::dispatch(
+				SOURCE_CHAIN_ID,
+				TARGET_CHAIN_ID,
+				id,
+				Ok(message),
+				|_, _| unreachable!(),
+			);
 			assert_eq!(result.unspent_weight, weight);
 			assert!(!result.dispatch_result);

@@ -652,10 +711,12 @@ mod tests {
 				System::events(),
 				vec![EventRecord {
 					phase: Phase::Initialization,
-					event: Event::Dispatch(call_dispatch::Event::<TestRuntime>::MessageSignatureMismatch(
-						SOURCE_CHAIN_ID,
-						id
-					)),
+					event: Event::Dispatch(
+						call_dispatch::Event::<TestRuntime>::MessageSignatureMismatch(
+							SOURCE_CHAIN_ID,
+							id
+						)
+					),
 					topics: vec![],
 				}],
 			);
@@ -668,7 +729,13 @@ mod tests {
 			let id = [0; 4];

 			System::set_block_number(1);
-			Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Err(()), |_, _| unreachable!());
+			Dispatch::dispatch(
+				SOURCE_CHAIN_ID,
+				TARGET_CHAIN_ID,
+				id,
+				Err(()),
+				|_, _| unreachable!(),
+			);

 			assert_eq!(
 				System::events(),
@@ -689,14 +756,20 @@ mod tests {
 		new_test_ext().execute_with(|| {
 			let id = [0; 4];

-			let mut message = prepare_root_message(Call::System(frame_system::Call::<TestRuntime>::remark {
+			let mut message = prepare_root_message(Call::System(frame_system::Call::remark {
 				remark: vec![1, 2, 3],
 			}));
 			let weight = message.weight;
 			message.call.0 = vec![];

 			System::set_block_number(1);
-			let result = Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| unreachable!());
+			let result = Dispatch::dispatch(
+				SOURCE_CHAIN_ID,
+				TARGET_CHAIN_ID,
+				id,
+				Ok(message),
+				|_, _| unreachable!(),
+			);
 			assert_eq!(result.unspent_weight, weight);
 			assert!(!result.dispatch_result);

@@ -704,10 +777,12 @@ mod tests {
 				System::events(),
 				vec![EventRecord {
 					phase: Phase::Initialization,
-					event: Event::Dispatch(call_dispatch::Event::<TestRuntime>::MessageCallDecodeFailed(
-						SOURCE_CHAIN_ID,
-						id
-					)),
+					event: Event::Dispatch(
+						call_dispatch::Event::<TestRuntime>::MessageCallDecodeFailed(
+							SOURCE_CHAIN_ID,
+							id
+						)
+					),
 					topics: vec![],
 				}],
 			);
@@ -719,15 +794,20 @@ mod tests {
 		new_test_ext().execute_with(|| {
 			let id = [0; 4];

-			let call = Call::System(frame_system::Call::<TestRuntime>::fill_block {
-				ratio: Perbill::from_percent(75),
-			});
+			let call =
+				Call::System(frame_system::Call::fill_block { ratio: Perbill::from_percent(75) });
 			let weight = call.get_dispatch_info().weight;
 			let mut message = prepare_root_message(call);
 			message.weight = weight;

 			System::set_block_number(1);
-			let result = Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| unreachable!());
+			let result = Dispatch::dispatch(
+				SOURCE_CHAIN_ID,
+				TARGET_CHAIN_ID,
+				id,
+				Ok(message),
+				|_, _| unreachable!(),
+			);
 			assert_eq!(result.unspent_weight, weight);
 			assert!(!result.dispatch_result);

@@ -735,10 +815,12 @@ mod tests {
 				System::events(),
 				vec![EventRecord {
 					phase: Phase::Initialization,
-					event: Event::Dispatch(call_dispatch::Event::<TestRuntime>::MessageCallRejected(
-						SOURCE_CHAIN_ID,
-						id
-					)),
+					event: Event::Dispatch(
+						call_dispatch::Event::<TestRuntime>::MessageCallRejected(
+							SOURCE_CHAIN_ID,
+							id
+						)
+					),
 					topics: vec![],
 				}],
 			);
@@ -750,14 +832,17 @@ mod tests {
 		new_test_ext().execute_with(|| {
 			let id = [0; 4];

-			let mut message = prepare_root_message(Call::System(frame_system::Call::<TestRuntime>::remark {
+			let mut message = prepare_root_message(Call::System(frame_system::Call::remark {
 				remark: vec![1, 2, 3],
 			}));
 			let weight = message.weight;
 			message.dispatch_fee_payment = DispatchFeePayment::AtTargetChain;

 			System::set_block_number(1);
-			let result = Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| Err(()));
+			let result =
+				Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| {
+					Err(())
+				});
 			assert_eq!(result.unspent_weight, weight);
 			assert!(!result.dispatch_result);

@@ -765,15 +850,17 @@ mod tests {
 				System::events(),
 				vec![EventRecord {
 					phase: Phase::Initialization,
-					event: Event::Dispatch(call_dispatch::Event::<TestRuntime>::MessageDispatchPaymentFailed(
-						SOURCE_CHAIN_ID,
-						id,
-						AccountIdConverter::convert(derive_account_id::<AccountId>(
+					event: Event::Dispatch(
+						call_dispatch::Event::<TestRuntime>::MessageDispatchPaymentFailed(
 							SOURCE_CHAIN_ID,
-							SourceAccount::Root
-						)),
-						TEST_WEIGHT,
-					)),
+							id,
+							AccountIdConverter::convert(derive_account_id::<AccountId>(
+								SOURCE_CHAIN_ID,
+								SourceAccount::Root
+							)),
+							TEST_WEIGHT,
+						)
+					),
 					topics: vec![],
 				}],
 			);
@@ -785,13 +872,19 @@ mod tests {
 		new_test_ext().execute_with(|| {
 			let id = [0; 4];

-			let mut message = prepare_root_message(Call::System(frame_system::Call::<TestRuntime>::remark {
+			let mut message = prepare_root_message(Call::System(frame_system::Call::remark {
 				remark: vec![1, 2, 3],
 			}));
 			message.dispatch_fee_payment = DispatchFeePayment::AtTargetChain;

 			System::set_block_number(1);
-			let result = Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| Ok(()));
+			let result = Dispatch::dispatch(
+				SOURCE_CHAIN_ID,
+				TARGET_CHAIN_ID,
+				id,
+				Ok(message),
+				|_, _| Ok(()),
+			);
 			assert!(result.dispatch_fee_paid_during_dispatch);
 			assert!(result.dispatch_result);

@@ -815,11 +908,17 @@ mod tests {
 		new_test_ext().execute_with(|| {
 			let id = [0; 4];

-			let call = Call::System(frame_system::Call::<TestRuntime>::set_heap_pages { pages: 1 });
+			let call = Call::System(frame_system::Call::set_heap_pages { pages: 1 });
 			let message = prepare_target_message(call);

 			System::set_block_number(1);
-			let result = Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| unreachable!());
+			let result = Dispatch::dispatch(
+				SOURCE_CHAIN_ID,
+				TARGET_CHAIN_ID,
+				id,
+				Ok(message),
+				|_, _| unreachable!(),
+			);
 			assert!(!result.dispatch_fee_paid_during_dispatch);
 			assert!(!result.dispatch_result);

@@ -842,12 +941,18 @@ mod tests {
 	fn should_dispatch_bridge_message_from_root_origin() {
 		new_test_ext().execute_with(|| {
 			let id = [0; 4];
-			let message = prepare_root_message(Call::System(frame_system::Call::<TestRuntime>::remark {
+			let message = prepare_root_message(Call::System(frame_system::Call::remark {
 				remark: vec![1, 2, 3],
 			}));

 			System::set_block_number(1);
-			let result = Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| unreachable!());
+			let result = Dispatch::dispatch(
+				SOURCE_CHAIN_ID,
+				TARGET_CHAIN_ID,
+				id,
+				Ok(message),
+				|_, _| unreachable!(),
+			);
 			assert!(!result.dispatch_fee_paid_during_dispatch);
 			assert!(result.dispatch_result);

@@ -871,11 +976,17 @@ mod tests {
 		new_test_ext().execute_with(|| {
 			let id = [0; 4];

-			let call = Call::System(frame_system::Call::<TestRuntime>::remark { remark: vec![] });
+			let call = Call::System(frame_system::Call::remark { remark: vec![] });
 			let message = prepare_target_message(call);

 			System::set_block_number(1);
-			let result = Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| unreachable!());
+			let result = Dispatch::dispatch(
+				SOURCE_CHAIN_ID,
+				TARGET_CHAIN_ID,
+				id,
+				Ok(message),
+				|_, _| unreachable!(),
+			);
 			assert!(!result.dispatch_fee_paid_during_dispatch);
 			assert!(result.dispatch_result);

@@ -899,11 +1010,17 @@ mod tests {
 		new_test_ext().execute_with(|| {
 			let id = [0; 4];

-			let call = Call::System(frame_system::Call::<TestRuntime>::remark { remark: vec![] });
+			let call = Call::System(frame_system::Call::remark { remark: vec![] });
 			let message = prepare_source_message(call);

 			System::set_block_number(1);
-			let result = Dispatch::dispatch(SOURCE_CHAIN_ID, TARGET_CHAIN_ID, id, Ok(message), |_, _| unreachable!());
+			let result = Dispatch::dispatch(
+				SOURCE_CHAIN_ID,
+				TARGET_CHAIN_ID,
+				id,
+				Ok(message),
+				|_, _| unreachable!(),
+			);
 			assert!(!result.dispatch_fee_paid_during_dispatch);
 			assert!(result.dispatch_result);

@@ -924,60 +1041,42 @@ mod tests {

 	#[test]
 	fn origin_is_checked_when_verifying_sending_message_using_source_root_account() {
-		let call = Call::System(frame_system::Call::<TestRuntime>::remark { remark: vec![] });
+		let call = Call::System(frame_system::Call::remark { remark: vec![] });
 		let message = prepare_root_message(call);

 		// When message is sent by Root, CallOrigin::SourceRoot is allowed
 		assert!(matches!(verify_message_origin(&RawOrigin::Root, &message), Ok(None)));

 		// when message is sent by some real account, CallOrigin::SourceRoot is not allowed
-		assert!(matches!(
-			verify_message_origin(&RawOrigin::Signed(1), &message),
-			Err(BadOrigin)
-		));
+		assert!(matches!(verify_message_origin(&RawOrigin::Signed(1), &message), Err(BadOrigin)));
 	}

 	#[test]
 	fn origin_is_checked_when_verifying_sending_message_using_target_account() {
-		let call = Call::System(frame_system::Call::<TestRuntime>::remark { remark: vec![] });
+		let call = Call::System(frame_system::Call::remark { remark: vec![] });
 		let message = prepare_target_message(call);

 		// When message is sent by Root, CallOrigin::TargetAccount is not allowed
-		assert!(matches!(
-			verify_message_origin(&RawOrigin::Root, &message),
-			Err(BadOrigin)
-		));
+		assert!(matches!(verify_message_origin(&RawOrigin::Root, &message), Err(BadOrigin)));

 		// When message is sent by some other account, it is rejected
-		assert!(matches!(
-			verify_message_origin(&RawOrigin::Signed(2), &message),
-			Err(BadOrigin)
-		));
+		assert!(matches!(verify_message_origin(&RawOrigin::Signed(2), &message), Err(BadOrigin)));

 		// When message is sent by a real account, it is allowed to have origin
 		// CallOrigin::TargetAccount
-		assert!(matches!(
-			verify_message_origin(&RawOrigin::Signed(1), &message),
-			Ok(Some(1))
-		));
+		assert!(matches!(verify_message_origin(&RawOrigin::Signed(1), &message), Ok(Some(1))));
 	}

 	#[test]
 	fn origin_is_checked_when_verifying_sending_message_using_source_account() {
-		let call = Call::System(frame_system::Call::<TestRuntime>::remark { remark: vec![] });
+		let call = Call::System(frame_system::Call::remark { remark: vec![] });
 		let message = prepare_source_message(call);

 		// Sending a message from the expected origin account works
-		assert!(matches!(
-			verify_message_origin(&RawOrigin::Signed(1), &message),
-			Ok(Some(1))
-		));
+		assert!(matches!(verify_message_origin(&RawOrigin::Signed(1), &message), Ok(Some(1))));

 		// If we send a message from a different account, it is rejected
-		assert!(matches!(
-			verify_message_origin(&RawOrigin::Signed(2), &message),
-			Err(BadOrigin)
-		));
+		assert!(matches!(verify_message_origin(&RawOrigin::Signed(2), &message), Err(BadOrigin)));

 		// The Root account is allowed to assume any expected origin account
 		assert!(matches!(verify_message_origin(&RawOrigin::Root, &message), Ok(Some(1))));