Squashed 'bridges/' changes from b2099c5..23dda62 (#3369)

23dda62 Rococo <> Wococo messages relay (#1030)
bcde21d Update the wasm builder to substrate master (#1029)
a8318ce Make target signer optional when sending message. (#1018)
f8602e1 Fix insufficient balance when send message. (#1020)
d95c0a7 greedy relayer don't need message dispatch to be prepaid if dispatch is supposed to be paid at the target chain (#1016)
ad5876f Update types. (#1027)
116cbbc CI: fix starting the pipeline (#1022)
7e0fadd Add temporary `canary` job (#1019)
6787091 Update types to contain dispatch_fee_payment (#1017)
03f79ad Allow Root to assume SourceAccount. (#1011)
372d019 Return dispatch_fee_payment from message details RPC (#1014)
604eb1c Relay basic single-bit message dispatch results back to the source chain (#935)
bf52fff Use plain source_queue view when selecting nonces for delivery (#1010)
fc5cf7d pay dispatch fee at target chain (#911)
1e35477 Bump Substrate to `286d7ce` (#1006)
7ad07b3 Add --only-mandatory-headers mode (#1004)
5351dc9 Messages relayer operating mode (#995)
9bc29a7 Rococo <> Wococo relayer balance guard (#998)
bc17341 rename messages_dispatch_weight -> message_details (#996)
95be244 Bump Rococo and Wococo spec versions (#999)
c35567b Move ChainWithBalances::NativeBalance -> Chain::Balance (#990)
1bfece1 Fix some nits (#988)
334ea0f Increase pause before starting relays again (#989)
7fb8248 Fix clippy in test code (#993)
d60ae50 fix clippy issues (#991)
75ca813 Make sure GRANDPA shares state with RPC. (#987)
da2a38a Bump Substrate (#986)
5a9862f Update submit finality proof weight formula (#981)
69df513 Flag for rejecting all outbound messages (#982)
14d0506 Add script to setup bench machine. (#984)
e74e8ab Move CI from GitHub Actions to GitLab (#814)
c5ca5dd Custom justification verification (#979)
643f10d Always run on-demand headers relay in complex relay (#975)
a35b0ef Add JSON type definitions for Rococo<>Wococo bridge (#977)
0eb83f2 Update cargo.deny (#980)
e1d1f4c Bump Rococo/Wococo spec_version (#976)
deac90d increase pause before starting relays (#974)
68d6d79 Revert to use InspectCmd, bump substrate `6bef4f4` (#966)
66e1508 Avoid hashing headers twice in verify_justification (#973)
a31844f Bump `environmental` dependency (#972)
2a4c29a in auto-relays keep trying to connect to nodes until connection is established (#971)
0e767b3 removed stray file (#969)
b9545dc Serve multiple lanes with single complex relay instance (#964)
73419f4 Correct type error (#968)
bac256f Start finality relay spec-version guards for Rococo <> Wococo finality relays (#965)
bfd7037 pass source and target chain ids to account_ownership_proof (#963)
8436073 Upstream changes from Polkadot repo (#961)
e58d851 Increase account endowment amount (#960)

git-subtree-dir: bridges
git-subtree-split: 23dda6248236b27f20d76cbedc30e189cc6f736c

polkadot/bridges/relays/bin-substrate/src/chains/millau.rs

@@ -23,7 +23,7 @@ use crate::cli::{
 };
 use bp_message_dispatch::{CallOrigin, MessagePayload};
 use codec::Decode;
-use frame_support::weights::{GetDispatchInfo, Weight};
+use frame_support::weights::{DispatchInfo, GetDispatchInfo, Weight};
 use relay_millau_client::Millau;
 use sp_version::RuntimeVersion;
 
@@ -62,6 +62,10 @@ impl CliEncodeCall for Millau {
 			},
 		})
 	}
+
+	fn get_dispatch_info(call: &millau_runtime::Call) -> anyhow::Result<DispatchInfo> {
+		Ok(call.get_dispatch_info())
+	}
 }
 
 impl CliChain for Millau {

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

@@ -23,7 +23,7 @@ use crate::messages_source::SubstrateMessagesSource;
 use crate::messages_target::SubstrateMessagesTarget;
 
 use bp_messages::MessageNonce;
-use bp_runtime::{MILLAU_BRIDGE_INSTANCE, RIALTO_BRIDGE_INSTANCE};
+use bp_runtime::{MILLAU_CHAIN_ID, RIALTO_CHAIN_ID};
 use bridge_runtime_common::messages::target::FromBridgedChainMessagesProof;
 use codec::Encode;
 use frame_support::dispatch::GetDispatchInfo;
@@ -42,8 +42,7 @@ pub type MillauMessagesToRialto =
 	SubstrateMessageLaneToSubstrate<Millau, MillauSigningParams, Rialto, RialtoSigningParams>;
 
 impl SubstrateMessageLane for MillauMessagesToRialto {
-	const OUTBOUND_LANE_MESSAGES_DISPATCH_WEIGHT_METHOD: &'static str =
-		bp_rialto::TO_RIALTO_MESSAGES_DISPATCH_WEIGHT_METHOD;
+	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;
 	const OUTBOUND_LANE_LATEST_RECEIVED_NONCE_METHOD: &'static str = bp_rialto::TO_RIALTO_LATEST_RECEIVED_NONCE_METHOD;
@@ -59,7 +58,7 @@ impl SubstrateMessageLane for MillauMessagesToRialto {
 	type SourceChain = Millau;
 	type TargetChain = Rialto;
 
-	fn source_transactions_author(&self) -> bp_rialto::AccountId {
+	fn source_transactions_author(&self) -> bp_millau::AccountId {
 		(*self.source_sign.public().as_array_ref()).into()
 	}
 
@@ -127,20 +126,12 @@ impl SubstrateMessageLane for MillauMessagesToRialto {
 }
 
 /// Millau node as messages source.
-type MillauSourceClient = SubstrateMessagesSource<
-	Millau,
-	MillauMessagesToRialto,
-	millau_runtime::Runtime,
-	millau_runtime::WithRialtoMessagesInstance,
->;
+type MillauSourceClient =
+	SubstrateMessagesSource<Millau, MillauMessagesToRialto, millau_runtime::WithRialtoMessagesInstance>;
 
 /// Rialto node as messages target.
-type RialtoTargetClient = SubstrateMessagesTarget<
-	Rialto,
-	MillauMessagesToRialto,
-	rialto_runtime::Runtime,
-	rialto_runtime::WithMillauMessagesInstance,
->;
+type RialtoTargetClient =
+	SubstrateMessagesTarget<Rialto, MillauMessagesToRialto, rialto_runtime::WithMillauMessagesInstance>;
 
 /// Run Millau-to-Rialto messages sync.
 pub async fn run(
@@ -160,7 +151,7 @@ pub async fn run(
 	};
 
 	// 2/3 is reserved for proofs and tx overhead
-	let max_messages_size_in_single_batch = bp_rialto::max_extrinsic_size() as usize / 3;
+	let max_messages_size_in_single_batch = bp_rialto::max_extrinsic_size() / 3;
 	// TODO: use Millau weights after https://github.com/paritytech/parity-bridges-common/issues/390
 	let (max_messages_in_single_batch, max_messages_weight_in_single_batch) =
 		select_delivery_transaction_limits::<pallet_bridge_messages::weights::RialtoWeight<millau_runtime::Runtime>>(
@@ -194,20 +185,21 @@ pub async fn run(
 				max_messages_in_single_batch,
 				max_messages_weight_in_single_batch,
 				max_messages_size_in_single_batch,
+				relayer_mode: messages_relay::message_lane_loop::RelayerMode::Altruistic,
 			},
 		},
 		MillauSourceClient::new(
 			source_client.clone(),
 			lane.clone(),
 			lane_id,
-			RIALTO_BRIDGE_INSTANCE,
+			RIALTO_CHAIN_ID,
 			params.target_to_source_headers_relay,
 		),
 		RialtoTargetClient::new(
 			params.target_client,
 			lane,
 			lane_id,
-			MILLAU_BRIDGE_INSTANCE,
+			MILLAU_CHAIN_ID,
 			params.source_to_target_headers_relay,
 		),
 		relay_utils::relay_metrics(

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

@@ -21,8 +21,10 @@ pub mod millau_messages_to_rialto;
 pub mod rialto_headers_to_millau;
 pub mod rialto_messages_to_millau;
 pub mod rococo_headers_to_wococo;
+pub mod rococo_messages_to_wococo;
 pub mod westend_headers_to_millau;
 pub mod wococo_headers_to_rococo;
+pub mod wococo_messages_to_rococo;
 
 mod millau;
 mod rialto;
@@ -86,7 +88,7 @@ mod tests {
 		let millau_public: bp_millau::AccountSigner = millau_sign.public().into();
 		let millau_account_id: bp_millau::AccountId = millau_public.into_account();
 
-		let digest = millau_runtime::rialto_account_ownership_digest(
+		let digest = millau_runtime::millau_to_rialto_account_ownership_digest(
 			&call,
 			millau_account_id,
 			rialto_runtime::VERSION.spec_version,
@@ -107,7 +109,7 @@ mod tests {
 		let rialto_public: bp_rialto::AccountSigner = rialto_sign.public().into();
 		let rialto_account_id: bp_rialto::AccountId = rialto_public.into_account();
 
-		let digest = rialto_runtime::millau_account_ownership_digest(
+		let digest = rialto_runtime::rialto_to_millau_account_ownership_digest(
 			&call,
 			rialto_account_id,
 			millau_runtime::VERSION.spec_version,
@@ -271,7 +273,10 @@ mod rococo_tests {
 			votes_ancestries: vec![],
 		};
 
-		let actual = bp_rococo::BridgeGrandpaWococoCall::submit_finality_proof(header.clone(), justification.clone());
+		let actual = relay_rococo_client::runtime::BridgeGrandpaWococoCall::submit_finality_proof(
+			header.clone(),
+			justification.clone(),
+		);
 		let expected = millau_runtime::BridgeGrandpaRialtoCall::<millau_runtime::Runtime>::submit_finality_proof(
 			header,
 			justification,

polkadot/bridges/relays/bin-substrate/src/chains/rialto.rs

@@ -23,7 +23,7 @@ use crate::cli::{
 };
 use bp_message_dispatch::{CallOrigin, MessagePayload};
 use codec::Decode;
-use frame_support::weights::{GetDispatchInfo, Weight};
+use frame_support::weights::{DispatchInfo, GetDispatchInfo, Weight};
 use relay_rialto_client::Rialto;
 use sp_version::RuntimeVersion;
 
@@ -60,6 +60,10 @@ impl CliEncodeCall for Rialto {
 			},
 		})
 	}
+
+	fn get_dispatch_info(call: &rialto_runtime::Call) -> anyhow::Result<DispatchInfo> {
+		Ok(call.get_dispatch_info())
+	}
 }
 
 impl CliChain for Rialto {

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

@@ -23,7 +23,7 @@ use crate::messages_source::SubstrateMessagesSource;
 use crate::messages_target::SubstrateMessagesTarget;
 
 use bp_messages::MessageNonce;
-use bp_runtime::{MILLAU_BRIDGE_INSTANCE, RIALTO_BRIDGE_INSTANCE};
+use bp_runtime::{MILLAU_CHAIN_ID, RIALTO_CHAIN_ID};
 use bridge_runtime_common::messages::target::FromBridgedChainMessagesProof;
 use codec::Encode;
 use frame_support::dispatch::GetDispatchInfo;
@@ -42,8 +42,7 @@ pub type RialtoMessagesToMillau =
 	SubstrateMessageLaneToSubstrate<Rialto, RialtoSigningParams, Millau, MillauSigningParams>;
 
 impl SubstrateMessageLane for RialtoMessagesToMillau {
-	const OUTBOUND_LANE_MESSAGES_DISPATCH_WEIGHT_METHOD: &'static str =
-		bp_millau::TO_MILLAU_MESSAGES_DISPATCH_WEIGHT_METHOD;
+	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;
 	const OUTBOUND_LANE_LATEST_RECEIVED_NONCE_METHOD: &'static str = bp_millau::TO_MILLAU_LATEST_RECEIVED_NONCE_METHOD;
@@ -86,7 +85,7 @@ impl SubstrateMessageLane for RialtoMessagesToMillau {
 		Bytes(transaction.encode())
 	}
 
-	fn target_transactions_author(&self) -> bp_rialto::AccountId {
+	fn target_transactions_author(&self) -> bp_millau::AccountId {
 		(*self.target_sign.public().as_array_ref()).into()
 	}
 
@@ -127,20 +126,12 @@ impl SubstrateMessageLane for RialtoMessagesToMillau {
 }
 
 /// Rialto node as messages source.
-type RialtoSourceClient = SubstrateMessagesSource<
-	Rialto,
-	RialtoMessagesToMillau,
-	rialto_runtime::Runtime,
-	rialto_runtime::WithMillauMessagesInstance,
->;
+type RialtoSourceClient =
+	SubstrateMessagesSource<Rialto, RialtoMessagesToMillau, rialto_runtime::WithMillauMessagesInstance>;
 
 /// Millau node as messages target.
-type MillauTargetClient = SubstrateMessagesTarget<
-	Millau,
-	RialtoMessagesToMillau,
-	millau_runtime::Runtime,
-	millau_runtime::WithRialtoMessagesInstance,
->;
+type MillauTargetClient =
+	SubstrateMessagesTarget<Millau, RialtoMessagesToMillau, millau_runtime::WithRialtoMessagesInstance>;
 
 /// Run Rialto-to-Millau messages sync.
 pub async fn run(
@@ -160,7 +151,7 @@ pub async fn run(
 	};
 
 	// 2/3 is reserved for proofs and tx overhead
-	let max_messages_size_in_single_batch = bp_millau::max_extrinsic_size() as usize / 3;
+	let max_messages_size_in_single_batch = bp_millau::max_extrinsic_size() / 3;
 	let (max_messages_in_single_batch, max_messages_weight_in_single_batch) =
 		select_delivery_transaction_limits::<pallet_bridge_messages::weights::RialtoWeight<rialto_runtime::Runtime>>(
 			bp_millau::max_extrinsic_weight(),
@@ -193,20 +184,21 @@ pub async fn run(
 				max_messages_in_single_batch,
 				max_messages_weight_in_single_batch,
 				max_messages_size_in_single_batch,
+				relayer_mode: messages_relay::message_lane_loop::RelayerMode::Altruistic,
 			},
 		},
 		RialtoSourceClient::new(
 			source_client.clone(),
 			lane.clone(),
 			lane_id,
-			MILLAU_BRIDGE_INSTANCE,
+			MILLAU_CHAIN_ID,
 			params.target_to_source_headers_relay,
 		),
 		MillauTargetClient::new(
 			params.target_client,
 			lane,
 			lane_id,
-			RIALTO_BRIDGE_INSTANCE,
+			RIALTO_CHAIN_ID,
 			params.source_to_target_headers_relay,
 		),
 		relay_utils::relay_metrics(

polkadot/bridges/relays/bin-substrate/src/chains/rococo.rs

@@ -14,11 +14,70 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
 
-use crate::cli::{encode_message, CliChain};
-use frame_support::weights::Weight;
+use codec::Decode;
+use frame_support::weights::{DispatchClass, DispatchInfo, Pays, Weight};
 use relay_rococo_client::Rococo;
 use sp_version::RuntimeVersion;
 
+use crate::cli::{
+	bridge,
+	encode_call::{Call, CliEncodeCall},
+	encode_message, CliChain,
+};
+
+/// Weight of the `system::remark` call at Rococo.
+///
+/// This weight is larger (x2) than actual weight at current Rooco runtime to avoid unsuccessful
+/// calls in the future. But since it is used only in tests (and on test chains), this is ok.
+pub(crate) const SYSTEM_REMARK_CALL_WEIGHT: Weight = 2 * 1_345_000;
+
+impl CliEncodeCall for Rococo {
+	fn max_extrinsic_size() -> u32 {
+		bp_rococo::max_extrinsic_size()
+	}
+
+	fn encode_call(call: &Call) -> anyhow::Result<Self::Call> {
+		Ok(match call {
+			Call::Remark { remark_payload, .. } => {
+				relay_rococo_client::runtime::Call::System(relay_rococo_client::runtime::SystemCall::remark(
+					remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
+				))
+			}
+			Call::BridgeSendMessage {
+				lane,
+				payload,
+				fee,
+				bridge_instance_index,
+			} => match *bridge_instance_index {
+				bridge::ROCOCO_TO_WOCOCO_INDEX => {
+					let payload = Decode::decode(&mut &*payload.0)?;
+					relay_rococo_client::runtime::Call::BridgeMessagesWococo(
+						relay_rococo_client::runtime::BridgeMessagesWococoCall::send_message(lane.0, payload, fee.0),
+					)
+				}
+				_ => anyhow::bail!(
+					"Unsupported target bridge pallet with instance index: {}",
+					bridge_instance_index
+				),
+			},
+			_ => anyhow::bail!("The call is not supported"),
+		})
+	}
+
+	fn get_dispatch_info(call: &relay_rococo_client::runtime::Call) -> anyhow::Result<DispatchInfo> {
+		match *call {
+			relay_rococo_client::runtime::Call::System(relay_rococo_client::runtime::SystemCall::remark(_)) => {
+				Ok(DispatchInfo {
+					weight: SYSTEM_REMARK_CALL_WEIGHT,
+					class: DispatchClass::Normal,
+					pays_fee: Pays::Yes,
+				})
+			}
+			_ => anyhow::bail!("Unsupported Rococo call: {:?}", call),
+		}
+	}
+}
+
 impl CliChain for Rococo {
 	const RUNTIME_VERSION: RuntimeVersion = bp_rococo::VERSION;
 
@@ -30,7 +89,7 @@ impl CliChain for Rococo {
 	}
 
 	fn max_extrinsic_weight() -> Weight {
-		0
+		bp_wococo::max_extrinsic_weight()
 	}
 
 	fn encode_message(_message: encode_message::MessagePayload) -> Result<Self::MessagePayload, String> {

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

@@ -16,6 +16,7 @@
 
 //! 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;
@@ -38,6 +39,18 @@ impl SubstrateFinalitySyncPipeline for RococoFinalityToWococo {
 		crate::chains::add_polkadot_kusama_price_metrics::<Self>(params)
 	}
 
+	fn start_relay_guards(&self) {
+		relay_substrate_client::guard::abort_on_spec_version_change(
+			self.target_client.clone(),
+			bp_wococo::VERSION.spec_version,
+		);
+		relay_substrate_client::guard::abort_when_account_balance_decreased(
+			self.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()
 	}
@@ -48,10 +61,9 @@ impl SubstrateFinalitySyncPipeline for RococoFinalityToWococo {
 		header: RococoSyncHeader,
 		proof: GrandpaJustification<bp_rococo::Header>,
 	) -> Bytes {
-		let call = bp_wococo::Call::BridgeGrandpaRococo(bp_wococo::BridgeGrandpaRococoCall::submit_finality_proof(
-			header.into_inner(),
-			proof,
-		));
+		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);
 

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

@@ -0,0 +1,227 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Rococo-to-Wococo messages sync entrypoint.
+
+use crate::messages_lane::{
+	select_delivery_transaction_limits, MessagesRelayParams, SubstrateMessageLane, SubstrateMessageLaneToSubstrate,
+};
+use crate::messages_source::SubstrateMessagesSource;
+use crate::messages_target::SubstrateMessagesTarget;
+
+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::{metrics::StorageProofOverheadMetric, Chain, TransactionSignScheme};
+use relay_wococo_client::{HeaderId as WococoHeaderId, SigningParams as WococoSigningParams, Wococo};
+use sp_core::{Bytes, Pair};
+use std::{ops::RangeInclusive, time::Duration};
+
+/// Rococo-to-Wococo message lane.
+pub type RococoMessagesToWococo =
+	SubstrateMessageLaneToSubstrate<Rococo, RococoSigningParams, Wococo, WococoSigningParams>;
+
+impl SubstrateMessageLane for RococoMessagesToWococo {
+	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;
+	const OUTBOUND_LANE_LATEST_RECEIVED_NONCE_METHOD: &'static str = bp_wococo::TO_WOCOCO_LATEST_RECEIVED_NONCE_METHOD;
+
+	const INBOUND_LANE_LATEST_RECEIVED_NONCE_METHOD: &'static str = bp_rococo::FROM_ROCOCO_LATEST_RECEIVED_NONCE_METHOD;
+	const INBOUND_LANE_LATEST_CONFIRMED_NONCE_METHOD: &'static str =
+		bp_rococo::FROM_ROCOCO_LATEST_CONFIRMED_NONCE_METHOD;
+	const INBOUND_LANE_UNREWARDED_RELAYERS_STATE: &'static str = bp_rococo::FROM_ROCOCO_UNREWARDED_RELAYERS_STATE;
+
+	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;
+
+	type SourceChain = Rococo;
+	type TargetChain = Wococo;
+
+	fn source_transactions_author(&self) -> bp_rococo::AccountId {
+		(*self.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,
+	) -> Bytes {
+		let (relayers_state, proof) = proof;
+		let call = relay_rococo_client::runtime::Call::BridgeMessagesWococo(
+			relay_rococo_client::runtime::BridgeMessagesWococoCall::receive_messages_delivery_proof(
+				proof,
+				relayers_state,
+			),
+		);
+		let genesis_hash = *self.source_client.genesis_hash();
+		let transaction = Rococo::sign_transaction(genesis_hash, &self.source_sign, transaction_nonce, call);
+		log::trace!(
+			target: "bridge",
+			"Prepared Wococo -> Rococo confirmation transaction. Weight: <unknown>/{}, size: {}/{}",
+			bp_rococo::max_extrinsic_weight(),
+			transaction.encode().len(),
+			bp_rococo::max_extrinsic_size(),
+		);
+		Bytes(transaction.encode())
+	}
+
+	fn target_transactions_author(&self) -> bp_wococo::AccountId {
+		(*self.target_sign.public().as_array_ref()).into()
+	}
+
+	fn make_messages_delivery_transaction(
+		&self,
+		transaction_nonce: <Wococo as Chain>::Index,
+		_generated_at_header: RococoHeaderId,
+		_nonces: RangeInclusive<MessageNonce>,
+		proof: <Self as MessageLane>::MessagesProof,
+	) -> Bytes {
+		let (dispatch_weight, proof) = proof;
+		let FromBridgedChainMessagesProof {
+			ref nonces_start,
+			ref nonces_end,
+			..
+		} = proof;
+		let messages_count = nonces_end - nonces_start + 1;
+
+		let call = relay_wococo_client::runtime::Call::BridgeMessagesRococo(
+			relay_wococo_client::runtime::BridgeMessagesRococoCall::receive_messages_proof(
+				self.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);
+		log::trace!(
+			target: "bridge",
+			"Prepared Rococo -> Wococo delivery transaction. Weight: <unknown>/{}, size: {}/{}",
+			bp_wococo::max_extrinsic_weight(),
+			transaction.encode().len(),
+			bp_wococo::max_extrinsic_size(),
+		);
+		Bytes(transaction.encode())
+	}
+}
+
+/// Rococo node as messages source.
+type RococoSourceClient =
+	SubstrateMessagesSource<Rococo, RococoMessagesToWococo, relay_rococo_client::runtime::WithWococoMessagesInstance>;
+
+/// Wococo node as messages target.
+type WococoTargetClient =
+	SubstrateMessagesTarget<Wococo, RococoMessagesToWococo, relay_wococo_client::runtime::WithRococoMessagesInstance>;
+
+/// Run Rococo-to-Wococo messages sync.
+pub async fn run(
+	params: MessagesRelayParams<Rococo, RococoSigningParams, Wococo, WococoSigningParams>,
+) -> Result<(), String> {
+	let stall_timeout = Duration::from_secs(5 * 60);
+	let relayer_id_at_rococo = (*params.source_sign.public().as_array_ref()).into();
+
+	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,
+	};
+
+	// 2/3 is reserved for proofs and tx overhead
+	let max_messages_size_in_single_batch = bp_wococo::max_extrinsic_size() / 3;
+	// we don't know exact weights of the Wococo runtime. So to guess weights we'll be using
+	// weights from Rialto and then simply dividing it by x2.
+	let (max_messages_in_single_batch, max_messages_weight_in_single_batch) =
+		select_delivery_transaction_limits::<pallet_bridge_messages::weights::RialtoWeight<rialto_runtime::Runtime>>(
+			bp_wococo::max_extrinsic_weight(),
+			bp_wococo::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE,
+		);
+	let (max_messages_in_single_batch, max_messages_weight_in_single_batch) = (
+		max_messages_in_single_batch / 2,
+		max_messages_weight_in_single_batch / 2,
+	);
+
+	log::info!(
+		target: "bridge",
+		"Starting Rococo -> Wococo messages relay.\n\t\
+			Rococo relayer account id: {:?}\n\t\
+			Max messages in single transaction: {}\n\t\
+			Max messages size in single transaction: {}\n\t\
+			Max messages weight in single transaction: {}",
+		lane.relayer_id_at_source,
+		max_messages_in_single_batch,
+		max_messages_size_in_single_batch,
+		max_messages_weight_in_single_batch,
+	);
+
+	messages_relay::message_lane_loop::run(
+		messages_relay::message_lane_loop::Params {
+			lane: lane_id,
+			source_tick: Rococo::AVERAGE_BLOCK_INTERVAL,
+			target_tick: Wococo::AVERAGE_BLOCK_INTERVAL,
+			reconnect_delay: relay_utils::relay_loop::RECONNECT_DELAY,
+			stall_timeout,
+			delivery_params: messages_relay::message_lane_loop::MessageDeliveryParams {
+				max_unrewarded_relayer_entries_at_target: bp_wococo::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE,
+				max_unconfirmed_nonces_at_target: bp_wococo::MAX_UNCONFIRMED_MESSAGES_AT_INBOUND_LANE,
+				max_messages_in_single_batch,
+				max_messages_weight_in_single_batch,
+				max_messages_size_in_single_batch,
+				relayer_mode: messages_relay::message_lane_loop::RelayerMode::Altruistic,
+			},
+		},
+		RococoSourceClient::new(
+			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,
+			params.source_to_target_headers_relay,
+		),
+		relay_utils::relay_metrics(
+			Some(messages_relay::message_lane_loop::metrics_prefix::<
+				RococoMessagesToWococo,
+			>(&lane_id)),
+			params.metrics_params,
+		)
+		.standalone_metric(|registry, prefix| {
+			StorageProofOverheadMetric::new(
+				registry,
+				prefix,
+				source_client.clone(),
+				"rococo_storage_proof_overhead".into(),
+				"Rococo storage proof overhead".into(),
+			)
+		})?
+		.into_params(),
+		futures::future::pending(),
+	)
+	.await
+}

polkadot/bridges/relays/bin-substrate/src/chains/westend_headers_to_rococo.rs

@@ -1,60 +0,0 @@
-// Copyright 2019-2021 Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity Bridges Common is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
-
-//! Westend-to-Rococo headers sync entrypoint.
-
-use crate::finality_pipeline::{SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate};
-
-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_utils::metrics::MetricsParams;
-use relay_westend_client::{SyncHeader as WestendSyncHeader, Westend};
-use sp_core::{Bytes, Pair};
-
-/// Westend-to-Rococo finality sync pipeline.
-pub(crate) type WestendFinalityToRococo = SubstrateFinalityToSubstrate<Westend, Rococo, RococoSigningParams>;
-
-impl SubstrateFinalitySyncPipeline for WestendFinalityToRococo {
-	const BEST_FINALIZED_SOURCE_HEADER_ID_AT_TARGET: &'static str = bp_westend::BEST_FINALIZED_WESTEND_HEADER_METHOD;
-
-	type TargetChain = Rococo;
-
-	fn customize_metrics(params: MetricsParams) -> anyhow::Result<MetricsParams> {
-		crate::chains::add_polkadot_kusama_price_metrics::<Self>(params)
-	}
-
-	fn transactions_author(&self) -> bp_rococo::AccountId {
-		(*self.target_sign.public().as_array_ref()).into()
-	}
-
-	fn make_submit_finality_proof_transaction(
-		&self,
-		transaction_nonce: <Rococo as Chain>::Index,
-		header: WestendSyncHeader,
-		proof: GrandpaJustification<bp_westend::Header>,
-	) -> Bytes {
-		let call = bp_rococo::Call::BridgeGrandpaWestend(bp_rococo::BridgeGrandpaCall::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);
-
-		Bytes(transaction.encode())
-	}
-}

polkadot/bridges/relays/bin-substrate/src/chains/wococo.rs

@@ -14,11 +14,64 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
 
-use crate::cli::{encode_message, CliChain};
-use frame_support::weights::Weight;
+use codec::Decode;
+use frame_support::weights::{DispatchClass, DispatchInfo, Pays, Weight};
 use relay_wococo_client::Wococo;
 use sp_version::RuntimeVersion;
 
+use crate::cli::{
+	bridge,
+	encode_call::{Call, CliEncodeCall},
+	encode_message, CliChain,
+};
+
+impl CliEncodeCall for Wococo {
+	fn max_extrinsic_size() -> u32 {
+		bp_wococo::max_extrinsic_size()
+	}
+
+	fn encode_call(call: &Call) -> anyhow::Result<Self::Call> {
+		Ok(match call {
+			Call::Remark { remark_payload, .. } => {
+				relay_wococo_client::runtime::Call::System(relay_wococo_client::runtime::SystemCall::remark(
+					remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
+				))
+			}
+			Call::BridgeSendMessage {
+				lane,
+				payload,
+				fee,
+				bridge_instance_index,
+			} => match *bridge_instance_index {
+				bridge::WOCOCO_TO_ROCOCO_INDEX => {
+					let payload = Decode::decode(&mut &*payload.0)?;
+					relay_wococo_client::runtime::Call::BridgeMessagesRococo(
+						relay_wococo_client::runtime::BridgeMessagesRococoCall::send_message(lane.0, payload, fee.0),
+					)
+				}
+				_ => anyhow::bail!(
+					"Unsupported target bridge pallet with instance index: {}",
+					bridge_instance_index
+				),
+			},
+			_ => anyhow::bail!("The call is not supported"),
+		})
+	}
+
+	fn get_dispatch_info(call: &relay_wococo_client::runtime::Call) -> anyhow::Result<DispatchInfo> {
+		match *call {
+			relay_wococo_client::runtime::Call::System(relay_wococo_client::runtime::SystemCall::remark(_)) => {
+				Ok(DispatchInfo {
+					weight: crate::chains::rococo::SYSTEM_REMARK_CALL_WEIGHT,
+					class: DispatchClass::Normal,
+					pays_fee: Pays::Yes,
+				})
+			}
+			_ => anyhow::bail!("Unsupported Rococo call: {:?}", call),
+		}
+	}
+}
+
 impl CliChain for Wococo {
 	const RUNTIME_VERSION: RuntimeVersion = bp_wococo::VERSION;
 
@@ -30,7 +83,7 @@ impl CliChain for Wococo {
 	}
 
 	fn max_extrinsic_weight() -> Weight {
-		0
+		bp_wococo::max_extrinsic_weight()
 	}
 
 	fn encode_message(_message: encode_message::MessagePayload) -> Result<Self::MessagePayload, String> {

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

@@ -26,6 +26,13 @@ use relay_utils::metrics::MetricsParams;
 use relay_wococo_client::{SyncHeader as WococoSyncHeader, Wococo};
 use sp_core::{Bytes, Pair};
 
+/// Maximal saturating difference between `balance(now)` and `balance(now-24h)` to treat
+/// relay as gone wild.
+///
+/// See `maximal_balance_decrease_per_day_is_sane` test for details.
+/// Note that this is in plancks, so this corresponds to `1500 UNITS`.
+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>;
 
@@ -38,6 +45,18 @@ impl SubstrateFinalitySyncPipeline for WococoFinalityToRococo {
 		crate::chains::add_polkadot_kusama_price_metrics::<Self>(params)
 	}
 
+	fn start_relay_guards(&self) {
+		relay_substrate_client::guard::abort_on_spec_version_change(
+			self.target_client.clone(),
+			bp_rococo::VERSION.spec_version,
+		);
+		relay_substrate_client::guard::abort_when_account_balance_decreased(
+			self.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()
 	}
@@ -48,13 +67,50 @@ impl SubstrateFinalitySyncPipeline for WococoFinalityToRococo {
 		header: WococoSyncHeader,
 		proof: GrandpaJustification<bp_wococo::Header>,
 	) -> Bytes {
-		let call = bp_rococo::Call::BridgeGrandpaWococo(bp_rococo::BridgeGrandpaWococoCall::submit_finality_proof(
-			header.into_inner(),
-			proof,
-		));
+		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);
 
 		Bytes(transaction.encode())
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use frame_support::weights::WeightToFeePolynomial;
+	use pallet_bridge_grandpa::weights::WeightInfo;
+
+	#[test]
+	fn maximal_balance_decrease_per_day_is_sane() {
+		// Rococo/Wococo GRANDPA pallet weights. They're now using Rialto weights => using `RialtoWeight` is justified.
+		//
+		// Using Rialto runtime this is slightly incorrect, because `DbWeight` of Rococo/Wococo runtime may differ
+		// from the `DbWeight` of Rialto runtime. But now (and most probably forever) it is the same.
+		type RococoGrandpaPalletWeights = pallet_bridge_grandpa::weights::RialtoWeight<rialto_runtime::Runtime>;
+
+		// The following formula shall not be treated as super-accurate - guard is to protect from mad relays,
+		// not to protect from over-average loses.
+		//
+		// Worst case: we're submitting proof for every source header. Since we submit every header, the number of
+		// headers in ancestry proof is near to 0 (let's round up to 2). And the number of authorities is 1024,
+		// which is (now) larger than on any existing chain => normally there'll be ~1024*2/3+1 commits.
+		const AVG_VOTES_ANCESTRIES_LEN: u32 = 2;
+		const AVG_PRECOMMITS_LEN: u32 = 1024 * 2 / 3 + 1;
+		let number_of_source_headers_per_day: bp_wococo::Balance = bp_wococo::DAYS as _;
+		let single_source_header_submit_call_weight =
+			RococoGrandpaPalletWeights::submit_finality_proof(AVG_VOTES_ANCESTRIES_LEN, AVG_PRECOMMITS_LEN);
+		// for simplicity - add extra weight for base tx fee + fee that is paid for the tx size + adjusted fee
+		let single_source_header_submit_tx_weight = single_source_header_submit_call_weight * 3 / 2;
+		let single_source_header_tx_cost = bp_rococo::WeightToFee::calc(&single_source_header_submit_tx_weight);
+		let maximal_expected_decrease = single_source_header_tx_cost * number_of_source_headers_per_day;
+		assert!(
+			MAXIMAL_BALANCE_DECREASE_PER_DAY >= maximal_expected_decrease,
+			"Maximal expected loss per day {} is larger than hardcoded {}",
+			maximal_expected_decrease,
+			MAXIMAL_BALANCE_DECREASE_PER_DAY,
+		);
+	}
+}

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

@@ -0,0 +1,227 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Wococo-to-Rococo messages sync entrypoint.
+
+use crate::messages_lane::{
+	select_delivery_transaction_limits, MessagesRelayParams, SubstrateMessageLane, SubstrateMessageLaneToSubstrate,
+};
+use crate::messages_source::SubstrateMessagesSource;
+use crate::messages_target::SubstrateMessagesTarget;
+
+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::{metrics::StorageProofOverheadMetric, Chain, TransactionSignScheme};
+use relay_wococo_client::{HeaderId as WococoHeaderId, SigningParams as WococoSigningParams, Wococo};
+use sp_core::{Bytes, Pair};
+use std::{ops::RangeInclusive, time::Duration};
+
+/// Wococo-to-Rococo message lane.
+pub type WococoMessagesToRococo =
+	SubstrateMessageLaneToSubstrate<Wococo, WococoSigningParams, Rococo, RococoSigningParams>;
+
+impl SubstrateMessageLane for WococoMessagesToRococo {
+	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;
+	const OUTBOUND_LANE_LATEST_RECEIVED_NONCE_METHOD: &'static str = bp_rococo::TO_ROCOCO_LATEST_RECEIVED_NONCE_METHOD;
+
+	const INBOUND_LANE_LATEST_RECEIVED_NONCE_METHOD: &'static str = bp_wococo::FROM_WOCOCO_LATEST_RECEIVED_NONCE_METHOD;
+	const INBOUND_LANE_LATEST_CONFIRMED_NONCE_METHOD: &'static str =
+		bp_wococo::FROM_WOCOCO_LATEST_CONFIRMED_NONCE_METHOD;
+	const INBOUND_LANE_UNREWARDED_RELAYERS_STATE: &'static str = bp_wococo::FROM_WOCOCO_UNREWARDED_RELAYERS_STATE;
+
+	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;
+
+	type SourceChain = Wococo;
+	type TargetChain = Rococo;
+
+	fn source_transactions_author(&self) -> bp_wococo::AccountId {
+		(*self.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,
+	) -> Bytes {
+		let (relayers_state, proof) = proof;
+		let call = relay_wococo_client::runtime::Call::BridgeMessagesRococo(
+			relay_wococo_client::runtime::BridgeMessagesRococoCall::receive_messages_delivery_proof(
+				proof,
+				relayers_state,
+			),
+		);
+		let genesis_hash = *self.source_client.genesis_hash();
+		let transaction = Wococo::sign_transaction(genesis_hash, &self.source_sign, transaction_nonce, call);
+		log::trace!(
+			target: "bridge",
+			"Prepared Rococo -> Wococo confirmation transaction. Weight: <unknown>/{}, size: {}/{}",
+			bp_wococo::max_extrinsic_weight(),
+			transaction.encode().len(),
+			bp_wococo::max_extrinsic_size(),
+		);
+		Bytes(transaction.encode())
+	}
+
+	fn target_transactions_author(&self) -> bp_rococo::AccountId {
+		(*self.target_sign.public().as_array_ref()).into()
+	}
+
+	fn make_messages_delivery_transaction(
+		&self,
+		transaction_nonce: <Rococo as Chain>::Index,
+		_generated_at_header: WococoHeaderId,
+		_nonces: RangeInclusive<MessageNonce>,
+		proof: <Self as MessageLane>::MessagesProof,
+	) -> Bytes {
+		let (dispatch_weight, proof) = proof;
+		let FromBridgedChainMessagesProof {
+			ref nonces_start,
+			ref nonces_end,
+			..
+		} = proof;
+		let messages_count = nonces_end - nonces_start + 1;
+
+		let call = relay_rococo_client::runtime::Call::BridgeMessagesWococo(
+			relay_rococo_client::runtime::BridgeMessagesWococoCall::receive_messages_proof(
+				self.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);
+		log::trace!(
+			target: "bridge",
+			"Prepared Wococo -> Rococo delivery transaction. Weight: <unknown>/{}, size: {}/{}",
+			bp_rococo::max_extrinsic_weight(),
+			transaction.encode().len(),
+			bp_rococo::max_extrinsic_size(),
+		);
+		Bytes(transaction.encode())
+	}
+}
+
+/// Wococo node as messages source.
+type WococoSourceClient =
+	SubstrateMessagesSource<Wococo, WococoMessagesToRococo, relay_wococo_client::runtime::WithRococoMessagesInstance>;
+
+/// Rococo node as messages target.
+type RococoTargetClient =
+	SubstrateMessagesTarget<Rococo, WococoMessagesToRococo, relay_rococo_client::runtime::WithWococoMessagesInstance>;
+
+/// Run Wococo-to-Rococo messages sync.
+pub async fn run(
+	params: MessagesRelayParams<Wococo, WococoSigningParams, Rococo, RococoSigningParams>,
+) -> Result<(), String> {
+	let stall_timeout = Duration::from_secs(5 * 60);
+	let relayer_id_at_wococo = (*params.source_sign.public().as_array_ref()).into();
+
+	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,
+	};
+
+	// 2/3 is reserved for proofs and tx overhead
+	let max_messages_size_in_single_batch = bp_rococo::max_extrinsic_size() / 3;
+	// we don't know exact weights of the Rococo runtime. So to guess weights we'll be using
+	// weights from Rialto and then simply dividing it by x2.
+	let (max_messages_in_single_batch, max_messages_weight_in_single_batch) =
+		select_delivery_transaction_limits::<pallet_bridge_messages::weights::RialtoWeight<rialto_runtime::Runtime>>(
+			bp_rococo::max_extrinsic_weight(),
+			bp_rococo::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE,
+		);
+	let (max_messages_in_single_batch, max_messages_weight_in_single_batch) = (
+		max_messages_in_single_batch / 2,
+		max_messages_weight_in_single_batch / 2,
+	);
+
+	log::info!(
+		target: "bridge",
+		"Starting Wococo -> Rococo messages relay.\n\t\
+			Wococo relayer account id: {:?}\n\t\
+			Max messages in single transaction: {}\n\t\
+			Max messages size in single transaction: {}\n\t\
+			Max messages weight in single transaction: {}",
+		lane.relayer_id_at_source,
+		max_messages_in_single_batch,
+		max_messages_size_in_single_batch,
+		max_messages_weight_in_single_batch,
+	);
+
+	messages_relay::message_lane_loop::run(
+		messages_relay::message_lane_loop::Params {
+			lane: lane_id,
+			source_tick: Wococo::AVERAGE_BLOCK_INTERVAL,
+			target_tick: Rococo::AVERAGE_BLOCK_INTERVAL,
+			reconnect_delay: relay_utils::relay_loop::RECONNECT_DELAY,
+			stall_timeout,
+			delivery_params: messages_relay::message_lane_loop::MessageDeliveryParams {
+				max_unrewarded_relayer_entries_at_target: bp_rococo::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE,
+				max_unconfirmed_nonces_at_target: bp_rococo::MAX_UNCONFIRMED_MESSAGES_AT_INBOUND_LANE,
+				max_messages_in_single_batch,
+				max_messages_weight_in_single_batch,
+				max_messages_size_in_single_batch,
+				relayer_mode: messages_relay::message_lane_loop::RelayerMode::Altruistic,
+			},
+		},
+		WococoSourceClient::new(
+			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,
+			params.source_to_target_headers_relay,
+		),
+		relay_utils::relay_metrics(
+			Some(messages_relay::message_lane_loop::metrics_prefix::<
+				WococoMessagesToRococo,
+			>(&lane_id)),
+			params.metrics_params,
+		)
+		.standalone_metric(|registry, prefix| {
+			StorageProofOverheadMetric::new(
+				registry,
+				prefix,
+				source_client.clone(),
+				"wococo_storage_proof_overhead".into(),
+				"Wococo storage proof overhead".into(),
+			)
+		})?
+		.into_params(),
+		futures::future::pending(),
+	)
+	.await
+}