CLI: Encode Call & Multiple Bridge Instances. (#859)

* Encode Call & Multiple Bridge Instances.

* Remove redundant clone.

* Fix comment.

* Rename pallet index bridge instance index.

* Update error messages related to target instances

Co-authored-by: Hernando Castano <hernando@hcastano.com>

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

@@ -28,7 +28,10 @@ pub type MillauClient = relay_substrate_client::Client<Millau>;
 /// Rialto node client.
 pub type RialtoClient = relay_substrate_client::Client<Rialto>;
 
-use crate::cli::{CliChain, ExplicitOrMaximal, HexBytes, Origins};
+use crate::cli::{
+	encode_call::{self, Call, CliEncodeCall, MILLAU_TO_RIALTO_INDEX, RIALTO_TO_MILLAU_INDEX},
+	CliChain, ExplicitOrMaximal, HexBytes, Origins,
+};
 use codec::{Decode, Encode};
 use frame_support::weights::{GetDispatchInfo, Weight};
 use pallet_bridge_dispatch::{CallOrigin, MessagePayload};
@@ -48,7 +51,7 @@ async fn run_send_message(command: cli::SendMessage) -> Result<(), String> {
 			source_sign,
 			target_sign,
 			lane,
-			message,
+			mut message,
 			dispatch_weight,
 			fee,
 			origin,
@@ -75,7 +78,9 @@ async fn run_send_message(command: cli::SendMessage) -> Result<(), String> {
 			let source_client = source.into_client::<Source>().await.map_err(format_err)?;
 			let source_sign = source_sign.into_keypair::<Source>().map_err(format_err)?;
 			let target_sign = target_sign.into_keypair::<Target>().map_err(format_err)?;
-			let target_call = Target::encode_call(message)?;
+
+			encode_call::preprocess_call::<Source, Target>(&mut message, MILLAU_TO_RIALTO_INDEX);
+			let target_call = Target::encode_call(&message).map_err(|e| e.to_string())?;
 
 			let payload = {
 				let target_call_weight = prepare_call_dispatch_weight(
@@ -154,7 +159,7 @@ async fn run_send_message(command: cli::SendMessage) -> Result<(), String> {
 			source_sign,
 			target_sign,
 			lane,
-			message,
+			mut message,
 			dispatch_weight,
 			fee,
 			origin,
@@ -181,7 +186,9 @@ async fn run_send_message(command: cli::SendMessage) -> Result<(), String> {
 			let source_client = source.into_client::<Source>().await.map_err(format_err)?;
 			let source_sign = source_sign.into_keypair::<Source>().map_err(format_err)?;
 			let target_sign = target_sign.into_keypair::<Target>().map_err(format_err)?;
-			let target_call = Target::encode_call(message)?;
+
+			encode_call::preprocess_call::<Source, Target>(&mut message, RIALTO_TO_MILLAU_INDEX);
+			let target_call = Target::encode_call(&message).map_err(|e| e.to_string())?;
 
 			let payload = {
 				let target_call_weight = prepare_call_dispatch_weight(
@@ -259,24 +266,6 @@ async fn run_send_message(command: cli::SendMessage) -> Result<(), String> {
 	Ok(())
 }
 
-async fn run_encode_call(call: cli::EncodeCall) -> Result<(), String> {
-	match call {
-		cli::EncodeCall::Rialto { call } => {
-			type Source = Rialto;
-
-			let call = Source::encode_call(call)?;
-			println!("{:?}", HexBytes::encode(&call));
-		}
-		cli::EncodeCall::Millau { call } => {
-			type Source = Millau;
-
-			let call = Source::encode_call(call)?;
-			println!("{:?}", HexBytes::encode(&call));
-		}
-	}
-	Ok(())
-}
-
 async fn run_encode_message_payload(call: cli::EncodeMessagePayload) -> Result<(), String> {
 	match call {
 		cli::EncodeMessagePayload::RialtoToMillau { payload } => {
@@ -348,22 +337,6 @@ async fn estimate_message_delivery_and_dispatch_fee<Fee: Decode, C: Chain, P: En
 	Ok(decoded_response)
 }
 
-fn remark_payload(remark_size: Option<ExplicitOrMaximal<usize>>, maximal_allowed_size: u32) -> Vec<u8> {
-	match remark_size {
-		Some(ExplicitOrMaximal::Explicit(remark_size)) => vec![0; remark_size],
-		Some(ExplicitOrMaximal::Maximal) => vec![0; maximal_allowed_size as _],
-		None => format!(
-			"Unix time: {}",
-			std::time::SystemTime::now()
-				.duration_since(std::time::SystemTime::UNIX_EPOCH)
-				.unwrap_or_default()
-				.as_secs(),
-		)
-		.as_bytes()
-		.to_vec(),
-	}
-}
-
 fn message_payload<SAccountId, TPublic, TSignature>(
 	spec_version: u32,
 	weight: Weight,
@@ -433,24 +406,41 @@ fn compute_maximal_message_dispatch_weight(maximal_extrinsic_weight: Weight) ->
 	bridge_runtime_common::messages::target::maximal_incoming_message_dispatch_weight(maximal_extrinsic_weight)
 }
 
-fn compute_maximal_message_arguments_size(
-	maximal_source_extrinsic_size: u32,
-	maximal_target_extrinsic_size: u32,
-) -> u32 {
-	// assume that both signed extensions and other arguments fit 1KB
-	let service_tx_bytes_on_source_chain = 1024;
-	let maximal_source_extrinsic_size = maximal_source_extrinsic_size - service_tx_bytes_on_source_chain;
-	let maximal_call_size =
-		bridge_runtime_common::messages::target::maximal_incoming_message_size(maximal_target_extrinsic_size);
-	let maximal_call_size = if maximal_call_size > maximal_source_extrinsic_size {
-		maximal_source_extrinsic_size
-	} else {
-		maximal_call_size
-	};
+impl CliEncodeCall for Millau {
+	fn max_extrinsic_size() -> u32 {
+		bp_millau::max_extrinsic_size()
+	}
 
-	// bytes in Call encoding that are used to encode everything except arguments
-	let service_bytes = 1 + 1 + 4;
-	maximal_call_size - service_bytes
+	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.0.clone()))
+			}
+			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 {
+				encode_call::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 {
@@ -467,58 +457,20 @@ impl CliChain for Millau {
 		bp_millau::max_extrinsic_weight()
 	}
 
-	fn encode_call(call: cli::Call) -> Result<Self::Call, String> {
-		let call = match call {
-			cli::Call::Raw { data } => {
-				Decode::decode(&mut &*data.0).map_err(|e| format!("Unable to decode message: {:#?}", e))?
-			}
-			cli::Call::Remark { remark_size } => {
-				millau_runtime::Call::System(millau_runtime::SystemCall::remark(remark_payload(
-					remark_size,
-					compute_maximal_message_arguments_size(
-						bp_rialto::max_extrinsic_size(),
-						bp_millau::max_extrinsic_size(),
-					),
-				)))
-			}
-			cli::Call::Transfer { mut recipient, amount } => {
-				recipient.enforce_chain::<Millau>();
-				let amount = amount.cast();
-				millau_runtime::Call::Balances(millau_runtime::BalancesCall::transfer(recipient.raw_id(), amount))
-			}
-			cli::Call::BridgeSendMessage { lane, payload, fee } => {
-				type Target = Rialto;
-
-				let payload = Target::encode_message(cli::MessagePayload::Raw { data: payload })?;
-				let lane = lane.into();
-				millau_runtime::Call::BridgeRialtoMessages(millau_runtime::MessagesCall::send_message(
-					lane,
-					payload,
-					fee.cast(),
-				))
-			}
-		};
-
-		log::info!(target: "bridge", "Generated Millau call: {:#?}", call);
-		log::info!(target: "bridge", "Weight of Millau call: {}", call.get_dispatch_info().weight);
-		log::info!(target: "bridge", "Encoded Millau call: {:?}", HexBytes::encode(&call));
-
-		Ok(call)
-	}
-
 	// TODO [#854|#843] support multiple bridges?
 	fn encode_message(message: cli::MessagePayload) -> Result<Self::MessagePayload, String> {
 		match message {
 			cli::MessagePayload::Raw { data } => MessagePayload::decode(&mut &*data.0)
 				.map_err(|e| format!("Failed to decode Millau's MessagePayload: {:?}", e)),
-			cli::MessagePayload::Call { call, mut sender } => {
+			cli::MessagePayload::Call { mut call, mut sender } => {
 				type Source = Millau;
 				type Target = Rialto;
 
 				sender.enforce_chain::<Source>();
 				let spec_version = Target::RUNTIME_VERSION.spec_version;
 				let origin = CallOrigin::SourceAccount(sender.raw_id());
-				let call = Target::encode_call(call)?;
+				encode_call::preprocess_call::<Source, Target>(&mut call, MILLAU_TO_RIALTO_INDEX);
+				let call = Target::encode_call(&call).map_err(|e| e.to_string())?;
 				let weight = call.get_dispatch_info().weight;
 
 				Ok(message_payload(spec_version, weight, origin, &call))
@@ -527,6 +479,41 @@ impl CliChain for Millau {
 	}
 }
 
+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.0.clone()))
+			}
+			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 {
+				encode_call::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;
 
@@ -541,57 +528,19 @@ impl CliChain for Rialto {
 		bp_rialto::max_extrinsic_weight()
 	}
 
-	fn encode_call(call: cli::Call) -> Result<Self::Call, String> {
-		let call = match call {
-			cli::Call::Raw { data } => {
-				Decode::decode(&mut &*data.0).map_err(|e| format!("Unable to decode message: {:#?}", e))?
-			}
-			cli::Call::Remark { remark_size } => {
-				rialto_runtime::Call::System(rialto_runtime::SystemCall::remark(remark_payload(
-					remark_size,
-					compute_maximal_message_arguments_size(
-						bp_millau::max_extrinsic_size(),
-						bp_rialto::max_extrinsic_size(),
-					),
-				)))
-			}
-			cli::Call::Transfer { mut recipient, amount } => {
-				type Source = Rialto;
-
-				recipient.enforce_chain::<Source>();
-				let amount = amount.0;
-				rialto_runtime::Call::Balances(rialto_runtime::BalancesCall::transfer(recipient.raw_id(), amount))
-			}
-			cli::Call::BridgeSendMessage { lane, payload, fee } => {
-				type Target = Millau;
-
-				let payload = Target::encode_message(cli::MessagePayload::Raw { data: payload })?;
-				let lane = lane.into();
-				rialto_runtime::Call::BridgeMillauMessages(rialto_runtime::MessagesCall::send_message(
-					lane, payload, fee.0,
-				))
-			}
-		};
-
-		log::info!(target: "bridge", "Generated Rialto call: {:#?}", call);
-		log::info!(target: "bridge", "Weight of Rialto call: {}", call.get_dispatch_info().weight);
-		log::info!(target: "bridge", "Encoded Rialto call: {:?}", HexBytes::encode(&call));
-
-		Ok(call)
-	}
-
 	fn encode_message(message: cli::MessagePayload) -> Result<Self::MessagePayload, String> {
 		match message {
 			cli::MessagePayload::Raw { data } => MessagePayload::decode(&mut &*data.0)
 				.map_err(|e| format!("Failed to decode Rialto's MessagePayload: {:?}", e)),
-			cli::MessagePayload::Call { call, mut sender } => {
+			cli::MessagePayload::Call { mut call, mut sender } => {
 				type Source = Rialto;
 				type Target = Millau;
 
 				sender.enforce_chain::<Source>();
 				let spec_version = Target::RUNTIME_VERSION.spec_version;
 				let origin = CallOrigin::SourceAccount(sender.raw_id());
-				let call = Target::encode_call(call)?;
+				encode_call::preprocess_call::<Source, Target>(&mut call, RIALTO_TO_MILLAU_INDEX);
+				let call = Target::encode_call(&call).map_err(|e| e.to_string())?;
 				let weight = call.get_dispatch_info().weight;
 
 				Ok(message_payload(spec_version, weight, origin, &call))
@@ -614,10 +563,6 @@ impl CliChain for Westend {
 		0
 	}
 
-	fn encode_call(_: cli::Call) -> Result<Self::Call, String> {
-		Err("Calling into Westend is not supported yet.".into())
-	}
-
 	fn encode_message(_message: cli::MessagePayload) -> Result<Self::MessagePayload, String> {
 		Err("Sending messages from Westend is not yet supported.".into())
 	}
@@ -680,8 +625,10 @@ mod tests {
 	fn maximal_rialto_to_millau_message_arguments_size_is_computed_correctly() {
 		use rialto_runtime::millau_messages::Millau;
 
-		let maximal_remark_size =
-			compute_maximal_message_arguments_size(bp_rialto::max_extrinsic_size(), bp_millau::max_extrinsic_size());
+		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 = message_payload(