CLI: naming clean-up. (#897)

* Small naming clean up.

* Small naming clean up.

* Add Rococo module to CLI

Co-authored-by: Svyatoslav Nikolsky <svyatonik@gmail.com>
Co-authored-by: Hernando Castano <hernando@hcastano.com>

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

@@ -0,0 +1,101 @@
+// 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/>.
+
+//! Millau chain specification for CLI.
+
+use crate::cli::{
+	bridge,
+	encode_call::{self, Call, CliEncodeCall},
+	encode_message, send_message, CliChain,
+};
+use codec::Decode;
+use frame_support::weights::{GetDispatchInfo, Weight};
+use pallet_bridge_dispatch::{CallOrigin, MessagePayload};
+use relay_millau_client::Millau;
+use sp_version::RuntimeVersion;
+
+impl CliEncodeCall for Millau {
+	fn max_extrinsic_size() -> u32 {
+		bp_millau::max_extrinsic_size()
+	}
+
+	fn encode_call(call: &Call) -> anyhow::Result<Self::Call> {
+		Ok(match call {
+			Call::Raw { data } => Decode::decode(&mut &*data.0)?,
+			Call::Remark { remark_payload, .. } => millau_runtime::Call::System(millau_runtime::SystemCall::remark(
+				remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
+			)),
+			Call::Transfer { recipient, amount } => millau_runtime::Call::Balances(
+				millau_runtime::BalancesCall::transfer(recipient.raw_id(), amount.cast()),
+			),
+			Call::BridgeSendMessage {
+				lane,
+				payload,
+				fee,
+				bridge_instance_index,
+			} => match *bridge_instance_index {
+				bridge::MILLAU_TO_RIALTO_INDEX => {
+					let payload = Decode::decode(&mut &*payload.0)?;
+					millau_runtime::Call::BridgeRialtoMessages(millau_runtime::MessagesCall::send_message(
+						lane.0,
+						payload,
+						fee.cast(),
+					))
+				}
+				_ => anyhow::bail!(
+					"Unsupported target bridge pallet with instance index: {}",
+					bridge_instance_index
+				),
+			},
+		})
+	}
+}
+
+impl CliChain for Millau {
+	const RUNTIME_VERSION: RuntimeVersion = millau_runtime::VERSION;
+
+	type KeyPair = sp_core::sr25519::Pair;
+	type MessagePayload = MessagePayload<bp_millau::AccountId, bp_rialto::AccountSigner, bp_rialto::Signature, Vec<u8>>;
+
+	fn ss58_format() -> u16 {
+		millau_runtime::SS58Prefix::get() as u16
+	}
+
+	fn max_extrinsic_weight() -> Weight {
+		bp_millau::max_extrinsic_weight()
+	}
+
+	// TODO [#854|#843] support multiple bridges?
+	fn encode_message(message: encode_message::MessagePayload) -> Result<Self::MessagePayload, String> {
+		match message {
+			encode_message::MessagePayload::Raw { data } => MessagePayload::decode(&mut &*data.0)
+				.map_err(|e| format!("Failed to decode Millau's MessagePayload: {:?}", e)),
+			encode_message::MessagePayload::Call { mut call, mut sender } => {
+				type Source = Millau;
+				type Target = relay_rialto_client::Rialto;
+
+				sender.enforce_chain::<Source>();
+				let spec_version = Target::RUNTIME_VERSION.spec_version;
+				let origin = CallOrigin::SourceAccount(sender.raw_id());
+				encode_call::preprocess_call::<Source, Target>(&mut call, bridge::MILLAU_TO_RIALTO_INDEX);
+				let call = Target::encode_call(&call).map_err(|e| e.to_string())?;
+				let weight = call.get_dispatch_info().weight;
+
+				Ok(send_message::message_payload(spec_version, weight, origin, &call))
+			}
+		}
+	}
+}

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

@@ -0,0 +1,53 @@
+// 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/>.
+
+//! 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};
+
+/// Millau-to-Rialto finality sync pipeline.
+pub(crate) type MillauFinalityToRialto = SubstrateFinalityToSubstrate<Millau, Rialto, RialtoSigningParams>;
+
+impl SubstrateFinalitySyncPipeline for MillauFinalityToRialto {
+	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()
+	}
+
+	fn make_submit_finality_proof_transaction(
+		&self,
+		transaction_nonce: <Rialto as Chain>::Index,
+		header: MillauSyncHeader,
+		proof: GrandpaJustification<bp_millau::Header>,
+	) -> 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);
+
+		Bytes(transaction.encode())
+	}
+}

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

@@ -0,0 +1,245 @@
+// 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/>.
+
+//! Millau-to-Rialto 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::{MILLAU_BRIDGE_INSTANCE, RIALTO_BRIDGE_INSTANCE};
+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::{
+	metrics::{FloatStorageValueMetric, StorageProofOverheadMetric},
+	Chain, TransactionSignScheme,
+};
+use sp_core::{Bytes, Pair};
+use std::{ops::RangeInclusive, time::Duration};
+
+/// Millau-to-Rialto message lane.
+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_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;
+
+	const INBOUND_LANE_LATEST_RECEIVED_NONCE_METHOD: &'static str = bp_millau::FROM_MILLAU_LATEST_RECEIVED_NONCE_METHOD;
+	const INBOUND_LANE_LATEST_CONFIRMED_NONCE_METHOD: &'static str =
+		bp_millau::FROM_MILLAU_LATEST_CONFIRMED_NONCE_METHOD;
+	const INBOUND_LANE_UNREWARDED_RELAYERS_STATE: &'static str = bp_millau::FROM_MILLAU_UNREWARDED_RELAYERS_STATE;
+
+	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;
+
+	type SourceChain = Millau;
+	type TargetChain = Rialto;
+
+	fn source_transactions_author(&self) -> bp_rialto::AccountId {
+		(*self.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,
+	) -> 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);
+		log::trace!(
+			target: "bridge",
+			"Prepared Rialto -> Millau confirmation transaction. Weight: {}/{}, size: {}/{}",
+			call_weight,
+			bp_millau::max_extrinsic_weight(),
+			transaction.encode().len(),
+			bp_millau::max_extrinsic_size(),
+		);
+		Bytes(transaction.encode())
+	}
+
+	fn target_transactions_author(&self) -> bp_rialto::AccountId {
+		(*self.target_sign.public().as_array_ref()).into()
+	}
+
+	fn make_messages_delivery_transaction(
+		&self,
+		transaction_nonce: <Rialto as Chain>::Index,
+		_generated_at_header: MillauHeaderId,
+		_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: rialto_runtime::Call = rialto_runtime::MessagesCall::receive_messages_proof(
+			self.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);
+		log::trace!(
+			target: "bridge",
+			"Prepared Millau -> Rialto delivery transaction. Weight: {}/{}, size: {}/{}",
+			call_weight,
+			bp_rialto::max_extrinsic_weight(),
+			transaction.encode().len(),
+			bp_rialto::max_extrinsic_size(),
+		);
+		Bytes(transaction.encode())
+	}
+}
+
+/// Millau node as messages source.
+type MillauSourceClient = SubstrateMessagesSource<
+	Millau,
+	MillauMessagesToRialto,
+	millau_runtime::Runtime,
+	millau_runtime::WithRialtoMessagesInstance,
+>;
+
+/// Rialto node as messages target.
+type RialtoTargetClient = SubstrateMessagesTarget<
+	Rialto,
+	MillauMessagesToRialto,
+	rialto_runtime::Runtime,
+	rialto_runtime::WithMillauMessagesInstance,
+>;
+
+/// Run Millau-to-Rialto messages sync.
+pub async fn run(
+	params: MessagesRelayParams<Millau, MillauSigningParams, Rialto, RialtoSigningParams>,
+) -> Result<(), String> {
+	let stall_timeout = Duration::from_secs(5 * 60);
+	let relayer_id_at_millau = (*params.source_sign.public().as_array_ref()).into();
+
+	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,
+	};
+
+	// 2/3 is reserved for proofs and tx overhead
+	let max_messages_size_in_single_batch = bp_rialto::max_extrinsic_size() as usize / 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>>(
+			bp_rialto::max_extrinsic_weight(),
+			bp_rialto::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE,
+		);
+
+	log::info!(
+		target: "bridge",
+		"Starting Millau -> Rialto messages relay.\n\t\
+			Millau 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: Millau::AVERAGE_BLOCK_INTERVAL,
+			target_tick: Rialto::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_rialto::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE,
+				max_unconfirmed_nonces_at_target: bp_rialto::MAX_UNCONFIRMED_MESSAGES_AT_INBOUND_LANE,
+				max_messages_in_single_batch,
+				max_messages_weight_in_single_batch,
+				max_messages_size_in_single_batch,
+			},
+		},
+		MillauSourceClient::new(
+			source_client.clone(),
+			lane.clone(),
+			lane_id,
+			RIALTO_BRIDGE_INSTANCE,
+			params.target_to_source_headers_relay,
+		),
+		RialtoTargetClient::new(
+			params.target_client,
+			lane,
+			lane_id,
+			MILLAU_BRIDGE_INSTANCE,
+			params.source_to_target_headers_relay,
+		),
+		relay_utils::relay_metrics(
+			Some(messages_relay::message_lane_loop::metrics_prefix::<
+				MillauMessagesToRialto,
+			>(&lane_id)),
+			params.metrics_params,
+		)
+		.standalone_metric(|registry, prefix| {
+			StorageProofOverheadMetric::new(
+				registry,
+				prefix,
+				source_client.clone(),
+				"millau_storage_proof_overhead".into(),
+				"Millau storage proof overhead".into(),
+			)
+		})?
+		.standalone_metric(|registry, prefix| {
+			FloatStorageValueMetric::<_, sp_runtime::FixedU128>::new(
+				registry,
+				prefix,
+				source_client,
+				sp_core::storage::StorageKey(
+					millau_runtime::rialto_messages::RialtoToMillauConversionRate::key().to_vec(),
+				),
+				Some(millau_runtime::rialto_messages::INITIAL_RIALTO_TO_MILLAU_CONVERSION_RATE),
+				"millau_rialto_to_millau_conversion_rate".into(),
+				"Rialto to Millau tokens conversion rate (used by Rialto)".into(),
+			)
+		})?
+		.into_params(),
+		futures::future::pending(),
+	)
+	.await
+}

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

@@ -0,0 +1,331 @@
+// 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/>.
+
+//! Chain-specific relayer configuration.
+
+pub mod millau_headers_to_rialto;
+pub mod millau_messages_to_rialto;
+pub mod rialto_headers_to_millau;
+pub mod rialto_messages_to_millau;
+pub mod rococo_headers_to_westend;
+pub mod westend_headers_to_millau;
+pub mod westend_headers_to_rococo;
+
+mod millau;
+mod rialto;
+mod rococo;
+mod westend;
+
+use relay_utils::metrics::{FloatJsonValueMetric, MetricsParams};
+
+pub(crate) fn add_polkadot_kusama_price_metrics<T: finality_relay::FinalitySyncPipeline>(
+	params: MetricsParams,
+) -> anyhow::Result<MetricsParams> {
+	Ok(
+		relay_utils::relay_metrics(Some(finality_relay::metrics_prefix::<T>()), params)
+			// 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
+			.standalone_metric(|registry, prefix| {
+				FloatJsonValueMetric::new(
+					registry,
+					prefix,
+					"https://api.coingecko.com/api/v3/simple/price?ids=Polkadot&vs_currencies=usd".into(),
+					"$.polkadot.usd".into(),
+					"polkadot_price".into(),
+					"Polkadot price in USD".into(),
+				)
+			})
+			.map_err(|e| anyhow::format_err!("{}", e))?
+			.standalone_metric(|registry, prefix| {
+				FloatJsonValueMetric::new(
+					registry,
+					prefix,
+					"https://api.coingecko.com/api/v3/simple/price?ids=Kusama&vs_currencies=usd".into(),
+					"$.kusama.usd".into(),
+					"kusama_price".into(),
+					"Kusama price in USD".into(),
+				)
+			})
+			.map_err(|e| anyhow::format_err!("{}", e))?
+			.into_params(),
+	)
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::cli::{encode_call, send_message};
+	use bp_messages::source_chain::TargetHeaderChain;
+	use codec::Encode;
+	use frame_support::dispatch::GetDispatchInfo;
+	use relay_millau_client::Millau;
+	use relay_rialto_client::Rialto;
+	use relay_substrate_client::TransactionSignScheme;
+	use sp_core::Pair;
+	use sp_runtime::traits::{IdentifyAccount, Verify};
+
+	#[test]
+	fn millau_signature_is_valid_on_rialto() {
+		let millau_sign = relay_millau_client::SigningParams::from_string("//Dave", None).unwrap();
+
+		let call = rialto_runtime::Call::System(rialto_runtime::SystemCall::remark(vec![]));
+
+		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(
+			&call,
+			millau_account_id,
+			rialto_runtime::VERSION.spec_version,
+		);
+
+		let rialto_signer = relay_rialto_client::SigningParams::from_string("//Dave", None).unwrap();
+		let signature = rialto_signer.sign(&digest);
+
+		assert!(signature.verify(&digest[..], &rialto_signer.public()));
+	}
+
+	#[test]
+	fn rialto_signature_is_valid_on_millau() {
+		let rialto_sign = relay_rialto_client::SigningParams::from_string("//Dave", None).unwrap();
+
+		let call = millau_runtime::Call::System(millau_runtime::SystemCall::remark(vec![]));
+
+		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(
+			&call,
+			rialto_account_id,
+			millau_runtime::VERSION.spec_version,
+		);
+
+		let millau_signer = relay_millau_client::SigningParams::from_string("//Dave", None).unwrap();
+		let signature = millau_signer.sign(&digest);
+
+		assert!(signature.verify(&digest[..], &millau_signer.public()));
+	}
+
+	#[test]
+	fn maximal_rialto_to_millau_message_arguments_size_is_computed_correctly() {
+		use rialto_runtime::millau_messages::Millau;
+
+		let maximal_remark_size = encode_call::compute_maximal_message_arguments_size(
+			bp_rialto::max_extrinsic_size(),
+			bp_millau::max_extrinsic_size(),
+		);
+
+		let call: millau_runtime::Call = millau_runtime::SystemCall::remark(vec![42; maximal_remark_size as _]).into();
+		let payload = send_message::message_payload(
+			Default::default(),
+			call.get_dispatch_info().weight,
+			pallet_bridge_dispatch::CallOrigin::SourceRoot,
+			&call,
+		);
+		assert_eq!(Millau::verify_message(&payload), Ok(()));
+
+		let call: millau_runtime::Call =
+			millau_runtime::SystemCall::remark(vec![42; (maximal_remark_size + 1) as _]).into();
+		let payload = send_message::message_payload(
+			Default::default(),
+			call.get_dispatch_info().weight,
+			pallet_bridge_dispatch::CallOrigin::SourceRoot,
+			&call,
+		);
+		assert!(Millau::verify_message(&payload).is_err());
+	}
+
+	#[test]
+	fn maximal_size_remark_to_rialto_is_generated_correctly() {
+		assert!(
+			bridge_runtime_common::messages::target::maximal_incoming_message_size(
+				bp_rialto::max_extrinsic_size()
+			) > bp_millau::max_extrinsic_size(),
+			"We can't actually send maximal messages to Rialto from Millau, because Millau extrinsics can't be that large",
+		)
+	}
+
+	#[test]
+	fn maximal_rialto_to_millau_message_dispatch_weight_is_computed_correctly() {
+		use rialto_runtime::millau_messages::Millau;
+
+		let maximal_dispatch_weight =
+			send_message::compute_maximal_message_dispatch_weight(bp_millau::max_extrinsic_weight());
+		let call: millau_runtime::Call = rialto_runtime::SystemCall::remark(vec![]).into();
+
+		let payload = send_message::message_payload(
+			Default::default(),
+			maximal_dispatch_weight,
+			pallet_bridge_dispatch::CallOrigin::SourceRoot,
+			&call,
+		);
+		assert_eq!(Millau::verify_message(&payload), Ok(()));
+
+		let payload = send_message::message_payload(
+			Default::default(),
+			maximal_dispatch_weight + 1,
+			pallet_bridge_dispatch::CallOrigin::SourceRoot,
+			&call,
+		);
+		assert!(Millau::verify_message(&payload).is_err());
+	}
+
+	#[test]
+	fn maximal_weight_fill_block_to_rialto_is_generated_correctly() {
+		use millau_runtime::rialto_messages::Rialto;
+
+		let maximal_dispatch_weight =
+			send_message::compute_maximal_message_dispatch_weight(bp_rialto::max_extrinsic_weight());
+		let call: rialto_runtime::Call = millau_runtime::SystemCall::remark(vec![]).into();
+
+		let payload = send_message::message_payload(
+			Default::default(),
+			maximal_dispatch_weight,
+			pallet_bridge_dispatch::CallOrigin::SourceRoot,
+			&call,
+		);
+		assert_eq!(Rialto::verify_message(&payload), Ok(()));
+
+		let payload = send_message::message_payload(
+			Default::default(),
+			maximal_dispatch_weight + 1,
+			pallet_bridge_dispatch::CallOrigin::SourceRoot,
+			&call,
+		);
+		assert!(Rialto::verify_message(&payload).is_err());
+	}
+
+	#[test]
+	fn rialto_tx_extra_bytes_constant_is_correct() {
+		let rialto_call = rialto_runtime::Call::System(rialto_runtime::SystemCall::remark(vec![]));
+		let rialto_tx = Rialto::sign_transaction(
+			Default::default(),
+			&sp_keyring::AccountKeyring::Alice.pair(),
+			0,
+			rialto_call.clone(),
+		);
+		let extra_bytes_in_transaction = rialto_tx.encode().len() - rialto_call.encode().len();
+		assert!(
+			bp_rialto::TX_EXTRA_BYTES as usize >= extra_bytes_in_transaction,
+			"Hardcoded number of extra bytes in Rialto transaction {} is lower than actual value: {}",
+			bp_rialto::TX_EXTRA_BYTES,
+			extra_bytes_in_transaction,
+		);
+	}
+
+	#[test]
+	fn millau_tx_extra_bytes_constant_is_correct() {
+		let millau_call = millau_runtime::Call::System(millau_runtime::SystemCall::remark(vec![]));
+		let millau_tx = Millau::sign_transaction(
+			Default::default(),
+			&sp_keyring::AccountKeyring::Alice.pair(),
+			0,
+			millau_call.clone(),
+		);
+		let extra_bytes_in_transaction = millau_tx.encode().len() - millau_call.encode().len();
+		assert!(
+			bp_millau::TX_EXTRA_BYTES as usize >= extra_bytes_in_transaction,
+			"Hardcoded number of extra bytes in Millau transaction {} is lower than actual value: {}",
+			bp_millau::TX_EXTRA_BYTES,
+			extra_bytes_in_transaction,
+		);
+	}
+}
+
+#[cfg(test)]
+mod rococo_tests {
+	use bp_header_chain::justification::GrandpaJustification;
+	use codec::Encode;
+
+	#[test]
+	fn scale_compatibility_of_bridges_call() {
+		// given
+		let header = sp_runtime::generic::Header {
+			parent_hash: Default::default(),
+			number: Default::default(),
+			state_root: Default::default(),
+			extrinsics_root: Default::default(),
+			digest: sp_runtime::generic::Digest { logs: vec![] },
+		};
+		let justification = GrandpaJustification {
+			round: 0,
+			commit: finality_grandpa::Commit {
+				target_hash: Default::default(),
+				target_number: Default::default(),
+				precommits: vec![],
+			},
+			votes_ancestries: vec![],
+		};
+		let actual = bp_rococo::BridgeGrandpaWestendCall::submit_finality_proof(header.clone(), justification.clone());
+		let expected = millau_runtime::BridgeGrandpaRialtoCall::<millau_runtime::Runtime>::submit_finality_proof(
+			header,
+			justification,
+		);
+
+		// when
+		let actual_encoded = actual.encode();
+		let expected_encoded = expected.encode();
+
+		// then
+		assert_eq!(
+			actual_encoded, expected_encoded,
+			"Encoding difference. Raw: {:?} vs {:?}",
+			actual, expected
+		);
+	}
+}
+
+#[cfg(test)]
+mod westend_tests {
+	use bp_header_chain::justification::GrandpaJustification;
+	use codec::Encode;
+
+	#[test]
+	fn scale_compatibility_of_bridges_call() {
+		// given
+		let header = sp_runtime::generic::Header {
+			parent_hash: Default::default(),
+			number: Default::default(),
+			state_root: Default::default(),
+			extrinsics_root: Default::default(),
+			digest: sp_runtime::generic::Digest { logs: vec![] },
+		};
+		let justification = GrandpaJustification {
+			round: 0,
+			commit: finality_grandpa::Commit {
+				target_hash: Default::default(),
+				target_number: Default::default(),
+				precommits: vec![],
+			},
+			votes_ancestries: vec![],
+		};
+		let actual = bp_westend::BridgeGrandpaRococoCall::submit_finality_proof(header.clone(), justification.clone());
+		let expected = millau_runtime::BridgeGrandpaRialtoCall::<millau_runtime::Runtime>::submit_finality_proof(
+			header,
+			justification,
+		);
+
+		// when
+		let actual_encoded = actual.encode();
+		let expected_encoded = expected.encode();
+
+		// then
+		assert_eq!(
+			actual_encoded, expected_encoded,
+			"Encoding difference. Raw: {:?} vs {:?}",
+			actual, expected
+		);
+	}
+}

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

@@ -0,0 +1,98 @@
+// 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/>.
+
+//! Rialto chain specification for CLI.
+
+use crate::cli::{
+	bridge,
+	encode_call::{self, Call, CliEncodeCall},
+	encode_message, send_message, CliChain,
+};
+use codec::Decode;
+use frame_support::weights::{GetDispatchInfo, Weight};
+use pallet_bridge_dispatch::{CallOrigin, MessagePayload};
+use relay_rialto_client::Rialto;
+use sp_version::RuntimeVersion;
+
+impl CliEncodeCall for Rialto {
+	fn max_extrinsic_size() -> u32 {
+		bp_rialto::max_extrinsic_size()
+	}
+
+	fn encode_call(call: &Call) -> anyhow::Result<Self::Call> {
+		Ok(match call {
+			Call::Raw { data } => Decode::decode(&mut &*data.0)?,
+			Call::Remark { remark_payload, .. } => rialto_runtime::Call::System(rialto_runtime::SystemCall::remark(
+				remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
+			)),
+			Call::Transfer { recipient, amount } => {
+				rialto_runtime::Call::Balances(rialto_runtime::BalancesCall::transfer(recipient.raw_id(), amount.0))
+			}
+			Call::BridgeSendMessage {
+				lane,
+				payload,
+				fee,
+				bridge_instance_index,
+			} => match *bridge_instance_index {
+				bridge::RIALTO_TO_MILLAU_INDEX => {
+					let payload = Decode::decode(&mut &*payload.0)?;
+					rialto_runtime::Call::BridgeMillauMessages(rialto_runtime::MessagesCall::send_message(
+						lane.0, payload, fee.0,
+					))
+				}
+				_ => anyhow::bail!(
+					"Unsupported target bridge pallet with instance index: {}",
+					bridge_instance_index
+				),
+			},
+		})
+	}
+}
+
+impl CliChain for Rialto {
+	const RUNTIME_VERSION: RuntimeVersion = rialto_runtime::VERSION;
+
+	type KeyPair = sp_core::sr25519::Pair;
+	type MessagePayload = MessagePayload<bp_rialto::AccountId, bp_millau::AccountSigner, bp_millau::Signature, Vec<u8>>;
+
+	fn ss58_format() -> u16 {
+		rialto_runtime::SS58Prefix::get() as u16
+	}
+
+	fn max_extrinsic_weight() -> Weight {
+		bp_rialto::max_extrinsic_weight()
+	}
+
+	fn encode_message(message: encode_message::MessagePayload) -> Result<Self::MessagePayload, String> {
+		match message {
+			encode_message::MessagePayload::Raw { data } => MessagePayload::decode(&mut &*data.0)
+				.map_err(|e| format!("Failed to decode Rialto's MessagePayload: {:?}", e)),
+			encode_message::MessagePayload::Call { mut call, mut sender } => {
+				type Source = Rialto;
+				type Target = relay_millau_client::Millau;
+
+				sender.enforce_chain::<Source>();
+				let spec_version = Target::RUNTIME_VERSION.spec_version;
+				let origin = CallOrigin::SourceAccount(sender.raw_id());
+				encode_call::preprocess_call::<Source, Target>(&mut call, bridge::RIALTO_TO_MILLAU_INDEX);
+				let call = Target::encode_call(&call).map_err(|e| e.to_string())?;
+				let weight = call.get_dispatch_info().weight;
+
+				Ok(send_message::message_payload(spec_version, weight, origin, &call))
+			}
+		}
+	}
+}

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

@@ -0,0 +1,57 @@
+// 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/>.
+
+//! 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};
+
+/// Rialto-to-Millau finality sync pipeline.
+pub(crate) type RialtoFinalityToMillau = SubstrateFinalityToSubstrate<Rialto, Millau, MillauSigningParams>;
+
+impl SubstrateFinalitySyncPipeline for RialtoFinalityToMillau {
+	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()
+	}
+
+	fn make_submit_finality_proof_transaction(
+		&self,
+		transaction_nonce: <Millau as Chain>::Index,
+		header: RialtoSyncHeader,
+		proof: GrandpaJustification<bp_rialto::Header>,
+	) -> Bytes {
+		let call = millau_runtime::BridgeGrandpaRialtoCall::<
+			millau_runtime::Runtime,
+			millau_runtime::RialtoGrandpaInstance,
+		>::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);
+
+		Bytes(transaction.encode())
+	}
+}

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

@@ -0,0 +1,244 @@
+// 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/>.
+
+//! Rialto-to-Millau 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::{MILLAU_BRIDGE_INSTANCE, RIALTO_BRIDGE_INSTANCE};
+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::{
+	metrics::{FloatStorageValueMetric, StorageProofOverheadMetric},
+	Chain, TransactionSignScheme,
+};
+use sp_core::{Bytes, Pair};
+use std::{ops::RangeInclusive, time::Duration};
+
+/// Rialto-to-Millau message lane.
+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_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;
+
+	const INBOUND_LANE_LATEST_RECEIVED_NONCE_METHOD: &'static str = bp_rialto::FROM_RIALTO_LATEST_RECEIVED_NONCE_METHOD;
+	const INBOUND_LANE_LATEST_CONFIRMED_NONCE_METHOD: &'static str =
+		bp_rialto::FROM_RIALTO_LATEST_CONFIRMED_NONCE_METHOD;
+	const INBOUND_LANE_UNREWARDED_RELAYERS_STATE: &'static str = bp_rialto::FROM_RIALTO_UNREWARDED_RELAYERS_STATE;
+
+	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;
+
+	type SourceChain = Rialto;
+	type TargetChain = Millau;
+
+	fn source_transactions_author(&self) -> bp_rialto::AccountId {
+		(*self.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,
+	) -> 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);
+		log::trace!(
+			target: "bridge",
+			"Prepared Millau -> Rialto confirmation transaction. Weight: {}/{}, size: {}/{}",
+			call_weight,
+			bp_rialto::max_extrinsic_weight(),
+			transaction.encode().len(),
+			bp_rialto::max_extrinsic_size(),
+		);
+		Bytes(transaction.encode())
+	}
+
+	fn target_transactions_author(&self) -> bp_rialto::AccountId {
+		(*self.target_sign.public().as_array_ref()).into()
+	}
+
+	fn make_messages_delivery_transaction(
+		&self,
+		transaction_nonce: <Millau as Chain>::Index,
+		_generated_at_header: RialtoHeaderId,
+		_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: millau_runtime::Call = millau_runtime::MessagesCall::receive_messages_proof(
+			self.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);
+		log::trace!(
+			target: "bridge",
+			"Prepared Rialto -> Millau delivery transaction. Weight: {}/{}, size: {}/{}",
+			call_weight,
+			bp_millau::max_extrinsic_weight(),
+			transaction.encode().len(),
+			bp_millau::max_extrinsic_size(),
+		);
+		Bytes(transaction.encode())
+	}
+}
+
+/// Rialto node as messages source.
+type RialtoSourceClient = SubstrateMessagesSource<
+	Rialto,
+	RialtoMessagesToMillau,
+	rialto_runtime::Runtime,
+	rialto_runtime::WithMillauMessagesInstance,
+>;
+
+/// Millau node as messages target.
+type MillauTargetClient = SubstrateMessagesTarget<
+	Millau,
+	RialtoMessagesToMillau,
+	millau_runtime::Runtime,
+	millau_runtime::WithRialtoMessagesInstance,
+>;
+
+/// Run Rialto-to-Millau messages sync.
+pub async fn run(
+	params: MessagesRelayParams<Rialto, RialtoSigningParams, Millau, MillauSigningParams>,
+) -> Result<(), String> {
+	let stall_timeout = Duration::from_secs(5 * 60);
+	let relayer_id_at_rialto = (*params.source_sign.public().as_array_ref()).into();
+
+	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,
+	};
+
+	// 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_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(),
+			bp_millau::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE,
+		);
+
+	log::info!(
+		target: "bridge",
+		"Starting Rialto -> Millau messages relay.\n\t\
+			Rialto 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: Rialto::AVERAGE_BLOCK_INTERVAL,
+			target_tick: Millau::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_millau::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE,
+				max_unconfirmed_nonces_at_target: bp_millau::MAX_UNCONFIRMED_MESSAGES_AT_INBOUND_LANE,
+				max_messages_in_single_batch,
+				max_messages_weight_in_single_batch,
+				max_messages_size_in_single_batch,
+			},
+		},
+		RialtoSourceClient::new(
+			source_client.clone(),
+			lane.clone(),
+			lane_id,
+			MILLAU_BRIDGE_INSTANCE,
+			params.target_to_source_headers_relay,
+		),
+		MillauTargetClient::new(
+			params.target_client,
+			lane,
+			lane_id,
+			RIALTO_BRIDGE_INSTANCE,
+			params.source_to_target_headers_relay,
+		),
+		relay_utils::relay_metrics(
+			Some(messages_relay::message_lane_loop::metrics_prefix::<
+				RialtoMessagesToMillau,
+			>(&lane_id)),
+			params.metrics_params,
+		)
+		.standalone_metric(|registry, prefix| {
+			StorageProofOverheadMetric::new(
+				registry,
+				prefix,
+				source_client.clone(),
+				"rialto_storage_proof_overhead".into(),
+				"Rialto storage proof overhead".into(),
+			)
+		})?
+		.standalone_metric(|registry, prefix| {
+			FloatStorageValueMetric::<_, sp_runtime::FixedU128>::new(
+				registry,
+				prefix,
+				source_client,
+				sp_core::storage::StorageKey(
+					rialto_runtime::millau_messages::MillauToRialtoConversionRate::key().to_vec(),
+				),
+				Some(rialto_runtime::millau_messages::INITIAL_MILLAU_TO_RIALTO_CONVERSION_RATE),
+				"rialto_millau_to_rialto_conversion_rate".into(),
+				"Millau to Rialto tokens conversion rate (used by Millau)".into(),
+			)
+		})?
+		.into_params(),
+		futures::future::pending(),
+	)
+	.await
+}

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

@@ -0,0 +1,39 @@
+// 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/>.
+
+use crate::cli::{encode_message, CliChain};
+use frame_support::weights::Weight;
+use relay_rococo_client::Rococo;
+use sp_version::RuntimeVersion;
+
+impl CliChain for Rococo {
+	const RUNTIME_VERSION: RuntimeVersion = bp_rococo::VERSION;
+
+	type KeyPair = sp_core::sr25519::Pair;
+	type MessagePayload = ();
+
+	fn ss58_format() -> u16 {
+		42
+	}
+
+	fn max_extrinsic_weight() -> Weight {
+		0
+	}
+
+	fn encode_message(_message: encode_message::MessagePayload) -> Result<Self::MessagePayload, String> {
+		Err("Sending messages from Rococo is not yet supported.".into())
+	}
+}

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

@@ -0,0 +1,60 @@
+// 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-Westend headers sync entrypoint.
+
+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_westend_client::{SigningParams as WestendSigningParams, Westend};
+use sp_core::{Bytes, Pair};
+
+/// Rococo-to-Westend finality sync pipeline.
+pub(crate) type RococoFinalityToWestend = SubstrateFinalityToSubstrate<Rococo, Westend, WestendSigningParams>;
+
+impl SubstrateFinalitySyncPipeline for RococoFinalityToWestend {
+	const BEST_FINALIZED_SOURCE_HEADER_ID_AT_TARGET: &'static str = bp_rococo::BEST_FINALIZED_ROCOCO_HEADER_METHOD;
+
+	type TargetChain = Westend;
+
+	fn customize_metrics(params: MetricsParams) -> anyhow::Result<MetricsParams> {
+		crate::chains::add_polkadot_kusama_price_metrics::<Self>(params)
+	}
+
+	fn transactions_author(&self) -> bp_westend::AccountId {
+		(*self.target_sign.public().as_array_ref()).into()
+	}
+
+	fn make_submit_finality_proof_transaction(
+		&self,
+		transaction_nonce: <Westend as Chain>::Index,
+		header: RococoSyncHeader,
+		proof: GrandpaJustification<bp_rococo::Header>,
+	) -> Bytes {
+		let call = bp_westend::Call::BridgeGrandpaRococo(bp_westend::BridgeGrandpaRococoCall::submit_finality_proof(
+			header.into_inner(),
+			proof,
+		));
+		let genesis_hash = *self.target_client.genesis_hash();
+		let transaction = Westend::sign_transaction(genesis_hash, &self.target_sign, transaction_nonce, call);
+
+		Bytes(transaction.encode())
+	}
+}

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

@@ -0,0 +1,41 @@
+// 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 chain specification for CLI.
+
+use crate::cli::{encode_message, CliChain};
+use frame_support::weights::Weight;
+use relay_westend_client::Westend;
+use sp_version::RuntimeVersion;
+
+impl CliChain for Westend {
+	const RUNTIME_VERSION: RuntimeVersion = bp_westend::VERSION;
+
+	type KeyPair = sp_core::sr25519::Pair;
+	type MessagePayload = ();
+
+	fn ss58_format() -> u16 {
+		42
+	}
+
+	fn max_extrinsic_weight() -> Weight {
+		0
+	}
+
+	fn encode_message(_message: encode_message::MessagePayload) -> Result<Self::MessagePayload, String> {
+		Err("Sending messages from Westend is not yet supported.".into())
+	}
+}

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

@@ -0,0 +1,62 @@
+// 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-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};
+
+/// Westend-to-Millau finality sync pipeline.
+pub(crate) type WestendFinalityToMillau = SubstrateFinalityToSubstrate<Westend, Millau, MillauSigningParams>;
+
+impl SubstrateFinalitySyncPipeline for WestendFinalityToMillau {
+	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>(params)
+	}
+
+	fn transactions_author(&self) -> bp_millau::AccountId {
+		(*self.target_sign.public().as_array_ref()).into()
+	}
+
+	fn make_submit_finality_proof_transaction(
+		&self,
+		transaction_nonce: <Millau as Chain>::Index,
+		header: WestendSyncHeader,
+		proof: GrandpaJustification<bp_westend::Header>,
+	) -> Bytes {
+		let call = millau_runtime::BridgeGrandpaWestendCall::<
+			millau_runtime::Runtime,
+			millau_runtime::WestendGrandpaInstance,
+		>::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);
+
+		Bytes(transaction.encode())
+	}
+}

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

@@ -0,0 +1,60 @@
+// 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::BridgeGrandpaWestendCall::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())
+	}
+}