SubmitMillauToRialtoMessage subcommand in substrate-relay (#460)

* substrate-relay::SubmitMillauToRialtoMessage

* typo

* Update relays/substrate/src/cli.rs

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

bridges/relays/substrate/src/cli.rs

@@ -16,7 +16,8 @@
 
 //! Deal with CLI args of substrate-to-substrate relay.
 
-use structopt::StructOpt;
+use bp_message_lane::LaneId;
+use structopt::{clap::arg_enum, StructOpt};
 
 /// Parse relay CLI args.
 pub fn parse_args() -> Command {
@@ -38,6 +39,52 @@ pub enum Command {
 		#[structopt(flatten)]
 		prometheus_params: PrometheusParams,
 	},
+	/// Submit message to given Rialto -> Millau lane.
+	SubmitMillauToRialtoMessage {
+		#[structopt(flatten)]
+		millau: MillauConnectionParams,
+		#[structopt(flatten)]
+		millau_sign: MillauSigningParams,
+		#[structopt(flatten)]
+		rialto_sign: RialtoSigningParams,
+		/// Hex-encoded lane id.
+		#[structopt(long)]
+		lane: HexLaneId,
+		/// Message type.
+		#[structopt(long, possible_values = &ToRialtoMessage::variants())]
+		message: ToRialtoMessage,
+		/// Delivery and dispatch fee.
+		#[structopt(long)]
+		fee: bp_millau::Balance,
+	},
+}
+
+arg_enum! {
+	#[derive(Debug)]
+	/// All possible messages that may be delivered to the Rialto chain.
+	pub enum ToRialtoMessage {
+		Remark,
+	}
+}
+
+/// Lane id.
+#[derive(Debug)]
+pub struct HexLaneId(LaneId);
+
+impl From<HexLaneId> for LaneId {
+	fn from(lane_id: HexLaneId) -> LaneId {
+		lane_id.0
+	}
+}
+
+impl std::str::FromStr for HexLaneId {
+	type Err = hex::FromHexError;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		let mut lane_id = LaneId::default();
+		hex::decode_to_slice(s, &mut lane_id)?;
+		Ok(HexLaneId(lane_id))
+	}
 }
 
 /// Prometheus metrics params.

bridges/relays/substrate/src/main.rs

@@ -18,14 +18,19 @@
 
 #![warn(missing_docs)]
 
-use relay_rialto_client::SigningParams as RialtoSigningParams;
-use relay_substrate_client::ConnectionParams;
+use codec::Encode;
+use frame_support::weights::GetDispatchInfo;
+use pallet_bridge_call_dispatch::{CallOrigin, MessagePayload};
+use relay_millau_client::{Millau, SigningParams as MillauSigningParams};
+use relay_rialto_client::{Rialto, SigningParams as RialtoSigningParams};
+use relay_substrate_client::{ConnectionParams, TransactionSignScheme};
 use relay_utils::initialize::initialize_relay;
+use sp_core::{Bytes, Pair};
 
 /// Millau node client.
-pub type MillauClient = relay_substrate_client::Client<relay_millau_client::Millau>;
+pub type MillauClient = relay_substrate_client::Client<Millau>;
 /// Rialto node client.
-pub type RialtoClient = relay_substrate_client::Client<relay_rialto_client::Rialto>;
+pub type RialtoClient = relay_substrate_client::Client<Rialto>;
 
 mod cli;
 mod headers_maintain;
@@ -66,6 +71,80 @@ async fn run_command(command: cli::Command) -> Result<(), String> {
 			.map_err(|e| format!("Failed to parse rialto-signer: {:?}", e))?;
 			millau_headers_to_rialto::run(millau_client, rialto_client, rialto_sign, prometheus_params.into()).await;
 		}
+		cli::Command::SubmitMillauToRialtoMessage {
+			millau,
+			millau_sign,
+			rialto_sign,
+			lane,
+			message,
+			fee,
+		} => {
+			let millau_client = MillauClient::new(ConnectionParams {
+				host: millau.millau_host,
+				port: millau.millau_port,
+			})
+			.await?;
+			let millau_sign = MillauSigningParams::from_suri(
+				&millau_sign.millau_signer,
+				millau_sign.millau_signer_password.as_deref(),
+			)
+			.map_err(|e| format!("Failed to parse millau-signer: {:?}", e))?;
+			let rialto_sign = RialtoSigningParams::from_suri(
+				&rialto_sign.rialto_signer,
+				rialto_sign.rialto_signer_password.as_deref(),
+			)
+			.map_err(|e| format!("Failed to parse rialto-signer: {:?}", e))?;
+
+			let rialto_call = match message {
+				cli::ToRialtoMessage::Remark => rialto_runtime::Call::System(rialto_runtime::SystemCall::remark(
+					format!(
+						"Unix time: {}",
+						std::time::SystemTime::now()
+							.duration_since(std::time::SystemTime::UNIX_EPOCH)
+							.unwrap_or_default()
+							.as_secs(),
+					)
+					.as_bytes()
+					.to_vec(),
+				)),
+			};
+			let rialto_call_weight = rialto_call.get_dispatch_info().weight;
+
+			let millau_sender_public = millau_sign.signer.public();
+			let rialto_origin_public = rialto_sign.signer.public();
+
+			let mut rialto_origin_signature_message = Vec::new();
+			rialto_call.encode_to(&mut rialto_origin_signature_message);
+			millau_sender_public.encode_to(&mut rialto_origin_signature_message);
+			let rialto_origin_signature = rialto_sign.signer.sign(&rialto_origin_signature_message);
+
+			let millau_call =
+				millau_runtime::Call::BridgeRialtoMessageLane(millau_runtime::MessageLaneCall::send_message(
+					lane.into(),
+					MessagePayload {
+						spec_version: millau_runtime::VERSION.spec_version,
+						weight: rialto_call_weight,
+						origin: CallOrigin::RealAccount(
+							millau_sender_public.into(),
+							rialto_origin_public.into(),
+							rialto_origin_signature.into(),
+						),
+						call: rialto_call.encode(),
+					},
+					fee,
+				));
+
+			let signed_millau_call = Millau::sign_transaction(
+				&millau_client,
+				&millau_sign.signer,
+				millau_client.next_account_index(millau_sender_public.into()).await?,
+				millau_call,
+			);
+
+			millau_client
+				.submit_extrinsic(Bytes(signed_millau_call.encode()))
+				.await?;
+		}
 	}
 
 	Ok(())