Remove support for encoded-call messaging from relay and runtime integration code (#1376)

* remove support for encoded-call messaging

* continue cleanup

* continue cleanup

* continue cleanup

* more cleanpup

* more cleanup

* fmt

* continue cleanup

* spellcheck

* rename

* fix benchmarks

* mention encoded-calls-messaging tag

* fixing deployments

* fix messages generation

* fmt

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

@@ -14,82 +14,46 @@
 // 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 anyhow::anyhow;
-use bp_message_dispatch::{CallOrigin, MessagePayload};
+use bp_messages::LaneId;
 use bp_runtime::EncodedOrDecodedCall;
-use codec::Decode;
-use frame_support::weights::{DispatchClass, DispatchInfo, Pays, Weight};
 use relay_kusama_client::Kusama;
+use relay_substrate_client::BalanceOf;
 use sp_version::RuntimeVersion;
 
 use crate::cli::{
 	bridge,
-	encode_call::{self, Call, CliEncodeCall},
-	encode_message,
-	send_message::{self, DispatchFeePayment},
+	encode_message::{CliEncodeMessage, RawMessage},
 	CliChain,
 };
 
-/// Weight of the `system::remark` call at Kusama.
-///
-/// This weight is larger (x2) than actual weight at current Kusama runtime to avoid unsuccessful
-/// calls in the future. But since it is used only in tests (and on test chains), this is ok.
-pub(crate) const SYSTEM_REMARK_CALL_WEIGHT: Weight = 2 * 1_345_000;
-
-impl CliEncodeCall for Kusama {
-	fn encode_call(call: &Call) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
-		Ok(match call {
-			Call::Raw { data } => EncodedOrDecodedCall::Encoded(data.0.clone()),
-			Call::Remark { remark_payload, .. } => relay_kusama_client::runtime::Call::System(
-				relay_kusama_client::runtime::SystemCall::remark(
-					remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
-				),
-			)
-			.into(),
-			Call::BridgeSendMessage { lane, payload, fee, bridge_instance_index } =>
-				match *bridge_instance_index {
-					bridge::KUSAMA_TO_POLKADOT_INDEX => {
-						let payload = Decode::decode(&mut &*payload.0)?;
-						relay_kusama_client::runtime::Call::BridgePolkadotMessages(
-							relay_kusama_client::runtime::BridgePolkadotMessagesCall::send_message(
-								lane.0, payload, fee.0,
-							),
-						)
-						.into()
-					},
-					_ => anyhow::bail!(
-						"Unsupported target bridge pallet with instance index: {}",
-						bridge_instance_index
+impl CliEncodeMessage for Kusama {
+	fn encode_send_message_call(
+		lane: LaneId,
+		payload: RawMessage,
+		fee: BalanceOf<Self>,
+		bridge_instance_index: u8,
+	) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
+		Ok(match bridge_instance_index {
+			bridge::KUSAMA_TO_POLKADOT_INDEX =>
+				relay_kusama_client::runtime::Call::BridgePolkadotMessages(
+					relay_kusama_client::runtime::BridgePolkadotMessagesCall::send_message(
+						lane, payload, fee,
 					),
-				},
-			_ => anyhow::bail!("Unsupported Kusama call: {:?}", call),
+				)
+				.into(),
+			_ => anyhow::bail!(
+				"Unsupported target bridge pallet with instance index: {}",
+				bridge_instance_index
+			),
 		})
 	}
-
-	fn get_dispatch_info(call: &EncodedOrDecodedCall<Self::Call>) -> anyhow::Result<DispatchInfo> {
-		match *call {
-			EncodedOrDecodedCall::Decoded(relay_kusama_client::runtime::Call::System(
-				relay_kusama_client::runtime::SystemCall::remark(_),
-			)) => Ok(DispatchInfo {
-				weight: crate::chains::kusama::SYSTEM_REMARK_CALL_WEIGHT,
-				class: DispatchClass::Normal,
-				pays_fee: Pays::Yes,
-			}),
-			_ => anyhow::bail!("Unsupported Kusama call: {:?}", call),
-		}
-	}
 }
 
 impl CliChain for Kusama {
 	const RUNTIME_VERSION: RuntimeVersion = bp_kusama::VERSION;
 
 	type KeyPair = sp_core::sr25519::Pair;
-	type MessagePayload = MessagePayload<
-		bp_kusama::AccountId,
-		bp_polkadot::AccountPublic,
-		bp_polkadot::Signature,
-		Vec<u8>,
-	>;
+	type MessagePayload = Vec<u8>;
 
 	fn ss58_format() -> u16 {
 		sp_core::crypto::Ss58AddressFormat::from(
@@ -97,39 +61,4 @@ impl CliChain for Kusama {
 		)
 		.into()
 	}
-
-	fn encode_message(
-		message: encode_message::MessagePayload,
-	) -> anyhow::Result<Self::MessagePayload> {
-		match message {
-			encode_message::MessagePayload::Raw { data } => MessagePayload::decode(&mut &*data.0)
-				.map_err(|e| anyhow!("Failed to decode Kusama's MessagePayload: {:?}", e)),
-			encode_message::MessagePayload::Call { mut call, mut sender, dispatch_weight } => {
-				type Source = Kusama;
-				type Target = relay_polkadot_client::Polkadot;
-
-				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::KUSAMA_TO_POLKADOT_INDEX,
-				);
-				let call = Target::encode_call(&call)?;
-				let dispatch_weight = dispatch_weight.map(Ok).unwrap_or_else(|| {
-					Err(anyhow::format_err!(
-						"Please specify dispatch weight of the encoded Polkadot call"
-					))
-				})?;
-
-				Ok(send_message::message_payload(
-					spec_version,
-					dispatch_weight,
-					origin,
-					&call,
-					DispatchFeePayment::AtSourceChain,
-				))
-			},
-		}
-	}
 }

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

@@ -18,106 +18,46 @@
 
 use crate::cli::{
 	bridge,
-	encode_call::{self, Call, CliEncodeCall},
-	encode_message,
-	send_message::{self, DispatchFeePayment},
+	encode_message::{CliEncodeMessage, RawMessage},
 	CliChain,
 };
-use anyhow::anyhow;
-use bp_message_dispatch::{CallOrigin, MessagePayload};
+use bp_messages::LaneId;
 use bp_runtime::EncodedOrDecodedCall;
-use codec::Decode;
-use frame_support::weights::{DispatchInfo, GetDispatchInfo};
 use relay_millau_client::Millau;
+use relay_substrate_client::BalanceOf;
 use sp_version::RuntimeVersion;
 
-impl CliEncodeCall for Millau {
-	fn encode_call(call: &Call) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
-		Ok(match call {
-			Call::Raw { data } => Self::Call::decode(&mut &*data.0)?.into(),
-			Call::Remark { remark_payload, .. } =>
-				millau_runtime::Call::System(millau_runtime::SystemCall::remark {
-					remark: remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
-				})
-				.into(),
-			Call::Transfer { recipient, amount } =>
-				millau_runtime::Call::Balances(millau_runtime::BalancesCall::transfer {
-					dest: recipient.raw_id(),
-					value: amount.cast(),
-				})
-				.into(),
-			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_id: lane.0,
-								payload,
-								delivery_and_dispatch_fee: fee.cast(),
-							},
-						)
-						.into()
-					},
-					_ => anyhow::bail!(
-						"Unsupported target bridge pallet with instance index: {}",
-						bridge_instance_index
-					),
+impl CliEncodeMessage for Millau {
+	fn encode_send_message_call(
+		lane: LaneId,
+		payload: RawMessage,
+		fee: BalanceOf<Self>,
+		bridge_instance_index: u8,
+	) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
+		Ok(match bridge_instance_index {
+			bridge::MILLAU_TO_RIALTO_INDEX => millau_runtime::Call::BridgeRialtoMessages(
+				millau_runtime::MessagesCall::send_message {
+					lane_id: lane,
+					payload,
+					delivery_and_dispatch_fee: fee,
 				},
+			)
+			.into(),
+			_ => anyhow::bail!(
+				"Unsupported target bridge pallet with instance index: {}",
+				bridge_instance_index
+			),
 		})
 	}
-
-	fn get_dispatch_info(call: &EncodedOrDecodedCall<Self::Call>) -> anyhow::Result<DispatchInfo> {
-		Ok(call.to_decoded()?.get_dispatch_info())
-	}
 }
 
 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>,
-	>;
+	type MessagePayload = Vec<u8>;
 
 	fn ss58_format() -> u16 {
 		millau_runtime::SS58Prefix::get() as u16
 	}
-
-	// TODO [#854|#843] support multiple bridges?
-	fn encode_message(
-		message: encode_message::MessagePayload,
-	) -> anyhow::Result<Self::MessagePayload> {
-		match message {
-			encode_message::MessagePayload::Raw { data } => MessagePayload::decode(&mut &*data.0)
-				.map_err(|e| anyhow!("Failed to decode Millau's MessagePayload: {:?}", e)),
-			encode_message::MessagePayload::Call { mut call, mut sender, dispatch_weight } => {
-				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)?;
-				let dispatch_weight = dispatch_weight.map(Ok).unwrap_or_else(|| {
-					call.to_decoded().map(|call| call.get_dispatch_info().weight)
-				})?;
-
-				Ok(send_message::message_payload(
-					spec_version,
-					dispatch_weight,
-					origin,
-					&call,
-					DispatchFeePayment::AtSourceChain,
-				))
-			},
-		}
-	}
 }

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

@@ -41,95 +41,28 @@ mod wococo;
 
 #[cfg(test)]
 mod tests {
-	use crate::cli::{encode_call, send_message};
+	use crate::cli::encode_message;
 	use bp_messages::source_chain::TargetHeaderChain;
 	use bp_runtime::Chain as _;
 	use codec::Encode;
-	use frame_support::dispatch::GetDispatchInfo;
 	use relay_millau_client::Millau;
 	use relay_rialto_client::Rialto;
 	use relay_substrate_client::{SignParam, TransactionSignScheme, UnsignedTransaction};
-	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 { 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::millau_to_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 { 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::rialto_to_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() {
+	fn maximal_rialto_to_millau_message_size_is_computed_correctly() {
 		use rialto_runtime::millau_messages::Millau;
 
-		let maximal_remark_size = encode_call::compute_maximal_message_arguments_size(
+		let maximal_message_size = encode_message::compute_maximal_message_size(
 			bp_rialto::Rialto::max_extrinsic_size(),
 			bp_millau::Millau::max_extrinsic_size(),
 		);
 
-		let call: millau_runtime::Call =
-			millau_runtime::SystemCall::remark { remark: vec![42; maximal_remark_size as _] }
-				.into();
-		let payload = send_message::message_payload(
-			Default::default(),
-			call.get_dispatch_info().weight,
-			bp_message_dispatch::CallOrigin::SourceRoot,
-			&call,
-			send_message::DispatchFeePayment::AtSourceChain,
-		);
-		assert_eq!(Millau::verify_message(&payload), Ok(()));
+		let message = vec![42; maximal_message_size as _];
+		assert_eq!(Millau::verify_message(&message), Ok(()));
 
-		let call: millau_runtime::Call =
-			millau_runtime::SystemCall::remark { remark: vec![42; (maximal_remark_size + 1) as _] }
-				.into();
-		let payload = send_message::message_payload(
-			Default::default(),
-			call.get_dispatch_info().weight,
-			bp_message_dispatch::CallOrigin::SourceRoot,
-			&call,
-			send_message::DispatchFeePayment::AtSourceChain,
-		);
-		assert!(Millau::verify_message(&payload).is_err());
+		let message = vec![42; (maximal_message_size + 1) as _];
+		assert!(Millau::verify_message(&message).is_err());
 	}
 
 	#[test]
@@ -141,65 +74,6 @@ mod tests {
 			"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::Millau::max_extrinsic_weight(),
-		);
-		let call: millau_runtime::Call =
-			rialto_runtime::SystemCall::remark { remark: vec![] }.into();
-
-		let payload = send_message::message_payload(
-			Default::default(),
-			maximal_dispatch_weight,
-			bp_message_dispatch::CallOrigin::SourceRoot,
-			&call,
-			send_message::DispatchFeePayment::AtSourceChain,
-		);
-		assert_eq!(Millau::verify_message(&payload), Ok(()));
-
-		let payload = send_message::message_payload(
-			Default::default(),
-			maximal_dispatch_weight + 1,
-			bp_message_dispatch::CallOrigin::SourceRoot,
-			&call,
-			send_message::DispatchFeePayment::AtSourceChain,
-		);
-		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::Rialto::max_extrinsic_weight(),
-		);
-		let call: rialto_runtime::Call =
-			millau_runtime::SystemCall::remark { remark: vec![] }.into();
-
-		let payload = send_message::message_payload(
-			Default::default(),
-			maximal_dispatch_weight,
-			bp_message_dispatch::CallOrigin::SourceRoot,
-			&call,
-			send_message::DispatchFeePayment::AtSourceChain,
-		);
-		assert_eq!(Rialto::verify_message(&payload), Ok(()));
-
-		let payload = send_message::message_payload(
-			Default::default(),
-			maximal_dispatch_weight + 1,
-			bp_message_dispatch::CallOrigin::SourceRoot,
-			&call,
-			send_message::DispatchFeePayment::AtSourceChain,
-		);
-		assert!(Rialto::verify_message(&payload).is_err());
-	}
-
 	#[test]
 	fn rialto_tx_extra_bytes_constant_is_correct() {
 		let rialto_call =

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

@@ -14,82 +14,46 @@
 // 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 anyhow::anyhow;
-use bp_message_dispatch::{CallOrigin, MessagePayload};
+use bp_messages::LaneId;
 use bp_runtime::EncodedOrDecodedCall;
-use codec::Decode;
-use frame_support::weights::{DispatchClass, DispatchInfo, Pays, Weight};
 use relay_polkadot_client::Polkadot;
+use relay_substrate_client::BalanceOf;
 use sp_version::RuntimeVersion;
 
 use crate::cli::{
 	bridge,
-	encode_call::{self, Call, CliEncodeCall},
-	encode_message,
-	send_message::{self, DispatchFeePayment},
+	encode_message::{CliEncodeMessage, RawMessage},
 	CliChain,
 };
 
-/// Weight of the `system::remark` call at Polkadot.
-///
-/// This weight is larger (x2) than actual weight at current Polkadot runtime to avoid unsuccessful
-/// calls in the future. But since it is used only in tests (and on test chains), this is ok.
-pub(crate) const SYSTEM_REMARK_CALL_WEIGHT: Weight = 2 * 1_345_000;
-
-impl CliEncodeCall for Polkadot {
-	fn encode_call(call: &Call) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
-		Ok(match call {
-			Call::Raw { data } => EncodedOrDecodedCall::Encoded(data.0.clone()),
-			Call::Remark { remark_payload, .. } => relay_polkadot_client::runtime::Call::System(
-				relay_polkadot_client::runtime::SystemCall::remark(
-					remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
-				),
-			)
-			.into(),
-			Call::BridgeSendMessage { lane, payload, fee, bridge_instance_index } =>
-				match *bridge_instance_index {
-					bridge::POLKADOT_TO_KUSAMA_INDEX => {
-						let payload = Decode::decode(&mut &*payload.0)?;
-						relay_polkadot_client::runtime::Call::BridgeKusamaMessages(
-							relay_polkadot_client::runtime::BridgeKusamaMessagesCall::send_message(
-								lane.0, payload, fee.0,
-							),
-						)
-						.into()
-					},
-					_ => anyhow::bail!(
-						"Unsupported target bridge pallet with instance index: {}",
-						bridge_instance_index
+impl CliEncodeMessage for Polkadot {
+	fn encode_send_message_call(
+		lane: LaneId,
+		payload: RawMessage,
+		fee: BalanceOf<Self>,
+		bridge_instance_index: u8,
+	) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
+		Ok(match bridge_instance_index {
+			bridge::POLKADOT_TO_KUSAMA_INDEX =>
+				relay_polkadot_client::runtime::Call::BridgeKusamaMessages(
+					relay_polkadot_client::runtime::BridgeKusamaMessagesCall::send_message(
+						lane, payload, fee,
 					),
-				},
-			_ => anyhow::bail!("Unsupported Polkadot call: {:?}", call),
+				)
+				.into(),
+			_ => anyhow::bail!(
+				"Unsupported target bridge pallet with instance index: {}",
+				bridge_instance_index
+			),
 		})
 	}
-
-	fn get_dispatch_info(call: &EncodedOrDecodedCall<Self::Call>) -> anyhow::Result<DispatchInfo> {
-		match *call {
-			EncodedOrDecodedCall::Decoded(relay_polkadot_client::runtime::Call::System(
-				relay_polkadot_client::runtime::SystemCall::remark(_),
-			)) => Ok(DispatchInfo {
-				weight: crate::chains::polkadot::SYSTEM_REMARK_CALL_WEIGHT,
-				class: DispatchClass::Normal,
-				pays_fee: Pays::Yes,
-			}),
-			_ => anyhow::bail!("Unsupported Polkadot call: {:?}", call),
-		}
-	}
 }
 
 impl CliChain for Polkadot {
 	const RUNTIME_VERSION: RuntimeVersion = bp_polkadot::VERSION;
 
 	type KeyPair = sp_core::sr25519::Pair;
-	type MessagePayload = MessagePayload<
-		bp_polkadot::AccountId,
-		bp_kusama::AccountPublic,
-		bp_kusama::Signature,
-		Vec<u8>,
-	>;
+	type MessagePayload = Vec<u8>;
 
 	fn ss58_format() -> u16 {
 		sp_core::crypto::Ss58AddressFormat::from(
@@ -97,39 +61,4 @@ impl CliChain for Polkadot {
 		)
 		.into()
 	}
-
-	fn encode_message(
-		message: encode_message::MessagePayload,
-	) -> anyhow::Result<Self::MessagePayload> {
-		match message {
-			encode_message::MessagePayload::Raw { data } => MessagePayload::decode(&mut &*data.0)
-				.map_err(|e| anyhow!("Failed to decode Polkadot's MessagePayload: {:?}", e)),
-			encode_message::MessagePayload::Call { mut call, mut sender, dispatch_weight } => {
-				type Source = Polkadot;
-				type Target = relay_kusama_client::Kusama;
-
-				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::POLKADOT_TO_KUSAMA_INDEX,
-				);
-				let call = Target::encode_call(&call)?;
-				let dispatch_weight = dispatch_weight.map(Ok).unwrap_or_else(|| {
-					Err(anyhow::format_err!(
-						"Please specify dispatch weight of the encoded Kusama call"
-					))
-				})?;
-
-				Ok(send_message::message_payload(
-					spec_version,
-					dispatch_weight,
-					origin,
-					&call,
-					DispatchFeePayment::AtSourceChain,
-				))
-			},
-		}
-	}
 }

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

@@ -18,105 +18,46 @@
 
 use crate::cli::{
 	bridge,
-	encode_call::{self, Call, CliEncodeCall},
-	encode_message,
-	send_message::{self, DispatchFeePayment},
+	encode_message::{CliEncodeMessage, RawMessage},
 	CliChain,
 };
-use anyhow::anyhow;
-use bp_message_dispatch::{CallOrigin, MessagePayload};
+use bp_messages::LaneId;
 use bp_runtime::EncodedOrDecodedCall;
-use codec::Decode;
-use frame_support::weights::{DispatchInfo, GetDispatchInfo};
 use relay_rialto_client::Rialto;
+use relay_substrate_client::BalanceOf;
 use sp_version::RuntimeVersion;
 
-impl CliEncodeCall for Rialto {
-	fn encode_call(call: &Call) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
-		Ok(match call {
-			Call::Raw { data } => Self::Call::decode(&mut &*data.0)?.into(),
-			Call::Remark { remark_payload, .. } =>
-				rialto_runtime::Call::System(rialto_runtime::SystemCall::remark {
-					remark: remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
-				})
-				.into(),
-			Call::Transfer { recipient, amount } =>
-				rialto_runtime::Call::Balances(rialto_runtime::BalancesCall::transfer {
-					dest: recipient.raw_id().into(),
-					value: amount.0,
-				})
-				.into(),
-			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_id: lane.0,
-								payload,
-								delivery_and_dispatch_fee: fee.0,
-							},
-						)
-						.into()
-					},
-					_ => anyhow::bail!(
-						"Unsupported target bridge pallet with instance index: {}",
-						bridge_instance_index
-					),
+impl CliEncodeMessage for Rialto {
+	fn encode_send_message_call(
+		lane: LaneId,
+		payload: RawMessage,
+		fee: BalanceOf<Self>,
+		bridge_instance_index: u8,
+	) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
+		Ok(match bridge_instance_index {
+			bridge::RIALTO_TO_MILLAU_INDEX => rialto_runtime::Call::BridgeMillauMessages(
+				rialto_runtime::MessagesCall::send_message {
+					lane_id: lane,
+					payload,
+					delivery_and_dispatch_fee: fee,
 				},
+			)
+			.into(),
+			_ => anyhow::bail!(
+				"Unsupported target bridge pallet with instance index: {}",
+				bridge_instance_index
+			),
 		})
 	}
-
-	fn get_dispatch_info(call: &EncodedOrDecodedCall<Self::Call>) -> anyhow::Result<DispatchInfo> {
-		Ok(call.to_decoded()?.get_dispatch_info())
-	}
 }
 
 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>,
-	>;
+	type MessagePayload = Vec<u8>;
 
 	fn ss58_format() -> u16 {
 		rialto_runtime::SS58Prefix::get() as u16
 	}
-
-	fn encode_message(
-		message: encode_message::MessagePayload,
-	) -> anyhow::Result<Self::MessagePayload> {
-		match message {
-			encode_message::MessagePayload::Raw { data } => MessagePayload::decode(&mut &*data.0)
-				.map_err(|e| anyhow!("Failed to decode Rialto's MessagePayload: {:?}", e)),
-			encode_message::MessagePayload::Call { mut call, mut sender, dispatch_weight } => {
-				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)?;
-				let dispatch_weight = dispatch_weight.map(Ok).unwrap_or_else(|| {
-					call.to_decoded().map(|call| call.get_dispatch_info().weight)
-				})?;
-
-				Ok(send_message::message_payload(
-					spec_version,
-					dispatch_weight,
-					origin,
-					&call,
-					DispatchFeePayment::AtSourceChain,
-				))
-			},
-		}
-	}
 }

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

@@ -16,63 +16,17 @@
 
 //! Rialto parachain specification for CLI.
 
-use crate::cli::{
-	encode_call::{Call, CliEncodeCall},
-	encode_message, CliChain,
-};
-use bp_message_dispatch::MessagePayload;
-use bp_runtime::EncodedOrDecodedCall;
-use codec::Decode;
-use frame_support::weights::{DispatchInfo, GetDispatchInfo};
+use crate::cli::CliChain;
 use relay_rialto_parachain_client::RialtoParachain;
 use sp_version::RuntimeVersion;
 
-impl CliEncodeCall for RialtoParachain {
-	fn encode_call(call: &Call) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
-		Ok(match call {
-			Call::Raw { data } => Self::Call::decode(&mut &*data.0)?.into(),
-			Call::Remark { remark_payload, .. } => rialto_parachain_runtime::Call::System(
-				rialto_parachain_runtime::SystemCall::remark {
-					remark: remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
-				},
-			)
-			.into(),
-			Call::Transfer { recipient, amount } => rialto_parachain_runtime::Call::Balances(
-				rialto_parachain_runtime::BalancesCall::transfer {
-					dest: recipient.raw_id().into(),
-					value: amount.0,
-				},
-			)
-			.into(),
-			Call::BridgeSendMessage { .. } => {
-				anyhow::bail!("Bridge messages are not (yet) supported here",)
-			},
-		})
-	}
-
-	fn get_dispatch_info(call: &EncodedOrDecodedCall<Self::Call>) -> anyhow::Result<DispatchInfo> {
-		Ok(call.to_decoded()?.get_dispatch_info())
-	}
-}
-
 impl CliChain for RialtoParachain {
 	const RUNTIME_VERSION: RuntimeVersion = rialto_parachain_runtime::VERSION;
 
 	type KeyPair = sp_core::sr25519::Pair;
-	type MessagePayload = MessagePayload<
-		bp_rialto_parachain::AccountId,
-		bp_millau::AccountSigner,
-		bp_millau::Signature,
-		Vec<u8>,
-	>;
+	type MessagePayload = Vec<u8>;
 
 	fn ss58_format() -> u16 {
 		rialto_parachain_runtime::SS58Prefix::get() as u16
 	}
-
-	fn encode_message(
-		_message: encode_message::MessagePayload,
-	) -> anyhow::Result<Self::MessagePayload> {
-		anyhow::bail!("Not supported")
-	}
 }

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

@@ -14,119 +14,47 @@
 // 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 anyhow::anyhow;
-use bp_message_dispatch::{CallOrigin, MessagePayload};
+use bp_messages::LaneId;
 use bp_runtime::EncodedOrDecodedCall;
-use codec::Decode;
-use frame_support::weights::{DispatchClass, DispatchInfo, Pays, Weight};
 use relay_rococo_client::Rococo;
+use relay_substrate_client::BalanceOf;
 use sp_version::RuntimeVersion;
 
 use crate::cli::{
 	bridge,
-	encode_call::{self, Call, CliEncodeCall},
-	encode_message,
-	send_message::{self, DispatchFeePayment},
+	encode_message::{CliEncodeMessage, RawMessage},
 	CliChain,
 };
 
-/// Weight of the `system::remark` call at Rococo.
-///
-/// This weight is larger (x2) than actual weight at current Rococo runtime to avoid unsuccessful
-/// calls in the future. But since it is used only in tests (and on test chains), this is ok.
-pub(crate) const SYSTEM_REMARK_CALL_WEIGHT: Weight = 2 * 1_345_000;
-
-impl CliEncodeCall for Rococo {
-	fn encode_call(call: &Call) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
-		Ok(match call {
-			Call::Raw { data } => EncodedOrDecodedCall::Encoded(data.0.clone()),
-			Call::Remark { remark_payload, .. } => relay_rococo_client::runtime::Call::System(
-				relay_rococo_client::runtime::SystemCall::remark(
-					remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
-				),
-			)
-			.into(),
-			Call::BridgeSendMessage { lane, payload, fee, bridge_instance_index } =>
-				match *bridge_instance_index {
-					bridge::ROCOCO_TO_WOCOCO_INDEX => {
-						let payload = Decode::decode(&mut &*payload.0)?;
-						relay_rococo_client::runtime::Call::BridgeWococoMessages(
-							relay_rococo_client::runtime::BridgeWococoMessagesCall::send_message(
-								lane.0, payload, fee.0,
-							),
-						)
-						.into()
-					},
-					_ => anyhow::bail!(
-						"Unsupported target bridge pallet with instance index: {}",
-						bridge_instance_index
+impl CliEncodeMessage for Rococo {
+	fn encode_send_message_call(
+		lane: LaneId,
+		payload: RawMessage,
+		fee: BalanceOf<Self>,
+		bridge_instance_index: u8,
+	) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
+		Ok(match bridge_instance_index {
+			bridge::ROCOCO_TO_WOCOCO_INDEX =>
+				relay_rococo_client::runtime::Call::BridgeWococoMessages(
+					relay_rococo_client::runtime::BridgeWococoMessagesCall::send_message(
+						lane, payload, fee,
 					),
-				},
-			_ => anyhow::bail!("The call is not supported"),
+				)
+				.into(),
+			_ => anyhow::bail!(
+				"Unsupported target bridge pallet with instance index: {}",
+				bridge_instance_index
+			),
 		})
 	}
-
-	fn get_dispatch_info(call: &EncodedOrDecodedCall<Self::Call>) -> anyhow::Result<DispatchInfo> {
-		match *call {
-			EncodedOrDecodedCall::Decoded(relay_rococo_client::runtime::Call::System(
-				relay_rococo_client::runtime::SystemCall::remark(_),
-			)) => Ok(DispatchInfo {
-				weight: SYSTEM_REMARK_CALL_WEIGHT,
-				class: DispatchClass::Normal,
-				pays_fee: Pays::Yes,
-			}),
-			_ => anyhow::bail!("Unsupported Rococo call: {:?}", call),
-		}
-	}
 }
-
 impl CliChain for Rococo {
 	const RUNTIME_VERSION: RuntimeVersion = bp_rococo::VERSION;
 
 	type KeyPair = sp_core::sr25519::Pair;
-	type MessagePayload = MessagePayload<
-		bp_rococo::AccountId,
-		bp_wococo::AccountPublic,
-		bp_wococo::Signature,
-		Vec<u8>,
-	>;
+	type MessagePayload = Vec<u8>;
 
 	fn ss58_format() -> u16 {
 		42
 	}
-
-	fn encode_message(
-		message: encode_message::MessagePayload,
-	) -> anyhow::Result<Self::MessagePayload> {
-		match message {
-			encode_message::MessagePayload::Raw { data } => MessagePayload::decode(&mut &*data.0)
-				.map_err(|e| anyhow!("Failed to decode Rococo's MessagePayload: {:?}", e)),
-			encode_message::MessagePayload::Call { mut call, mut sender, dispatch_weight } => {
-				type Source = Rococo;
-				type Target = relay_wococo_client::Wococo;
-
-				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::ROCOCO_TO_WOCOCO_INDEX,
-				);
-				let call = Target::encode_call(&call)?;
-				let dispatch_weight = dispatch_weight.map(Ok).unwrap_or_else(|| {
-					Err(anyhow::format_err!(
-						"Please specify dispatch weight of the encoded Wococo call"
-					))
-				})?;
-
-				Ok(send_message::message_payload(
-					spec_version,
-					dispatch_weight,
-					origin,
-					&call,
-					DispatchFeePayment::AtSourceChain,
-				))
-			},
-		}
-	}
 }

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

@@ -16,8 +16,7 @@
 
 //! Westend chain specification for CLI.
 
-use crate::cli::{encode_message, CliChain};
-use anyhow::anyhow;
+use crate::cli::CliChain;
 use relay_westend_client::Westend;
 use sp_version::RuntimeVersion;
 
@@ -25,7 +24,7 @@ impl CliChain for Westend {
 	const RUNTIME_VERSION: RuntimeVersion = bp_westend::VERSION;
 
 	type KeyPair = sp_core::sr25519::Pair;
-	type MessagePayload = ();
+	type MessagePayload = Vec<u8>;
 
 	fn ss58_format() -> u16 {
 		sp_core::crypto::Ss58AddressFormat::from(
@@ -33,10 +32,4 @@ impl CliChain for Westend {
 		)
 		.into()
 	}
-
-	fn encode_message(
-		_message: encode_message::MessagePayload,
-	) -> anyhow::Result<Self::MessagePayload> {
-		Err(anyhow!("Sending messages from Westend is not yet supported."))
-	}
 }

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

@@ -14,113 +14,48 @@
 // 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 anyhow::anyhow;
-use bp_message_dispatch::{CallOrigin, MessagePayload};
+use bp_messages::LaneId;
 use bp_runtime::EncodedOrDecodedCall;
-use codec::Decode;
-use frame_support::weights::{DispatchClass, DispatchInfo, Pays};
+use relay_substrate_client::BalanceOf;
 use relay_wococo_client::Wococo;
 use sp_version::RuntimeVersion;
 
 use crate::cli::{
 	bridge,
-	encode_call::{self, Call, CliEncodeCall},
-	encode_message,
-	send_message::{self, DispatchFeePayment},
+	encode_message::{CliEncodeMessage, RawMessage},
 	CliChain,
 };
 
-impl CliEncodeCall for Wococo {
-	fn encode_call(call: &Call) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
-		Ok(match call {
-			Call::Raw { data } => EncodedOrDecodedCall::Encoded(data.0.clone()),
-			Call::Remark { remark_payload, .. } => relay_wococo_client::runtime::Call::System(
-				relay_wococo_client::runtime::SystemCall::remark(
-					remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
-				),
-			)
-			.into(),
-			Call::BridgeSendMessage { lane, payload, fee, bridge_instance_index } =>
-				match *bridge_instance_index {
-					bridge::WOCOCO_TO_ROCOCO_INDEX => {
-						let payload = Decode::decode(&mut &*payload.0)?;
-						relay_wococo_client::runtime::Call::BridgeRococoMessages(
-							relay_wococo_client::runtime::BridgeRococoMessagesCall::send_message(
-								lane.0, payload, fee.0,
-							),
-						)
-						.into()
-					},
-					_ => anyhow::bail!(
-						"Unsupported target bridge pallet with instance index: {}",
-						bridge_instance_index
+impl CliEncodeMessage for Wococo {
+	fn encode_send_message_call(
+		lane: LaneId,
+		payload: RawMessage,
+		fee: BalanceOf<Self>,
+		bridge_instance_index: u8,
+	) -> anyhow::Result<EncodedOrDecodedCall<Self::Call>> {
+		Ok(match bridge_instance_index {
+			bridge::WOCOCO_TO_ROCOCO_INDEX =>
+				relay_wococo_client::runtime::Call::BridgeRococoMessages(
+					relay_wococo_client::runtime::BridgeRococoMessagesCall::send_message(
+						lane, payload, fee,
 					),
-				},
-			_ => anyhow::bail!("The call is not supported"),
+				)
+				.into(),
+			_ => anyhow::bail!(
+				"Unsupported target bridge pallet with instance index: {}",
+				bridge_instance_index
+			),
 		})
 	}
-
-	fn get_dispatch_info(call: &EncodedOrDecodedCall<Self::Call>) -> anyhow::Result<DispatchInfo> {
-		match *call {
-			EncodedOrDecodedCall::Decoded(relay_wococo_client::runtime::Call::System(
-				relay_wococo_client::runtime::SystemCall::remark(_),
-			)) => Ok(DispatchInfo {
-				weight: crate::chains::rococo::SYSTEM_REMARK_CALL_WEIGHT,
-				class: DispatchClass::Normal,
-				pays_fee: Pays::Yes,
-			}),
-			_ => anyhow::bail!("Unsupported Wococo call: {:?}", call),
-		}
-	}
 }
 
 impl CliChain for Wococo {
 	const RUNTIME_VERSION: RuntimeVersion = bp_wococo::VERSION;
 
 	type KeyPair = sp_core::sr25519::Pair;
-	type MessagePayload = MessagePayload<
-		bp_wococo::AccountId,
-		bp_rococo::AccountPublic,
-		bp_rococo::Signature,
-		Vec<u8>,
-	>;
+	type MessagePayload = Vec<u8>;
 
 	fn ss58_format() -> u16 {
 		42
 	}
-
-	fn encode_message(
-		message: encode_message::MessagePayload,
-	) -> anyhow::Result<Self::MessagePayload> {
-		match message {
-			encode_message::MessagePayload::Raw { data } => MessagePayload::decode(&mut &*data.0)
-				.map_err(|e| anyhow!("Failed to decode Wococo's MessagePayload: {:?}", e)),
-			encode_message::MessagePayload::Call { mut call, mut sender, dispatch_weight } => {
-				type Source = Wococo;
-				type Target = relay_rococo_client::Rococo;
-
-				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::WOCOCO_TO_ROCOCO_INDEX,
-				);
-				let call = Target::encode_call(&call)?;
-				let dispatch_weight = dispatch_weight.map(Ok).unwrap_or_else(|| {
-					Err(anyhow::format_err!(
-						"Please specify dispatch weight of the encoded Rococo call"
-					))
-				})?;
-
-				Ok(send_message::message_payload(
-					spec_version,
-					dispatch_weight,
-					origin,
-					&call,
-					DispatchFeePayment::AtSourceChain,
-				))
-			},
-		}
-	}
 }