Removed relayer_account: &AccountId from MessageDispatch (paritytech#…

…2080)

* SourceBridgeHubChain/TargetBridgeHubChain replaced with RelayerAccountChain

* Fix

* Removed `relayer_account: &AccountId` from `MessageDispatch`

bridges/bin/millau/runtime/src/rialto_messages.rs

@@ -64,8 +64,6 @@ pub type ToRialtoMessagesDeliveryProof =
 /// Call-dispatch based message dispatch for Rialto -> Millau messages.
 pub type FromRialtoMessageDispatch =
  bridge_runtime_common::messages_xcm_extension::XcmBlobMessageDispatch<
- bp_millau::Millau,
- bp_rialto::Rialto,
  crate::xcm_config::OnMillauBlobDispatcher,
  (),
  >;

bridges/bin/millau/runtime/src/rialto_parachain_messages.rs

@@ -59,8 +59,6 @@ pub type FromRialtoParachainMessagePayload = messages::target::FromBridgedChainM
 /// Call-dispatch based message dispatch for RialtoParachain -> Millau messages.
 pub type FromRialtoParachainMessageDispatch =
  bridge_runtime_common::messages_xcm_extension::XcmBlobMessageDispatch<
- bp_millau::Millau,
- bp_rialto::Rialto,
  crate::xcm_config::OnMillauBlobDispatcher,
  (),
  >;

bridges/bin/millau/runtime/src/xcm_config.rs

@@ -349,8 +349,7 @@ mod tests {
 
  // we care only about handing message to the XCM dispatcher, so we don't care about its
  // actual dispatch
- let dispatch_result =
- FromRialtoMessageDispatch::dispatch(&AccountId::from([0u8; 32]), incoming_message);
+ let dispatch_result = FromRialtoMessageDispatch::dispatch(incoming_message);
  assert!(matches!(
  dispatch_result.dispatch_level_result,
  XcmBlobMessageDispatchResult::NotDispatched(_),
@@ -363,8 +362,7 @@ mod tests {
 
  // we care only about handing message to the XCM dispatcher, so we don't care about its
  // actual dispatch
- let dispatch_result =
- FromRialtoMessageDispatch::dispatch(&AccountId::from([0u8; 32]), incoming_message);
+ let dispatch_result = FromRialtoMessageDispatch::dispatch(incoming_message);
  assert!(matches!(
  dispatch_result.dispatch_level_result,
  XcmBlobMessageDispatchResult::NotDispatched(_),

bridges/bin/rialto-parachain/runtime/src/lib.rs

@@ -926,8 +926,7 @@ mod tests {
 
  // we care only about handing message to the XCM dispatcher, so we don't care about its
  // actual dispatch
- let dispatch_result =
- FromMillauMessageDispatch::dispatch(&AccountId::from([0u8; 32]), incoming_message);
+ let dispatch_result = FromMillauMessageDispatch::dispatch(incoming_message);
  assert!(matches!(
  dispatch_result.dispatch_level_result,
  XcmBlobMessageDispatchResult::NotDispatched(_),

bridges/bin/rialto-parachain/runtime/src/millau_messages.rs

@@ -60,8 +60,6 @@ pub type FromMillauMessagePayload = messages::target::FromBridgedChainMessagePay
 /// Call-dispatch based message dispatch for Millau -> RialtoParachain messages.
 pub type FromMillauMessageDispatch =
  bridge_runtime_common::messages_xcm_extension::XcmBlobMessageDispatch<
- bp_rialto_parachain::RialtoParachain,
- bp_millau::Millau,
  crate::OnRialtoParachainBlobDispatcher,
  (),
  >;

bridges/bin/rialto/runtime/src/millau_messages.rs

@@ -57,8 +57,6 @@ pub type FromMillauMessagePayload = messages::target::FromBridgedChainMessagePay
 /// Call-dispatch based message dispatch for Millau -> Rialto messages.
 pub type FromMillauMessageDispatch =
  bridge_runtime_common::messages_xcm_extension::XcmBlobMessageDispatch<
- bp_rialto::Rialto,
- bp_millau::Millau,
  crate::xcm_config::OnRialtoBlobDispatcher,
  (),
  >;

bridges/bin/rialto/runtime/src/xcm_config.rs

@@ -266,8 +266,7 @@ mod tests {
 
  // we care only about handing message to the XCM dispatcher, so we don't care about its
  // actual dispatch
- let dispatch_result =
- FromMillauMessageDispatch::dispatch(&AccountId::from([0u8; 32]), incoming_message);
+ let dispatch_result = FromMillauMessageDispatch::dispatch(incoming_message);
  assert!(matches!(
  dispatch_result.dispatch_level_result,
  XcmBlobMessageDispatchResult::NotDispatched(_),

bridges/bin/runtime-common/src/messages_xcm_extension.rs

@@ -26,7 +26,7 @@ use bp_messages::{
  target_chain::{DispatchMessage, MessageDispatch},
  LaneId,
 };
-use bp_runtime::{messages::MessageDispatchResult, AccountIdOf, Chain};
+use bp_runtime::messages::MessageDispatchResult;
 use codec::{Decode, Encode};
 use frame_support::{dispatch::Weight, CloneNoBound, EqNoBound, PartialEqNoBound};
 use pallet_bridge_messages::WeightInfoExt as MessagesPalletWeights;
@@ -46,23 +46,12 @@ pub enum XcmBlobMessageDispatchResult {
 }
 
 /// [`XcmBlobMessageDispatch`] is responsible for dispatching received messages
-pub struct XcmBlobMessageDispatch<SourceBridgeHubChain, TargetBridgeHubChain, DispatchBlob, Weights>
-{
- _marker: sp_std::marker::PhantomData<(
- SourceBridgeHubChain,
- TargetBridgeHubChain,
- DispatchBlob,
- Weights,
- )>,
+pub struct XcmBlobMessageDispatch<DispatchBlob, Weights> {
+ _marker: sp_std::marker::PhantomData<(DispatchBlob, Weights)>,
 }
 
-impl<
- SourceBridgeHubChain: Chain,
- TargetBridgeHubChain: Chain,
- BlobDispatcher: DispatchBlob,
- Weights: MessagesPalletWeights,
- > MessageDispatch<AccountIdOf<SourceBridgeHubChain>>
- for XcmBlobMessageDispatch<SourceBridgeHubChain, TargetBridgeHubChain, BlobDispatcher, Weights>
+impl<BlobDispatcher: DispatchBlob, Weights: MessagesPalletWeights> MessageDispatch
+ for XcmBlobMessageDispatch<BlobDispatcher, Weights>
 {
  type DispatchPayload = XcmAsPlainPayload;
  type DispatchLevelResult = XcmBlobMessageDispatchResult;
@@ -78,7 +67,6 @@ impl<
  }
 
  fn dispatch(
- _relayer_account: &AccountIdOf<SourceBridgeHubChain>,
  message: DispatchMessage<Self::DispatchPayload>,
  ) -> MessageDispatchResult<Self::DispatchLevelResult> {
  let payload = match message.data.payload {

bridges/modules/grandpa/src/lib.rs

@@ -834,6 +834,7 @@ mod tests {
  run_test(|| {
  assert_eq!(BestFinalized::<TestRuntime>::get(), None,);
  assert_eq!(Pallet::<TestRuntime>::best_finalized(), None);
+ assert_eq!(PalletOperatingMode::<TestRuntime>::try_get(), Err(()));
 
  let init_data = init_with_origin(RuntimeOrigin::root()).unwrap();
 
@@ -843,7 +844,10 @@ mod tests {
  CurrentAuthoritySet::<TestRuntime>::get().authorities,
  init_data.authority_list
  );
- assert_eq!(PalletOperatingMode::<TestRuntime>::get(), BasicOperatingMode::Normal);
+ assert_eq!(
+ PalletOperatingMode::<TestRuntime>::try_get(),
+ Ok(BasicOperatingMode::Normal)
+ );
  })
  }
 

bridges/modules/messages/src/inbound_lane.rs

@@ -164,10 +164,9 @@ impl<S: InboundLaneStorage> InboundLane<S> {
  }
 
  /// Receive new message.
- pub fn receive_message<Dispatch: MessageDispatch<AccountId>, AccountId>(
+ pub fn receive_message<Dispatch: MessageDispatch>(
  &mut self,
  relayer_at_bridged_chain: &S::Relayer,
- relayer_at_this_chain: &AccountId,
  nonce: MessageNonce,
  message_data: DispatchMessageData<Dispatch::DispatchPayload>,
  ) -> ReceivalResult<Dispatch::DispatchLevelResult> {
@@ -189,13 +188,10 @@ impl<S: InboundLaneStorage> InboundLane<S> {
  }
 
  // then, dispatch message
- let dispatch_result = Dispatch::dispatch(
- relayer_at_this_chain,
- DispatchMessage {
- key: MessageKey { lane_id: self.storage.id(), nonce },
- data: message_data,
- },
- );
+ let dispatch_result = Dispatch::dispatch(DispatchMessage {
+ key: MessageKey { lane_id: self.storage.id(), nonce },
+ data: message_data,
+ });
 
  // now let's update inbound lane storage
  match data.relayers.back_mut() {
@@ -234,8 +230,7 @@ mod tests {
  nonce: MessageNonce,
  ) {
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &TEST_RELAYER_A,
+ lane.receive_message::<TestMessageDispatch>(
  &TEST_RELAYER_A,
  nonce,
  inbound_message_data(REGULAR_PAYLOAD)
@@ -362,8 +357,7 @@ mod tests {
  run_test(|| {
  let mut lane = inbound_lane::<TestRuntime, _>(TEST_LANE_ID);
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &TEST_RELAYER_A,
+ lane.receive_message::<TestMessageDispatch>(
  &TEST_RELAYER_A,
  10,
  inbound_message_data(REGULAR_PAYLOAD)
@@ -382,8 +376,7 @@ mod tests {
  <TestRuntime as Config>::MaxUnrewardedRelayerEntriesAtInboundLane::get();
  for current_nonce in 1..max_nonce + 1 {
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &(TEST_RELAYER_A + current_nonce),
+ lane.receive_message::<TestMessageDispatch>(
  &(TEST_RELAYER_A + current_nonce),
  current_nonce,
  inbound_message_data(REGULAR_PAYLOAD)
@@ -393,8 +386,7 @@ mod tests {
  }
  // Fails to dispatch new message from different than latest relayer.
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &(TEST_RELAYER_A + max_nonce + 1),
+ lane.receive_message::<TestMessageDispatch>(
  &(TEST_RELAYER_A + max_nonce + 1),
  max_nonce + 1,
  inbound_message_data(REGULAR_PAYLOAD)
@@ -403,8 +395,7 @@ mod tests {
  );
  // Fails to dispatch new messages from latest relayer. Prevents griefing attacks.
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &(TEST_RELAYER_A + max_nonce),
+ lane.receive_message::<TestMessageDispatch>(
  &(TEST_RELAYER_A + max_nonce),
  max_nonce + 1,
  inbound_message_data(REGULAR_PAYLOAD)
@@ -421,8 +412,7 @@ mod tests {
  let max_nonce = <TestRuntime as Config>::MaxUnconfirmedMessagesAtInboundLane::get();
  for current_nonce in 1..=max_nonce {
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &TEST_RELAYER_A,
+ lane.receive_message::<TestMessageDispatch>(
  &TEST_RELAYER_A,
  current_nonce,
  inbound_message_data(REGULAR_PAYLOAD)
@@ -432,8 +422,7 @@ mod tests {
  }
  // Fails to dispatch new message from different than latest relayer.
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &TEST_RELAYER_B,
+ lane.receive_message::<TestMessageDispatch>(
  &TEST_RELAYER_B,
  max_nonce + 1,
  inbound_message_data(REGULAR_PAYLOAD)
@@ -442,8 +431,7 @@ mod tests {
  );
  // Fails to dispatch new messages from latest relayer.
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &TEST_RELAYER_A,
+ lane.receive_message::<TestMessageDispatch>(
  &TEST_RELAYER_A,
  max_nonce + 1,
  inbound_message_data(REGULAR_PAYLOAD)
@@ -458,26 +446,23 @@ mod tests {
  run_test(|| {
  let mut lane = inbound_lane::<TestRuntime, _>(TEST_LANE_ID);
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &TEST_RELAYER_A,
+ lane.receive_message::<TestMessageDispatch>(
  &TEST_RELAYER_A,
  1,
  inbound_message_data(REGULAR_PAYLOAD)
  ),
  ReceivalResult::Dispatched(dispatch_result(0))
  );
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &TEST_RELAYER_B,
+ lane.receive_message::<TestMessageDispatch>(
  &TEST_RELAYER_B,
  2,
  inbound_message_data(REGULAR_PAYLOAD)
  ),
  ReceivalResult::Dispatched(dispatch_result(0))
  );
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &TEST_RELAYER_A,
+ lane.receive_message::<TestMessageDispatch>(
  &TEST_RELAYER_A,
  3,
  inbound_message_data(REGULAR_PAYLOAD)
@@ -500,17 +485,15 @@ mod tests {
  run_test(|| {
  let mut lane = inbound_lane::<TestRuntime, _>(TEST_LANE_ID);
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &TEST_RELAYER_A,
+ lane.receive_message::<TestMessageDispatch>(
  &TEST_RELAYER_A,
  1,
  inbound_message_data(REGULAR_PAYLOAD)
  ),
  ReceivalResult::Dispatched(dispatch_result(0))
  );
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &TEST_RELAYER_B,
+ lane.receive_message::<TestMessageDispatch>(
  &TEST_RELAYER_B,
  1,
  inbound_message_data(REGULAR_PAYLOAD)
@@ -536,8 +519,7 @@ mod tests {
  let mut payload = REGULAR_PAYLOAD;
  *payload.dispatch_result.unspent_weight.ref_time_mut() = 1;
  assert_eq!(
- lane.receive_message::<TestMessageDispatch, _>(
- &TEST_RELAYER_A,
+ lane.receive_message::<TestMessageDispatch>(
  &TEST_RELAYER_A,
  1,
  inbound_message_data(payload)

bridges/modules/messages/src/lib.rs

@@ -162,10 +162,7 @@ pub mod pallet {
  /// Source header chain, as it is represented on target chain.
  type SourceHeaderChain: SourceHeaderChain;
  /// Message dispatch.
- type MessageDispatch: MessageDispatch<
- Self::AccountId,
- DispatchPayload = Self::InboundPayload,
- >;
+ type MessageDispatch: MessageDispatch<DispatchPayload = Self::InboundPayload>;
  }
 
  /// Shortcut to messages proof type for Config.
@@ -361,9 +358,8 @@ pub mod pallet {
  fail!(Error::<T, I>::InsufficientDispatchWeight);
  }
 
- let receival_result = lane.receive_message::<T::MessageDispatch, T::AccountId>(
+ let receival_result = lane.receive_message::<T::MessageDispatch>(
  &relayer_id_at_bridged_chain,
- &relayer_id_at_this_chain,
  message.key.nonce,
  message.data,
  );
@@ -545,11 +541,7 @@ pub mod pallet {
  MessageAccepted { lane_id: LaneId, nonce: MessageNonce },
  /// Messages have been received from the bridged chain.
  MessagesReceived(
- Vec<
- ReceivedMessages<
- <T::MessageDispatch as MessageDispatch<T::AccountId>>::DispatchLevelResult,
- >,
- >,
+ Vec<ReceivedMessages<<T::MessageDispatch as MessageDispatch>::DispatchLevelResult>>,
  ),
  /// Messages in the inclusive range have been delivered to the bridged chain.
  MessagesDelivered { lane_id: LaneId, messages: DeliveredMessages },

bridges/modules/messages/src/mock.rs

@@ -416,7 +416,7 @@ impl SourceHeaderChain for TestSourceHeaderChain {
 #[derive(Debug)]
 pub struct TestMessageDispatch;
 
-impl MessageDispatch<AccountId> for TestMessageDispatch {
+impl MessageDispatch for TestMessageDispatch {
  type DispatchPayload = TestPayload;
  type DispatchLevelResult = TestDispatchLevelResult;
 
@@ -428,7 +428,6 @@ impl MessageDispatch<AccountId> for TestMessageDispatch {
  }
 
  fn dispatch(
- _relayer_account: &AccountId,
  message: DispatchMessage<TestPayload>,
  ) -> MessageDispatchResult<TestDispatchLevelResult> {
  match message.data.payload.as_ref() {