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/cli/bridge.rs

@@ -22,6 +22,8 @@ arg_enum! {
 	pub enum FullBridge {
 		MillauToRialto,
 		RialtoToMillau,
+		RococoToWococo,
+		WococoToRococo,
 	}
 }
 
@@ -31,12 +33,16 @@ impl FullBridge {
 		match self {
 			Self::MillauToRialto => MILLAU_TO_RIALTO_INDEX,
 			Self::RialtoToMillau => RIALTO_TO_MILLAU_INDEX,
+			Self::RococoToWococo => ROCOCO_TO_WOCOCO_INDEX,
+			Self::WococoToRococo => WOCOCO_TO_ROCOCO_INDEX,
 		}
 	}
 }
 
 pub const RIALTO_TO_MILLAU_INDEX: u8 = 0;
 pub const MILLAU_TO_RIALTO_INDEX: u8 = 0;
+pub const ROCOCO_TO_WOCOCO_INDEX: u8 = 0;
+pub const WOCOCO_TO_ROCOCO_INDEX: u8 = 0;
 
 /// The macro allows executing bridge-specific code without going fully generic.
 ///
@@ -64,7 +70,7 @@ macro_rules! select_full_bridge {
 				use bp_rialto::TO_RIALTO_ESTIMATE_MESSAGE_FEE_METHOD as ESTIMATE_MESSAGE_FEE_METHOD;
 				// Send-message
 				#[allow(unused_imports)]
-				use millau_runtime::rialto_account_ownership_digest as account_ownership_digest;
+				use millau_runtime::millau_to_rialto_account_ownership_digest as account_ownership_digest;
 
 				$generic
 			}
@@ -87,7 +93,51 @@ macro_rules! select_full_bridge {
 
 				// Send-message
 				#[allow(unused_imports)]
-				use rialto_runtime::millau_account_ownership_digest as account_ownership_digest;
+				use rialto_runtime::rialto_to_millau_account_ownership_digest as account_ownership_digest;
+
+				$generic
+			}
+			FullBridge::RococoToWococo => {
+				type Source = relay_rococo_client::Rococo;
+				#[allow(dead_code)]
+				type Target = relay_wococo_client::Wococo;
+
+				// Derive-account
+				#[allow(unused_imports)]
+				use bp_wococo::derive_account_from_rococo_id as derive_account;
+
+				// Relay-messages
+				#[allow(unused_imports)]
+				use crate::chains::rococo_messages_to_wococo::run as relay_messages;
+
+				// Send-message / Estimate-fee
+				#[allow(unused_imports)]
+				use bp_wococo::TO_WOCOCO_ESTIMATE_MESSAGE_FEE_METHOD as ESTIMATE_MESSAGE_FEE_METHOD;
+				// Send-message
+				#[allow(unused_imports)]
+				use relay_rococo_client::runtime::rococo_to_wococo_account_ownership_digest as account_ownership_digest;
+
+				$generic
+			}
+			FullBridge::WococoToRococo => {
+				type Source = relay_wococo_client::Wococo;
+				#[allow(dead_code)]
+				type Target = relay_rococo_client::Rococo;
+
+				// Derive-account
+				#[allow(unused_imports)]
+				use bp_rococo::derive_account_from_wococo_id as derive_account;
+
+				// Relay-messages
+				#[allow(unused_imports)]
+				use crate::chains::wococo_messages_to_rococo::run as relay_messages;
+
+				// Send-message / Estimate-fee
+				#[allow(unused_imports)]
+				use bp_rococo::TO_ROCOCO_ESTIMATE_MESSAGE_FEE_METHOD as ESTIMATE_MESSAGE_FEE_METHOD;
+				// Send-message
+				#[allow(unused_imports)]
+				use relay_wococo_client::runtime::wococo_to_rococo_account_ownership_digest as account_ownership_digest;
 
 				$generic
 			}

polkadot/bridges/relays/bin-substrate/src/cli/encode_call.rs

@@ -17,7 +17,7 @@
 use crate::cli::bridge::FullBridge;
 use crate::cli::{AccountId, Balance, CliChain, ExplicitOrMaximal, HexBytes, HexLaneId};
 use crate::select_full_bridge;
-use frame_support::dispatch::GetDispatchInfo;
+use frame_support::weights::DispatchInfo;
 use relay_substrate_client::Chain;
 use structopt::StructOpt;
 
@@ -85,6 +85,9 @@ pub trait CliEncodeCall: Chain {
 
 	/// Encode a CLI call.
 	fn encode_call(call: &Call) -> anyhow::Result<Self::Call>;
+
+	/// Get dispatch info for the call.
+	fn get_dispatch_info(call: &Self::Call) -> anyhow::Result<DispatchInfo>;
 }
 
 impl EncodeCall {
@@ -96,7 +99,7 @@ impl EncodeCall {
 			let encoded = HexBytes::encode(&call);
 
 			log::info!(target: "bridge", "Generated {} call: {:#?}", Source::NAME, call);
-			log::info!(target: "bridge", "Weight of {} call: {}", Source::NAME, call.get_dispatch_info().weight);
+			log::info!(target: "bridge", "Weight of {} call: {}", Source::NAME, Source::get_dispatch_info(&call)?.weight);
 			log::info!(target: "bridge", "Encoded {} call: {:?}", Source::NAME, encoded);
 
 			Ok(encoded)
@@ -129,7 +132,7 @@ pub(crate) fn preprocess_call<Source: CliEncodeCall + CliChain, Target: CliEncod
 		} => {
 			if remark_payload.is_none() {
 				*remark_payload = Some(HexBytes(generate_remark_payload(
-					&remark_size,
+					remark_size,
 					compute_maximal_message_arguments_size(Source::max_extrinsic_size(), Target::max_extrinsic_size()),
 				)));
 			}

polkadot/bridges/relays/bin-substrate/src/cli/encode_message.rs

@@ -72,7 +72,7 @@ mod tests {
 	#[test]
 	fn should_encode_raw_message() {
 		// given
-		let msg = "01000000e88514000000000002d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d3c040130000000000000000000000000";
+		let msg = "01000000e88514000000000002d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d003c040130000000000000000000000000";
 		let encode_message = EncodeMessage::from_iter(vec!["encode-message", "MillauToRialto", "raw", msg]);
 
 		// when
@@ -101,6 +101,6 @@ mod tests {
 		let hex = encode_message.encode().unwrap();
 
 		// then
-		assert_eq!(format!("{:?}", hex), "0x01000000e88514000000000002d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d3c040130000000000000000000000000");
+		assert_eq!(format!("{:?}", hex), "0x01000000b0d60f000000000002d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d003c040130000000000000000000000000");
 	}
 }

polkadot/bridges/relays/bin-substrate/src/cli/estimate_fee.rs

@@ -18,7 +18,7 @@ use crate::cli::bridge::FullBridge;
 use crate::cli::{Balance, CliChain, HexBytes, HexLaneId, SourceConnectionParams};
 use crate::select_full_bridge;
 use codec::{Decode, Encode};
-use relay_substrate_client::{Chain, ChainWithBalances};
+use relay_substrate_client::Chain;
 use structopt::StructOpt;
 
 /// Estimate Delivery & Dispatch Fee command.
@@ -52,7 +52,7 @@ impl EstimateFee {
 			let lane = lane.into();
 			let payload = Source::encode_message(payload).map_err(|e| anyhow::format_err!("{:?}", e))?;
 
-			let fee: <Source as ChainWithBalances>::NativeBalance =
+			let fee: <Source as Chain>::Balance =
 				estimate_message_delivery_and_dispatch_fee(&source_client, ESTIMATE_MESSAGE_FEE_METHOD, lane, payload)
 					.await?;
 

polkadot/bridges/relays/bin-substrate/src/cli/init_bridge.rs

@@ -109,7 +109,9 @@ macro_rules! select_bridge {
 				fn encode_init_bridge(
 					init_data: InitializationData<<Source as ChainBase>::Header>,
 				) -> <Target as Chain>::Call {
-					bp_wococo::Call::BridgeGrandpaRococo(bp_wococo::BridgeGrandpaRococoCall::initialize(init_data))
+					relay_wococo_client::runtime::Call::BridgeGrandpaRococo(
+						relay_wococo_client::runtime::BridgeGrandpaRococoCall::initialize(init_data),
+					)
 				}
 
 				$generic
@@ -121,7 +123,9 @@ macro_rules! select_bridge {
 				fn encode_init_bridge(
 					init_data: InitializationData<<Source as ChainBase>::Header>,
 				) -> <Target as Chain>::Call {
-					bp_rococo::Call::BridgeGrandpaWococo(bp_rococo::BridgeGrandpaWococoCall::initialize(init_data))
+					relay_rococo_client::runtime::Call::BridgeGrandpaWococo(
+						relay_rococo_client::runtime::BridgeGrandpaWococoCall::initialize(init_data),
+					)
 				}
 
 				$generic

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

@@ -406,7 +406,7 @@ macro_rules! declare_chain_options {
 						port: self.[<$chain_prefix _port>],
 						secure: self.[<$chain_prefix _secure>],
 					})
-					.await?
+					.await
 					)
 				}
 			}

polkadot/bridges/relays/bin-substrate/src/cli/relay_headers.rs

@@ -24,6 +24,9 @@ pub struct RelayHeaders {
 	/// A bridge instance to relay headers for.
 	#[structopt(possible_values = &RelayHeadersBridge::variants(), case_insensitive = true)]
 	bridge: RelayHeadersBridge,
+	/// If passed, only mandatory headers (headers that are changing the GRANDPA authorities set) are relayed.
+	#[structopt(long)]
+	only_mandatory_headers: bool,
 	#[structopt(flatten)]
 	source: SourceConnectionParams,
 	#[structopt(flatten)]
@@ -97,12 +100,14 @@ impl RelayHeaders {
 			let target_client = self.target.to_client::<Target>().await?;
 			let target_sign = self.target_sign.to_keypair::<Target>()?;
 			let metrics_params = Finality::customize_metrics(self.prometheus_params.into())?;
+			let finality = Finality::new(target_client.clone(), target_sign);
+			finality.start_relay_guards();
 
 			crate::finality_pipeline::run(
-				Finality::new(target_client.clone(), target_sign),
+				finality,
 				source_client,
 				target_client,
-				false,
+				self.only_mandatory_headers,
 				metrics_params,
 			)
 			.await

polkadot/bridges/relays/bin-substrate/src/cli/relay_headers_and_messages.rs

@@ -35,14 +35,15 @@ use structopt::StructOpt;
 #[derive(StructOpt)]
 pub enum RelayHeadersAndMessages {
 	MillauRialto(MillauRialtoHeadersAndMessages),
+	RococoWococo(RococoWococoHeadersAndMessages),
 }
 
 /// Parameters that have the same names across all bridges.
 #[derive(StructOpt)]
 pub struct HeadersAndMessagesSharedParams {
-	/// Hex-encoded lane id that should be served by the relay. Defaults to `00000000`.
+	/// Hex-encoded lane identifiers that should be served by the complex relay.
 	#[structopt(long, default_value = "00000000")]
-	lane: HexLaneId,
+	lane: Vec<HexLaneId>,
 	#[structopt(flatten)]
 	prometheus_params: PrometheusParams,
 }
@@ -102,6 +103,26 @@ macro_rules! select_bridge {
 				use crate::chains::millau_messages_to_rialto::run as left_to_right_messages;
 				use crate::chains::rialto_messages_to_millau::run as right_to_left_messages;
 
+				$generic
+			}
+			RelayHeadersAndMessages::RococoWococo(_) => {
+				type Params = RococoWococoHeadersAndMessages;
+
+				type Left = relay_rococo_client::Rococo;
+				type Right = relay_wococo_client::Wococo;
+
+				type LeftToRightFinality = crate::chains::rococo_headers_to_wococo::RococoFinalityToWococo;
+				type RightToLeftFinality = crate::chains::wococo_headers_to_rococo::WococoFinalityToRococo;
+
+				type LeftToRightMessages = crate::chains::rococo_messages_to_wococo::RococoMessagesToWococo;
+				type RightToLeftMessages = crate::chains::wococo_messages_to_rococo::WococoMessagesToRococo;
+
+				const MAX_MISSING_LEFT_HEADERS_AT_RIGHT: bp_rococo::BlockNumber = bp_rococo::SESSION_LENGTH;
+				const MAX_MISSING_RIGHT_HEADERS_AT_LEFT: bp_wococo::BlockNumber = bp_wococo::SESSION_LENGTH;
+
+				use crate::chains::rococo_messages_to_wococo::run as left_to_right_messages;
+				use crate::chains::wococo_messages_to_rococo::run as right_to_left_messages;
+
 				$generic
 			}
 		}
@@ -111,8 +132,11 @@ macro_rules! select_bridge {
 // All supported chains.
 declare_chain_options!(Millau, millau);
 declare_chain_options!(Rialto, rialto);
+declare_chain_options!(Rococo, rococo);
+declare_chain_options!(Wococo, wococo);
 // All supported bridges.
 declare_bridge_options!(Millau, Rialto);
+declare_bridge_options!(Rococo, Wococo);
 
 impl RelayHeadersAndMessages {
 	/// Run the command.
@@ -125,7 +149,7 @@ impl RelayHeadersAndMessages {
 			let right_client = params.right.to_client::<Right>().await?;
 			let right_sign = params.right_sign.to_keypair::<Right>()?;
 
-			let lane = params.shared.lane.into();
+			let lanes = params.shared.lane;
 
 			let metrics_params: MetricsParams = params.shared.prometheus_params.into();
 			let metrics_params = relay_utils::relay_metrics(None, metrics_params).into_params();
@@ -143,46 +167,49 @@ impl RelayHeadersAndMessages {
 				MAX_MISSING_RIGHT_HEADERS_AT_LEFT,
 			);
 
-			let left_to_right_messages = left_to_right_messages(MessagesRelayParams {
-				source_client: left_client.clone(),
-				source_sign: left_sign.clone(),
-				target_client: right_client.clone(),
-				target_sign: right_sign.clone(),
-				source_to_target_headers_relay: Some(left_to_right_on_demand_headers.clone()),
-				target_to_source_headers_relay: Some(right_to_left_on_demand_headers.clone()),
-				lane_id: lane,
-				metrics_params: metrics_params
-					.clone()
-					.disable()
-					.metrics_prefix(messages_relay::message_lane_loop::metrics_prefix::<LeftToRightMessages>(&lane)),
-			})
-			.map_err(|e| anyhow::format_err!("{}", e))
-			.boxed();
-			let right_to_left_messages = right_to_left_messages(MessagesRelayParams {
-				source_client: right_client,
-				source_sign: right_sign,
-				target_client: left_client.clone(),
-				target_sign: left_sign.clone(),
-				source_to_target_headers_relay: Some(right_to_left_on_demand_headers),
-				target_to_source_headers_relay: Some(left_to_right_on_demand_headers),
-				lane_id: lane,
-				metrics_params: metrics_params
-					.clone()
-					.disable()
-					.metrics_prefix(messages_relay::message_lane_loop::metrics_prefix::<RightToLeftMessages>(&lane)),
-			})
-			.map_err(|e| anyhow::format_err!("{}", e))
-			.boxed();
+			// Need 2x capacity since we consider both directions for each lane
+			let mut message_relays = Vec::with_capacity(lanes.len() * 2);
+			for lane in lanes {
+				let lane = lane.into();
+				let left_to_right_messages = left_to_right_messages(MessagesRelayParams {
+					source_client: left_client.clone(),
+					source_sign: left_sign.clone(),
+					target_client: right_client.clone(),
+					target_sign: right_sign.clone(),
+					source_to_target_headers_relay: Some(left_to_right_on_demand_headers.clone()),
+					target_to_source_headers_relay: Some(right_to_left_on_demand_headers.clone()),
+					lane_id: lane,
+					metrics_params: metrics_params.clone().disable().metrics_prefix(
+						messages_relay::message_lane_loop::metrics_prefix::<LeftToRightMessages>(&lane),
+					),
+				})
+				.map_err(|e| anyhow::format_err!("{}", e))
+				.boxed();
+				let right_to_left_messages = right_to_left_messages(MessagesRelayParams {
+					source_client: right_client.clone(),
+					source_sign: right_sign.clone(),
+					target_client: left_client.clone(),
+					target_sign: left_sign.clone(),
+					source_to_target_headers_relay: Some(right_to_left_on_demand_headers.clone()),
+					target_to_source_headers_relay: Some(left_to_right_on_demand_headers.clone()),
+					lane_id: lane,
+					metrics_params: metrics_params.clone().disable().metrics_prefix(
+						messages_relay::message_lane_loop::metrics_prefix::<RightToLeftMessages>(&lane),
+					),
+				})
+				.map_err(|e| anyhow::format_err!("{}", e))
+				.boxed();
+
+				message_relays.push(left_to_right_messages);
+				message_relays.push(right_to_left_messages);
+			}
 
 			relay_utils::relay_metrics(None, metrics_params)
 				.expose()
 				.await
 				.map_err(|e| anyhow::format_err!("{}", e))?;
 
-			futures::future::select(left_to_right_messages, right_to_left_messages)
-				.await
-				.factor_first()
-				.0
+			futures::future::select_all(message_relays).await.0
 		})
 	}
 }

polkadot/bridges/relays/bin-substrate/src/cli/send_message.rs

@@ -22,8 +22,9 @@ use crate::cli::{
 	TargetSigningParams,
 };
 use bp_message_dispatch::{CallOrigin, MessagePayload};
+use bp_runtime::messages::DispatchFeePayment;
 use codec::Encode;
-use frame_support::{dispatch::GetDispatchInfo, weights::Weight};
+use frame_support::weights::Weight;
 use relay_substrate_client::{Chain, TransactionSignScheme};
 use sp_core::{Bytes, Pair};
 use sp_runtime::{traits::IdentifyAccount, AccountId32, MultiSignature, MultiSigner};
@@ -40,9 +41,12 @@ pub struct SendMessage {
 	source: SourceConnectionParams,
 	#[structopt(flatten)]
 	source_sign: SourceSigningParams,
-	// TODO [#885] Move TargetSign to origins
-	#[structopt(flatten)]
-	target_sign: TargetSigningParams,
+	/// The SURI of secret key to use when transactions are submitted to the Target node.
+	#[structopt(long, required_if("origin", "Target"))]
+	target_signer: Option<String>,
+	/// The password for the SURI of secret key to use when transactions are submitted to the Target node.
+	#[structopt(long)]
+	target_signer_password: Option<String>,
 	/// Hex-encoded lane id. Defaults to `00000000`.
 	#[structopt(long, default_value = "00000000")]
 	lane: HexLaneId,
@@ -68,7 +72,8 @@ impl SendMessage {
 		crate::select_full_bridge!(self.bridge, {
 			let SendMessage {
 				source_sign,
-				target_sign,
+				target_signer,
+				target_signer_password,
 				ref mut message,
 				dispatch_weight,
 				origin,
@@ -77,15 +82,14 @@ impl SendMessage {
 			} = self;
 
 			let source_sign = source_sign.to_keypair::<Source>()?;
-			let target_sign = target_sign.to_keypair::<Target>()?;
 
 			encode_call::preprocess_call::<Source, Target>(message, bridge.bridge_instance_index());
-			let target_call = Target::encode_call(&message)?;
+			let target_call = Target::encode_call(message)?;
 
 			let payload = {
 				let target_call_weight = prepare_call_dispatch_weight(
 					dispatch_weight,
-					ExplicitOrMaximal::Explicit(target_call.get_dispatch_info().weight),
+					ExplicitOrMaximal::Explicit(Target::get_dispatch_info(&target_call)?.weight),
 					compute_maximal_message_dispatch_weight(Target::max_extrinsic_weight()),
 				);
 				let source_sender_public: MultiSigner = source_sign.public().into();
@@ -97,6 +101,13 @@ impl SendMessage {
 					match origin {
 						Origins::Source => CallOrigin::SourceAccount(source_account_id),
 						Origins::Target => {
+							let target_sign = TargetSigningParams {
+								target_signer: target_signer.clone().ok_or_else(|| {
+									anyhow::format_err!("The argument target_signer is not available")
+								})?,
+								target_signer_password: target_signer_password.clone(),
+							};
+							let target_sign = target_sign.to_keypair::<Target>()?;
 							let digest = account_ownership_digest(
 								&target_call,
 								source_account_id.clone(),
@@ -130,11 +141,12 @@ impl SendMessage {
 			let fee = match self.fee {
 				Some(fee) => fee,
 				None => Balance(
-					estimate_message_delivery_and_dispatch_fee::<
-						<Source as relay_substrate_client::ChainWithBalances>::NativeBalance,
-						_,
-						_,
-					>(&source_client, ESTIMATE_MESSAGE_FEE_METHOD, lane, payload.clone())
+					estimate_message_delivery_and_dispatch_fee::<<Source as Chain>::Balance, _, _>(
+						&source_client,
+						ESTIMATE_MESSAGE_FEE_METHOD,
+						lane,
+						payload.clone(),
+					)
 					.await? as _,
 				),
 			};
@@ -210,6 +222,7 @@ where
 		spec_version,
 		weight,
 		origin,
+		dispatch_fee_payment: DispatchFeePayment::AtSourceChain,
 		call: HexBytes::encode(call),
 	};
 
@@ -221,12 +234,14 @@ where
 		spec_version,
 		weight,
 		origin,
+		dispatch_fee_payment,
 		call,
 	} = payload;
 	MessagePayload {
 		spec_version,
 		weight,
 		origin,
+		dispatch_fee_payment,
 		call: call.0,
 	}
 }
@@ -250,8 +265,6 @@ mod tests {
 			"1234",
 			"--source-signer",
 			"//Alice",
-			"--target-signer",
-			"//Bob",
 			"remark",
 			"--remark-payload",
 			"1234",
@@ -265,8 +278,9 @@ mod tests {
 			payload,
 			MessagePayload {
 				spec_version: relay_millau_client::Millau::RUNTIME_VERSION.spec_version,
-				weight: 1345000,
+				weight: 1038000,
 				origin: CallOrigin::SourceAccount(sp_keyring::AccountKeyring::Alice.to_account_id()),
+				dispatch_fee_payment: DispatchFeePayment::AtSourceChain,
 				call: hex!("0401081234").to_vec(),
 			}
 		);
@@ -304,14 +318,35 @@ mod tests {
 			payload,
 			MessagePayload {
 				spec_version: relay_millau_client::Millau::RUNTIME_VERSION.spec_version,
-				weight: 1345000,
+				weight: 1038000,
 				origin: CallOrigin::TargetAccount(
 					sp_keyring::AccountKeyring::Alice.to_account_id(),
 					sp_keyring::AccountKeyring::Bob.into(),
 					signature,
 				),
+				dispatch_fee_payment: DispatchFeePayment::AtSourceChain,
 				call: hex!("0701081234").to_vec(),
 			}
 		);
 	}
+
+	#[test]
+	fn target_signer_must_exist_if_origin_is_target() {
+		// given
+		let send_message = SendMessage::from_iter_safe(vec![
+			"send-message",
+			"MillauToRialto",
+			"--source-port",
+			"1234",
+			"--source-signer",
+			"//Alice",
+			"--origin",
+			"Target",
+			"remark",
+			"--remark-payload",
+			"1234",
+		]);
+
+		assert!(send_message.is_err());
+	}
 }