Refactor substrate messages source and substrate messages target (#1105)

* Remove redundant generic parameters from SubstrateMessagesSource

* Remove redundant generic parameters from SubstrateMessagesTarget

* use uniform alias naming

* use aliases instead of fully quallified syntax

* pr feedback

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

@@ -147,10 +147,10 @@ impl SubstrateMessageLane for MillauMessagesToRialto {
 }
 
 /// Millau node as messages source.
-type MillauSourceClient = SubstrateMessagesSource<Millau, Rialto, MillauMessagesToRialto>;
+type MillauSourceClient = SubstrateMessagesSource<MillauMessagesToRialto>;
 
 /// Rialto node as messages target.
-type RialtoTargetClient = SubstrateMessagesTarget<Millau, Rialto, MillauMessagesToRialto>;
+type RialtoTargetClient = SubstrateMessagesTarget<MillauMessagesToRialto>;
 
 /// Run Millau-to-Rialto messages sync.
 pub async fn run(

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

@@ -147,10 +147,10 @@ impl SubstrateMessageLane for RialtoMessagesToMillau {
 }
 
 /// Rialto node as messages source.
-type RialtoSourceClient = SubstrateMessagesSource<Rialto, Millau, RialtoMessagesToMillau>;
+type RialtoSourceClient = SubstrateMessagesSource<RialtoMessagesToMillau>;
 
 /// Millau node as messages target.
-type MillauTargetClient = SubstrateMessagesTarget<Rialto, Millau, RialtoMessagesToMillau>;
+type MillauTargetClient = SubstrateMessagesTarget<RialtoMessagesToMillau>;
 
 /// Run Rialto-to-Millau messages sync.
 pub async fn run(

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

@@ -148,10 +148,10 @@ impl SubstrateMessageLane for RococoMessagesToWococo {
 }
 
 /// Rococo node as messages source.
-type RococoSourceClient = SubstrateMessagesSource<Rococo, Wococo, RococoMessagesToWococo>;
+type RococoSourceClient = SubstrateMessagesSource<RococoMessagesToWococo>;
 
 /// Wococo node as messages target.
-type WococoTargetClient = SubstrateMessagesTarget<Rococo, Wococo, RococoMessagesToWococo>;
+type WococoTargetClient = SubstrateMessagesTarget<RococoMessagesToWococo>;
 
 /// Run Rococo-to-Wococo messages sync.
 pub async fn run(

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

@@ -147,10 +147,10 @@ impl SubstrateMessageLane for WococoMessagesToRococo {
 }
 
 /// Wococo node as messages source.
-type WococoSourceClient = SubstrateMessagesSource<Wococo, Rococo, WococoMessagesToRococo>;
+type WococoSourceClient = SubstrateMessagesSource<WococoMessagesToRococo>;
 
 /// Rococo node as messages target.
-type RococoTargetClient = SubstrateMessagesTarget<Wococo, Rococo, WococoMessagesToRococo>;
+type RococoTargetClient = SubstrateMessagesTarget<WococoMessagesToRococo>;
 
 /// Run Wococo-to-Rococo messages sync.
 pub async fn run(

bridges/relays/client-substrate/src/chain.rs

@@ -79,6 +79,11 @@ pub trait Chain: ChainBase + Clone {
 		+ std::convert::TryFrom<sp_core::U256>;
 }
 
+/// Balance type used by the chain
+pub type BalanceOf<C> = <C as Chain>::Balance;
+/// Index type used by the chain
+pub type IndexOf<C> = <C as Chain>::Index;
+
 /// Substrate-based chain with `frame_system::Config::AccountData` set to
 /// the `pallet_balances::AccountData<Balance>`.
 pub trait ChainWithBalances: Chain {

bridges/relays/client-substrate/src/lib.rs

@@ -31,7 +31,7 @@ pub mod metrics;
 
 use std::time::Duration;
 
-pub use crate::chain::{BlockWithJustification, Chain, ChainWithBalances, TransactionSignScheme};
+pub use crate::chain::{BalanceOf, BlockWithJustification, Chain, ChainWithBalances, IndexOf, TransactionSignScheme};
 pub use crate::client::{Client, JustificationsSubscription, OpaqueGrandpaAuthoritiesSet};
 pub use crate::error::{Error, Result};
 pub use crate::sync_header::SyncHeader;

bridges/relays/lib-substrate-relay/src/messages_source.rs

@@ -38,7 +38,9 @@ use messages_relay::{
 	},
 };
 use num_traits::{Bounded, Zero};
-use relay_substrate_client::{Chain, Client, Error as SubstrateError, HashOf, HeaderIdOf};
+use relay_substrate_client::{
+	BalanceOf, BlockNumberOf, Chain, Client, Error as SubstrateError, HashOf, HeaderIdOf, HeaderOf, IndexOf,
+};
 use relay_utils::{relay_loop::Client as RelayClient, BlockNumberBase, HeaderId};
 use sp_core::Bytes;
 use sp_runtime::{traits::Header as HeaderT, DeserializeOwned};
@@ -50,20 +52,20 @@ use std::ops::RangeInclusive;
 pub type SubstrateMessagesProof<C> = (Weight, FromBridgedChainMessagesProof<HashOf<C>>);
 
 /// Substrate client as Substrate messages source.
-pub struct SubstrateMessagesSource<SC: Chain, TC: Chain, P: SubstrateMessageLane> {
-	client: Client<SC>,
+pub struct SubstrateMessagesSource<P: SubstrateMessageLane> {
+	client: Client<P::SourceChain>,
 	lane: P,
 	lane_id: LaneId,
-	target_to_source_headers_relay: Option<OnDemandHeadersRelay<TC>>,
+	target_to_source_headers_relay: Option<OnDemandHeadersRelay<P::TargetChain>>,
 }
 
-impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> SubstrateMessagesSource<SC, TC, P> {
+impl<P: SubstrateMessageLane> SubstrateMessagesSource<P> {
 	/// Create new Substrate headers source.
 	pub fn new(
-		client: Client<SC>,
+		client: Client<P::SourceChain>,
 		lane: P,
 		lane_id: LaneId,
-		target_to_source_headers_relay: Option<OnDemandHeadersRelay<TC>>,
+		target_to_source_headers_relay: Option<OnDemandHeadersRelay<P::TargetChain>>,
 	) -> Self {
 		SubstrateMessagesSource {
 			client,
@@ -74,7 +76,7 @@ impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> SubstrateMessagesSource<SC,
 	}
 }
 
-impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> Clone for SubstrateMessagesSource<SC, TC, P> {
+impl<P: SubstrateMessageLane> Clone for SubstrateMessagesSource<P> {
 	fn clone(&self) -> Self {
 		Self {
 			client: self.client.clone(),
@@ -86,12 +88,7 @@ impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> Clone for SubstrateMessagesS
 }
 
 #[async_trait]
-impl<SC, TC, P> RelayClient for SubstrateMessagesSource<SC, TC, P>
-where
-	SC: Chain,
-	TC: Chain,
-	P: SubstrateMessageLane,
-{
+impl<P: SubstrateMessageLane> RelayClient for SubstrateMessagesSource<P> {
 	type Error = SubstrateError;
 
 	async fn reconnect(&mut self) -> Result<(), SubstrateError> {
@@ -100,27 +97,27 @@ where
 }
 
 #[async_trait]
-impl<SC, TC, P> SourceClient<P::MessageLane> for SubstrateMessagesSource<SC, TC, P>
+impl<P> SourceClient<P::MessageLane> for SubstrateMessagesSource<P>
 where
-	SC: Chain<
+	P: SubstrateMessageLane,
+	P::SourceChain: Chain<
 		Hash = <P::MessageLane as MessageLane>::SourceHeaderHash,
 		BlockNumber = <P::MessageLane as MessageLane>::SourceHeaderNumber,
 		Balance = <P::MessageLane as MessageLane>::SourceChainBalance,
 	>,
-	SC::Hash: Copy,
-	SC::BlockNumber: Copy,
-	SC::Balance: Decode + Bounded,
-	SC::Header: DeserializeOwned,
-	SC::Index: DeserializeOwned,
-	SC::BlockNumber: BlockNumberBase,
-	TC: Chain<
+	BalanceOf<P::SourceChain>: Decode + Bounded,
+	IndexOf<P::SourceChain>: DeserializeOwned,
+	HashOf<P::SourceChain>: Copy,
+	BlockNumberOf<P::SourceChain>: BlockNumberBase + Copy,
+	HeaderOf<P::SourceChain>: DeserializeOwned,
+	P::TargetChain: Chain<
 		Hash = <P::MessageLane as MessageLane>::TargetHeaderHash,
 		BlockNumber = <P::MessageLane as MessageLane>::TargetHeaderNumber,
 	>,
-	P: SubstrateMessageLane<SourceChain = SC, TargetChain = TC>,
+
 	P::MessageLane: MessageLane<
-		MessagesProof = SubstrateMessagesProof<SC>,
-		MessagesReceivingProof = SubstrateMessagesReceivingProof<TC>,
+		MessagesProof = SubstrateMessagesProof<P::SourceChain>,
+		MessagesReceivingProof = SubstrateMessagesReceivingProof<P::TargetChain>,
 	>,
 	<P::MessageLane as MessageLane>::TargetHeaderNumber: Decode,
 	<P::MessageLane as MessageLane>::TargetHeaderHash: Decode,
@@ -186,7 +183,7 @@ where
 			)
 			.await?;
 
-		make_message_details_map::<SC>(
+		make_message_details_map::<P::SourceChain>(
 			Decode::decode(&mut &encoded_response.0[..]).map_err(SubstrateError::ResponseParseFailed)?,
 			nonces,
 		)
@@ -264,10 +261,10 @@ where
 			.estimate_extrinsic_fee(self.lane.make_messages_receiving_proof_transaction(
 				Zero::zero(),
 				HeaderId(Default::default(), Default::default()),
-				prepare_dummy_messages_delivery_proof::<SC, TC>(),
+				prepare_dummy_messages_delivery_proof::<P::SourceChain, P::TargetChain>(),
 			))
 			.await
-			.unwrap_or_else(|_| SC::Balance::max_value())
+			.unwrap_or_else(|_| BalanceOf::<P::SourceChain>::max_value())
 	}
 }
 

bridges/relays/lib-substrate-relay/src/messages_target.rs

@@ -24,6 +24,7 @@ use crate::on_demand_headers::OnDemandHeadersRelay;
 
 use async_trait::async_trait;
 use bp_messages::{LaneId, MessageNonce, UnrewardedRelayersState};
+
 use bridge_runtime_common::messages::{
 	source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof,
 };
@@ -35,10 +36,12 @@ use messages_relay::{
 	message_lane_loop::{TargetClient, TargetClientState},
 };
 use num_traits::{Bounded, Zero};
-use relay_substrate_client::{Chain, Client, Error as SubstrateError, HashOf};
+use relay_substrate_client::{
+	BalanceOf, BlockNumberOf, Chain, Client, Error as SubstrateError, HashOf, HeaderOf, IndexOf,
+};
 use relay_utils::{relay_loop::Client as RelayClient, BlockNumberBase, HeaderId};
 use sp_core::Bytes;
-use sp_runtime::{traits::Header as HeaderT, DeserializeOwned, FixedPointNumber, FixedU128};
+use sp_runtime::{DeserializeOwned, FixedPointNumber, FixedU128};
 use std::{convert::TryFrom, ops::RangeInclusive};
 
 /// Message receiving proof returned by the target Substrate node.
@@ -48,22 +51,22 @@ pub type SubstrateMessagesReceivingProof<C> = (
 );
 
 /// Substrate client as Substrate messages target.
-pub struct SubstrateMessagesTarget<SC: Chain, TC: Chain, P: SubstrateMessageLane> {
-	client: Client<TC>,
+pub struct SubstrateMessagesTarget<P: SubstrateMessageLane> {
+	client: Client<P::TargetChain>,
 	lane: P,
 	lane_id: LaneId,
 	metric_values: StandaloneMessagesMetrics,
-	source_to_target_headers_relay: Option<OnDemandHeadersRelay<SC>>,
+	source_to_target_headers_relay: Option<OnDemandHeadersRelay<P::SourceChain>>,
 }
 
-impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> SubstrateMessagesTarget<SC, TC, P> {
+impl<P: SubstrateMessageLane> SubstrateMessagesTarget<P> {
 	/// Create new Substrate headers target.
 	pub fn new(
-		client: Client<TC>,
+		client: Client<P::TargetChain>,
 		lane: P,
 		lane_id: LaneId,
 		metric_values: StandaloneMessagesMetrics,
-		source_to_target_headers_relay: Option<OnDemandHeadersRelay<SC>>,
+		source_to_target_headers_relay: Option<OnDemandHeadersRelay<P::SourceChain>>,
 	) -> Self {
 		SubstrateMessagesTarget {
 			client,
@@ -75,7 +78,7 @@ impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> SubstrateMessagesTarget<SC,
 	}
 }
 
-impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> Clone for SubstrateMessagesTarget<SC, TC, P> {
+impl<P: SubstrateMessageLane> Clone for SubstrateMessagesTarget<P> {
 	fn clone(&self) -> Self {
 		Self {
 			client: self.client.clone(),
@@ -88,12 +91,7 @@ impl<SC: Chain, TC: Chain, P: SubstrateMessageLane> Clone for SubstrateMessagesT
 }
 
 #[async_trait]
-impl<SC, TC, P> RelayClient for SubstrateMessagesTarget<SC, TC, P>
-where
-	SC: Chain,
-	TC: Chain,
-	P: SubstrateMessageLane,
-{
+impl<P: SubstrateMessageLane> RelayClient for SubstrateMessagesTarget<P> {
 	type Error = SubstrateError;
 
 	async fn reconnect(&mut self) -> Result<(), SubstrateError> {
@@ -102,27 +100,28 @@ where
 }
 
 #[async_trait]
-impl<SC, TC, P> TargetClient<P::MessageLane> for SubstrateMessagesTarget<SC, TC, P>
+impl<P> TargetClient<P::MessageLane> for SubstrateMessagesTarget<P>
 where
-	SC: Chain<
+	P: SubstrateMessageLane,
+	P::SourceChain: Chain<
 		Hash = <P::MessageLane as MessageLane>::SourceHeaderHash,
 		BlockNumber = <P::MessageLane as MessageLane>::SourceHeaderNumber,
 		Balance = <P::MessageLane as MessageLane>::SourceChainBalance,
 	>,
-	SC::Balance: TryFrom<TC::Balance> + Bounded,
-	TC: Chain<
+	BalanceOf<P::SourceChain>: TryFrom<<P::TargetChain as Chain>::Balance> + Bounded,
+	P::TargetChain: Chain<
 		Hash = <P::MessageLane as MessageLane>::TargetHeaderHash,
 		BlockNumber = <P::MessageLane as MessageLane>::TargetHeaderNumber,
 	>,
-	TC::Hash: Copy,
-	TC::BlockNumber: Copy,
-	TC::Header: DeserializeOwned,
-	TC::Index: DeserializeOwned,
-	<TC::Header as HeaderT>::Number: BlockNumberBase,
-	P: SubstrateMessageLane<SourceChain = SC, TargetChain = TC>,
+	IndexOf<P::TargetChain>: DeserializeOwned,
+	HashOf<P::TargetChain>: Copy,
+	BlockNumberOf<P::TargetChain>: Copy,
+	HeaderOf<P::TargetChain>: DeserializeOwned,
+	BlockNumberOf<P::TargetChain>: BlockNumberBase,
+
 	P::MessageLane: MessageLane<
-		MessagesProof = SubstrateMessagesProof<SC>,
-		MessagesReceivingProof = SubstrateMessagesReceivingProof<TC>,
+		MessagesProof = SubstrateMessagesProof<P::SourceChain>,
+		MessagesReceivingProof = SubstrateMessagesReceivingProof<P::TargetChain>,
 	>,
 	<P::MessageLane as MessageLane>::SourceHeaderNumber: Decode,
 	<P::MessageLane as MessageLane>::SourceHeaderHash: Decode,
@@ -255,29 +254,31 @@ where
 			.ok_or_else(|| {
 				SubstrateError::Custom(format!(
 					"Failed to compute conversion rate from {} to {}",
-					TC::NAME,
-					SC::NAME,
+					P::TargetChain::NAME,
+					P::SourceChain::NAME,
 				))
 			})?;
 		log::trace!(
 			target: "bridge",
 			"Using conversion rate {} when converting from {} tokens to {} tokens",
 			conversion_rate,
-			TC::NAME,
-			SC::NAME
+			P::TargetChain::NAME,
+			P::SourceChain::NAME,
 		);
-		Ok(convert_target_tokens_to_source_tokens::<SC, TC>(
-			FixedU128::from_float(conversion_rate),
-			self.client
-				.estimate_extrinsic_fee(self.lane.make_messages_delivery_transaction(
-					Zero::zero(),
-					HeaderId(Default::default(), Default::default()),
-					nonces.clone(),
-					prepare_dummy_messages_proof::<SC>(nonces, total_dispatch_weight, total_size),
-				))
-				.await
-				.unwrap_or_else(|_| TC::Balance::max_value()),
-		))
+		Ok(
+			convert_target_tokens_to_source_tokens::<P::SourceChain, P::TargetChain>(
+				FixedU128::from_float(conversion_rate),
+				self.client
+					.estimate_extrinsic_fee(self.lane.make_messages_delivery_transaction(
+						Zero::zero(),
+						HeaderId(Default::default(), Default::default()),
+						nonces.clone(),
+						prepare_dummy_messages_proof::<P::SourceChain>(nonces, total_dispatch_weight, total_size),
+					))
+					.await
+					.unwrap_or_else(|_| <P::TargetChain as Chain>::Balance::max_value()),
+			),
+		)
 	}
 }