[BREAKING] Migrate messages pallet to frame v2 (#1088)

* get rid of frame_support::traits::Instance usage in messaging

* migrate messages pallet to frame v2

* fix benchmarks

* remove dummy event + add Parameter to metadata

* review

* typo

bridges/bin/millau/node/src/chain_spec.rs

@@ -136,7 +136,7 @@ impl Alternative {
 							get_account_id_from_seed::<sr25519::Public>("Harry//stash"),
 							pallet_bridge_messages::Pallet::<
 								millau_runtime::Runtime,
-								pallet_bridge_messages::DefaultInstance,
+								millau_runtime::WithRialtoMessagesInstance,
 							>::relayer_fund_account_id(),
 							derive_account_from_rialto_id(bp_runtime::SourceAccount::Account(
 								get_account_id_from_seed::<sr25519::Public>("Alice"),

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

@@ -366,7 +366,7 @@ parameter_types! {
 }
 
 /// Instance of the messages pallet used to relay messages to/from Rialto chain.
-pub type WithRialtoMessagesInstance = pallet_bridge_messages::DefaultInstance;
+pub type WithRialtoMessagesInstance = ();
 
 impl pallet_bridge_messages::Config<WithRialtoMessagesInstance> for Runtime {
 	type Event = Event;

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

@@ -80,10 +80,10 @@ impl MessageBridge for WithRialtoMessageBridge {
 	const RELAYER_FEE_PERCENT: u32 = 10;
 	const THIS_CHAIN_ID: ChainId = MILLAU_CHAIN_ID;
 	const BRIDGED_CHAIN_ID: ChainId = RIALTO_CHAIN_ID;
+	const BRIDGED_MESSAGES_PALLET_NAME: &'static str = bp_rialto::WITH_MILLAU_MESSAGES_PALLET_NAME;
 
 	type ThisChain = Millau;
 	type BridgedChain = Rialto;
-	type BridgedMessagesInstance = crate::WithRialtoMessagesInstance;
 
 	fn bridged_balance_to_this_balance(bridged_balance: bp_rialto::Balance) -> bp_millau::Balance {
 		bp_millau::Balance::try_from(RialtoToMillauConversionRate::get().saturating_mul_int(bridged_balance))

bridges/bin/rialto/node/src/chain_spec.rs

@@ -137,7 +137,7 @@ impl Alternative {
 							get_account_id_from_seed::<sr25519::Public>("Harry//stash"),
 							pallet_bridge_messages::Pallet::<
 								rialto_runtime::Runtime,
-								pallet_bridge_messages::DefaultInstance,
+								rialto_runtime::WithMillauMessagesInstance,
 							>::relayer_fund_account_id(),
 							derive_account_from_millau_id(bp_runtime::SourceAccount::Account(
 								get_account_id_from_seed::<sr25519::Public>("Alice"),

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

@@ -494,7 +494,7 @@ parameter_types! {
 }
 
 /// Instance of the messages pallet used to relay messages to/from Millau chain.
-pub type WithMillauMessagesInstance = pallet_bridge_messages::DefaultInstance;
+pub type WithMillauMessagesInstance = ();
 
 impl pallet_bridge_messages::Config<WithMillauMessagesInstance> for Runtime {
 	type Event = Event;
@@ -1021,14 +1021,12 @@ impl_runtime_apis! {
 						Self::endow_account(&rialto_public.clone().into_account());
 					}
 
-					let make_millau_message_key = |message_key: MessageKey| storage_keys::message_key::<
-						<WithMillauMessageBridge as MessageBridge>::BridgedMessagesInstance,
-					>(
+					let make_millau_message_key = |message_key: MessageKey| storage_keys::message_key(
+						<WithMillauMessageBridge as MessageBridge>::BRIDGED_MESSAGES_PALLET_NAME,
 						&message_key.lane_id, message_key.nonce,
 					).0;
-					let make_millau_outbound_lane_data_key = |lane_id| storage_keys::outbound_lane_data_key::<
-						<WithMillauMessageBridge as MessageBridge>::BridgedMessagesInstance,
-					>(
+					let make_millau_outbound_lane_data_key = |lane_id| storage_keys::outbound_lane_data_key(
+						<WithMillauMessageBridge as MessageBridge>::BRIDGED_MESSAGES_PALLET_NAME,
 						&lane_id,
 					).0;
 
@@ -1074,9 +1072,8 @@ impl_runtime_apis! {
 
 					prepare_message_delivery_proof::<WithMillauMessageBridge, bp_millau::Hasher, Runtime, (), _, _>(
 						params,
-						|lane_id| pallet_bridge_messages::storage_keys::inbound_lane_data_key::<
-							<WithMillauMessageBridge as MessageBridge>::BridgedMessagesInstance,
-						>(
+						|lane_id| pallet_bridge_messages::storage_keys::inbound_lane_data_key(
+							<WithMillauMessageBridge as MessageBridge>::BRIDGED_MESSAGES_PALLET_NAME,
 							&lane_id,
 						).0,
 						|state_root| bp_millau::Header::new(

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

@@ -80,10 +80,10 @@ impl MessageBridge for WithMillauMessageBridge {
 	const RELAYER_FEE_PERCENT: u32 = 10;
 	const THIS_CHAIN_ID: ChainId = RIALTO_CHAIN_ID;
 	const BRIDGED_CHAIN_ID: ChainId = MILLAU_CHAIN_ID;
+	const BRIDGED_MESSAGES_PALLET_NAME: &'static str = bp_millau::WITH_RIALTO_MESSAGES_PALLET_NAME;
 
 	type ThisChain = Rialto;
 	type BridgedChain = Millau;
-	type BridgedMessagesInstance = crate::WithMillauMessagesInstance;
 
 	fn bridged_balance_to_this_balance(bridged_balance: bp_millau::Balance) -> bp_rialto::Balance {
 		bp_rialto::Balance::try_from(MillauToRialtoConversionRate::get().saturating_mul_int(bridged_balance))

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

@@ -32,7 +32,7 @@ use bp_runtime::{
 };
 use codec::{Decode, Encode};
 use frame_support::{
-	traits::{Currency, ExistenceRequirement, Instance},
+	traits::{Currency, ExistenceRequirement},
 	weights::{Weight, WeightToFeePolynomial},
 	RuntimeDebug,
 };
@@ -53,13 +53,15 @@ pub trait MessageBridge {
 	const THIS_CHAIN_ID: ChainId;
 	/// Identifier of the Bridged chain.
 	const BRIDGED_CHAIN_ID: ChainId;
+	/// Name of the paired messages pallet instance at the Bridged chain.
+	///
+	/// Should be the name that is used in the `construct_runtime!()` macro.
+	const BRIDGED_MESSAGES_PALLET_NAME: &'static str;
 
 	/// This chain in context of message bridge.
 	type ThisChain: ThisChainWithMessages;
 	/// Bridged chain in context of message bridge.
 	type BridgedChain: BridgedChainWithMessages;
-	/// Instance of the `pallet-bridge-messages` pallet at the Bridged chain.
-	type BridgedMessagesInstance: Instance;
 
 	/// Convert Bridged chain balance into This chain balance.
 	fn bridged_balance_to_this_balance(bridged_balance: BalanceOf<BridgedChain<Self>>) -> BalanceOf<ThisChain<Self>>;
@@ -391,7 +393,7 @@ pub mod source {
 				// Messages delivery proof is just proof of single storage key read => any error
 				// is fatal.
 				let storage_inbound_lane_data_key =
-					pallet_bridge_messages::storage_keys::inbound_lane_data_key::<B::BridgedMessagesInstance>(&lane);
+					pallet_bridge_messages::storage_keys::inbound_lane_data_key(B::BRIDGED_MESSAGES_PALLET_NAME, &lane);
 				let raw_inbound_lane_data = storage
 					.read_value(storage_inbound_lane_data_key.0.as_ref())
 					.map_err(|_| "Failed to read inbound lane state from storage proof")?
@@ -563,7 +565,6 @@ pub mod target {
 	) -> Result<ProvedMessages<Message<BalanceOf<BridgedChain<B>>>>, &'static str>
 	where
 		ThisRuntime: pallet_bridge_grandpa::Config<GrandpaInstance>,
-		ThisRuntime: pallet_bridge_messages::Config<B::BridgedMessagesInstance>,
 		HashOf<BridgedChain<B>>:
 			Into<bp_runtime::HashOf<<ThisRuntime as pallet_bridge_grandpa::Config<GrandpaInstance>>::BridgedChain>>,
 	{
@@ -628,14 +629,15 @@ pub mod target {
 	{
 		fn read_raw_outbound_lane_data(&self, lane_id: &LaneId) -> Option<Vec<u8>> {
 			let storage_outbound_lane_data_key =
-				pallet_bridge_messages::storage_keys::outbound_lane_data_key::<B::BridgedMessagesInstance>(lane_id);
+				pallet_bridge_messages::storage_keys::outbound_lane_data_key(B::BRIDGED_MESSAGES_PALLET_NAME, lane_id);
 			self.storage
 				.read_value(storage_outbound_lane_data_key.0.as_ref())
 				.ok()?
 		}
 
 		fn read_raw_message(&self, message_key: &MessageKey) -> Option<Vec<u8>> {
-			let storage_message_key = pallet_bridge_messages::storage_keys::message_key::<B::BridgedMessagesInstance>(
+			let storage_message_key = pallet_bridge_messages::storage_keys::message_key(
+				B::BRIDGED_MESSAGES_PALLET_NAME,
 				&message_key.lane_id,
 				message_key.nonce,
 			);
@@ -745,10 +747,10 @@ mod tests {
 		const RELAYER_FEE_PERCENT: u32 = 10;
 		const THIS_CHAIN_ID: ChainId = *b"this";
 		const BRIDGED_CHAIN_ID: ChainId = *b"brdg";
+		const BRIDGED_MESSAGES_PALLET_NAME: &'static str = "";
 
 		type ThisChain = ThisChain;
 		type BridgedChain = BridgedChain;
-		type BridgedMessagesInstance = pallet_bridge_messages::DefaultInstance;
 
 		fn bridged_balance_to_this_balance(bridged_balance: BridgedChainBalance) -> ThisChainBalance {
 			ThisChainBalance(bridged_balance.0 * BRIDGED_CHAIN_TO_THIS_CHAIN_BALANCE_RATE as u32)
@@ -763,10 +765,10 @@ mod tests {
 		const RELAYER_FEE_PERCENT: u32 = 20;
 		const THIS_CHAIN_ID: ChainId = *b"brdg";
 		const BRIDGED_CHAIN_ID: ChainId = *b"this";
+		const BRIDGED_MESSAGES_PALLET_NAME: &'static str = "";
 
 		type ThisChain = BridgedChain;
 		type BridgedChain = ThisChain;
-		type BridgedMessagesInstance = pallet_bridge_messages::DefaultInstance;
 
 		fn bridged_balance_to_this_balance(_this_balance: ThisChainBalance) -> BridgedChainBalance {
 			unreachable!()

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

@@ -20,7 +20,6 @@ use crate::messages::{source::FromThisChainMessagePayload, MessageBridge};
 
 use bp_messages::{LaneId, MessageDetails, MessageNonce};
 use codec::Decode;
-use frame_support::traits::Instance;
 use sp_std::vec::Vec;
 
 /// Implementation of the `To*OutboundLaneApi::message_details`.
@@ -31,7 +30,7 @@ pub fn outbound_message_details<Runtime, MessagesPalletInstance, BridgeConfig>(
 ) -> Vec<MessageDetails<Runtime::OutboundMessageFee>>
 where
 	Runtime: pallet_bridge_messages::Config<MessagesPalletInstance>,
-	MessagesPalletInstance: Instance,
+	MessagesPalletInstance: 'static,
 	BridgeConfig: MessageBridge,
 {
 	(begin..=end)

bridges/modules/messages/src/benchmarking.rs

@@ -19,7 +19,7 @@
 use crate::weights_ext::EXPECTED_DEFAULT_MESSAGE_LENGTH;
 use crate::{
 	inbound_lane::InboundLaneStorage, inbound_lane_storage, outbound_lane, outbound_lane::ReceivalConfirmationResult,
-	Call, Instance,
+	Call,
 };
 
 use bp_messages::{
@@ -27,7 +27,7 @@ use bp_messages::{
 	MessageData, MessageNonce, OutboundLaneData, UnrewardedRelayer, UnrewardedRelayersState,
 };
 use bp_runtime::messages::DispatchFeePayment;
-use frame_benchmarking::{account, benchmarks_instance};
+use frame_benchmarking::{account, benchmarks_instance_pallet};
 use frame_support::{traits::Get, weights::Weight};
 use frame_system::RawOrigin;
 use sp_std::{
@@ -43,7 +43,7 @@ pub const MESSAGE_FEE: u64 = 100_000_000_000;
 const SEED: u32 = 0;
 
 /// Pallet we're benchmarking here.
-pub struct Pallet<T: Config<I>, I: crate::Instance>(crate::Pallet<T, I>);
+pub struct Pallet<T: Config<I>, I: 'static>(crate::Pallet<T, I>);
 
 /// Proof size requirements.
 pub enum ProofSize {
@@ -91,7 +91,7 @@ pub struct MessageDeliveryProofParams<ThisChainAccountId> {
 }
 
 /// Trait that must be implemented by runtime.
-pub trait Config<I: Instance>: crate::Config<I> {
+pub trait Config<I: 'static>: crate::Config<I> {
 	/// Lane id to use in benchmarks.
 	fn bench_lane_id() -> LaneId {
 		Default::default()
@@ -123,7 +123,7 @@ pub trait Config<I: Instance>: crate::Config<I> {
 	fn is_message_dispatched(nonce: MessageNonce) -> bool;
 }
 
-benchmarks_instance! {
+benchmarks_instance_pallet! {
 	//
 	// Benchmarks that are used directly by the runtime.
 	//
@@ -898,7 +898,7 @@ benchmarks_instance! {
 	}
 }
 
-fn send_regular_message<T: Config<I>, I: Instance>() {
+fn send_regular_message<T: Config<I>, I: 'static>() {
 	let mut outbound_lane = outbound_lane::<T, I>(T::bench_lane_id());
 	outbound_lane.send_message(MessageData {
 		payload: vec![],
@@ -906,7 +906,7 @@ fn send_regular_message<T: Config<I>, I: Instance>() {
 	});
 }
 
-fn send_regular_message_with_payload<T: Config<I>, I: Instance>(payload: Vec<u8>) {
+fn send_regular_message_with_payload<T: Config<I>, I: 'static>(payload: Vec<u8>) {
 	let mut outbound_lane = outbound_lane::<T, I>(T::bench_lane_id());
 	outbound_lane.send_message(MessageData {
 		payload,
@@ -914,7 +914,7 @@ fn send_regular_message_with_payload<T: Config<I>, I: Instance>(payload: Vec<u8>
 	});
 }
 
-fn confirm_message_delivery<T: Config<I>, I: Instance>(nonce: MessageNonce) {
+fn confirm_message_delivery<T: Config<I>, I: 'static>(nonce: MessageNonce) {
 	let mut outbound_lane = outbound_lane::<T, I>(T::bench_lane_id());
 	let latest_received_nonce = outbound_lane.data().latest_received_nonce;
 	let mut relayers = VecDeque::with_capacity((nonce - latest_received_nonce) as usize);
@@ -930,7 +930,7 @@ fn confirm_message_delivery<T: Config<I>, I: Instance>(nonce: MessageNonce) {
 	));
 }
 
-fn receive_messages<T: Config<I>, I: Instance>(nonce: MessageNonce) {
+fn receive_messages<T: Config<I>, I: 'static>(nonce: MessageNonce) {
 	let mut inbound_lane_storage = inbound_lane_storage::<T, I>(T::bench_lane_id());
 	inbound_lane_storage.set_data(InboundLaneData {
 		relayers: vec![UnrewardedRelayer {
@@ -943,7 +943,7 @@ fn receive_messages<T: Config<I>, I: Instance>(nonce: MessageNonce) {
 	});
 }
 
-fn ensure_relayer_rewarded<T: Config<I>, I: Instance>(relayer_id: &T::AccountId, old_balance: &T::OutboundMessageFee) {
+fn ensure_relayer_rewarded<T: Config<I>, I: 'static>(relayer_id: &T::AccountId, old_balance: &T::OutboundMessageFee) {
 	let new_balance = T::account_balance(relayer_id);
 	assert!(
 		new_balance > *old_balance,

bridges/modules/messages/src/inbound_lane.rs

@@ -179,11 +179,11 @@ mod tests {
 			dispatch_result, message_data, run_test, unrewarded_relayer, TestMessageDispatch, TestRuntime,
 			REGULAR_PAYLOAD, TEST_LANE_ID, TEST_RELAYER_A, TEST_RELAYER_B, TEST_RELAYER_C,
 		},
-		DefaultInstance, RuntimeInboundLaneStorage,
+		RuntimeInboundLaneStorage,
 	};
 
 	fn receive_regular_message(
-		lane: &mut InboundLane<RuntimeInboundLaneStorage<TestRuntime, DefaultInstance>>,
+		lane: &mut InboundLane<RuntimeInboundLaneStorage<TestRuntime, ()>>,
 		nonce: MessageNonce,
 	) {
 		assert_eq!(

bridges/primitives/chain-millau/src/lib.rs

@@ -245,6 +245,9 @@ pub fn max_extrinsic_size() -> u32 {
 	*BlockLength::get().max.get(DispatchClass::Normal)
 }
 
+/// Name of the With-Rialto messages pallet instance in the Millau runtime.
+pub const WITH_RIALTO_MESSAGES_PALLET_NAME: &str = "BridgeRialtoMessages";
+
 /// Name of the `MillauFinalityApi::best_finalized` runtime method.
 pub const BEST_FINALIZED_MILLAU_HEADER_METHOD: &str = "MillauFinalityApi_best_finalized";
 

bridges/primitives/chain-rialto/src/lib.rs

@@ -214,6 +214,9 @@ pub fn max_extrinsic_size() -> u32 {
 	*BlockLength::get().max.get(DispatchClass::Normal)
 }
 
+/// Name of the With-Millau messages pallet instance in the Millau runtime.
+pub const WITH_MILLAU_MESSAGES_PALLET_NAME: &str = "BridgeMillauMessages";
+
 /// Name of the `RialtoFinalityApi::best_finalized` runtime method.
 pub const BEST_FINALIZED_RIALTO_HEADER_METHOD: &str = "RialtoFinalityApi_best_finalized";
 

bridges/primitives/chain-rococo/src/lib.rs

@@ -72,6 +72,9 @@ pub fn derive_account_from_wococo_id(id: bp_runtime::SourceAccount<AccountId>) -
 	AccountIdConverter::convert(encoded_id)
 }
 
+/// Name of the With-Wococo messages pallet instance in the Rococo runtime.
+pub const WITH_WOCOCO_MESSAGES_PALLET_NAME: &str = "BridgeWococoMessages";
+
 /// Name of the `RococoFinalityApi::best_finalized` runtime method.
 pub const BEST_FINALIZED_ROCOCO_HEADER_METHOD: &str = "RococoFinalityApi_best_finalized";
 /// Name of the `RococoFinalityApi::is_known_header` runtime method.

bridges/primitives/chain-wococo/src/lib.rs

@@ -37,6 +37,9 @@ pub fn derive_account_from_rococo_id(id: bp_runtime::SourceAccount<AccountId>) -
 	AccountIdConverter::convert(encoded_id)
 }
 
+/// Name of the With-Rococo messages pallet instance in the Wococo runtime.
+pub const WITH_ROCOCO_MESSAGES_PALLET_NAME: &str = "BridgeRococoMessages";
+
 /// Name of the `WococoFinalityApi::best_finalized` runtime method.
 pub const BEST_FINALIZED_WOCOCO_HEADER_METHOD: &str = "WococoFinalityApi_best_finalized";
 /// Name of the `WococoFinalityApi::is_known_header` runtime method.

bridges/relays/bin-substrate/src/chains/millau_messages_to_rialto.rs

@@ -23,7 +23,6 @@ use frame_support::dispatch::GetDispatchInfo;
 use sp_core::{Bytes, Pair};
 
 use bp_messages::MessageNonce;
-use bp_runtime::{MILLAU_CHAIN_ID, RIALTO_CHAIN_ID};
 use bridge_runtime_common::messages::target::FromBridgedChainMessagesProof;
 use messages_relay::message_lane::MessageLane;
 use relay_millau_client::{HeaderId as MillauHeaderId, Millau, SigningParams as MillauSigningParams};
@@ -62,6 +61,9 @@ impl SubstrateMessageLane for MillauMessagesToRialto {
 	const BEST_FINALIZED_SOURCE_HEADER_ID_AT_TARGET: &'static str = bp_millau::BEST_FINALIZED_MILLAU_HEADER_METHOD;
 	const BEST_FINALIZED_TARGET_HEADER_ID_AT_SOURCE: &'static str = bp_rialto::BEST_FINALIZED_RIALTO_HEADER_METHOD;
 
+	const MESSAGE_PALLET_NAME_AT_SOURCE: &'static str = bp_millau::WITH_RIALTO_MESSAGES_PALLET_NAME;
+	const MESSAGE_PALLET_NAME_AT_TARGET: &'static str = bp_rialto::WITH_MILLAU_MESSAGES_PALLET_NAME;
+
 	type SourceChain = Millau;
 	type TargetChain = Rialto;
 
@@ -135,12 +137,10 @@ impl SubstrateMessageLane for MillauMessagesToRialto {
 }
 
 /// Millau node as messages source.
-type MillauSourceClient =
-	SubstrateMessagesSource<Millau, Rialto, MillauMessagesToRialto, millau_runtime::WithRialtoMessagesInstance>;
+type MillauSourceClient = SubstrateMessagesSource<Millau, Rialto, MillauMessagesToRialto>;
 
 /// Rialto node as messages target.
-type RialtoTargetClient =
-	SubstrateMessagesTarget<Millau, Rialto, MillauMessagesToRialto, rialto_runtime::WithMillauMessagesInstance>;
+type RialtoTargetClient = SubstrateMessagesTarget<Millau, Rialto, MillauMessagesToRialto>;
 
 /// Run Millau-to-Rialto messages sync.
 pub async fn run(
@@ -212,14 +212,12 @@ pub async fn run(
 			source_client.clone(),
 			lane.clone(),
 			lane_id,
-			RIALTO_CHAIN_ID,
 			params.target_to_source_headers_relay,
 		),
 		RialtoTargetClient::new(
 			params.target_client,
 			lane,
 			lane_id,
-			MILLAU_CHAIN_ID,
 			metrics_values,
 			params.source_to_target_headers_relay,
 		),

bridges/relays/bin-substrate/src/chains/rialto_messages_to_millau.rs

@@ -23,7 +23,6 @@ use frame_support::dispatch::GetDispatchInfo;
 use sp_core::{Bytes, Pair};
 
 use bp_messages::MessageNonce;
-use bp_runtime::{MILLAU_CHAIN_ID, RIALTO_CHAIN_ID};
 use bridge_runtime_common::messages::target::FromBridgedChainMessagesProof;
 use messages_relay::message_lane::MessageLane;
 use relay_millau_client::{HeaderId as MillauHeaderId, Millau, SigningParams as MillauSigningParams};
@@ -62,6 +61,9 @@ impl SubstrateMessageLane for RialtoMessagesToMillau {
 	const BEST_FINALIZED_SOURCE_HEADER_ID_AT_TARGET: &'static str = bp_rialto::BEST_FINALIZED_RIALTO_HEADER_METHOD;
 	const BEST_FINALIZED_TARGET_HEADER_ID_AT_SOURCE: &'static str = bp_millau::BEST_FINALIZED_MILLAU_HEADER_METHOD;
 
+	const MESSAGE_PALLET_NAME_AT_SOURCE: &'static str = bp_rialto::WITH_MILLAU_MESSAGES_PALLET_NAME;
+	const MESSAGE_PALLET_NAME_AT_TARGET: &'static str = bp_millau::WITH_RIALTO_MESSAGES_PALLET_NAME;
+
 	type SourceChain = Rialto;
 	type TargetChain = Millau;
 
@@ -135,12 +137,10 @@ impl SubstrateMessageLane for RialtoMessagesToMillau {
 }
 
 /// Rialto node as messages source.
-type RialtoSourceClient =
-	SubstrateMessagesSource<Rialto, Millau, RialtoMessagesToMillau, rialto_runtime::WithMillauMessagesInstance>;
+type RialtoSourceClient = SubstrateMessagesSource<Rialto, Millau, RialtoMessagesToMillau>;
 
 /// Millau node as messages target.
-type MillauTargetClient =
-	SubstrateMessagesTarget<Rialto, Millau, RialtoMessagesToMillau, millau_runtime::WithRialtoMessagesInstance>;
+type MillauTargetClient = SubstrateMessagesTarget<Rialto, Millau, RialtoMessagesToMillau>;
 
 /// Run Rialto-to-Millau messages sync.
 pub async fn run(
@@ -211,14 +211,12 @@ pub async fn run(
 			source_client.clone(),
 			lane.clone(),
 			lane_id,
-			MILLAU_CHAIN_ID,
 			params.target_to_source_headers_relay,
 		),
 		MillauTargetClient::new(
 			params.target_client,
 			lane,
 			lane_id,
-			RIALTO_CHAIN_ID,
 			metrics_values,
 			params.source_to_target_headers_relay,
 		),

bridges/relays/bin-substrate/src/chains/rococo_messages_to_wococo.rs

@@ -22,7 +22,6 @@ use codec::Encode;
 use sp_core::{Bytes, Pair};
 
 use bp_messages::MessageNonce;
-use bp_runtime::{ROCOCO_CHAIN_ID, WOCOCO_CHAIN_ID};
 use bridge_runtime_common::messages::target::FromBridgedChainMessagesProof;
 use messages_relay::message_lane::MessageLane;
 use relay_rococo_client::{HeaderId as RococoHeaderId, Rococo, SigningParams as RococoSigningParams};
@@ -61,6 +60,9 @@ impl SubstrateMessageLane for RococoMessagesToWococo {
 	const BEST_FINALIZED_SOURCE_HEADER_ID_AT_TARGET: &'static str = bp_rococo::BEST_FINALIZED_ROCOCO_HEADER_METHOD;
 	const BEST_FINALIZED_TARGET_HEADER_ID_AT_SOURCE: &'static str = bp_wococo::BEST_FINALIZED_WOCOCO_HEADER_METHOD;
 
+	const MESSAGE_PALLET_NAME_AT_SOURCE: &'static str = bp_rococo::WITH_WOCOCO_MESSAGES_PALLET_NAME;
+	const MESSAGE_PALLET_NAME_AT_TARGET: &'static str = bp_wococo::WITH_ROCOCO_MESSAGES_PALLET_NAME;
+
 	type SourceChain = Rococo;
 	type TargetChain = Wococo;
 
@@ -136,20 +138,10 @@ impl SubstrateMessageLane for RococoMessagesToWococo {
 }
 
 /// Rococo node as messages source.
-type RococoSourceClient = SubstrateMessagesSource<
-	Rococo,
-	Wococo,
-	RococoMessagesToWococo,
-	relay_rococo_client::runtime::WithWococoMessagesInstance,
->;
+type RococoSourceClient = SubstrateMessagesSource<Rococo, Wococo, RococoMessagesToWococo>;
 
 /// Wococo node as messages target.
-type WococoTargetClient = SubstrateMessagesTarget<
-	Rococo,
-	Wococo,
-	RococoMessagesToWococo,
-	relay_wococo_client::runtime::WithRococoMessagesInstance,
->;
+type WococoTargetClient = SubstrateMessagesTarget<Rococo, Wococo, RococoMessagesToWococo>;
 
 /// Run Rococo-to-Wococo messages sync.
 pub async fn run(
@@ -226,14 +218,12 @@ pub async fn run(
 			source_client.clone(),
 			lane.clone(),
 			lane_id,
-			WOCOCO_CHAIN_ID,
 			params.target_to_source_headers_relay,
 		),
 		WococoTargetClient::new(
 			params.target_client,
 			lane,
 			lane_id,
-			ROCOCO_CHAIN_ID,
 			metrics_values,
 			params.source_to_target_headers_relay,
 		),

bridges/relays/bin-substrate/src/chains/wococo_messages_to_rococo.rs

@@ -22,7 +22,6 @@ use codec::Encode;
 use sp_core::{Bytes, Pair};
 
 use bp_messages::MessageNonce;
-use bp_runtime::{ROCOCO_CHAIN_ID, WOCOCO_CHAIN_ID};
 use bridge_runtime_common::messages::target::FromBridgedChainMessagesProof;
 use messages_relay::message_lane::MessageLane;
 use relay_rococo_client::{HeaderId as RococoHeaderId, Rococo, SigningParams as RococoSigningParams};
@@ -60,6 +59,9 @@ impl SubstrateMessageLane for WococoMessagesToRococo {
 	const BEST_FINALIZED_SOURCE_HEADER_ID_AT_TARGET: &'static str = bp_wococo::BEST_FINALIZED_WOCOCO_HEADER_METHOD;
 	const BEST_FINALIZED_TARGET_HEADER_ID_AT_SOURCE: &'static str = bp_rococo::BEST_FINALIZED_ROCOCO_HEADER_METHOD;
 
+	const MESSAGE_PALLET_NAME_AT_SOURCE: &'static str = bp_wococo::WITH_ROCOCO_MESSAGES_PALLET_NAME;
+	const MESSAGE_PALLET_NAME_AT_TARGET: &'static str = bp_rococo::WITH_WOCOCO_MESSAGES_PALLET_NAME;
+
 	type SourceChain = Wococo;
 	type TargetChain = Rococo;
 
@@ -135,20 +137,10 @@ impl SubstrateMessageLane for WococoMessagesToRococo {
 }
 
 /// Wococo node as messages source.
-type WococoSourceClient = SubstrateMessagesSource<
-	Wococo,
-	Rococo,
-	WococoMessagesToRococo,
-	relay_wococo_client::runtime::WithRococoMessagesInstance,
->;
+type WococoSourceClient = SubstrateMessagesSource<Wococo, Rococo, WococoMessagesToRococo>;
 
 /// Rococo node as messages target.
-type RococoTargetClient = SubstrateMessagesTarget<
-	Wococo,
-	Rococo,
-	WococoMessagesToRococo,
-	relay_rococo_client::runtime::WithWococoMessagesInstance,
->;
+type RococoTargetClient = SubstrateMessagesTarget<Wococo, Rococo, WococoMessagesToRococo>;
 
 /// Run Wococo-to-Rococo messages sync.
 pub async fn run(
@@ -225,14 +217,12 @@ pub async fn run(
 			source_client.clone(),
 			lane.clone(),
 			lane_id,
-			ROCOCO_CHAIN_ID,
 			params.target_to_source_headers_relay,
 		),
 		RococoTargetClient::new(
 			params.target_client,
 			lane,
 			lane_id,
-			WOCOCO_CHAIN_ID,
 			metrics_values,
 			params.source_to_target_headers_relay,
 		),

bridges/relays/client-rococo/src/runtime.rs

@@ -22,9 +22,6 @@ use bp_runtime::Chain;
 use codec::{Decode, Encode};
 use frame_support::weights::Weight;
 
-/// Instance of messages pallet that is used to bridge with Wococo chain.
-pub type WithWococoMessagesInstance = pallet_bridge_messages::Instance1;
-
 /// Unchecked Rococo extrinsic.
 pub type UncheckedExtrinsic = bp_polkadot_core::UncheckedExtrinsic<Call>;
 

bridges/relays/client-wococo/src/runtime.rs

@@ -22,9 +22,6 @@ use bp_runtime::Chain;
 use codec::{Decode, Encode};
 use frame_support::weights::Weight;
 
-/// Instance of messages pallet that is used to bridge with Rococo chain.
-pub type WithRococoMessagesInstance = pallet_bridge_messages::DefaultInstance;
-
 /// Unchecked Wococo extrinsic.
 pub type UncheckedExtrinsic = bp_polkadot_core::UncheckedExtrinsic<Call>;
 

bridges/relays/lib-substrate-relay/src/messages_lane.rs

@@ -81,6 +81,11 @@ pub trait SubstrateMessageLane: 'static + Clone + Send + Sync {
 	/// Name of the runtime method that returns id of best finalized target header at source chain.
 	const BEST_FINALIZED_TARGET_HEADER_ID_AT_SOURCE: &'static str;
 
+	/// Name of the messages pallet as it is declared in the `construct_runtime!()` at source chain.
+	const MESSAGE_PALLET_NAME_AT_SOURCE: &'static str;
+	/// Name of the messages pallet as it is declared in the `construct_runtime!()` at target chain.
+	const MESSAGE_PALLET_NAME_AT_TARGET: &'static str;
+
 	/// Source chain.
 	type SourceChain: Chain;
 	/// Target chain.

bridges/relays/lib-substrate-relay/src/messages_source.rs

@@ -24,12 +24,12 @@ use crate::on_demand_headers::OnDemandHeadersRelay;
 
 use async_trait::async_trait;
 use bp_messages::{LaneId, MessageNonce, UnrewardedRelayersState};
-use bp_runtime::{messages::DispatchFeePayment, ChainId};
+use bp_runtime::messages::DispatchFeePayment;
 use bridge_runtime_common::messages::{
 	source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof,
 };
 use codec::{Decode, Encode};
-use frame_support::{traits::Instance, weights::Weight};
+use frame_support::weights::Weight;
 use messages_relay::message_lane::MessageLane;
 use messages_relay::{
 	message_lane::{SourceHeaderIdOf, TargetHeaderIdOf},
@@ -42,7 +42,7 @@ use relay_substrate_client::{Chain, Client, Error as SubstrateError, HashOf, Hea
 use relay_utils::{relay_loop::Client as RelayClient, BlockNumberBase, HeaderId};
 use sp_core::Bytes;
 use sp_runtime::{traits::Header as HeaderT, DeserializeOwned};
-use std::{marker::PhantomData, ops::RangeInclusive};
+use std::ops::RangeInclusive;
 
 /// Intermediate message proof returned by the source Substrate node. Includes everything
 /// required to submit to the target node: cumulative dispatch weight of bundled messages and
@@ -50,55 +50,47 @@ use std::{marker::PhantomData, ops::RangeInclusive};
 pub type SubstrateMessagesProof<C> = (Weight, FromBridgedChainMessagesProof<HashOf<C>>);
 
 /// Substrate client as Substrate messages source.
-pub struct SubstrateMessagesSource<SC: Chain, TC: Chain, P: SubstrateMessageLane, I> {
+pub struct SubstrateMessagesSource<SC: Chain, TC: Chain, P: SubstrateMessageLane> {
 	client: Client<SC>,
 	lane: P,
 	lane_id: LaneId,
-	instance: ChainId,
 	target_to_source_headers_relay: Option<OnDemandHeadersRelay<TC>>,
-	_phantom: PhantomData<I>,
 }
 
-impl<SC: Chain, TC: Chain, P: SubstrateMessageLane, I> SubstrateMessagesSource<SC, TC, P, I> {
+impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> SubstrateMessagesSource<SC, TC, P> {
 	/// Create new Substrate headers source.
 	pub fn new(
 		client: Client<SC>,
 		lane: P,
 		lane_id: LaneId,
-		instance: ChainId,
 		target_to_source_headers_relay: Option<OnDemandHeadersRelay<TC>>,
 	) -> Self {
 		SubstrateMessagesSource {
 			client,
 			lane,
 			lane_id,
-			instance,
 			target_to_source_headers_relay,
-			_phantom: Default::default(),
 		}
 	}
 }
 
-impl<SC: Chain, TC: Chain, P: SubstrateMessageLane, I> Clone for SubstrateMessagesSource<SC, TC, P, I> {
+impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> Clone for SubstrateMessagesSource<SC, TC, P> {
 	fn clone(&self) -> Self {
 		Self {
 			client: self.client.clone(),
 			lane: self.lane.clone(),
 			lane_id: self.lane_id,
-			instance: self.instance,
 			target_to_source_headers_relay: self.target_to_source_headers_relay.clone(),
-			_phantom: Default::default(),
 		}
 	}
 }
 
 #[async_trait]
-impl<SC, TC, P, I> RelayClient for SubstrateMessagesSource<SC, TC, P, I>
+impl<SC, TC, P> RelayClient for SubstrateMessagesSource<SC, TC, P>
 where
 	SC: Chain,
 	TC: Chain,
 	P: SubstrateMessageLane,
-	I: Send + Sync + Instance,
 {
 	type Error = SubstrateError;
 
@@ -108,7 +100,7 @@ where
 }
 
 #[async_trait]
-impl<SC, TC, P, I> SourceClient<P::MessageLane> for SubstrateMessagesSource<SC, TC, P, I>
+impl<SC, TC, P> SourceClient<P::MessageLane> for SubstrateMessagesSource<SC, TC, P>
 where
 	SC: Chain<
 		Hash = <P::MessageLane as MessageLane>::SourceHeaderHash,
@@ -132,7 +124,6 @@ where
 	>,
 	<P::MessageLane as MessageLane>::TargetHeaderNumber: Decode,
 	<P::MessageLane as MessageLane>::TargetHeaderHash: Decode,
-	I: Send + Sync + Instance,
 {
 	async fn state(&self) -> Result<SourceClientState<P::MessageLane>, SubstrateError> {
 		// we can't continue to deliver confirmations if source node is out of sync, because
@@ -217,12 +208,17 @@ where
 		let mut storage_keys = Vec::with_capacity(nonces.end().saturating_sub(*nonces.start()) as usize + 1);
 		let mut message_nonce = *nonces.start();
 		while message_nonce <= *nonces.end() {
-			let message_key = pallet_bridge_messages::storage_keys::message_key::<I>(&self.lane_id, message_nonce);
+			let message_key = pallet_bridge_messages::storage_keys::message_key(
+				P::MESSAGE_PALLET_NAME_AT_SOURCE,
+				&self.lane_id,
+				message_nonce,
+			);
 			storage_keys.push(message_key);
 			message_nonce += 1;
 		}
 		if proof_parameters.outbound_state_proof_required {
-			storage_keys.push(pallet_bridge_messages::storage_keys::outbound_lane_data_key::<I>(
+			storage_keys.push(pallet_bridge_messages::storage_keys::outbound_lane_data_key(
+				P::MESSAGE_PALLET_NAME_AT_SOURCE,
 				&self.lane_id,
 			));
 		}

bridges/relays/lib-substrate-relay/src/messages_target.rs

@@ -24,12 +24,11 @@ use crate::on_demand_headers::OnDemandHeadersRelay;
 
 use async_trait::async_trait;
 use bp_messages::{LaneId, MessageNonce, UnrewardedRelayersState};
-use bp_runtime::ChainId;
 use bridge_runtime_common::messages::{
 	source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof,
 };
 use codec::{Decode, Encode};
-use frame_support::{traits::Instance, weights::Weight};
+use frame_support::weights::Weight;
 use messages_relay::message_lane::MessageLane;
 use messages_relay::{
 	message_lane::{SourceHeaderIdOf, TargetHeaderIdOf},
@@ -40,7 +39,7 @@ use relay_substrate_client::{Chain, Client, Error as SubstrateError, HashOf};
 use relay_utils::{relay_loop::Client as RelayClient, BlockNumberBase, HeaderId};
 use sp_core::Bytes;
 use sp_runtime::{traits::Header as HeaderT, DeserializeOwned, FixedPointNumber, FixedU128};
-use std::{convert::TryFrom, marker::PhantomData, ops::RangeInclusive};
+use std::{convert::TryFrom, ops::RangeInclusive};
 
 /// Message receiving proof returned by the target Substrate node.
 pub type SubstrateMessagesReceivingProof<C> = (
@@ -49,23 +48,20 @@ pub type SubstrateMessagesReceivingProof<C> = (
 );
 
 /// Substrate client as Substrate messages target.
-pub struct SubstrateMessagesTarget<SC: Chain, TC: Chain, P: SubstrateMessageLane, I> {
+pub struct SubstrateMessagesTarget<SC: Chain, TC: Chain, P: SubstrateMessageLane> {
 	client: Client<TC>,
 	lane: P,
 	lane_id: LaneId,
-	instance: ChainId,
 	metric_values: StandaloneMessagesMetrics,
 	source_to_target_headers_relay: Option<OnDemandHeadersRelay<SC>>,
-	_phantom: PhantomData<I>,
 }
 
-impl<SC: Chain, TC: Chain, P: SubstrateMessageLane, I> SubstrateMessagesTarget<SC, TC, P, I> {
+impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> SubstrateMessagesTarget<SC, TC, P> {
 	/// Create new Substrate headers target.
 	pub fn new(
 		client: Client<TC>,
 		lane: P,
 		lane_id: LaneId,
-		instance: ChainId,
 		metric_values: StandaloneMessagesMetrics,
 		source_to_target_headers_relay: Option<OnDemandHeadersRelay<SC>>,
 	) -> Self {
@@ -73,35 +69,30 @@ impl<SC: Chain, TC: Chain, P: SubstrateMessageLane, I> SubstrateMessagesTarget<S
 			client,
 			lane,
 			lane_id,
-			instance,
 			metric_values,
 			source_to_target_headers_relay,
-			_phantom: Default::default(),
 		}
 	}
 }
 
-impl<SC: Chain, TC: Chain, P: SubstrateMessageLane, I> Clone for SubstrateMessagesTarget<SC, TC, P, I> {
+impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> Clone for SubstrateMessagesTarget<SC, TC, P> {
 	fn clone(&self) -> Self {
 		Self {
 			client: self.client.clone(),
 			lane: self.lane.clone(),
 			lane_id: self.lane_id,
-			instance: self.instance,
 			metric_values: self.metric_values.clone(),
 			source_to_target_headers_relay: self.source_to_target_headers_relay.clone(),
-			_phantom: Default::default(),
 		}
 	}
 }
 
 #[async_trait]
-impl<SC, TC, P, I> RelayClient for SubstrateMessagesTarget<SC, TC, P, I>
+impl<SC, TC, P> RelayClient for SubstrateMessagesTarget<SC, TC, P>
 where
 	SC: Chain,
 	TC: Chain,
 	P: SubstrateMessageLane,
-	I: Send + Sync + Instance,
 {
 	type Error = SubstrateError;
 
@@ -111,7 +102,7 @@ where
 }
 
 #[async_trait]
-impl<SC, TC, P, I> TargetClient<P::MessageLane> for SubstrateMessagesTarget<SC, TC, P, I>
+impl<SC, TC, P> TargetClient<P::MessageLane> for SubstrateMessagesTarget<SC, TC, P>
 where
 	SC: Chain<
 		Hash = <P::MessageLane as MessageLane>::SourceHeaderHash,
@@ -135,7 +126,6 @@ where
 	>,
 	<P::MessageLane as MessageLane>::SourceHeaderNumber: Decode,
 	<P::MessageLane as MessageLane>::SourceHeaderHash: Decode,
-	I: Send + Sync + Instance,
 {
 	async fn state(&self) -> Result<TargetClientState<P::MessageLane>, SubstrateError> {
 		// we can't continue to deliver messages if target node is out of sync, because
@@ -212,7 +202,10 @@ where
 		SubstrateError,
 	> {
 		let (id, relayers_state) = self.unrewarded_relayers_state(id).await?;
-		let inbound_data_key = pallet_bridge_messages::storage_keys::inbound_lane_data_key::<I>(&self.lane_id);
+		let inbound_data_key = pallet_bridge_messages::storage_keys::inbound_lane_data_key(
+			P::MESSAGE_PALLET_NAME_AT_TARGET,
+			&self.lane_id,
+		);
 		let proof = self
 			.client
 			.prove_storage(vec![inbound_data_key], id.1)