Match substrate's fmt (#1148)

* Alter gitlab.

* Use substrate's rustfmt.toml

* cargo +nightly fmt --all

* Fix spellcheck.

* cargo +nightly fmt --all

* format.

* Fix spellcheck and fmt

* fmt?

* Fix spellcheck

Co-authored-by: Tomasz Drwięga <tomasz@parity.io>

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

@@ -33,7 +33,8 @@ enum TransactionStatus {
 
 /// Run infinite conversion rate updater loop.
 ///
-/// The loop is maintaining the Left -> Right conversion rate, used as `RightTokens = LeftTokens * Rate`.
+/// The loop is maintaining the Left -> Right conversion rate, used as `RightTokens = LeftTokens *
+/// Rate`.
 pub fn run_conversion_rate_update_loop<
 	SubmitConversionRateFuture: Future<Output = anyhow::Result<()>> + Send + 'static,
 >(
@@ -60,10 +61,10 @@ pub fn run_conversion_rate_update_loop<
 				match submit_conversion_rate_future.await {
 					Ok(()) => {
 						transaction_status = TransactionStatus::Submitted(prev_conversion_rate);
-					}
+					},
 					Err(error) => {
 						log::trace!(target: "bridge", "Failed to submit conversion rate update transaction: {:?}", error);
-					}
+					},
 				}
 			}
 		}
@@ -78,41 +79,43 @@ async fn maybe_select_new_conversion_rate(
 	right_to_base_conversion_rate: &F64SharedRef,
 	max_difference_ratio: f64,
 ) -> Option<(f64, f64)> {
-	let left_to_right_stored_conversion_rate = (*left_to_right_stored_conversion_rate.read().await)?;
+	let left_to_right_stored_conversion_rate =
+		(*left_to_right_stored_conversion_rate.read().await)?;
 	match *transaction_status {
 		TransactionStatus::Idle => (),
 		TransactionStatus::Submitted(previous_left_to_right_stored_conversion_rate) => {
-			// we can't compare float values from different sources directly, so we only care whether the
-			// stored rate has been changed or not. If it has been changed, then we assume that our proposal
-			// has been accepted.
+			// we can't compare float values from different sources directly, so we only care
+			// whether the stored rate has been changed or not. If it has been changed, then we
+			// assume that our proposal has been accepted.
 			//
-			// float comparison is ok here, because we compare same-origin (stored in runtime storage) values
-			// and if they are different, it means that the value has actually been updated
+			// float comparison is ok here, because we compare same-origin (stored in runtime
+			// storage) values and if they are different, it means that the value has actually been
+			// updated
 			#[allow(clippy::float_cmp)]
-			if previous_left_to_right_stored_conversion_rate == left_to_right_stored_conversion_rate {
-				// the rate has not been changed => we won't submit any transactions until it is accepted,
-				// or the rate is changed by someone else
-				return None;
+			if previous_left_to_right_stored_conversion_rate == left_to_right_stored_conversion_rate
+			{
+				// the rate has not been changed => we won't submit any transactions until it is
+				// accepted, or the rate is changed by someone else
+				return None
 			}
 
 			*transaction_status = TransactionStatus::Idle;
-		}
+		},
 	}
 
 	let left_to_base_conversion_rate = (*left_to_base_conversion_rate.read().await)?;
 	let right_to_base_conversion_rate = (*right_to_base_conversion_rate.read().await)?;
-	let actual_left_to_right_conversion_rate = right_to_base_conversion_rate / left_to_base_conversion_rate;
+	let actual_left_to_right_conversion_rate =
+		right_to_base_conversion_rate / left_to_base_conversion_rate;
 
-	let rate_difference = (actual_left_to_right_conversion_rate - left_to_right_stored_conversion_rate).abs();
+	let rate_difference =
+		(actual_left_to_right_conversion_rate - left_to_right_stored_conversion_rate).abs();
 	let rate_difference_ratio = rate_difference / left_to_right_stored_conversion_rate;
 	if rate_difference_ratio < max_difference_ratio {
-		return None;
+		return None
 	}
 
-	Some((
-		left_to_right_stored_conversion_rate,
-		actual_left_to_right_conversion_rate,
-	))
+	Some((left_to_right_stored_conversion_rate, actual_left_to_right_conversion_rate))
 }
 
 #[cfg(test)]
@@ -171,7 +174,13 @@ mod tests {
 	#[test]
 	fn transaction_is_not_submitted_when_left_to_base_rate_is_unknown() {
 		assert_eq!(
-			test_maybe_select_new_conversion_rate(TransactionStatus::Idle, Some(10.0), None, Some(1.0), 0.0),
+			test_maybe_select_new_conversion_rate(
+				TransactionStatus::Idle,
+				Some(10.0),
+				None,
+				Some(1.0),
+				0.0
+			),
 			(None, TransactionStatus::Idle),
 		);
 	}
@@ -179,7 +188,13 @@ mod tests {
 	#[test]
 	fn transaction_is_not_submitted_when_right_to_base_rate_is_unknown() {
 		assert_eq!(
-			test_maybe_select_new_conversion_rate(TransactionStatus::Idle, Some(10.0), Some(1.0), None, 0.0),
+			test_maybe_select_new_conversion_rate(
+				TransactionStatus::Idle,
+				Some(10.0),
+				Some(1.0),
+				None,
+				0.0
+			),
 			(None, TransactionStatus::Idle),
 		);
 	}
@@ -187,7 +202,13 @@ mod tests {
 	#[test]
 	fn transaction_is_not_submitted_when_stored_rate_is_unknown() {
 		assert_eq!(
-			test_maybe_select_new_conversion_rate(TransactionStatus::Idle, None, Some(1.0), Some(1.0), 0.0),
+			test_maybe_select_new_conversion_rate(
+				TransactionStatus::Idle,
+				None,
+				Some(1.0),
+				Some(1.0),
+				0.0
+			),
 			(None, TransactionStatus::Idle),
 		);
 	}
@@ -195,7 +216,13 @@ mod tests {
 	#[test]
 	fn transaction_is_not_submitted_when_difference_is_below_threshold() {
 		assert_eq!(
-			test_maybe_select_new_conversion_rate(TransactionStatus::Idle, Some(1.0), Some(1.0), Some(1.01), 0.02),
+			test_maybe_select_new_conversion_rate(
+				TransactionStatus::Idle,
+				Some(1.0),
+				Some(1.0),
+				Some(1.01),
+				0.02
+			),
 			(None, TransactionStatus::Idle),
 		);
 	}
@@ -203,7 +230,13 @@ mod tests {
 	#[test]
 	fn transaction_is_submitted_when_difference_is_above_threshold() {
 		assert_eq!(
-			test_maybe_select_new_conversion_rate(TransactionStatus::Idle, Some(1.0), Some(1.0), Some(1.03), 0.02),
+			test_maybe_select_new_conversion_rate(
+				TransactionStatus::Idle,
+				Some(1.0),
+				Some(1.0),
+				Some(1.03),
+				0.02
+			),
 			(Some((1.0, 1.03)), TransactionStatus::Idle),
 		);
 	}

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

@@ -21,7 +21,9 @@ use crate::finality_target::SubstrateFinalityTarget;
 use bp_header_chain::justification::GrandpaJustification;
 use bp_runtime::AccountIdOf;
 use finality_relay::{FinalitySyncParams, FinalitySyncPipeline};
-use relay_substrate_client::{finality_source::FinalitySource, BlockNumberOf, Chain, Client, HashOf, SyncHeader};
+use relay_substrate_client::{
+	finality_source::FinalitySource, BlockNumberOf, Chain, Client, HashOf, SyncHeader,
+};
 use relay_utils::{metrics::MetricsParams, BlockNumberBase};
 use sp_core::Bytes;
 use std::{fmt::Debug, marker::PhantomData, time::Duration};
@@ -97,14 +99,12 @@ impl<SourceChain, TargetChain: Chain, TargetSign> Debug
 	}
 }
 
-impl<SourceChain, TargetChain: Chain, TargetSign> SubstrateFinalityToSubstrate<SourceChain, TargetChain, TargetSign> {
+impl<SourceChain, TargetChain: Chain, TargetSign>
+	SubstrateFinalityToSubstrate<SourceChain, TargetChain, TargetSign>
+{
 	/// Create new Substrate-to-Substrate headers pipeline.
 	pub fn new(target_client: Client<TargetChain>, target_sign: TargetSign) -> Self {
-		SubstrateFinalityToSubstrate {
-			target_client,
-			target_sign,
-			_marker: Default::default(),
-		}
+		SubstrateFinalityToSubstrate { target_client, target_sign, _marker: Default::default() }
 	}
 }
 
@@ -157,7 +157,10 @@ where
 		FinalitySource::new(source_client, None),
 		SubstrateFinalityTarget::new(target_client, pipeline, transactions_mortality),
 		FinalitySyncParams {
-			tick: std::cmp::max(SourceChain::AVERAGE_BLOCK_INTERVAL, TargetChain::AVERAGE_BLOCK_INTERVAL),
+			tick: std::cmp::max(
+				SourceChain::AVERAGE_BLOCK_INTERVAL,
+				TargetChain::AVERAGE_BLOCK_INTERVAL,
+			),
 			recent_finality_proofs_limit: RECENT_FINALITY_PROOFS_LIMIT,
 			stall_timeout: relay_substrate_client::transaction_stall_timeout(
 				transactions_mortality,

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

@@ -36,11 +36,7 @@ pub struct SubstrateFinalityTarget<C: Chain, P> {
 impl<C: Chain, P> SubstrateFinalityTarget<C, P> {
 	/// Create new Substrate headers target.
 	pub fn new(client: Client<C>, pipeline: P, transactions_mortality: Option<u32>) -> Self {
-		SubstrateFinalityTarget {
-			client,
-			pipeline,
-			transactions_mortality,
-		}
+		SubstrateFinalityTarget { client, pipeline, transactions_mortality }
 	}
 }
 
@@ -97,18 +93,21 @@ where
 		let pipeline = self.pipeline.clone();
 		let transactions_mortality = self.transactions_mortality;
 		self.client
-			.submit_signed_extrinsic(transactions_author, move |best_block_id, transaction_nonce| {
-				pipeline.make_submit_finality_proof_transaction(
-					relay_substrate_client::TransactionEra::new(
-						best_block_id.0,
-						best_block_id.1,
-						transactions_mortality,
-					),
-					transaction_nonce,
-					header,
-					proof,
-				)
-			})
+			.submit_signed_extrinsic(
+				transactions_author,
+				move |best_block_id, transaction_nonce| {
+					pipeline.make_submit_finality_proof_transaction(
+						relay_substrate_client::TransactionEra::new(
+							best_block_id.0,
+							best_block_id.1,
+							transactions_mortality,
+						),
+						transaction_nonce,
+						header,
+						proof,
+					)
+				},
+			)
 			.await
 			.map(drop)
 	}

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

@@ -21,10 +21,10 @@
 //! and authorities set from source to target chain. The headers sync starts
 //! with this header.
 
-use bp_header_chain::InitializationData;
 use bp_header_chain::{
 	find_grandpa_authorities_scheduled_change,
 	justification::{verify_justification, GrandpaJustification},
+	InitializationData,
 };
 use codec::Decode;
 use finality_grandpa::voter_set::VoterSet;
@@ -103,31 +103,30 @@ async fn prepare_initialization_data<SourceChain: Chain>(
 	// In ideal world we just need to get best finalized header and then to read GRANDPA authorities
 	// set (`pallet_grandpa::CurrentSetId` + `GrandpaApi::grandpa_authorities()`) at this header.
 	//
-	// But now there are problems with this approach - `CurrentSetId` may return invalid value. So here
-	// we're waiting for the next justification, read the authorities set and then try to figure out
-	// the set id with bruteforce.
-	let justifications = source_client
-		.subscribe_justifications()
-		.await
-		.map_err(|err| format!("Failed to subscribe to {} justifications: {:?}", SourceChain::NAME, err))?;
+	// But now there are problems with this approach - `CurrentSetId` may return invalid value. So
+	// here we're waiting for the next justification, read the authorities set and then try to
+	// figure out the set id with bruteforce.
+	let justifications = source_client.subscribe_justifications().await.map_err(|err| {
+		format!("Failed to subscribe to {} justifications: {:?}", SourceChain::NAME, err)
+	})?;
 
 	// Read next justification - the header that it finalizes will be used as initial header.
 	let justification = justifications
 		.next()
 		.await
 		.map_err(|err| err.to_string())
-		.and_then(|justification| justification.ok_or_else(|| "stream has ended unexpectedly".into()))
+		.and_then(|justification| {
+			justification.ok_or_else(|| "stream has ended unexpectedly".into())
+		})
 		.map_err(|err| {
-			format!(
-				"Failed to read {} justification from the stream: {}",
-				SourceChain::NAME,
-				err,
-			)
+			format!("Failed to read {} justification from the stream: {}", SourceChain::NAME, err,)
 		})?;
 
 	// Read initial header.
-	let justification: GrandpaJustification<SourceChain::Header> = Decode::decode(&mut &justification.0[..])
-		.map_err(|err| format!("Failed to decode {} justification: {:?}", SourceChain::NAME, err))?;
+	let justification: GrandpaJustification<SourceChain::Header> =
+		Decode::decode(&mut &justification.0[..]).map_err(|err| {
+			format!("Failed to decode {} justification: {:?}", SourceChain::NAME, err)
+		})?;
 
 	let (initial_header_hash, initial_header_number) =
 		(justification.commit.target_hash, justification.commit.target_number);
@@ -140,7 +139,8 @@ async fn prepare_initialization_data<SourceChain: Chain>(
 	);
 
 	// Read GRANDPA authorities set at initial header.
-	let initial_authorities_set = source_authorities_set(&source_client, initial_header_hash).await?;
+	let initial_authorities_set =
+		source_authorities_set(&source_client, initial_header_hash).await?;
 	log::trace!(target: "bridge", "Selected {} initial authorities set: {:?}",
 		SourceChain::NAME,
 		initial_authorities_set,
@@ -159,7 +159,8 @@ async fn prepare_initialization_data<SourceChain: Chain>(
 	);
 	let schedules_change = scheduled_change.is_some();
 	if schedules_change {
-		authorities_for_verification = source_authorities_set(&source_client, *initial_header.parent_hash()).await?;
+		authorities_for_verification =
+			source_authorities_set(&source_client, *initial_header.parent_hash()).await?;
 		log::trace!(
 			target: "bridge",
 			"Selected {} header is scheduling GRANDPA authorities set changes. Using previous set: {:?}",
@@ -171,13 +172,14 @@ async fn prepare_initialization_data<SourceChain: Chain>(
 	// Now let's try to guess authorities set id by verifying justification.
 	let mut initial_authorities_set_id = 0;
 	let mut min_possible_block_number = SourceChain::BlockNumber::zero();
-	let authorities_for_verification = VoterSet::new(authorities_for_verification.clone()).ok_or_else(|| {
-		format!(
-			"Read invalid {} authorities set: {:?}",
-			SourceChain::NAME,
-			authorities_for_verification,
-		)
-	})?;
+	let authorities_for_verification = VoterSet::new(authorities_for_verification.clone())
+		.ok_or_else(|| {
+			format!(
+				"Read invalid {} authorities set: {:?}",
+				SourceChain::NAME,
+				authorities_for_verification,
+			)
+		})?;
 	loop {
 		log::trace!(
 			target: "bridge", "Trying {} GRANDPA authorities set id: {}",
@@ -194,21 +196,21 @@ async fn prepare_initialization_data<SourceChain: Chain>(
 		.is_ok();
 
 		if is_valid_set_id {
-			break;
+			break
 		}
 
 		initial_authorities_set_id += 1;
 		min_possible_block_number += One::one();
 		if min_possible_block_number > initial_header_number {
-			// there can't be more authorities set changes than headers => if we have reached `initial_block_number`
-			// and still have not found correct value of `initial_authorities_set_id`, then something
-			// else is broken => fail
+			// there can't be more authorities set changes than headers => if we have reached
+			// `initial_block_number` and still have not found correct value of
+			// `initial_authorities_set_id`, then something else is broken => fail
 			return Err(format!(
 				"Failed to guess initial {} GRANDPA authorities set id: checked all\
 			possible ids in range [0; {}]",
 				SourceChain::NAME,
 				initial_header_number
-			));
+			))
 		}
 	}
 
@@ -244,10 +246,8 @@ async fn source_authorities_set<SourceChain: Chain>(
 	source_client: &Client<SourceChain>,
 	header_hash: SourceChain::Hash,
 ) -> Result<GrandpaAuthoritiesSet, String> {
-	let raw_authorities_set = source_client
-		.grandpa_authorities_set(header_hash)
-		.await
-		.map_err(|err| {
+	let raw_authorities_set =
+		source_client.grandpa_authorities_set(header_hash).await.map_err(|err| {
 			format!(
 				"Failed to retrive {} GRANDPA authorities set at header {}: {:?}",
 				SourceChain::NAME,

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

@@ -27,15 +27,9 @@ pub fn token_price_metric(
 	FloatJsonValueMetric::new(
 		registry,
 		prefix,
-		format!(
-			"https://api.coingecko.com/api/v3/simple/price?ids={}&vs_currencies=btc",
-			token_id
-		),
+		format!("https://api.coingecko.com/api/v3/simple/price?ids={}&vs_currencies=btc", token_id),
 		format!("$.{}.btc", token_id),
 		format!("{}_to_base_conversion_rate", token_id.replace("-", "_")),
-		format!(
-			"Rate used to convert from {} to some BASE tokens",
-			token_id.to_uppercase()
-		),
+		format!("Rate used to convert from {} to some BASE tokens", token_id.to_uppercase()),
 	)
 }

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

@@ -16,9 +16,10 @@
 
 //! Tools for supporting message lanes between two Substrate-based chains.
 
-use crate::messages_source::SubstrateMessagesProof;
-use crate::messages_target::SubstrateMessagesReceivingProof;
-use crate::on_demand_headers::OnDemandHeadersRelay;
+use crate::{
+	messages_source::SubstrateMessagesProof, messages_target::SubstrateMessagesReceivingProof,
+	on_demand_headers::OnDemandHeadersRelay,
+};
 
 use async_trait::async_trait;
 use bp_messages::{LaneId, MessageNonce};
@@ -65,18 +66,22 @@ pub trait SubstrateMessageLane: 'static + Clone + Send + Sync {
 	/// Underlying generic message lane.
 	type MessageLane: MessageLane;
 
-	/// Name of the runtime method that returns dispatch weight of outbound messages at the source chain.
+	/// Name of the runtime method that returns dispatch weight of outbound messages at the source
+	/// chain.
 	const OUTBOUND_LANE_MESSAGE_DETAILS_METHOD: &'static str;
 	/// Name of the runtime method that returns latest generated nonce at the source chain.
 	const OUTBOUND_LANE_LATEST_GENERATED_NONCE_METHOD: &'static str;
-	/// Name of the runtime method that returns latest received (confirmed) nonce at the the source chain.
+	/// Name of the runtime method that returns latest received (confirmed) nonce at the the source
+	/// chain.
 	const OUTBOUND_LANE_LATEST_RECEIVED_NONCE_METHOD: &'static str;
 
 	/// Name of the runtime method that returns latest received nonce at the target chain.
 	const INBOUND_LANE_LATEST_RECEIVED_NONCE_METHOD: &'static str;
-	/// Name of the runtime method that returns the latest confirmed (reward-paid) nonce at the target chain.
+	/// Name of the runtime method that returns the latest confirmed (reward-paid) nonce at the
+	/// target chain.
 	const INBOUND_LANE_LATEST_CONFIRMED_NONCE_METHOD: &'static str;
-	/// Number of the runtime method that returns state of "unrewarded relayers" set at the target chain.
+	/// Number of the runtime method that returns state of "unrewarded relayers" set at the target
+	/// chain.
 	const INBOUND_LANE_UNREWARDED_RELAYERS_STATE: &'static str;
 
 	/// Name of the runtime method that returns id of best finalized source header at target chain.
@@ -101,7 +106,8 @@ pub trait SubstrateMessageLane: 'static + Clone + Send + Sync {
 	/// Target chain.
 	type TargetChain: Chain;
 
-	/// Returns id of account that we're using to sign transactions at target chain (messages proof).
+	/// Returns id of account that we're using to sign transactions at target chain (messages
+	/// proof).
 	fn target_transactions_author(&self) -> AccountIdOf<Self::TargetChain>;
 
 	/// Make messages delivery transaction.
@@ -113,7 +119,8 @@ pub trait SubstrateMessageLane: 'static + Clone + Send + Sync {
 		proof: <Self::MessageLane as MessageLane>::MessagesProof,
 	) -> Bytes;
 
-	/// Returns id of account that we're using to sign transactions at source chain (delivery proof).
+	/// Returns id of account that we're using to sign transactions at source chain (delivery
+	/// proof).
 	fn source_transactions_author(&self) -> AccountIdOf<Self::SourceChain>;
 
 	/// Make messages receiving proof transaction.
@@ -127,7 +134,12 @@ pub trait SubstrateMessageLane: 'static + Clone + Send + Sync {
 
 /// Substrate-to-Substrate message lane.
 #[derive(Debug)]
-pub struct SubstrateMessageLaneToSubstrate<Source: Chain, SourceSignParams, Target: Chain, TargetSignParams> {
+pub struct SubstrateMessageLaneToSubstrate<
+	Source: Chain,
+	SourceSignParams,
+	Target: Chain,
+	TargetSignParams,
+> {
 	/// Client for the source Substrate chain.
 	pub source_client: Client<Source>,
 	/// Parameters required to sign transactions for source chain.
@@ -194,8 +206,8 @@ pub fn select_delivery_transaction_limits<W: pallet_bridge_messages::WeightInfoE
 	let weight_for_delivery_tx = max_extrinsic_weight / 3;
 	let weight_for_messages_dispatch = max_extrinsic_weight - weight_for_delivery_tx;
 
-	let delivery_tx_base_weight =
-		W::receive_messages_proof_overhead() + W::receive_messages_proof_outbound_lane_state_overhead();
+	let delivery_tx_base_weight = W::receive_messages_proof_overhead() +
+		W::receive_messages_proof_outbound_lane_state_overhead();
 	let delivery_tx_weight_rest = weight_for_delivery_tx - delivery_tx_base_weight;
 	let max_number_of_messages = std::cmp::min(
 		delivery_tx_weight_rest / W::receive_messages_proof_messages_overhead(1),
@@ -221,15 +233,18 @@ pub struct StandaloneMessagesMetrics {
 	pub target_to_base_conversion_rate: Option<F64SharedRef>,
 	/// Shared reference to the actual source -> <base> chain token conversion rate.
 	pub source_to_base_conversion_rate: Option<F64SharedRef>,
-	/// Shared reference to the stored (in the source chain runtime storage) target -> source chain conversion rate.
+	/// Shared reference to the stored (in the source chain runtime storage) target -> source chain
+	/// conversion rate.
 	pub target_to_source_conversion_rate: Option<F64SharedRef>,
 }
 
 impl StandaloneMessagesMetrics {
 	/// Return conversion rate from target to source tokens.
 	pub async fn target_to_source_conversion_rate(&self) -> Option<f64> {
-		let target_to_base_conversion_rate = (*self.target_to_base_conversion_rate.as_ref()?.read().await)?;
-		let source_to_base_conversion_rate = (*self.source_to_base_conversion_rate.as_ref()?.read().await)?;
+		let target_to_base_conversion_rate =
+			(*self.target_to_base_conversion_rate.as_ref()?.read().await)?;
+		let source_to_base_conversion_rate =
+			(*self.source_to_base_conversion_rate.as_ref()?.read().await)?;
 		Some(source_to_base_conversion_rate / target_to_base_conversion_rate)
 	}
 }
@@ -246,8 +261,8 @@ pub fn add_standalone_metrics<P: SubstrateMessageLane>(
 	let mut target_to_source_conversion_rate = None;
 	let mut source_to_base_conversion_rate = None;
 	let mut target_to_base_conversion_rate = None;
-	let mut metrics_params =
-		relay_utils::relay_metrics(metrics_prefix, metrics_params).standalone_metric(|registry, prefix| {
+	let mut metrics_params = relay_utils::relay_metrics(metrics_prefix, metrics_params)
+		.standalone_metric(|registry, prefix| {
 			StorageProofOverheadMetric::new(
 				registry,
 				prefix,
@@ -256,8 +271,10 @@ pub fn add_standalone_metrics<P: SubstrateMessageLane>(
 				format!("{} storage proof overhead", P::SourceChain::NAME),
 			)
 		})?;
-	if let Some((target_to_source_conversion_rate_storage_key, initial_target_to_source_conversion_rate)) =
-		target_to_source_conversion_rate_params
+	if let Some((
+		target_to_source_conversion_rate_storage_key,
+		initial_target_to_source_conversion_rate,
+	)) = target_to_source_conversion_rate_params
 	{
 		metrics_params = metrics_params.standalone_metric(|registry, prefix| {
 			let metric = FloatStorageValueMetric::<_, sp_runtime::FixedU128>::new(
@@ -285,14 +302,16 @@ pub fn add_standalone_metrics<P: SubstrateMessageLane>(
 	}
 	if let Some(source_chain_token_id) = source_chain_token_id {
 		metrics_params = metrics_params.standalone_metric(|registry, prefix| {
-			let metric = crate::helpers::token_price_metric(registry, prefix, source_chain_token_id)?;
+			let metric =
+				crate::helpers::token_price_metric(registry, prefix, source_chain_token_id)?;
 			source_to_base_conversion_rate = Some(metric.shared_value_ref());
 			Ok(metric)
 		})?;
 	}
 	if let Some(target_chain_token_id) = target_chain_token_id {
 		metrics_params = metrics_params.standalone_metric(|registry, prefix| {
-			let metric = crate::helpers::token_price_metric(registry, prefix, target_chain_token_id)?;
+			let metric =
+				crate::helpers::token_price_metric(registry, prefix, target_chain_token_id)?;
 			target_to_base_conversion_rate = Some(metric.shared_value_ref());
 			Ok(metric)
 		})?;
@@ -312,19 +331,21 @@ mod tests {
 	use super::*;
 	use async_std::sync::{Arc, RwLock};
 
-	type RialtoToMillauMessagesWeights = pallet_bridge_messages::weights::RialtoWeight<rialto_runtime::Runtime>;
+	type RialtoToMillauMessagesWeights =
+		pallet_bridge_messages::weights::RialtoWeight<rialto_runtime::Runtime>;
 
 	#[test]
 	fn select_delivery_transaction_limits_works() {
-		let (max_count, max_weight) = select_delivery_transaction_limits::<RialtoToMillauMessagesWeights>(
-			bp_millau::max_extrinsic_weight(),
-			bp_millau::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE,
-		);
+		let (max_count, max_weight) =
+			select_delivery_transaction_limits::<RialtoToMillauMessagesWeights>(
+				bp_millau::max_extrinsic_weight(),
+				bp_millau::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE,
+			);
 		assert_eq!(
 			(max_count, max_weight),
 			// We don't actually care about these values, so feel free to update them whenever test
-			// fails. The only thing to do before that is to ensure that new values looks sane: i.e. weight
-			// reserved for messages dispatch allows dispatch of non-trivial messages.
+			// fails. The only thing to do before that is to ensure that new values looks sane:
+			// i.e. weight reserved for messages dispatch allows dispatch of non-trivial messages.
 			//
 			// Any significant change in this values should attract additional attention.
 			(782, 216_583_333_334),

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

@@ -18,9 +18,10 @@
 //! runtime that implements `<BridgedChainName>HeaderApi` to allow bridging with
 //! <BridgedName> chain.
 
-use crate::messages_lane::SubstrateMessageLane;
-use crate::messages_target::SubstrateMessagesReceivingProof;
-use crate::on_demand_headers::OnDemandHeadersRelay;
+use crate::{
+	messages_lane::SubstrateMessageLane, messages_target::SubstrateMessagesReceivingProof,
+	on_demand_headers::OnDemandHeadersRelay,
+};
 
 use async_trait::async_trait;
 use bp_messages::{LaneId, MessageNonce, UnrewardedRelayersState};
@@ -29,16 +30,17 @@ use bridge_runtime_common::messages::{
 };
 use codec::{Decode, Encode};
 use frame_support::weights::Weight;
-use messages_relay::message_lane::MessageLane;
 use messages_relay::{
-	message_lane::{SourceHeaderIdOf, TargetHeaderIdOf},
+	message_lane::{MessageLane, SourceHeaderIdOf, TargetHeaderIdOf},
 	message_lane_loop::{
-		ClientState, MessageDetails, MessageDetailsMap, MessageProofParameters, SourceClient, SourceClientState,
+		ClientState, MessageDetails, MessageDetailsMap, MessageProofParameters, SourceClient,
+		SourceClientState,
 	},
 };
 use num_traits::{Bounded, Zero};
 use relay_substrate_client::{
-	BalanceOf, BlockNumberOf, Chain, Client, Error as SubstrateError, HashOf, HeaderIdOf, HeaderOf, IndexOf,
+	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;
@@ -69,12 +71,7 @@ impl<P: SubstrateMessageLane> SubstrateMessagesSource<P> {
 		lane_id: LaneId,
 		target_to_source_headers_relay: Option<OnDemandHeadersRelay<P::TargetChain>>,
 	) -> Self {
-		SubstrateMessagesSource {
-			client,
-			lane,
-			lane_id,
-			target_to_source_headers_relay,
-		}
+		SubstrateMessagesSource { client, lane, lane_id, target_to_source_headers_relay }
 	}
 }
 
@@ -150,8 +147,8 @@ where
 				Some(id.1),
 			)
 			.await?;
-		let latest_generated_nonce: MessageNonce =
-			Decode::decode(&mut &encoded_response.0[..]).map_err(SubstrateError::ResponseParseFailed)?;
+		let latest_generated_nonce: MessageNonce = Decode::decode(&mut &encoded_response.0[..])
+			.map_err(SubstrateError::ResponseParseFailed)?;
 		Ok((id, latest_generated_nonce))
 	}
 
@@ -167,8 +164,8 @@ where
 				Some(id.1),
 			)
 			.await?;
-		let latest_received_nonce: MessageNonce =
-			Decode::decode(&mut &encoded_response.0[..]).map_err(SubstrateError::ResponseParseFailed)?;
+		let latest_received_nonce: MessageNonce = Decode::decode(&mut &encoded_response.0[..])
+			.map_err(SubstrateError::ResponseParseFailed)?;
 		Ok((id, latest_received_nonce))
 	}
 
@@ -176,7 +173,10 @@ where
 		&self,
 		id: SourceHeaderIdOf<P::MessageLane>,
 		nonces: RangeInclusive<MessageNonce>,
-	) -> Result<MessageDetailsMap<<P::MessageLane as MessageLane>::SourceChainBalance>, SubstrateError> {
+	) -> Result<
+		MessageDetailsMap<<P::MessageLane as MessageLane>::SourceChainBalance>,
+		SubstrateError,
+	> {
 		let encoded_response = self
 			.client
 			.state_call(
@@ -187,7 +187,8 @@ where
 			.await?;
 
 		make_message_details_map::<P::SourceChain>(
-			Decode::decode(&mut &encoded_response.0[..]).map_err(SubstrateError::ResponseParseFailed)?,
+			Decode::decode(&mut &encoded_response.0[..])
+				.map_err(SubstrateError::ResponseParseFailed)?,
 			nonces,
 		)
 	}
@@ -205,7 +206,8 @@ where
 		),
 		SubstrateError,
 	> {
-		let mut storage_keys = Vec::with_capacity(nonces.end().saturating_sub(*nonces.start()) as usize + 1);
+		let mut storage_keys =
+			Vec::with_capacity(nonces.end().saturating_sub(*nonces.start()) as usize + 1);
 		let mut message_nonce = *nonces.start();
 		while message_nonce <= *nonces.end() {
 			let message_key = pallet_bridge_messages::storage_keys::message_key(
@@ -223,12 +225,7 @@ where
 			));
 		}
 
-		let proof = self
-			.client
-			.prove_storage(storage_keys, id.1)
-			.await?
-			.iter_nodes()
-			.collect();
+		let proof = self.client.prove_storage(storage_keys, id.1).await?.iter_nodes().collect();
 		let proof = FromBridgedChainMessagesProof {
 			bridged_header_hash: id.1,
 			storage_proof: proof,
@@ -246,9 +243,16 @@ where
 	) -> Result<(), SubstrateError> {
 		let lane = self.lane.clone();
 		self.client
-			.submit_signed_extrinsic(self.lane.source_transactions_author(), move |_, transaction_nonce| {
-				lane.make_messages_receiving_proof_transaction(transaction_nonce, generated_at_block, proof)
-			})
+			.submit_signed_extrinsic(
+				self.lane.source_transactions_author(),
+				move |_, transaction_nonce| {
+					lane.make_messages_receiving_proof_transaction(
+						transaction_nonce,
+						generated_at_block,
+						proof,
+					)
+				},
+			)
 			.await?;
 		Ok(())
 	}
@@ -259,7 +263,9 @@ where
 		}
 	}
 
-	async fn estimate_confirmation_transaction(&self) -> <P::MessageLane as MessageLane>::SourceChainBalance {
+	async fn estimate_confirmation_transaction(
+		&self,
+	) -> <P::MessageLane as MessageLane>::SourceChainBalance {
 		self.client
 			.estimate_extrinsic_fee(self.lane.make_messages_receiving_proof_transaction(
 				Zero::zero(),
@@ -276,10 +282,14 @@ where
 ///
 /// We don't care about proof actually being the valid proof, because its validity doesn't
 /// affect the call weight - we only care about its size.
-fn prepare_dummy_messages_delivery_proof<SC: Chain, TC: Chain>() -> SubstrateMessagesReceivingProof<TC> {
-	let single_message_confirmation_size =
-		bp_messages::InboundLaneData::<()>::encoded_size_hint(SC::MAXIMAL_ENCODED_ACCOUNT_ID_SIZE, 1, 1)
-			.unwrap_or(u32::MAX);
+fn prepare_dummy_messages_delivery_proof<SC: Chain, TC: Chain>(
+) -> SubstrateMessagesReceivingProof<TC> {
+	let single_message_confirmation_size = bp_messages::InboundLaneData::<()>::encoded_size_hint(
+		SC::MAXIMAL_ENCODED_ACCOUNT_ID_SIZE,
+		1,
+		1,
+	)
+	.unwrap_or(u32::MAX);
 	let proof_size = TC::STORAGE_PROOF_OVERHEAD.saturating_add(single_message_confirmation_size);
 	(
 		UnrewardedRelayersState {
@@ -303,7 +313,10 @@ fn prepare_dummy_messages_delivery_proof<SC: Chain, TC: Chain>() -> SubstrateMes
 pub async fn read_client_state<SelfChain, BridgedHeaderHash, BridgedHeaderNumber>(
 	self_client: &Client<SelfChain>,
 	best_finalized_header_id_method_name: &str,
-) -> Result<ClientState<HeaderIdOf<SelfChain>, HeaderId<BridgedHeaderHash, BridgedHeaderNumber>>, SubstrateError>
+) -> Result<
+	ClientState<HeaderIdOf<SelfChain>, HeaderId<BridgedHeaderHash, BridgedHeaderNumber>>,
+	SubstrateError,
+>
 where
 	SelfChain: Chain,
 	SelfChain::Header: DeserializeOwned,
@@ -313,8 +326,10 @@ where
 {
 	// let's read our state first: we need best finalized header hash on **this** chain
 	let self_best_finalized_header_hash = self_client.best_finalized_header_hash().await?;
-	let self_best_finalized_header = self_client.header_by_hash(self_best_finalized_header_hash).await?;
-	let self_best_finalized_id = HeaderId(*self_best_finalized_header.number(), self_best_finalized_header_hash);
+	let self_best_finalized_header =
+		self_client.header_by_hash(self_best_finalized_header_hash).await?;
+	let self_best_finalized_id =
+		HeaderId(*self_best_finalized_header.number(), self_best_finalized_header_hash);
 
 	// now let's read our best header on **this** chain
 	let self_best_header = self_client.best_header().await?;
@@ -330,11 +345,10 @@ where
 		)
 		.await?;
 	let decoded_best_finalized_peer_on_self: (BridgedHeaderNumber, BridgedHeaderHash) =
-		Decode::decode(&mut &encoded_best_finalized_peer_on_self.0[..]).map_err(SubstrateError::ResponseParseFailed)?;
-	let peer_on_self_best_finalized_id = HeaderId(
-		decoded_best_finalized_peer_on_self.0,
-		decoded_best_finalized_peer_on_self.1,
-	);
+		Decode::decode(&mut &encoded_best_finalized_peer_on_self.0[..])
+			.map_err(SubstrateError::ResponseParseFailed)?;
+	let peer_on_self_best_finalized_id =
+		HeaderId(decoded_best_finalized_peer_on_self.0, decoded_best_finalized_peer_on_self.1);
 
 	Ok(ClientState {
 		best_self: self_best_id,
@@ -358,16 +372,14 @@ fn make_message_details_map<C: Chain>(
 
 	// this is actually prevented by external logic
 	if nonces.is_empty() {
-		return Ok(weights_map);
+		return Ok(weights_map)
 	}
 
 	// check if last nonce is missing - loop below is not checking this
-	let last_nonce_is_missing = weights
-		.last()
-		.map(|details| details.nonce != *nonces.end())
-		.unwrap_or(true);
+	let last_nonce_is_missing =
+		weights.last().map(|details| details.nonce != *nonces.end()).unwrap_or(true);
 	if last_nonce_is_missing {
-		return make_missing_nonce_error(*nonces.end());
+		return make_missing_nonce_error(*nonces.end())
 	}
 
 	let mut expected_nonce = *nonces.start();
@@ -379,20 +391,21 @@ fn make_message_details_map<C: Chain>(
 			(false, true) => {
 				// this may happen if some messages were already pruned from the source node
 				//
-				// this is not critical error and will be auto-resolved by messages lane (and target node)
+				// this is not critical error and will be auto-resolved by messages lane (and target
+				// node)
 				log::info!(
 					target: "bridge",
 					"Some messages are missing from the {} node: {:?}. Target node may be out of sync?",
 					C::NAME,
 					expected_nonce..details.nonce,
 				);
-			}
+			},
 			(false, false) => {
 				// some nonces are missing from the middle/tail of the range
 				//
 				// this is critical error, because we can't miss any nonces
-				return make_missing_nonce_error(expected_nonce);
-			}
+				return make_missing_nonce_error(expected_nonce)
+			},
 		}
 
 		weights_map.insert(
@@ -528,7 +541,8 @@ mod tests {
 
 	#[test]
 	fn prepare_dummy_messages_delivery_proof_works() {
-		let expected_minimal_size = Wococo::MAXIMAL_ENCODED_ACCOUNT_ID_SIZE + Rococo::STORAGE_PROOF_OVERHEAD;
+		let expected_minimal_size =
+			Wococo::MAXIMAL_ENCODED_ACCOUNT_ID_SIZE + Rococo::STORAGE_PROOF_OVERHEAD;
 		let dummy_proof = prepare_dummy_messages_delivery_proof::<Wococo, Rococo>();
 		assert!(
 			dummy_proof.1.encode().len() as u32 > expected_minimal_size,

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

@@ -18,9 +18,11 @@
 //! runtime that implements `<BridgedChainName>HeaderApi` to allow bridging with
 //! <BridgedName> chain.
 
-use crate::messages_lane::{StandaloneMessagesMetrics, SubstrateMessageLane};
-use crate::messages_source::{read_client_state, SubstrateMessagesProof};
-use crate::on_demand_headers::OnDemandHeadersRelay;
+use crate::{
+	messages_lane::{StandaloneMessagesMetrics, SubstrateMessageLane},
+	messages_source::{read_client_state, SubstrateMessagesProof},
+	on_demand_headers::OnDemandHeadersRelay,
+};
 
 use async_trait::async_trait;
 use bp_messages::{LaneId, MessageNonce, UnrewardedRelayersState};
@@ -30,14 +32,14 @@ use bridge_runtime_common::messages::{
 };
 use codec::{Decode, Encode};
 use frame_support::weights::{Weight, WeightToFeePolynomial};
-use messages_relay::message_lane::MessageLane;
 use messages_relay::{
-	message_lane::{SourceHeaderIdOf, TargetHeaderIdOf},
+	message_lane::{MessageLane, SourceHeaderIdOf, TargetHeaderIdOf},
 	message_lane_loop::{TargetClient, TargetClientState},
 };
 use num_traits::{Bounded, Zero};
 use relay_substrate_client::{
-	BalanceOf, BlockNumberOf, Chain, Client, Error as SubstrateError, HashOf, HeaderOf, IndexOf, WeightToFeeOf,
+	BalanceOf, BlockNumberOf, Chain, Client, Error as SubstrateError, HashOf, HeaderOf, IndexOf,
+	WeightToFeeOf,
 };
 use relay_utils::{relay_loop::Client as RelayClient, BlockNumberBase, HeaderId};
 use sp_core::Bytes;
@@ -45,10 +47,8 @@ use sp_runtime::{traits::Saturating, DeserializeOwned, FixedPointNumber, FixedU1
 use std::{convert::TryFrom, ops::RangeInclusive};
 
 /// Message receiving proof returned by the target Substrate node.
-pub type SubstrateMessagesReceivingProof<C> = (
-	UnrewardedRelayersState,
-	FromBridgedChainMessagesDeliveryProof<HashOf<C>>,
-);
+pub type SubstrateMessagesReceivingProof<C> =
+	(UnrewardedRelayersState, FromBridgedChainMessagesDeliveryProof<HashOf<C>>);
 
 /// Substrate client as Substrate messages target.
 pub struct SubstrateMessagesTarget<P: SubstrateMessageLane> {
@@ -150,8 +150,8 @@ where
 				Some(id.1),
 			)
 			.await?;
-		let latest_received_nonce: MessageNonce =
-			Decode::decode(&mut &encoded_response.0[..]).map_err(SubstrateError::ResponseParseFailed)?;
+		let latest_received_nonce: MessageNonce = Decode::decode(&mut &encoded_response.0[..])
+			.map_err(SubstrateError::ResponseParseFailed)?;
 		Ok((id, latest_received_nonce))
 	}
 
@@ -167,8 +167,8 @@ where
 				Some(id.1),
 			)
 			.await?;
-		let latest_received_nonce: MessageNonce =
-			Decode::decode(&mut &encoded_response.0[..]).map_err(SubstrateError::ResponseParseFailed)?;
+		let latest_received_nonce: MessageNonce = Decode::decode(&mut &encoded_response.0[..])
+			.map_err(SubstrateError::ResponseParseFailed)?;
 		Ok((id, latest_received_nonce))
 	}
 
@@ -185,7 +185,8 @@ where
 			)
 			.await?;
 		let unrewarded_relayers_state: UnrewardedRelayersState =
-			Decode::decode(&mut &encoded_response.0[..]).map_err(SubstrateError::ResponseParseFailed)?;
+			Decode::decode(&mut &encoded_response.0[..])
+				.map_err(SubstrateError::ResponseParseFailed)?;
 		Ok((id, unrewarded_relayers_state))
 	}
 
@@ -193,10 +194,7 @@ where
 		&self,
 		id: TargetHeaderIdOf<P::MessageLane>,
 	) -> Result<
-		(
-			TargetHeaderIdOf<P::MessageLane>,
-			<P::MessageLane as MessageLane>::MessagesReceivingProof,
-		),
+		(TargetHeaderIdOf<P::MessageLane>, <P::MessageLane as MessageLane>::MessagesReceivingProof),
 		SubstrateError,
 	> {
 		let (id, relayers_state) = self.unrewarded_relayers_state(id).await?;
@@ -227,9 +225,17 @@ where
 		let lane = self.lane.clone();
 		let nonces_clone = nonces.clone();
 		self.client
-			.submit_signed_extrinsic(self.lane.target_transactions_author(), move |_, transaction_nonce| {
-				lane.make_messages_delivery_transaction(transaction_nonce, generated_at_header, nonces_clone, proof)
-			})
+			.submit_signed_extrinsic(
+				self.lane.target_transactions_author(),
+				move |_, transaction_nonce| {
+					lane.make_messages_delivery_transaction(
+						transaction_nonce,
+						generated_at_header,
+						nonces_clone,
+						proof,
+					)
+				},
+			)
 			.await?;
 		Ok(nonces)
 	}
@@ -247,11 +253,8 @@ where
 		total_dispatch_weight: Weight,
 		total_size: u32,
 	) -> Result<<P::MessageLane as MessageLane>::SourceChainBalance, SubstrateError> {
-		let conversion_rate = self
-			.metric_values
-			.target_to_source_conversion_rate()
-			.await
-			.ok_or_else(|| {
+		let conversion_rate =
+			self.metric_values.target_to_source_conversion_rate().await.ok_or_else(|| {
 				SubstrateError::Custom(format!(
 					"Failed to compute conversion rate from {} to {}",
 					P::TargetChain::NAME,
@@ -264,26 +267,31 @@ where
 			Zero::zero(),
 			HeaderId(Default::default(), Default::default()),
 			nonces.clone(),
-			prepare_dummy_messages_proof::<P::SourceChain>(nonces.clone(), total_dispatch_weight, total_size),
+			prepare_dummy_messages_proof::<P::SourceChain>(
+				nonces.clone(),
+				total_dispatch_weight,
+				total_size,
+			),
 		);
 		let delivery_tx_fee = self.client.estimate_extrinsic_fee(delivery_tx).await?;
 		let inclusion_fee_in_target_tokens = delivery_tx_fee.inclusion_fee();
 
-		// The pre-dispatch cost of delivery transaction includes additional fee to cover dispatch fee payment
-		// (Currency::transfer in regular deployment). But if message dispatch has already been paid
-		// at the Source chain, the delivery transaction will refund relayer with this additional cost.
-		// But `estimate_extrinsic_fee` obviously just returns pre-dispatch cost of the transaction. So
-		// if transaction delivers prepaid message, then it may happen that pre-dispatch cost is larger
-		// than reward and `Rational` relayer will refuse to deliver this message.
+		// The pre-dispatch cost of delivery transaction includes additional fee to cover dispatch
+		// fee payment (Currency::transfer in regular deployment). But if message dispatch has
+		// already been paid at the Source chain, the delivery transaction will refund relayer with
+		// this additional cost. But `estimate_extrinsic_fee` obviously just returns pre-dispatch
+		// cost of the transaction. So if transaction delivers prepaid message, then it may happen
+		// that pre-dispatch cost is larger than reward and `Rational` relayer will refuse to
+		// deliver this message.
 		//
-		// The most obvious solution would be to deduct total weight of dispatch fee payments from the
-		// `total_dispatch_weight` and use regular `estimate_extrinsic_fee` call. But what if
-		// `total_dispatch_weight` is less than total dispatch fee payments weight? Weight is strictly
-		// positive, so we can't use this option.
+		// The most obvious solution would be to deduct total weight of dispatch fee payments from
+		// the `total_dispatch_weight` and use regular `estimate_extrinsic_fee` call. But what if
+		// `total_dispatch_weight` is less than total dispatch fee payments weight? Weight is
+		// strictly positive, so we can't use this option.
 		//
-		// Instead we'll be directly using `WeightToFee` and `NextFeeMultiplier` of the Target chain.
-		// This requires more knowledge of the Target chain, but seems there's no better way to solve
-		// this now.
+		// Instead we'll be directly using `WeightToFee` and `NextFeeMultiplier` of the Target
+		// chain. This requires more knowledge of the Target chain, but seems there's no better way
+		// to solve this now.
 		let expected_refund_in_target_tokens = if total_prepaid_nonces != 0 {
 			const WEIGHT_DIFFERENCE: Weight = 100;
 
@@ -294,7 +302,11 @@ where
 					Zero::zero(),
 					HeaderId(Default::default(), Default::default()),
 					nonces.clone(),
-					prepare_dummy_messages_proof::<P::SourceChain>(nonces.clone(), larger_dispatch_weight, total_size),
+					prepare_dummy_messages_proof::<P::SourceChain>(
+						nonces.clone(),
+						larger_dispatch_weight,
+						total_size,
+					),
 				))
 				.await?;
 
@@ -311,10 +323,11 @@ where
 			Zero::zero()
 		};
 
-		let delivery_fee_in_source_tokens = convert_target_tokens_to_source_tokens::<P::SourceChain, P::TargetChain>(
-			FixedU128::from_float(conversion_rate),
-			inclusion_fee_in_target_tokens.saturating_sub(expected_refund_in_target_tokens),
-		);
+		let delivery_fee_in_source_tokens =
+			convert_target_tokens_to_source_tokens::<P::SourceChain, P::TargetChain>(
+				FixedU128::from_float(conversion_rate),
+				inclusion_fee_in_target_tokens.saturating_sub(expected_refund_in_target_tokens),
+			);
 
 		log::trace!(
 			target: "bridge",
@@ -356,7 +369,10 @@ fn prepare_dummy_messages_proof<SC: Chain>(
 		total_dispatch_weight,
 		FromBridgedChainMessagesProof {
 			bridged_header_hash: Default::default(),
-			storage_proof: vec![vec![0; SC::STORAGE_PROOF_OVERHEAD.saturating_add(total_size) as usize]],
+			storage_proof: vec![vec![
+				0;
+				SC::STORAGE_PROOF_OVERHEAD.saturating_add(total_size) as usize
+			]],
 			lane: Default::default(),
 			nonces_start: *nonces.start(),
 			nonces_end: *nonces.end(),
@@ -373,8 +389,10 @@ fn convert_target_tokens_to_source_tokens<SC: Chain, TC: Chain>(
 where
 	SC::Balance: TryFrom<TC::Balance>,
 {
-	SC::Balance::try_from(target_to_source_conversion_rate.saturating_mul_int(target_transaction_fee))
-		.unwrap_or_else(|_| SC::Balance::max_value())
+	SC::Balance::try_from(
+		target_to_source_conversion_rate.saturating_mul_int(target_transaction_fee),
+	)
+	.unwrap_or_else(|_| SC::Balance::max_value())
 }
 
 /// Compute fee multiplier that is used by the chain, given a couple of fees for transactions
@@ -392,7 +410,8 @@ fn compute_fee_multiplier<C: Chain>(
 	larger_adjusted_weight_fee: BalanceOf<C>,
 	larger_tx_weight: Weight,
 ) -> FixedU128 {
-	let adjusted_weight_fee_difference = larger_adjusted_weight_fee.saturating_sub(smaller_adjusted_weight_fee);
+	let adjusted_weight_fee_difference =
+		larger_adjusted_weight_fee.saturating_sub(smaller_adjusted_weight_fee);
 	let smaller_tx_unadjusted_weight_fee = WeightToFeeOf::<C>::calc(&smaller_tx_weight);
 	let larger_tx_unadjusted_weight_fee = WeightToFeeOf::<C>::calc(&larger_tx_weight);
 	FixedU128::saturating_from_rational(
@@ -511,10 +530,12 @@ mod tests {
 		let multiplier = FixedU128::saturating_from_rational(1, 1000);
 
 		let smaller_weight = 1_000_000;
-		let smaller_adjusted_weight_fee = multiplier.saturating_mul_int(WeightToFeeOf::<Rococo>::calc(&smaller_weight));
+		let smaller_adjusted_weight_fee =
+			multiplier.saturating_mul_int(WeightToFeeOf::<Rococo>::calc(&smaller_weight));
 
 		let larger_weight = smaller_weight + 200_000;
-		let larger_adjusted_weight_fee = multiplier.saturating_mul_int(WeightToFeeOf::<Rococo>::calc(&larger_weight));
+		let larger_adjusted_weight_fee =
+			multiplier.saturating_mul_int(WeightToFeeOf::<Rococo>::calc(&larger_weight));
 
 		assert_eq!(
 			compute_fee_multiplier::<Rococo>(
@@ -533,7 +554,8 @@ mod tests {
 			compute_prepaid_messages_refund::<TestSubstrateMessageLane>(
 				10,
 				FixedU128::saturating_from_rational(110, 100),
-			) > (10 * TestSubstrateMessageLane::PAY_INBOUND_DISPATCH_FEE_WEIGHT_AT_TARGET_CHAIN).into()
+			) > (10 * TestSubstrateMessageLane::PAY_INBOUND_DISPATCH_FEE_WEIGHT_AT_TARGET_CHAIN)
+				.into()
 		);
 	}
 }

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

@@ -31,18 +31,23 @@ use relay_substrate_client::{
 	Chain, Client, HeaderIdOf, SyncHeader,
 };
 use relay_utils::{
-	metrics::MetricsParams, relay_loop::Client as RelayClient, BlockNumberBase, FailedClient, MaybeConnectionError,
+	metrics::MetricsParams, relay_loop::Client as RelayClient, BlockNumberBase, FailedClient,
+	MaybeConnectionError,
 };
 
-use crate::finality_pipeline::{
-	SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate, RECENT_FINALITY_PROOFS_LIMIT, STALL_TIMEOUT,
+use crate::{
+	finality_pipeline::{
+		SubstrateFinalitySyncPipeline, SubstrateFinalityToSubstrate, RECENT_FINALITY_PROOFS_LIMIT,
+		STALL_TIMEOUT,
+	},
+	finality_target::SubstrateFinalityTarget,
 };
-use crate::finality_target::SubstrateFinalityTarget;
 
 /// On-demand Substrate <-> Substrate headers relay.
 ///
-/// This relay may be requested to sync more headers, whenever some other relay (e.g. messages relay) needs
-/// it to continue its regular work. When enough headers are relayed, on-demand stops syncing headers.
+/// This relay may be requested to sync more headers, whenever some other relay (e.g. messages
+/// relay) needs it to continue its regular work. When enough headers are relayed, on-demand stops
+/// syncing headers.
 #[derive(Clone)]
 pub struct OnDemandHeadersRelay<SourceChain: Chain> {
 	/// Relay task name.
@@ -68,7 +73,11 @@ impl<SourceChain: Chain> OnDemandHeadersRelay<SourceChain> {
 		TargetChain::BlockNumber: BlockNumberBase,
 		TargetSign: Clone + Send + Sync + 'static,
 		P: SubstrateFinalitySyncPipeline<
-			FinalitySyncPipeline = SubstrateFinalityToSubstrate<SourceChain, TargetChain, TargetSign>,
+			FinalitySyncPipeline = SubstrateFinalityToSubstrate<
+				SourceChain,
+				TargetChain,
+				TargetSign,
+			>,
 			TargetChain = TargetChain,
 		>,
 	{
@@ -135,8 +144,11 @@ async fn background_task<SourceChain, TargetChain, TargetSign, P>(
 		_,
 		SubstrateFinalityToSubstrate<SourceChain, TargetChain, TargetSign>,
 	>::new(source_client.clone(), Some(required_header_number.clone()));
-	let mut finality_target =
-		SubstrateFinalityTarget::new(target_client.clone(), pipeline.clone(), target_transactions_mortality);
+	let mut finality_target = SubstrateFinalityTarget::new(
+		target_client.clone(),
+		pipeline.clone(),
+		target_transactions_mortality,
+	);
 	let mut latest_non_mandatory_at_source = Zero::zero();
 
 	let mut restart_relay = true;
@@ -163,12 +175,16 @@ async fn background_task<SourceChain, TargetChain, TargetSign, P>(
 				&mut finality_target,
 			)
 			.await;
-			continue;
+			continue
 		}
 
 		// read best finalized source header number from target
-		let best_finalized_source_header_at_target =
-			best_finalized_source_header_at_target::<SourceChain, _, _>(&finality_target, &relay_task_name).await;
+		let best_finalized_source_header_at_target = best_finalized_source_header_at_target::<
+			SourceChain,
+			_,
+			_,
+		>(&finality_target, &relay_task_name)
+		.await;
 		if matches!(best_finalized_source_header_at_target, Err(ref e) if e.is_connection_error()) {
 			relay_utils::relay_loop::reconnect_failed_client(
 				FailedClient::Target,
@@ -177,11 +193,12 @@ async fn background_task<SourceChain, TargetChain, TargetSign, P>(
 				&mut finality_target,
 			)
 			.await;
-			continue;
+			continue
 		}
 
 		// submit mandatory header if some headers are missing
-		let best_finalized_source_header_at_target_fmt = format!("{:?}", best_finalized_source_header_at_target);
+		let best_finalized_source_header_at_target_fmt =
+			format!("{:?}", best_finalized_source_header_at_target);
 		let mandatory_scan_range = mandatory_headers_scan_range::<SourceChain>(
 			best_finalized_source_header_at_source.ok(),
 			best_finalized_source_header_at_target.ok(),
@@ -207,8 +224,8 @@ async fn background_task<SourceChain, TargetChain, TargetSign, P>(
 					// there are no (or we don't need to relay them) mandatory headers in the range
 					// => to avoid scanning the same headers over and over again, remember that
 					latest_non_mandatory_at_source = mandatory_scan_range.1;
-				}
-				Err(e) => {
+				},
+				Err(e) =>
 					if e.is_connection_error() {
 						relay_utils::relay_loop::reconnect_failed_client(
 							FailedClient::Source,
@@ -217,9 +234,8 @@ async fn background_task<SourceChain, TargetChain, TargetSign, P>(
 							&mut finality_target,
 						)
 						.await;
-						continue;
-					}
-				}
+						continue
+					},
 			}
 		}
 
@@ -230,7 +246,10 @@ async fn background_task<SourceChain, TargetChain, TargetSign, P>(
 					finality_source.clone(),
 					finality_target.clone(),
 					FinalitySyncParams {
-						tick: std::cmp::max(SourceChain::AVERAGE_BLOCK_INTERVAL, TargetChain::AVERAGE_BLOCK_INTERVAL),
+						tick: std::cmp::max(
+							SourceChain::AVERAGE_BLOCK_INTERVAL,
+							TargetChain::AVERAGE_BLOCK_INTERVAL,
+						),
 						recent_finality_proofs_limit: RECENT_FINALITY_PROOFS_LIMIT,
 						stall_timeout: STALL_TIMEOUT,
 						only_mandatory_headers,
@@ -279,12 +298,12 @@ async fn mandatory_headers_scan_range<C: Chain>(
 		.checked_sub(&best_finalized_source_header_at_target)
 		.unwrap_or_else(Zero::zero);
 	if current_headers_difference <= maximal_headers_difference {
-		return None;
+		return None
 	}
 
 	// if relay is already asked to sync headers, don't do anything yet
 	if required_header_number > best_finalized_source_header_at_target {
-		return None;
+		return None
 	}
 
 	Some((
@@ -293,7 +312,8 @@ async fn mandatory_headers_scan_range<C: Chain>(
 	))
 }
 
-/// Try to find mandatory header in the inclusive headers range and, if one is found, ask to relay it.
+/// Try to find mandatory header in the inclusive headers range and, if one is found, ask to relay
+/// it.
 ///
 /// Returns `true` if header was found and (asked to be) relayed and `false` otherwise.
 async fn relay_mandatory_header_from_range<SourceChain: Chain, P>(
@@ -308,7 +328,8 @@ where
 	P: FinalitySyncPipeline<Number = SourceChain::BlockNumber>,
 {
 	// search for mandatory header first
-	let mandatory_source_header_number = find_mandatory_header_in_range(finality_source, range).await?;
+	let mandatory_source_header_number =
+		find_mandatory_header_in_range(finality_source, range).await?;
 
 	// if there are no mandatory headers - we have nothing to do
 	let mandatory_source_header_number = match mandatory_source_header_number {
@@ -320,7 +341,7 @@ where
 	// less than our `mandatory_source_header_number` before logging anything
 	let mut required_header_number = required_header_number.lock().await;
 	if *required_header_number >= mandatory_source_header_number {
-		return Ok(false);
+		return Ok(false)
 	}
 
 	log::trace!(
@@ -348,19 +369,16 @@ where
 	SubstrateFinalitySource<SourceChain, P>: FinalitySourceClient<P>,
 	P: FinalitySyncPipeline<Number = SourceChain::BlockNumber>,
 {
-	finality_source
-		.on_chain_best_finalized_block_number()
-		.await
-		.map_err(|error| {
-			log::error!(
-				target: "bridge",
-				"Failed to read best finalized source header from source in {} relay: {:?}",
-				relay_task_name,
-				error,
-			);
+	finality_source.on_chain_best_finalized_block_number().await.map_err(|error| {
+		log::error!(
+			target: "bridge",
+			"Failed to read best finalized source header from source in {} relay: {:?}",
+			relay_task_name,
+			error,
+		);
 
-			error
-		})
+		error
+	})
 }
 
 /// Read best finalized source block number from target client.
@@ -375,19 +393,16 @@ where
 	P: SubstrateFinalitySyncPipeline,
 	P::FinalitySyncPipeline: FinalitySyncPipeline<Number = SourceChain::BlockNumber>,
 {
-	finality_target
-		.best_finalized_source_block_number()
-		.await
-		.map_err(|error| {
-			log::error!(
-				target: "bridge",
-				"Failed to read best finalized source header from target in {} relay: {:?}",
-				relay_task_name,
-				error,
-			);
+	finality_target.best_finalized_source_block_number().await.map_err(|error| {
+		log::error!(
+			target: "bridge",
+			"Failed to read best finalized source header from target in {} relay: {:?}",
+			relay_task_name,
+			error,
+		);
 
-			error
-		})
+		error
+	})
 }
 
 /// Read first mandatory header in given inclusive range.
@@ -403,9 +418,10 @@ where
 {
 	let mut current = range.0;
 	while current <= range.1 {
-		let header: SyncHeader<SourceChain::Header> = finality_source.client().header_by_number(current).await?.into();
+		let header: SyncHeader<SourceChain::Header> =
+			finality_source.client().header_by_number(current).await?.into();
 		if header.is_mandatory() {
-			return Ok(Some(current));
+			return Ok(Some(current))
 		}
 
 		current += One::one();
@@ -431,7 +447,13 @@ mod tests {
 	#[async_std::test]
 	async fn mandatory_headers_scan_range_selects_range_if_too_many_headers_are_missing() {
 		assert_eq!(
-			mandatory_headers_scan_range::<TestChain>(AT_SOURCE, AT_TARGET, 5, &Arc::new(Mutex::new(0))).await,
+			mandatory_headers_scan_range::<TestChain>(
+				AT_SOURCE,
+				AT_TARGET,
+				5,
+				&Arc::new(Mutex::new(0))
+			)
+			.await,
 			Some((AT_TARGET.unwrap() + 1, AT_SOURCE.unwrap())),
 		);
 	}
@@ -439,7 +461,13 @@ mod tests {
 	#[async_std::test]
 	async fn mandatory_headers_scan_range_selects_nothing_if_enough_headers_are_relayed() {
 		assert_eq!(
-			mandatory_headers_scan_range::<TestChain>(AT_SOURCE, AT_TARGET, 10, &Arc::new(Mutex::new(0))).await,
+			mandatory_headers_scan_range::<TestChain>(
+				AT_SOURCE,
+				AT_TARGET,
+				10,
+				&Arc::new(Mutex::new(0))
+			)
+			.await,
 			None,
 		);
 	}