Common crate for substrate-relay (#1082)

* lib-substrate-relay

* pass to build

* remove unused file

* clippy && tests

* Changed follow suggestions

* License

* Make changes follow suggested

* docs

* fix fmt

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

@@ -16,25 +16,40 @@
 
 //! Millau-to-Rialto headers sync entrypoint.
 
-use crate::finality_pipeline::{SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate};
-
-use bp_header_chain::justification::GrandpaJustification;
 use codec::Encode;
-use relay_millau_client::{Millau, SyncHeader as MillauSyncHeader};
-use relay_rialto_client::{Rialto, SigningParams as RialtoSigningParams};
-use relay_substrate_client::{Chain, TransactionSignScheme};
 use sp_core::{Bytes, Pair};
 
+use bp_header_chain::justification::GrandpaJustification;
+use relay_millau_client::{Millau, SyncHeader as MillauSyncHeader};
+use relay_rialto_client::{Rialto, SigningParams as RialtoSigningParams};
+use relay_substrate_client::{Chain, Client, TransactionSignScheme};
+use substrate_relay_helper::finality_pipeline::{SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate};
+
 /// Millau-to-Rialto finality sync pipeline.
-pub(crate) type MillauFinalityToRialto = SubstrateFinalityToSubstrate<Millau, Rialto, RialtoSigningParams>;
+pub(crate) type FinalityPipelineMillauToRialto = SubstrateFinalityToSubstrate<Millau, Rialto, RialtoSigningParams>;
+
+#[derive(Clone, Debug)]
+pub(crate) struct MillauFinalityToRialto {
+	finality_pipeline: FinalityPipelineMillauToRialto,
+}
+
+impl MillauFinalityToRialto {
+	pub fn new(target_client: Client<Rialto>, target_sign: RialtoSigningParams) -> Self {
+		Self {
+			finality_pipeline: FinalityPipelineMillauToRialto::new(target_client, target_sign),
+		}
+	}
+}
 
 impl SubstrateFinalitySyncPipeline for MillauFinalityToRialto {
+	type FinalitySyncPipeline = FinalityPipelineMillauToRialto;
+
 	const BEST_FINALIZED_SOURCE_HEADER_ID_AT_TARGET: &'static str = bp_millau::BEST_FINALIZED_MILLAU_HEADER_METHOD;
 
 	type TargetChain = Rialto;
 
 	fn transactions_author(&self) -> bp_rialto::AccountId {
-		(*self.target_sign.public().as_array_ref()).into()
+		(*self.finality_pipeline.target_sign.public().as_array_ref()).into()
 	}
 
 	fn make_submit_finality_proof_transaction(
@@ -45,8 +60,13 @@ impl SubstrateFinalitySyncPipeline for MillauFinalityToRialto {
 	) -> Bytes {
 		let call = rialto_runtime::BridgeGrandpaMillauCall::submit_finality_proof(header.into_inner(), proof).into();
 
-		let genesis_hash = *self.target_client.genesis_hash();
-		let transaction = Rialto::sign_transaction(genesis_hash, &self.target_sign, transaction_nonce, call);
+		let genesis_hash = *self.finality_pipeline.target_client.genesis_hash();
+		let transaction = Rialto::sign_transaction(
+			genesis_hash,
+			&self.finality_pipeline.target_sign,
+			transaction_nonce,
+			call,
+		);
 
 		Bytes(transaction.encode())
 	}

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

@@ -16,31 +16,39 @@
 
 //! Millau-to-Rialto messages sync entrypoint.
 
-use crate::messages_lane::{
-	select_delivery_transaction_limits, MessagesRelayParams, StandaloneMessagesMetrics, SubstrateMessageLane,
-	SubstrateMessageLaneToSubstrate,
-};
-use crate::messages_source::SubstrateMessagesSource;
-use crate::messages_target::SubstrateMessagesTarget;
+use std::{ops::RangeInclusive, time::Duration};
+
+use codec::Encode;
+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 codec::Encode;
-use frame_support::dispatch::GetDispatchInfo;
 use messages_relay::message_lane::MessageLane;
 use relay_millau_client::{HeaderId as MillauHeaderId, Millau, SigningParams as MillauSigningParams};
 use relay_rialto_client::{HeaderId as RialtoHeaderId, Rialto, SigningParams as RialtoSigningParams};
 use relay_substrate_client::{Chain, Client, TransactionSignScheme};
 use relay_utils::metrics::MetricsParams;
-use sp_core::{Bytes, Pair};
-use std::{ops::RangeInclusive, time::Duration};
+use substrate_relay_helper::messages_lane::{
+	select_delivery_transaction_limits, MessagesRelayParams, StandaloneMessagesMetrics, SubstrateMessageLane,
+	SubstrateMessageLaneToSubstrate,
+};
+use substrate_relay_helper::messages_source::SubstrateMessagesSource;
+use substrate_relay_helper::messages_target::SubstrateMessagesTarget;
 
 /// Millau-to-Rialto message lane.
-pub type MillauMessagesToRialto =
+pub type MessageLaneMillauMessagesToRialto =
 	SubstrateMessageLaneToSubstrate<Millau, MillauSigningParams, Rialto, RialtoSigningParams>;
 
+#[derive(Clone)]
+pub struct MillauMessagesToRialto {
+	message_lane: MessageLaneMillauMessagesToRialto,
+}
+
 impl SubstrateMessageLane for MillauMessagesToRialto {
+	type MessageLane = MessageLaneMillauMessagesToRialto;
+
 	const OUTBOUND_LANE_MESSAGE_DETAILS_METHOD: &'static str = bp_rialto::TO_RIALTO_MESSAGE_DETAILS_METHOD;
 	const OUTBOUND_LANE_LATEST_GENERATED_NONCE_METHOD: &'static str =
 		bp_rialto::TO_RIALTO_LATEST_GENERATED_NONCE_METHOD;
@@ -58,21 +66,22 @@ impl SubstrateMessageLane for MillauMessagesToRialto {
 	type TargetChain = Rialto;
 
 	fn source_transactions_author(&self) -> bp_millau::AccountId {
-		(*self.source_sign.public().as_array_ref()).into()
+		(*self.message_lane.source_sign.public().as_array_ref()).into()
 	}
 
 	fn make_messages_receiving_proof_transaction(
 		&self,
 		transaction_nonce: <Millau as Chain>::Index,
 		_generated_at_block: RialtoHeaderId,
-		proof: <Self as MessageLane>::MessagesReceivingProof,
+		proof: <Self::MessageLane as MessageLane>::MessagesReceivingProof,
 	) -> Bytes {
 		let (relayers_state, proof) = proof;
 		let call: millau_runtime::Call =
 			millau_runtime::MessagesCall::receive_messages_delivery_proof(proof, relayers_state).into();
 		let call_weight = call.get_dispatch_info().weight;
-		let genesis_hash = *self.source_client.genesis_hash();
-		let transaction = Millau::sign_transaction(genesis_hash, &self.source_sign, transaction_nonce, call);
+		let genesis_hash = *self.message_lane.source_client.genesis_hash();
+		let transaction =
+			Millau::sign_transaction(genesis_hash, &self.message_lane.source_sign, transaction_nonce, call);
 		log::trace!(
 			target: "bridge",
 			"Prepared Rialto -> Millau confirmation transaction. Weight: {}/{}, size: {}/{}",
@@ -85,7 +94,7 @@ impl SubstrateMessageLane for MillauMessagesToRialto {
 	}
 
 	fn target_transactions_author(&self) -> bp_rialto::AccountId {
-		(*self.target_sign.public().as_array_ref()).into()
+		(*self.message_lane.target_sign.public().as_array_ref()).into()
 	}
 
 	fn make_messages_delivery_transaction(
@@ -93,7 +102,7 @@ impl SubstrateMessageLane for MillauMessagesToRialto {
 		transaction_nonce: <Rialto as Chain>::Index,
 		_generated_at_header: MillauHeaderId,
 		_nonces: RangeInclusive<MessageNonce>,
-		proof: <Self as MessageLane>::MessagesProof,
+		proof: <Self::MessageLane as MessageLane>::MessagesProof,
 	) -> Bytes {
 		let (dispatch_weight, proof) = proof;
 		let FromBridgedChainMessagesProof {
@@ -103,15 +112,16 @@ impl SubstrateMessageLane for MillauMessagesToRialto {
 		} = proof;
 		let messages_count = nonces_end - nonces_start + 1;
 		let call: rialto_runtime::Call = rialto_runtime::MessagesCall::receive_messages_proof(
-			self.relayer_id_at_source.clone(),
+			self.message_lane.relayer_id_at_source.clone(),
 			proof,
 			messages_count as _,
 			dispatch_weight,
 		)
 		.into();
 		let call_weight = call.get_dispatch_info().weight;
-		let genesis_hash = *self.target_client.genesis_hash();
-		let transaction = Rialto::sign_transaction(genesis_hash, &self.target_sign, transaction_nonce, call);
+		let genesis_hash = *self.message_lane.target_client.genesis_hash();
+		let transaction =
+			Rialto::sign_transaction(genesis_hash, &self.message_lane.target_sign, transaction_nonce, call);
 		log::trace!(
 			target: "bridge",
 			"Prepared Millau -> Rialto delivery transaction. Weight: {}/{}, size: {}/{}",
@@ -142,11 +152,13 @@ pub async fn run(
 	let lane_id = params.lane_id;
 	let source_client = params.source_client;
 	let lane = MillauMessagesToRialto {
-		source_client: source_client.clone(),
-		source_sign: params.source_sign,
-		target_client: params.target_client.clone(),
-		target_sign: params.target_sign,
-		relayer_id_at_source: relayer_id_at_millau,
+		message_lane: SubstrateMessageLaneToSubstrate {
+			source_client: source_client.clone(),
+			source_sign: params.source_sign,
+			target_client: params.target_client.clone(),
+			target_sign: params.target_sign,
+			relayer_id_at_source: relayer_id_at_millau,
+		},
 	};
 
 	// 2/3 is reserved for proofs and tx overhead
@@ -166,7 +178,7 @@ pub async fn run(
 			Max messages size in single transaction: {}\n\t\
 			Max messages weight in single transaction: {}\n\t\
 			Relayer mode: {:?}",
-		lane.relayer_id_at_source,
+		lane.message_lane.relayer_id_at_source,
 		max_messages_in_single_batch,
 		max_messages_size_in_single_batch,
 		max_messages_weight_in_single_batch,
@@ -175,7 +187,7 @@ pub async fn run(
 
 	let (metrics_params, metrics_values) = add_standalone_metrics(
 		Some(messages_relay::message_lane_loop::metrics_prefix::<
-			MillauMessagesToRialto,
+			<MillauMessagesToRialto as SubstrateMessageLane>::MessageLane,
 		>(&lane_id)),
 		params.metrics_params,
 		source_client.clone(),
@@ -223,7 +235,7 @@ pub(crate) fn add_standalone_metrics(
 	metrics_params: MetricsParams,
 	source_client: Client<Millau>,
 ) -> anyhow::Result<(MetricsParams, StandaloneMessagesMetrics)> {
-	crate::messages_lane::add_standalone_metrics::<MillauMessagesToRialto>(
+	substrate_relay_helper::messages_lane::add_standalone_metrics::<MillauMessagesToRialto>(
 		metrics_prefix,
 		metrics_params,
 		source_client,

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

@@ -41,7 +41,7 @@ pub(crate) const RIALTO_ASSOCIATED_TOKEN_ID: &str = "bitcoin";
 /// The identifier of token, which value is associated with Millau token value by relayer.
 pub(crate) const MILLAU_ASSOCIATED_TOKEN_ID: &str = "wrapped-bitcoin";
 
-use relay_utils::metrics::{FloatJsonValueMetric, MetricsParams, PrometheusError, Registry};
+use relay_utils::metrics::MetricsParams;
 
 pub(crate) fn add_polkadot_kusama_price_metrics<T: finality_relay::FinalitySyncPipeline>(
 	prefix: Option<String>,
@@ -50,33 +50,15 @@ pub(crate) fn add_polkadot_kusama_price_metrics<T: finality_relay::FinalitySyncP
 	// Polkadot/Kusama prices are added as metrics here, because atm we don't have Polkadot <-> Kusama
 	// relays, but we want to test metrics/dashboards in advance
 	Ok(relay_utils::relay_metrics(prefix, params)
-		.standalone_metric(|registry, prefix| token_price_metric(registry, prefix, "polkadot"))?
-		.standalone_metric(|registry, prefix| token_price_metric(registry, prefix, "kusama"))?
+		.standalone_metric(|registry, prefix| {
+			substrate_relay_helper::helpers::token_price_metric(registry, prefix, "polkadot")
+		})?
+		.standalone_metric(|registry, prefix| {
+			substrate_relay_helper::helpers::token_price_metric(registry, prefix, "kusama")
+		})?
 		.into_params())
 }
 
-/// Creates standalone token price metric.
-pub(crate) fn token_price_metric(
-	registry: &Registry,
-	prefix: Option<&str>,
-	token_id: &str,
-) -> Result<FloatJsonValueMetric, PrometheusError> {
-	FloatJsonValueMetric::new(
-		registry,
-		prefix,
-		format!(
-			"https://api.coingecko.com/api/v3/simple/price?ids={}&vs_currencies=btc",
-			token_id
-		),
-		format!("$.{}.btc", token_id),
-		format!("{}_to_base_conversion_rate", token_id.replace("-", "_")),
-		format!(
-			"Rate used to convert from {} to some BASE tokens",
-			token_id.to_uppercase()
-		),
-	)
-}
-
 #[cfg(test)]
 mod tests {
 	use crate::cli::{encode_call, send_message};

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

@@ -16,25 +16,41 @@
 
 //! Rialto-to-Millau headers sync entrypoint.
 
-use crate::finality_pipeline::{SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate};
-
-use bp_header_chain::justification::GrandpaJustification;
 use codec::Encode;
-use relay_millau_client::{Millau, SigningParams as MillauSigningParams};
-use relay_rialto_client::{Rialto, SyncHeader as RialtoSyncHeader};
-use relay_substrate_client::{Chain, TransactionSignScheme};
 use sp_core::{Bytes, Pair};
 
+use bp_header_chain::justification::GrandpaJustification;
+use relay_millau_client::{Millau, SigningParams as MillauSigningParams};
+use relay_rialto_client::{Rialto, SyncHeader as RialtoSyncHeader};
+use relay_substrate_client::{Chain, Client, TransactionSignScheme};
+use substrate_relay_helper::finality_pipeline::{SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate};
+
 /// Rialto-to-Millau finality sync pipeline.
-pub(crate) type RialtoFinalityToMillau = SubstrateFinalityToSubstrate<Rialto, Millau, MillauSigningParams>;
+pub(crate) type FinalityPipelineRialtoFinalityToMillau =
+	SubstrateFinalityToSubstrate<Rialto, Millau, MillauSigningParams>;
+
+#[derive(Clone, Debug)]
+pub struct RialtoFinalityToMillau {
+	finality_pipeline: FinalityPipelineRialtoFinalityToMillau,
+}
+
+impl RialtoFinalityToMillau {
+	pub fn new(target_client: Client<Millau>, target_sign: MillauSigningParams) -> Self {
+		Self {
+			finality_pipeline: FinalityPipelineRialtoFinalityToMillau::new(target_client, target_sign),
+		}
+	}
+}
 
 impl SubstrateFinalitySyncPipeline for RialtoFinalityToMillau {
+	type FinalitySyncPipeline = FinalityPipelineRialtoFinalityToMillau;
+
 	const BEST_FINALIZED_SOURCE_HEADER_ID_AT_TARGET: &'static str = bp_rialto::BEST_FINALIZED_RIALTO_HEADER_METHOD;
 
 	type TargetChain = Millau;
 
 	fn transactions_author(&self) -> bp_millau::AccountId {
-		(*self.target_sign.public().as_array_ref()).into()
+		(*self.finality_pipeline.target_sign.public().as_array_ref()).into()
 	}
 
 	fn make_submit_finality_proof_transaction(
@@ -49,8 +65,13 @@ impl SubstrateFinalitySyncPipeline for RialtoFinalityToMillau {
 		>::submit_finality_proof(header.into_inner(), proof)
 		.into();
 
-		let genesis_hash = *self.target_client.genesis_hash();
-		let transaction = Millau::sign_transaction(genesis_hash, &self.target_sign, transaction_nonce, call);
+		let genesis_hash = *self.finality_pipeline.target_client.genesis_hash();
+		let transaction = Millau::sign_transaction(
+			genesis_hash,
+			&self.finality_pipeline.target_sign,
+			transaction_nonce,
+			call,
+		);
 
 		Bytes(transaction.encode())
 	}

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

@@ -16,31 +16,39 @@
 
 //! Rialto-to-Millau messages sync entrypoint.
 
-use crate::messages_lane::{
-	select_delivery_transaction_limits, MessagesRelayParams, StandaloneMessagesMetrics, SubstrateMessageLane,
-	SubstrateMessageLaneToSubstrate,
-};
-use crate::messages_source::SubstrateMessagesSource;
-use crate::messages_target::SubstrateMessagesTarget;
+use std::{ops::RangeInclusive, time::Duration};
+
+use codec::Encode;
+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 codec::Encode;
-use frame_support::dispatch::GetDispatchInfo;
 use messages_relay::message_lane::MessageLane;
 use relay_millau_client::{HeaderId as MillauHeaderId, Millau, SigningParams as MillauSigningParams};
 use relay_rialto_client::{HeaderId as RialtoHeaderId, Rialto, SigningParams as RialtoSigningParams};
 use relay_substrate_client::{Chain, Client, TransactionSignScheme};
 use relay_utils::metrics::MetricsParams;
-use sp_core::{Bytes, Pair};
-use std::{ops::RangeInclusive, time::Duration};
+use substrate_relay_helper::messages_lane::{
+	select_delivery_transaction_limits, MessagesRelayParams, StandaloneMessagesMetrics, SubstrateMessageLane,
+	SubstrateMessageLaneToSubstrate,
+};
+use substrate_relay_helper::messages_source::SubstrateMessagesSource;
+use substrate_relay_helper::messages_target::SubstrateMessagesTarget;
 
 /// Rialto-to-Millau message lane.
-pub type RialtoMessagesToMillau =
+pub type MessageLaneRialtoMessagesToMillau =
 	SubstrateMessageLaneToSubstrate<Rialto, RialtoSigningParams, Millau, MillauSigningParams>;
 
+#[derive(Clone)]
+pub struct RialtoMessagesToMillau {
+	message_lane: MessageLaneRialtoMessagesToMillau,
+}
+
 impl SubstrateMessageLane for RialtoMessagesToMillau {
+	type MessageLane = MessageLaneRialtoMessagesToMillau;
+
 	const OUTBOUND_LANE_MESSAGE_DETAILS_METHOD: &'static str = bp_millau::TO_MILLAU_MESSAGE_DETAILS_METHOD;
 	const OUTBOUND_LANE_LATEST_GENERATED_NONCE_METHOD: &'static str =
 		bp_millau::TO_MILLAU_LATEST_GENERATED_NONCE_METHOD;
@@ -58,21 +66,22 @@ impl SubstrateMessageLane for RialtoMessagesToMillau {
 	type TargetChain = Millau;
 
 	fn source_transactions_author(&self) -> bp_rialto::AccountId {
-		(*self.source_sign.public().as_array_ref()).into()
+		(*self.message_lane.source_sign.public().as_array_ref()).into()
 	}
 
 	fn make_messages_receiving_proof_transaction(
 		&self,
 		transaction_nonce: <Rialto as Chain>::Index,
 		_generated_at_block: MillauHeaderId,
-		proof: <Self as MessageLane>::MessagesReceivingProof,
+		proof: <Self::MessageLane as MessageLane>::MessagesReceivingProof,
 	) -> Bytes {
 		let (relayers_state, proof) = proof;
 		let call: rialto_runtime::Call =
 			rialto_runtime::MessagesCall::receive_messages_delivery_proof(proof, relayers_state).into();
 		let call_weight = call.get_dispatch_info().weight;
-		let genesis_hash = *self.source_client.genesis_hash();
-		let transaction = Rialto::sign_transaction(genesis_hash, &self.source_sign, transaction_nonce, call);
+		let genesis_hash = *self.message_lane.source_client.genesis_hash();
+		let transaction =
+			Rialto::sign_transaction(genesis_hash, &self.message_lane.source_sign, transaction_nonce, call);
 		log::trace!(
 			target: "bridge",
 			"Prepared Millau -> Rialto confirmation transaction. Weight: {}/{}, size: {}/{}",
@@ -85,7 +94,7 @@ impl SubstrateMessageLane for RialtoMessagesToMillau {
 	}
 
 	fn target_transactions_author(&self) -> bp_millau::AccountId {
-		(*self.target_sign.public().as_array_ref()).into()
+		(*self.message_lane.target_sign.public().as_array_ref()).into()
 	}
 
 	fn make_messages_delivery_transaction(
@@ -93,7 +102,7 @@ impl SubstrateMessageLane for RialtoMessagesToMillau {
 		transaction_nonce: <Millau as Chain>::Index,
 		_generated_at_header: RialtoHeaderId,
 		_nonces: RangeInclusive<MessageNonce>,
-		proof: <Self as MessageLane>::MessagesProof,
+		proof: <Self::MessageLane as MessageLane>::MessagesProof,
 	) -> Bytes {
 		let (dispatch_weight, proof) = proof;
 		let FromBridgedChainMessagesProof {
@@ -103,15 +112,16 @@ impl SubstrateMessageLane for RialtoMessagesToMillau {
 		} = proof;
 		let messages_count = nonces_end - nonces_start + 1;
 		let call: millau_runtime::Call = millau_runtime::MessagesCall::receive_messages_proof(
-			self.relayer_id_at_source.clone(),
+			self.message_lane.relayer_id_at_source.clone(),
 			proof,
 			messages_count as _,
 			dispatch_weight,
 		)
 		.into();
 		let call_weight = call.get_dispatch_info().weight;
-		let genesis_hash = *self.target_client.genesis_hash();
-		let transaction = Millau::sign_transaction(genesis_hash, &self.target_sign, transaction_nonce, call);
+		let genesis_hash = *self.message_lane.target_client.genesis_hash();
+		let transaction =
+			Millau::sign_transaction(genesis_hash, &self.message_lane.target_sign, transaction_nonce, call);
 		log::trace!(
 			target: "bridge",
 			"Prepared Rialto -> Millau delivery transaction. Weight: {}/{}, size: {}/{}",
@@ -142,11 +152,13 @@ pub async fn run(
 	let lane_id = params.lane_id;
 	let source_client = params.source_client;
 	let lane = RialtoMessagesToMillau {
-		source_client: source_client.clone(),
-		source_sign: params.source_sign,
-		target_client: params.target_client.clone(),
-		target_sign: params.target_sign,
-		relayer_id_at_source: relayer_id_at_rialto,
+		message_lane: SubstrateMessageLaneToSubstrate {
+			source_client: source_client.clone(),
+			source_sign: params.source_sign,
+			target_client: params.target_client.clone(),
+			target_sign: params.target_sign,
+			relayer_id_at_source: relayer_id_at_rialto,
+		},
 	};
 
 	// 2/3 is reserved for proofs and tx overhead
@@ -165,7 +177,7 @@ pub async fn run(
 			Max messages size in single transaction: {}\n\t\
 			Max messages weight in single transaction: {}\n\t\
 			Relayer mode: {:?}",
-		lane.relayer_id_at_source,
+		lane.message_lane.relayer_id_at_source,
 		max_messages_in_single_batch,
 		max_messages_size_in_single_batch,
 		max_messages_weight_in_single_batch,
@@ -174,7 +186,7 @@ pub async fn run(
 
 	let (metrics_params, metrics_values) = add_standalone_metrics(
 		Some(messages_relay::message_lane_loop::metrics_prefix::<
-			RialtoMessagesToMillau,
+			<RialtoMessagesToMillau as SubstrateMessageLane>::MessageLane,
 		>(&lane_id)),
 		params.metrics_params,
 		source_client.clone(),
@@ -222,7 +234,7 @@ pub(crate) fn add_standalone_metrics(
 	metrics_params: MetricsParams,
 	source_client: Client<Rialto>,
 ) -> anyhow::Result<(MetricsParams, StandaloneMessagesMetrics)> {
-	crate::messages_lane::add_standalone_metrics::<RialtoMessagesToMillau>(
+	substrate_relay_helper::messages_lane::add_standalone_metrics::<RialtoMessagesToMillau>(
 		metrics_prefix,
 		metrics_params,
 		source_client,

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

@@ -16,43 +16,63 @@
 
 //! Rococo-to-Wococo headers sync entrypoint.
 
-use crate::chains::wococo_headers_to_rococo::MAXIMAL_BALANCE_DECREASE_PER_DAY;
-use crate::finality_pipeline::{SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate};
-
-use bp_header_chain::justification::GrandpaJustification;
 use codec::Encode;
-use relay_rococo_client::{Rococo, SyncHeader as RococoSyncHeader};
-use relay_substrate_client::{Chain, TransactionSignScheme};
-use relay_utils::metrics::MetricsParams;
-use relay_wococo_client::{SigningParams as WococoSigningParams, Wococo};
 use sp_core::{Bytes, Pair};
 
+use bp_header_chain::justification::GrandpaJustification;
+use relay_rococo_client::{Rococo, SyncHeader as RococoSyncHeader};
+use relay_substrate_client::{Chain, Client, TransactionSignScheme};
+use relay_utils::metrics::MetricsParams;
+use relay_wococo_client::{SigningParams as WococoSigningParams, Wococo};
+use substrate_relay_helper::finality_pipeline::{SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate};
+
+use crate::chains::wococo_headers_to_rococo::MAXIMAL_BALANCE_DECREASE_PER_DAY;
+
 /// Rococo-to-Wococo finality sync pipeline.
-pub(crate) type RococoFinalityToWococo = SubstrateFinalityToSubstrate<Rococo, Wococo, WococoSigningParams>;
+pub(crate) type FinalityPipelineRococoFinalityToWococo =
+	SubstrateFinalityToSubstrate<Rococo, Wococo, WococoSigningParams>;
+
+#[derive(Clone, Debug)]
+pub(crate) struct RococoFinalityToWococo {
+	finality_pipeline: FinalityPipelineRococoFinalityToWococo,
+}
+
+impl RococoFinalityToWococo {
+	pub fn new(target_client: Client<Wococo>, target_sign: WococoSigningParams) -> Self {
+		Self {
+			finality_pipeline: FinalityPipelineRococoFinalityToWococo::new(target_client, target_sign),
+		}
+	}
+}
 
 impl SubstrateFinalitySyncPipeline for RococoFinalityToWococo {
+	type FinalitySyncPipeline = FinalityPipelineRococoFinalityToWococo;
+
 	const BEST_FINALIZED_SOURCE_HEADER_ID_AT_TARGET: &'static str = bp_rococo::BEST_FINALIZED_ROCOCO_HEADER_METHOD;
 
 	type TargetChain = Wococo;
 
 	fn customize_metrics(params: MetricsParams) -> anyhow::Result<MetricsParams> {
-		crate::chains::add_polkadot_kusama_price_metrics::<Self>(Some(finality_relay::metrics_prefix::<Self>()), params)
+		crate::chains::add_polkadot_kusama_price_metrics::<Self::FinalitySyncPipeline>(
+			Some(finality_relay::metrics_prefix::<Self::FinalitySyncPipeline>()),
+			params,
+		)
 	}
 
 	fn start_relay_guards(&self) {
 		relay_substrate_client::guard::abort_on_spec_version_change(
-			self.target_client.clone(),
+			self.finality_pipeline.target_client.clone(),
 			bp_wococo::VERSION.spec_version,
 		);
 		relay_substrate_client::guard::abort_when_account_balance_decreased(
-			self.target_client.clone(),
+			self.finality_pipeline.target_client.clone(),
 			self.transactions_author(),
 			MAXIMAL_BALANCE_DECREASE_PER_DAY,
 		);
 	}
 
 	fn transactions_author(&self) -> bp_wococo::AccountId {
-		(*self.target_sign.public().as_array_ref()).into()
+		(*self.finality_pipeline.target_sign.public().as_array_ref()).into()
 	}
 
 	fn make_submit_finality_proof_transaction(
@@ -64,8 +84,13 @@ impl SubstrateFinalitySyncPipeline for RococoFinalityToWococo {
 		let call = relay_wococo_client::runtime::Call::BridgeGrandpaRococo(
 			relay_wococo_client::runtime::BridgeGrandpaRococoCall::submit_finality_proof(header.into_inner(), proof),
 		);
-		let genesis_hash = *self.target_client.genesis_hash();
-		let transaction = Wococo::sign_transaction(genesis_hash, &self.target_sign, transaction_nonce, call);
+		let genesis_hash = *self.finality_pipeline.target_client.genesis_hash();
+		let transaction = Wococo::sign_transaction(
+			genesis_hash,
+			&self.finality_pipeline.target_sign,
+			transaction_nonce,
+			call,
+		);
 
 		Bytes(transaction.encode())
 	}

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

@@ -16,30 +16,38 @@
 
 //! Rococo-to-Wococo messages sync entrypoint.
 
-use crate::messages_lane::{
-	select_delivery_transaction_limits, MessagesRelayParams, StandaloneMessagesMetrics, SubstrateMessageLane,
-	SubstrateMessageLaneToSubstrate,
-};
-use crate::messages_source::SubstrateMessagesSource;
-use crate::messages_target::SubstrateMessagesTarget;
+use std::{ops::RangeInclusive, time::Duration};
+
+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 codec::Encode;
 use messages_relay::message_lane::MessageLane;
 use relay_rococo_client::{HeaderId as RococoHeaderId, Rococo, SigningParams as RococoSigningParams};
 use relay_substrate_client::{Chain, Client, TransactionSignScheme};
 use relay_utils::metrics::MetricsParams;
 use relay_wococo_client::{HeaderId as WococoHeaderId, SigningParams as WococoSigningParams, Wococo};
-use sp_core::{Bytes, Pair};
-use std::{ops::RangeInclusive, time::Duration};
+use substrate_relay_helper::messages_lane::{
+	select_delivery_transaction_limits, MessagesRelayParams, StandaloneMessagesMetrics, SubstrateMessageLane,
+	SubstrateMessageLaneToSubstrate,
+};
+use substrate_relay_helper::messages_source::SubstrateMessagesSource;
+use substrate_relay_helper::messages_target::SubstrateMessagesTarget;
 
 /// Rococo-to-Wococo message lane.
-pub type RococoMessagesToWococo =
+pub type MessageLaneRococoMessagesToWococo =
 	SubstrateMessageLaneToSubstrate<Rococo, RococoSigningParams, Wococo, WococoSigningParams>;
 
+#[derive(Clone)]
+pub struct RococoMessagesToWococo {
+	message_lane: MessageLaneRococoMessagesToWococo,
+}
+
 impl SubstrateMessageLane for RococoMessagesToWococo {
+	type MessageLane = MessageLaneRococoMessagesToWococo;
+
 	const OUTBOUND_LANE_MESSAGE_DETAILS_METHOD: &'static str = bp_wococo::TO_WOCOCO_MESSAGE_DETAILS_METHOD;
 	const OUTBOUND_LANE_LATEST_GENERATED_NONCE_METHOD: &'static str =
 		bp_wococo::TO_WOCOCO_LATEST_GENERATED_NONCE_METHOD;
@@ -57,14 +65,14 @@ impl SubstrateMessageLane for RococoMessagesToWococo {
 	type TargetChain = Wococo;
 
 	fn source_transactions_author(&self) -> bp_rococo::AccountId {
-		(*self.source_sign.public().as_array_ref()).into()
+		(*self.message_lane.source_sign.public().as_array_ref()).into()
 	}
 
 	fn make_messages_receiving_proof_transaction(
 		&self,
 		transaction_nonce: <Rococo as Chain>::Index,
 		_generated_at_block: WococoHeaderId,
-		proof: <Self as MessageLane>::MessagesReceivingProof,
+		proof: <Self::MessageLane as MessageLane>::MessagesReceivingProof,
 	) -> Bytes {
 		let (relayers_state, proof) = proof;
 		let call = relay_rococo_client::runtime::Call::BridgeMessagesWococo(
@@ -73,8 +81,9 @@ impl SubstrateMessageLane for RococoMessagesToWococo {
 				relayers_state,
 			),
 		);
-		let genesis_hash = *self.source_client.genesis_hash();
-		let transaction = Rococo::sign_transaction(genesis_hash, &self.source_sign, transaction_nonce, call);
+		let genesis_hash = *self.message_lane.source_client.genesis_hash();
+		let transaction =
+			Rococo::sign_transaction(genesis_hash, &self.message_lane.source_sign, transaction_nonce, call);
 		log::trace!(
 			target: "bridge",
 			"Prepared Wococo -> Rococo confirmation transaction. Weight: <unknown>/{}, size: {}/{}",
@@ -86,7 +95,7 @@ impl SubstrateMessageLane for RococoMessagesToWococo {
 	}
 
 	fn target_transactions_author(&self) -> bp_wococo::AccountId {
-		(*self.target_sign.public().as_array_ref()).into()
+		(*self.message_lane.target_sign.public().as_array_ref()).into()
 	}
 
 	fn make_messages_delivery_transaction(
@@ -94,7 +103,7 @@ impl SubstrateMessageLane for RococoMessagesToWococo {
 		transaction_nonce: <Wococo as Chain>::Index,
 		_generated_at_header: RococoHeaderId,
 		_nonces: RangeInclusive<MessageNonce>,
-		proof: <Self as MessageLane>::MessagesProof,
+		proof: <Self::MessageLane as MessageLane>::MessagesProof,
 	) -> Bytes {
 		let (dispatch_weight, proof) = proof;
 		let FromBridgedChainMessagesProof {
@@ -106,14 +115,15 @@ impl SubstrateMessageLane for RococoMessagesToWococo {
 
 		let call = relay_wococo_client::runtime::Call::BridgeMessagesRococo(
 			relay_wococo_client::runtime::BridgeMessagesRococoCall::receive_messages_proof(
-				self.relayer_id_at_source.clone(),
+				self.message_lane.relayer_id_at_source.clone(),
 				proof,
 				messages_count as _,
 				dispatch_weight,
 			),
 		);
-		let genesis_hash = *self.target_client.genesis_hash();
-		let transaction = Wococo::sign_transaction(genesis_hash, &self.target_sign, transaction_nonce, call);
+		let genesis_hash = *self.message_lane.target_client.genesis_hash();
+		let transaction =
+			Wococo::sign_transaction(genesis_hash, &self.message_lane.target_sign, transaction_nonce, call);
 		log::trace!(
 			target: "bridge",
 			"Prepared Rococo -> Wococo delivery transaction. Weight: <unknown>/{}, size: {}/{}",
@@ -151,11 +161,13 @@ pub async fn run(
 	let lane_id = params.lane_id;
 	let source_client = params.source_client;
 	let lane = RococoMessagesToWococo {
-		source_client: source_client.clone(),
-		source_sign: params.source_sign,
-		target_client: params.target_client.clone(),
-		target_sign: params.target_sign,
-		relayer_id_at_source: relayer_id_at_rococo,
+		message_lane: SubstrateMessageLaneToSubstrate {
+			source_client: source_client.clone(),
+			source_sign: params.source_sign,
+			target_client: params.target_client.clone(),
+			target_sign: params.target_sign,
+			relayer_id_at_source: relayer_id_at_rococo,
+		},
 	};
 
 	// 2/3 is reserved for proofs and tx overhead
@@ -180,7 +192,7 @@ pub async fn run(
 			Max messages size in single transaction: {}\n\t\
 			Max messages weight in single transaction: {}\n\t\
 			Relayer mode: {:?}",
-		lane.relayer_id_at_source,
+		lane.message_lane.relayer_id_at_source,
 		max_messages_in_single_batch,
 		max_messages_size_in_single_batch,
 		max_messages_weight_in_single_batch,
@@ -189,7 +201,7 @@ pub async fn run(
 
 	let (metrics_params, metrics_values) = add_standalone_metrics(
 		Some(messages_relay::message_lane_loop::metrics_prefix::<
-			RococoMessagesToWococo,
+			<RococoMessagesToWococo as SubstrateMessageLane>::MessageLane,
 		>(&lane_id)),
 		params.metrics_params,
 		source_client.clone(),
@@ -237,7 +249,7 @@ pub(crate) fn add_standalone_metrics(
 	metrics_params: MetricsParams,
 	source_client: Client<Rococo>,
 ) -> anyhow::Result<(MetricsParams, StandaloneMessagesMetrics)> {
-	crate::messages_lane::add_standalone_metrics::<RococoMessagesToWococo>(
+	substrate_relay_helper::messages_lane::add_standalone_metrics::<RococoMessagesToWococo>(
 		metrics_prefix,
 		metrics_params,
 		source_client,

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

@@ -16,30 +16,49 @@
 
 //! Westend-to-Millau headers sync entrypoint.
 
-use crate::finality_pipeline::{SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate};
-
-use bp_header_chain::justification::GrandpaJustification;
 use codec::Encode;
-use relay_millau_client::{Millau, SigningParams as MillauSigningParams};
-use relay_substrate_client::{Chain, TransactionSignScheme};
-use relay_utils::metrics::MetricsParams;
-use relay_westend_client::{SyncHeader as WestendSyncHeader, Westend};
 use sp_core::{Bytes, Pair};
 
+use bp_header_chain::justification::GrandpaJustification;
+use relay_millau_client::{Millau, SigningParams as MillauSigningParams};
+use relay_substrate_client::{Chain, Client, TransactionSignScheme};
+use relay_utils::metrics::MetricsParams;
+use relay_westend_client::{SyncHeader as WestendSyncHeader, Westend};
+use substrate_relay_helper::finality_pipeline::{SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate};
+
 /// Westend-to-Millau finality sync pipeline.
-pub(crate) type WestendFinalityToMillau = SubstrateFinalityToSubstrate<Westend, Millau, MillauSigningParams>;
+pub(crate) type FinalityPipelineWestendFinalityToMillau =
+	SubstrateFinalityToSubstrate<Westend, Millau, MillauSigningParams>;
+
+#[derive(Clone, Debug)]
+pub(crate) struct WestendFinalityToMillau {
+	finality_pipeline: FinalityPipelineWestendFinalityToMillau,
+}
+
+impl WestendFinalityToMillau {
+	pub fn new(target_client: Client<Millau>, target_sign: MillauSigningParams) -> Self {
+		Self {
+			finality_pipeline: FinalityPipelineWestendFinalityToMillau::new(target_client, target_sign),
+		}
+	}
+}
 
 impl SubstrateFinalitySyncPipeline for WestendFinalityToMillau {
+	type FinalitySyncPipeline = FinalityPipelineWestendFinalityToMillau;
+
 	const BEST_FINALIZED_SOURCE_HEADER_ID_AT_TARGET: &'static str = bp_westend::BEST_FINALIZED_WESTEND_HEADER_METHOD;
 
 	type TargetChain = Millau;
 
 	fn customize_metrics(params: MetricsParams) -> anyhow::Result<MetricsParams> {
-		crate::chains::add_polkadot_kusama_price_metrics::<Self>(Some(finality_relay::metrics_prefix::<Self>()), params)
+		crate::chains::add_polkadot_kusama_price_metrics::<Self::FinalitySyncPipeline>(
+			Some(finality_relay::metrics_prefix::<Self::FinalitySyncPipeline>()),
+			params,
+		)
 	}
 
 	fn transactions_author(&self) -> bp_millau::AccountId {
-		(*self.target_sign.public().as_array_ref()).into()
+		(*self.finality_pipeline.target_sign.public().as_array_ref()).into()
 	}
 
 	fn make_submit_finality_proof_transaction(
@@ -54,8 +73,13 @@ impl SubstrateFinalitySyncPipeline for WestendFinalityToMillau {
 		>::submit_finality_proof(header.into_inner(), proof)
 		.into();
 
-		let genesis_hash = *self.target_client.genesis_hash();
-		let transaction = Millau::sign_transaction(genesis_hash, &self.target_sign, transaction_nonce, call);
+		let genesis_hash = *self.finality_pipeline.target_client.genesis_hash();
+		let transaction = Millau::sign_transaction(
+			genesis_hash,
+			&self.finality_pipeline.target_sign,
+			transaction_nonce,
+			call,
+		);
 
 		Bytes(transaction.encode())
 	}

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

@@ -16,15 +16,15 @@
 
 //! Wococo-to-Rococo headers sync entrypoint.
 
-use crate::finality_pipeline::{SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate};
+use codec::Encode;
+use sp_core::{Bytes, Pair};
 
 use bp_header_chain::justification::GrandpaJustification;
-use codec::Encode;
 use relay_rococo_client::{Rococo, SigningParams as RococoSigningParams};
-use relay_substrate_client::{Chain, TransactionSignScheme};
+use relay_substrate_client::{Chain, Client, TransactionSignScheme};
 use relay_utils::metrics::MetricsParams;
 use relay_wococo_client::{SyncHeader as WococoSyncHeader, Wococo};
-use sp_core::{Bytes, Pair};
+use substrate_relay_helper::finality_pipeline::{SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate};
 
 /// Maximal saturating difference between `balance(now)` and `balance(now-24h)` to treat
 /// relay as gone wild.
@@ -34,31 +34,50 @@ use sp_core::{Bytes, Pair};
 pub(crate) const MAXIMAL_BALANCE_DECREASE_PER_DAY: bp_rococo::Balance = 1_500_000_000_000_000;
 
 /// Wococo-to-Rococo finality sync pipeline.
-pub(crate) type WococoFinalityToRococo = SubstrateFinalityToSubstrate<Wococo, Rococo, RococoSigningParams>;
+pub(crate) type FinalityPipelineWococoFinalityToRococo =
+	SubstrateFinalityToSubstrate<Wococo, Rococo, RococoSigningParams>;
+
+#[derive(Clone, Debug)]
+pub(crate) struct WococoFinalityToRococo {
+	finality_pipeline: FinalityPipelineWococoFinalityToRococo,
+}
+
+impl WococoFinalityToRococo {
+	pub fn new(target_client: Client<Rococo>, target_sign: RococoSigningParams) -> Self {
+		Self {
+			finality_pipeline: FinalityPipelineWococoFinalityToRococo::new(target_client, target_sign),
+		}
+	}
+}
 
 impl SubstrateFinalitySyncPipeline for WococoFinalityToRococo {
+	type FinalitySyncPipeline = FinalityPipelineWococoFinalityToRococo;
+
 	const BEST_FINALIZED_SOURCE_HEADER_ID_AT_TARGET: &'static str = bp_wococo::BEST_FINALIZED_WOCOCO_HEADER_METHOD;
 
 	type TargetChain = Rococo;
 
 	fn customize_metrics(params: MetricsParams) -> anyhow::Result<MetricsParams> {
-		crate::chains::add_polkadot_kusama_price_metrics::<Self>(Some(finality_relay::metrics_prefix::<Self>()), params)
+		crate::chains::add_polkadot_kusama_price_metrics::<Self::FinalitySyncPipeline>(
+			Some(finality_relay::metrics_prefix::<Self::FinalitySyncPipeline>()),
+			params,
+		)
 	}
 
 	fn start_relay_guards(&self) {
 		relay_substrate_client::guard::abort_on_spec_version_change(
-			self.target_client.clone(),
+			self.finality_pipeline.target_client.clone(),
 			bp_rococo::VERSION.spec_version,
 		);
 		relay_substrate_client::guard::abort_when_account_balance_decreased(
-			self.target_client.clone(),
+			self.finality_pipeline.target_client.clone(),
 			self.transactions_author(),
 			MAXIMAL_BALANCE_DECREASE_PER_DAY,
 		);
 	}
 
 	fn transactions_author(&self) -> bp_rococo::AccountId {
-		(*self.target_sign.public().as_array_ref()).into()
+		(*self.finality_pipeline.target_sign.public().as_array_ref()).into()
 	}
 
 	fn make_submit_finality_proof_transaction(
@@ -70,8 +89,13 @@ impl SubstrateFinalitySyncPipeline for WococoFinalityToRococo {
 		let call = relay_rococo_client::runtime::Call::BridgeGrandpaWococo(
 			relay_rococo_client::runtime::BridgeGrandpaWococoCall::submit_finality_proof(header.into_inner(), proof),
 		);
-		let genesis_hash = *self.target_client.genesis_hash();
-		let transaction = Rococo::sign_transaction(genesis_hash, &self.target_sign, transaction_nonce, call);
+		let genesis_hash = *self.finality_pipeline.target_client.genesis_hash();
+		let transaction = Rococo::sign_transaction(
+			genesis_hash,
+			&self.finality_pipeline.target_sign,
+			transaction_nonce,
+			call,
+		);
 
 		Bytes(transaction.encode())
 	}
@@ -79,10 +103,12 @@ impl SubstrateFinalitySyncPipeline for WococoFinalityToRococo {
 
 #[cfg(test)]
 mod tests {
-	use super::*;
 	use frame_support::weights::WeightToFeePolynomial;
+
 	use pallet_bridge_grandpa::weights::WeightInfo;
 
+	use super::*;
+
 	#[test]
 	fn maximal_balance_decrease_per_day_is_sane() {
 		// Rococo/Wococo GRANDPA pallet weights. They're now using Rialto weights => using `RialtoWeight` is justified.

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

@@ -16,30 +16,37 @@
 
 //! Wococo-to-Rococo messages sync entrypoint.
 
-use crate::messages_lane::{
-	select_delivery_transaction_limits, MessagesRelayParams, StandaloneMessagesMetrics, SubstrateMessageLane,
-	SubstrateMessageLaneToSubstrate,
-};
-use crate::messages_source::SubstrateMessagesSource;
-use crate::messages_target::SubstrateMessagesTarget;
+use std::{ops::RangeInclusive, time::Duration};
+
+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 codec::Encode;
 use messages_relay::message_lane::MessageLane;
 use relay_rococo_client::{HeaderId as RococoHeaderId, Rococo, SigningParams as RococoSigningParams};
 use relay_substrate_client::{Chain, Client, TransactionSignScheme};
 use relay_utils::metrics::MetricsParams;
 use relay_wococo_client::{HeaderId as WococoHeaderId, SigningParams as WococoSigningParams, Wococo};
-use sp_core::{Bytes, Pair};
-use std::{ops::RangeInclusive, time::Duration};
+use substrate_relay_helper::messages_lane::{
+	select_delivery_transaction_limits, MessagesRelayParams, StandaloneMessagesMetrics, SubstrateMessageLane,
+	SubstrateMessageLaneToSubstrate,
+};
+use substrate_relay_helper::messages_source::SubstrateMessagesSource;
+use substrate_relay_helper::messages_target::SubstrateMessagesTarget;
 
 /// Wococo-to-Rococo message lane.
-pub type WococoMessagesToRococo =
+pub type MessageLaneWococoMessagesToRococo =
 	SubstrateMessageLaneToSubstrate<Wococo, WococoSigningParams, Rococo, RococoSigningParams>;
 
+#[derive(Clone)]
+pub struct WococoMessagesToRococo {
+	message_lane: MessageLaneWococoMessagesToRococo,
+}
+
 impl SubstrateMessageLane for WococoMessagesToRococo {
+	type MessageLane = MessageLaneWococoMessagesToRococo;
 	const OUTBOUND_LANE_MESSAGE_DETAILS_METHOD: &'static str = bp_rococo::TO_ROCOCO_MESSAGE_DETAILS_METHOD;
 	const OUTBOUND_LANE_LATEST_GENERATED_NONCE_METHOD: &'static str =
 		bp_rococo::TO_ROCOCO_LATEST_GENERATED_NONCE_METHOD;
@@ -57,14 +64,14 @@ impl SubstrateMessageLane for WococoMessagesToRococo {
 	type TargetChain = Rococo;
 
 	fn source_transactions_author(&self) -> bp_wococo::AccountId {
-		(*self.source_sign.public().as_array_ref()).into()
+		(*self.message_lane.source_sign.public().as_array_ref()).into()
 	}
 
 	fn make_messages_receiving_proof_transaction(
 		&self,
 		transaction_nonce: <Wococo as Chain>::Index,
 		_generated_at_block: RococoHeaderId,
-		proof: <Self as MessageLane>::MessagesReceivingProof,
+		proof: <Self::MessageLane as MessageLane>::MessagesReceivingProof,
 	) -> Bytes {
 		let (relayers_state, proof) = proof;
 		let call = relay_wococo_client::runtime::Call::BridgeMessagesRococo(
@@ -73,8 +80,9 @@ impl SubstrateMessageLane for WococoMessagesToRococo {
 				relayers_state,
 			),
 		);
-		let genesis_hash = *self.source_client.genesis_hash();
-		let transaction = Wococo::sign_transaction(genesis_hash, &self.source_sign, transaction_nonce, call);
+		let genesis_hash = *self.message_lane.source_client.genesis_hash();
+		let transaction =
+			Wococo::sign_transaction(genesis_hash, &self.message_lane.source_sign, transaction_nonce, call);
 		log::trace!(
 			target: "bridge",
 			"Prepared Rococo -> Wococo confirmation transaction. Weight: <unknown>/{}, size: {}/{}",
@@ -86,7 +94,7 @@ impl SubstrateMessageLane for WococoMessagesToRococo {
 	}
 
 	fn target_transactions_author(&self) -> bp_rococo::AccountId {
-		(*self.target_sign.public().as_array_ref()).into()
+		(*self.message_lane.target_sign.public().as_array_ref()).into()
 	}
 
 	fn make_messages_delivery_transaction(
@@ -94,7 +102,7 @@ impl SubstrateMessageLane for WococoMessagesToRococo {
 		transaction_nonce: <Rococo as Chain>::Index,
 		_generated_at_header: WococoHeaderId,
 		_nonces: RangeInclusive<MessageNonce>,
-		proof: <Self as MessageLane>::MessagesProof,
+		proof: <Self::MessageLane as MessageLane>::MessagesProof,
 	) -> Bytes {
 		let (dispatch_weight, proof) = proof;
 		let FromBridgedChainMessagesProof {
@@ -106,14 +114,15 @@ impl SubstrateMessageLane for WococoMessagesToRococo {
 
 		let call = relay_rococo_client::runtime::Call::BridgeMessagesWococo(
 			relay_rococo_client::runtime::BridgeMessagesWococoCall::receive_messages_proof(
-				self.relayer_id_at_source.clone(),
+				self.message_lane.relayer_id_at_source.clone(),
 				proof,
 				messages_count as _,
 				dispatch_weight,
 			),
 		);
-		let genesis_hash = *self.target_client.genesis_hash();
-		let transaction = Rococo::sign_transaction(genesis_hash, &self.target_sign, transaction_nonce, call);
+		let genesis_hash = *self.message_lane.target_client.genesis_hash();
+		let transaction =
+			Rococo::sign_transaction(genesis_hash, &self.message_lane.target_sign, transaction_nonce, call);
 		log::trace!(
 			target: "bridge",
 			"Prepared Wococo -> Rococo delivery transaction. Weight: <unknown>/{}, size: {}/{}",
@@ -151,11 +160,13 @@ pub async fn run(
 	let lane_id = params.lane_id;
 	let source_client = params.source_client;
 	let lane = WococoMessagesToRococo {
-		source_client: source_client.clone(),
-		source_sign: params.source_sign,
-		target_client: params.target_client.clone(),
-		target_sign: params.target_sign,
-		relayer_id_at_source: relayer_id_at_wococo,
+		message_lane: SubstrateMessageLaneToSubstrate {
+			source_client: source_client.clone(),
+			source_sign: params.source_sign,
+			target_client: params.target_client.clone(),
+			target_sign: params.target_sign,
+			relayer_id_at_source: relayer_id_at_wococo,
+		},
 	};
 
 	// 2/3 is reserved for proofs and tx overhead
@@ -180,7 +191,7 @@ pub async fn run(
 			Max messages size in single transaction: {}\n\t\
 			Max messages weight in single transaction: {}\n\t\
 			Relayer mode: {:?}",
-		lane.relayer_id_at_source,
+		lane.message_lane.relayer_id_at_source,
 		max_messages_in_single_batch,
 		max_messages_size_in_single_batch,
 		max_messages_weight_in_single_batch,
@@ -189,7 +200,7 @@ pub async fn run(
 
 	let (metrics_params, metrics_values) = add_standalone_metrics(
 		Some(messages_relay::message_lane_loop::metrics_prefix::<
-			WococoMessagesToRococo,
+			<WococoMessagesToRococo as SubstrateMessageLane>::MessageLane,
 		>(&lane_id)),
 		params.metrics_params,
 		source_client.clone(),
@@ -237,7 +248,7 @@ pub(crate) fn add_standalone_metrics(
 	metrics_params: MetricsParams,
 	source_client: Client<Wococo>,
 ) -> anyhow::Result<(MetricsParams, StandaloneMessagesMetrics)> {
-	crate::messages_lane::add_standalone_metrics::<WococoMessagesToRococo>(
+	substrate_relay_helper::messages_lane::add_standalone_metrics::<WococoMessagesToRococo>(
 		metrics_prefix,
 		metrics_params,
 		source_client,