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/client-substrate/src/chain.rs

@@ -92,11 +92,7 @@ pub struct UnsignedTransaction<C: Chain> {
 impl<C: Chain> UnsignedTransaction<C> {
 	/// Create new unsigned transaction with given call, nonce and zero tip.
 	pub fn new(call: C::Call, nonce: C::Index) -> Self {
-		Self {
-			call,
-			nonce,
-			tip: Zero::zero(),
-		}
+		Self { call, nonce, tip: Zero::zero() }
 	}
 
 	/// Set transaction tip.

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

@@ -16,17 +16,21 @@
 
 //! Substrate node client.
 
-use crate::chain::{Chain, ChainWithBalances, TransactionStatusOf};
-use crate::rpc::Substrate;
-use crate::{ConnectionParams, Error, HashOf, HeaderIdOf, Result};
+use crate::{
+	chain::{Chain, ChainWithBalances, TransactionStatusOf},
+	rpc::Substrate,
+	ConnectionParams, Error, HashOf, HeaderIdOf, Result,
+};
 
 use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
 use codec::{Decode, Encode};
 use frame_system::AccountInfo;
 use futures::{SinkExt, StreamExt};
-use jsonrpsee_ws_client::{traits::SubscriptionClient, v2::params::JsonRpcParams, DeserializeOwned};
-use jsonrpsee_ws_client::{WsClient as RpcClient, WsClientBuilder as RpcClientBuilder};
+use jsonrpsee_ws_client::{
+	traits::SubscriptionClient, v2::params::JsonRpcParams, DeserializeOwned, WsClient as RpcClient,
+	WsClientBuilder as RpcClientBuilder,
+};
 use num_traits::{Bounded, Zero};
 use pallet_balances::AccountData;
 use pallet_transaction_payment::InclusionFee;
@@ -62,9 +66,10 @@ pub struct Client<C: Chain> {
 	client: Arc<RpcClient>,
 	/// Genesis block hash.
 	genesis_hash: HashOf<C>,
-	/// If several tasks are submitting their transactions simultaneously using `submit_signed_extrinsic`
-	/// method, they may get the same transaction nonce. So one of transactions will be rejected
-	/// from the pool. This lock is here to prevent situations like that.
+	/// If several tasks are submitting their transactions simultaneously using
+	/// `submit_signed_extrinsic` method, they may get the same transaction nonce. So one of
+	/// transactions will be rejected from the pool. This lock is here to prevent situations like
+	/// that.
 	submit_signed_extrinsic_lock: Arc<Mutex<()>>,
 }
 
@@ -94,9 +99,7 @@ impl<C: Chain> Clone for Client<C> {
 
 impl<C: Chain> std::fmt::Debug for Client<C> {
 	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
-		fmt.debug_struct("Client")
-			.field("genesis_hash", &self.genesis_hash)
-			.finish()
+		fmt.debug_struct("Client").field("genesis_hash", &self.genesis_hash).finish()
 	}
 }
 
@@ -130,7 +133,9 @@ impl<C: Chain> Client<C> {
 		let number: C::BlockNumber = Zero::zero();
 		let genesis_hash_client = client.clone();
 		let genesis_hash = tokio
-			.spawn(async move { Substrate::<C>::chain_get_block_hash(&*genesis_hash_client, number).await })
+			.spawn(async move {
+				Substrate::<C>::chain_get_block_hash(&*genesis_hash_client, number).await
+			})
 			.await??;
 
 		Ok(Self {
@@ -143,7 +148,9 @@ impl<C: Chain> Client<C> {
 	}
 
 	/// Build client to use in connection.
-	async fn build_client(params: ConnectionParams) -> Result<(Arc<tokio::runtime::Runtime>, Arc<RpcClient>)> {
+	async fn build_client(
+		params: ConnectionParams,
+	) -> Result<(Arc<tokio::runtime::Runtime>, Arc<RpcClient>)> {
 		let tokio = tokio::runtime::Runtime::new()?;
 		let uri = format!(
 			"{}://{}:{}",
@@ -186,16 +193,15 @@ impl<C: Chain> Client<C> {
 
 	/// Return hash of the best finalized block.
 	pub async fn best_finalized_header_hash(&self) -> Result<C::Hash> {
-		self.jsonrpsee_execute(|client| async move { Ok(Substrate::<C>::chain_get_finalized_head(&*client).await?) })
-			.await
+		self.jsonrpsee_execute(|client| async move {
+			Ok(Substrate::<C>::chain_get_finalized_head(&*client).await?)
+		})
+		.await
 	}
 
 	/// Return number of the best finalized block.
 	pub async fn best_finalized_header_number(&self) -> Result<C::BlockNumber> {
-		Ok(*self
-			.header_by_hash(self.best_finalized_header_hash().await?)
-			.await?
-			.number())
+		Ok(*self.header_by_hash(self.best_finalized_header_hash().await?).await?.number())
 	}
 
 	/// Returns the best Substrate header.
@@ -203,15 +209,17 @@ impl<C: Chain> Client<C> {
 	where
 		C::Header: DeserializeOwned,
 	{
-		self.jsonrpsee_execute(|client| async move { Ok(Substrate::<C>::chain_get_header(&*client, None).await?) })
-			.await
+		self.jsonrpsee_execute(|client| async move {
+			Ok(Substrate::<C>::chain_get_header(&*client, None).await?)
+		})
+		.await
 	}
 
 	/// Get a Substrate block from its hash.
 	pub async fn get_block(&self, block_hash: Option<C::Hash>) -> Result<C::SignedBlock> {
-		self.jsonrpsee_execute(
-			move |client| async move { Ok(Substrate::<C>::chain_get_block(&*client, block_hash).await?) },
-		)
+		self.jsonrpsee_execute(move |client| async move {
+			Ok(Substrate::<C>::chain_get_block(&*client, block_hash).await?)
+		})
 		.await
 	}
 
@@ -246,8 +254,10 @@ impl<C: Chain> Client<C> {
 
 	/// Return runtime version.
 	pub async fn runtime_version(&self) -> Result<RuntimeVersion> {
-		self.jsonrpsee_execute(move |client| async move { Ok(Substrate::<C>::state_runtime_version(&*client).await?) })
-			.await
+		self.jsonrpsee_execute(move |client| async move {
+			Ok(Substrate::<C>::state_runtime_version(&*client).await?)
+		})
+		.await
 	}
 
 	/// Read value from runtime storage.
@@ -259,7 +269,9 @@ impl<C: Chain> Client<C> {
 		self.jsonrpsee_execute(move |client| async move {
 			Substrate::<C>::state_get_storage(&*client, storage_key, block_hash)
 				.await?
-				.map(|encoded_value| T::decode(&mut &encoded_value.0[..]).map_err(Error::ResponseParseFailed))
+				.map(|encoded_value| {
+					T::decode(&mut &encoded_value.0[..]).map_err(Error::ResponseParseFailed)
+				})
 				.transpose()
 		})
 		.await
@@ -272,12 +284,14 @@ impl<C: Chain> Client<C> {
 	{
 		self.jsonrpsee_execute(move |client| async move {
 			let storage_key = C::account_info_storage_key(&account);
-			let encoded_account_data = Substrate::<C>::state_get_storage(&*client, storage_key, None)
-				.await?
-				.ok_or(Error::AccountDoesNotExist)?;
-			let decoded_account_data =
-				AccountInfo::<C::Index, AccountData<C::Balance>>::decode(&mut &encoded_account_data.0[..])
-					.map_err(Error::ResponseParseFailed)?;
+			let encoded_account_data =
+				Substrate::<C>::state_get_storage(&*client, storage_key, None)
+					.await?
+					.ok_or(Error::AccountDoesNotExist)?;
+			let decoded_account_data = AccountInfo::<C::Index, AccountData<C::Balance>>::decode(
+				&mut &encoded_account_data.0[..],
+			)
+			.map_err(Error::ResponseParseFailed)?;
 			Ok(decoded_account_data.data.free)
 		})
 		.await
@@ -348,9 +362,8 @@ impl<C: Chain> Client<C> {
 				let subscription = client
 					.subscribe(
 						"author_submitAndWatchExtrinsic",
-						JsonRpcParams::Array(vec![
-							jsonrpsee_types::to_json_value(extrinsic).map_err(|e| Error::RpcError(e.into()))?
-						]),
+						JsonRpcParams::Array(vec![jsonrpsee_types::to_json_value(extrinsic)
+							.map_err(|e| Error::RpcError(e.into()))?]),
 						"author_unwatchExtrinsic",
 					)
 					.await?;
@@ -370,9 +383,9 @@ impl<C: Chain> Client<C> {
 
 	/// Returns pending extrinsics from transaction pool.
 	pub async fn pending_extrinsics(&self) -> Result<Vec<Bytes>> {
-		self.jsonrpsee_execute(
-			move |client| async move { Ok(Substrate::<C>::author_pending_extrinsics(&*client).await?) },
-		)
+		self.jsonrpsee_execute(move |client| async move {
+			Ok(Substrate::<C>::author_pending_extrinsics(&*client).await?)
+		})
 		.await
 	}
 
@@ -386,9 +399,10 @@ impl<C: Chain> Client<C> {
 			let call = SUB_API_TXPOOL_VALIDATE_TRANSACTION.to_string();
 			let data = Bytes((TransactionSource::External, transaction, at_block).encode());
 
-			let encoded_response = Substrate::<C>::state_call(&*client, call, data, Some(at_block)).await?;
-			let validity =
-				TransactionValidity::decode(&mut &encoded_response.0[..]).map_err(Error::ResponseParseFailed)?;
+			let encoded_response =
+				Substrate::<C>::state_call(&*client, call, data, Some(at_block)).await?;
+			let validity = TransactionValidity::decode(&mut &encoded_response.0[..])
+				.map_err(Error::ResponseParseFailed)?;
 
 			Ok(validity)
 		})
@@ -396,9 +410,13 @@ impl<C: Chain> Client<C> {
 	}
 
 	/// Estimate fee that will be spent on given extrinsic.
-	pub async fn estimate_extrinsic_fee(&self, transaction: Bytes) -> Result<InclusionFee<C::Balance>> {
+	pub async fn estimate_extrinsic_fee(
+		&self,
+		transaction: Bytes,
+	) -> Result<InclusionFee<C::Balance>> {
 		self.jsonrpsee_execute(move |client| async move {
-			let fee_details = Substrate::<C>::payment_query_fee_details(&*client, transaction, None).await?;
+			let fee_details =
+				Substrate::<C>::payment_query_fee_details(&*client, transaction, None).await?;
 			let inclusion_fee = fee_details
 				.inclusion_fee
 				.map(|inclusion_fee| InclusionFee {
@@ -406,8 +424,10 @@ impl<C: Chain> Client<C> {
 						.unwrap_or_else(|_| C::Balance::max_value()),
 					len_fee: C::Balance::try_from(inclusion_fee.len_fee.into_u256())
 						.unwrap_or_else(|_| C::Balance::max_value()),
-					adjusted_weight_fee: C::Balance::try_from(inclusion_fee.adjusted_weight_fee.into_u256())
-						.unwrap_or_else(|_| C::Balance::max_value()),
+					adjusted_weight_fee: C::Balance::try_from(
+						inclusion_fee.adjusted_weight_fee.into_u256(),
+					)
+					.unwrap_or_else(|_| C::Balance::max_value()),
 				})
 				.unwrap_or_else(|| InclusionFee {
 					base_fee: Zero::zero(),
@@ -420,12 +440,16 @@ impl<C: Chain> Client<C> {
 	}
 
 	/// Get the GRANDPA authority set at given block.
-	pub async fn grandpa_authorities_set(&self, block: C::Hash) -> Result<OpaqueGrandpaAuthoritiesSet> {
+	pub async fn grandpa_authorities_set(
+		&self,
+		block: C::Hash,
+	) -> Result<OpaqueGrandpaAuthoritiesSet> {
 		self.jsonrpsee_execute(move |client| async move {
 			let call = SUB_API_GRANDPA_AUTHORITIES.to_string();
 			let data = Bytes(Vec::new());
 
-			let encoded_response = Substrate::<C>::state_call(&*client, call, data, Some(block)).await?;
+			let encoded_response =
+				Substrate::<C>::state_call(&*client, call, data, Some(block)).await?;
 			let authority_list = encoded_response.0;
 
 			Ok(authority_list)
@@ -434,7 +458,12 @@ impl<C: Chain> Client<C> {
 	}
 
 	/// Execute runtime call at given block.
-	pub async fn state_call(&self, method: String, data: Bytes, at_block: Option<C::Hash>) -> Result<Bytes> {
+	pub async fn state_call(
+		&self,
+		method: String,
+		data: Bytes,
+		at_block: Option<C::Hash>,
+	) -> Result<Bytes> {
 		self.jsonrpsee_execute(move |client| async move {
 			Substrate::<C>::state_call(&*client, method, data, at_block)
 				.await
@@ -444,7 +473,11 @@ impl<C: Chain> Client<C> {
 	}
 
 	/// Returns storage proof of given storage keys.
-	pub async fn prove_storage(&self, keys: Vec<StorageKey>, at_block: C::Hash) -> Result<StorageProof> {
+	pub async fn prove_storage(
+		&self,
+		keys: Vec<StorageKey>,
+		at_block: C::Hash,
+	) -> Result<StorageProof> {
 		self.jsonrpsee_execute(move |client| async move {
 			Substrate::<C>::state_prove_storage(&*client, keys, Some(at_block))
 				.await
@@ -485,9 +518,7 @@ impl<C: Chain> Client<C> {
 		T: Send + 'static,
 	{
 		let client = self.client.clone();
-		self.tokio
-			.spawn(async move { make_jsonrpsee_future(client).await })
-			.await?
+		self.tokio.spawn(async move { make_jsonrpsee_future(client).await }).await?
 	}
 }
 
@@ -508,11 +539,10 @@ impl<T: DeserializeOwned> Subscription<T> {
 	) {
 		loop {
 			match subscription.next().await {
-				Ok(Some(item)) => {
+				Ok(Some(item)) =>
 					if sender.send(Some(item)).await.is_err() {
-						break;
-					}
-				}
+						break
+					},
 				Ok(None) => {
 					log::trace!(
 						target: "bridge",
@@ -521,8 +551,8 @@ impl<T: DeserializeOwned> Subscription<T> {
 						item_type,
 					);
 					let _ = sender.send(None).await;
-					break;
-				}
+					break
+				},
 				Err(e) => {
 					log::trace!(
 						target: "bridge",
@@ -532,8 +562,8 @@ impl<T: DeserializeOwned> Subscription<T> {
 						e,
 					);
 					let _ = sender.send(None).await;
-					break;
-				}
+					break
+				},
 			}
 		}
 	}

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

@@ -96,10 +96,10 @@ impl MaybeConnectionError for Error {
 	fn is_connection_error(&self) -> bool {
 		matches!(
 			*self,
-			Error::RpcError(RpcError::Transport(_))
-				| Error::RpcError(RpcError::Internal(_))
-				| Error::RpcError(RpcError::RestartNeeded(_))
-				| Error::ClientNotSynced(_),
+			Error::RpcError(RpcError::Transport(_)) |
+				Error::RpcError(RpcError::Internal(_)) |
+				Error::RpcError(RpcError::RestartNeeded(_)) |
+				Error::ClientNotSynced(_),
 		)
 	}
 }
@@ -110,9 +110,11 @@ impl std::fmt::Display for Error {
 			Self::Io(e) => e.to_string(),
 			Self::RpcError(e) => e.to_string(),
 			Self::ResponseParseFailed(e) => e.to_string(),
-			Self::UninitializedBridgePallet => "The Substrate bridge pallet has not been initialized yet.".into(),
+			Self::UninitializedBridgePallet =>
+				"The Substrate bridge pallet has not been initialized yet.".into(),
 			Self::AccountDoesNotExist => "Account does not exist on the chain".into(),
-			Self::MissingMandatoryCodeEntry => "Mandatory :code: entry is missing from runtime storage".into(),
+			Self::MissingMandatoryCodeEntry =>
+				"Mandatory :code: entry is missing from runtime storage".into(),
 			Self::StorageProofError(e) => format!("Error when parsing storage proof: {:?}", e),
 			Self::ClientNotSynced(health) => format!("Substrate client is not synced: {}", health),
 			Self::TransactionInvalid(e) => format!("Substrate transaction is invalid: {:?}", e),

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

@@ -16,10 +16,12 @@
 
 //! Default generic implementation of finality source for basic Substrate client.
 
-use crate::chain::{BlockWithJustification, Chain};
-use crate::client::Client;
-use crate::error::Error;
-use crate::sync_header::SyncHeader;
+use crate::{
+	chain::{BlockWithJustification, Chain},
+	client::Client,
+	error::Error,
+	sync_header::SyncHeader,
+};
 
 use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
@@ -43,12 +45,11 @@ pub struct FinalitySource<C: Chain, P> {
 
 impl<C: Chain, P> FinalitySource<C, P> {
 	/// Create new headers source using given client.
-	pub fn new(client: Client<C>, maximal_header_number: Option<RequiredHeaderNumberRef<C>>) -> Self {
-		FinalitySource {
-			client,
-			maximal_header_number,
-			_phantom: Default::default(),
-		}
+	pub fn new(
+		client: Client<C>,
+		maximal_header_number: Option<RequiredHeaderNumberRef<C>>,
+	) -> Self {
+		FinalitySource { client, maximal_header_number, _phantom: Default::default() }
 	}
 
 	/// Returns reference to the underlying RPC client.
@@ -122,7 +123,9 @@ where
 
 		let justification = signed_block
 			.justification()
-			.map(|raw_justification| GrandpaJustification::<C::Header>::decode(&mut raw_justification.as_slice()))
+			.map(|raw_justification| {
+				GrandpaJustification::<C::Header>::decode(&mut raw_justification.as_slice())
+			})
 			.transpose()
 			.map_err(Error::ResponseParseFailed)?;
 
@@ -155,11 +158,11 @@ where
 						Ok(j) => j,
 						Err(err) => {
 							log_error(format!("decode failed with error {:?}", err));
-							continue;
-						}
+							continue
+						},
 					};
 
-					return Some((justification, subscription));
+					return Some((justification, subscription))
 				}
 			},
 		)

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

@@ -52,7 +52,10 @@ pub trait Environment<C: ChainWithBalances>: Send + Sync + 'static {
 }
 
 /// Abort when runtime spec version is different from specified.
-pub fn abort_on_spec_version_change<C: ChainWithBalances>(mut env: impl Environment<C>, expected_spec_version: u32) {
+pub fn abort_on_spec_version_change<C: ChainWithBalances>(
+	mut env: impl Environment<C>,
+	expected_spec_version: u32,
+) {
 	async_std::task::spawn(async move {
 		loop {
 			let actual_spec_version = env.runtime_version().await;
@@ -68,7 +71,7 @@ pub fn abort_on_spec_version_change<C: ChainWithBalances>(mut env: impl Environm
 					);
 
 					env.abort().await;
-				}
+				},
 				Err(error) => log::warn!(
 					target: "bridge-guard",
 					"Failed to read {} runtime version: {:?}. Relay may need to be stopped manually",
@@ -83,7 +86,8 @@ pub fn abort_on_spec_version_change<C: ChainWithBalances>(mut env: impl Environm
 }
 
 /// Abort if, during 24 hours, free balance of given account is decreased at least by given value.
-/// Other components may increase (or decrease) balance of account and it WILL affect logic of the guard.
+/// Other components may increase (or decrease) balance of account and it WILL affect logic of the
+/// guard.
 pub fn abort_when_account_balance_decreased<C: ChainWithBalances>(
 	mut env: impl Environment<C>,
 	account_id: C::AccountId,
@@ -129,7 +133,7 @@ pub fn abort_when_account_balance_decreased<C: ChainWithBalances>(
 
 						env.abort().await;
 					}
-				}
+				},
 				Err(error) => {
 					log::warn!(
 						target: "bridge-guard",
@@ -138,7 +142,7 @@ pub fn abort_when_account_balance_decreased<C: ChainWithBalances>(
 						account_id,
 						error,
 					);
-				}
+				},
 			};
 
 			env.sleep(conditions_check_delay::<C>()).await;
@@ -158,9 +162,7 @@ impl<C: ChainWithBalances> Environment<C> for Client<C> {
 	}
 
 	async fn free_native_balance(&mut self, account: C::AccountId) -> Result<C::Balance, String> {
-		Client::<C>::free_native_balance(self, account)
-			.await
-			.map_err(|e| e.to_string())
+		Client::<C>::free_native_balance(self, account).await.map_err(|e| e.to_string())
 	}
 }
 
@@ -196,8 +198,9 @@ mod tests {
 		const STORAGE_PROOF_OVERHEAD: u32 = 0;
 		const MAXIMAL_ENCODED_ACCOUNT_ID_SIZE: u32 = 0;
 
-		type SignedBlock =
-			sp_runtime::generic::SignedBlock<sp_runtime::generic::Block<Self::Header, sp_runtime::OpaqueExtrinsic>>;
+		type SignedBlock = sp_runtime::generic::SignedBlock<
+			sp_runtime::generic::Block<Self::Header, sp_runtime::OpaqueExtrinsic>,
+		>;
 		type Call = ();
 		type WeightToFee = IdentityFee<u32>;
 	}
@@ -257,10 +260,7 @@ mod tests {
 
 			// client responds with wrong version
 			runtime_version_tx
-				.send(RuntimeVersion {
-					spec_version: 42,
-					..Default::default()
-				})
+				.send(RuntimeVersion { spec_version: 42, ..Default::default() })
 				.await
 				.unwrap();
 
@@ -292,10 +292,7 @@ mod tests {
 
 			// client responds with the same version
 			runtime_version_tx
-				.send(RuntimeVersion {
-					spec_version: 42,
-					..Default::default()
-				})
+				.send(RuntimeVersion { spec_version: 42, ..Default::default() })
 				.await
 				.unwrap();
 

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

@@ -16,9 +16,11 @@
 
 //! Default generic implementation of headers source for basic Substrate client.
 
-use crate::chain::{BlockWithJustification, Chain};
-use crate::client::Client;
-use crate::error::Error;
+use crate::{
+	chain::{BlockWithJustification, Chain},
+	client::Client,
+	error::Error,
+};
 
 use async_trait::async_trait;
 use headers_relay::{
@@ -38,19 +40,13 @@ pub struct HeadersSource<C: Chain, P> {
 impl<C: Chain, P> HeadersSource<C, P> {
 	/// Create new headers source using given client.
 	pub fn new(client: Client<C>) -> Self {
-		HeadersSource {
-			client,
-			_phantom: Default::default(),
-		}
+		HeadersSource { client, _phantom: Default::default() }
 	}
 }
 
 impl<C: Chain, P> Clone for HeadersSource<C, P> {
 	fn clone(&self) -> Self {
-		HeadersSource {
-			client: self.client.clone(),
-			_phantom: Default::default(),
-		}
+		HeadersSource { client: self.client.clone(), _phantom: Default::default() }
 	}
 }
 
@@ -69,7 +65,12 @@ where
 	C: Chain,
 	C::BlockNumber: relay_utils::BlockNumberBase,
 	C::Header: Into<P::Header>,
-	P: HeadersSyncPipeline<Extra = (), Completion = EncodedJustification, Hash = C::Hash, Number = C::BlockNumber>,
+	P: HeadersSyncPipeline<
+		Extra = (),
+		Completion = EncodedJustification,
+		Hash = C::Hash,
+		Number = C::BlockNumber,
+	>,
 	P::Header: SourceHeader<C::Hash, C::BlockNumber>,
 {
 	async fn best_block_number(&self) -> Result<P::Number, Error> {
@@ -79,22 +80,17 @@ where
 	}
 
 	async fn header_by_hash(&self, hash: P::Hash) -> Result<P::Header, Error> {
-		self.client
-			.header_by_hash(hash)
-			.await
-			.map(Into::into)
-			.map_err(Into::into)
+		self.client.header_by_hash(hash).await.map(Into::into).map_err(Into::into)
 	}
 
 	async fn header_by_number(&self, number: P::Number) -> Result<P::Header, Error> {
-		self.client
-			.header_by_number(number)
-			.await
-			.map(Into::into)
-			.map_err(Into::into)
+		self.client.header_by_number(number).await.map(Into::into).map_err(Into::into)
 	}
 
-	async fn header_completion(&self, id: HeaderIdOf<P>) -> Result<(HeaderIdOf<P>, Option<P::Completion>), Error> {
+	async fn header_completion(
+		&self,
+		id: HeaderIdOf<P>,
+	) -> Result<(HeaderIdOf<P>, Option<P::Completion>), Error> {
 		let hash = id.1;
 		let signed_block = self.client.get_block(Some(hash)).await?;
 		let grandpa_justification = signed_block.justification().cloned();
@@ -102,7 +98,11 @@ where
 		Ok((id, grandpa_justification))
 	}
 
-	async fn header_extra(&self, id: HeaderIdOf<P>, _header: QueuedHeader<P>) -> Result<(HeaderIdOf<P>, ()), Error> {
+	async fn header_extra(
+		&self,
+		id: HeaderIdOf<P>,
+		_header: QueuedHeader<P>,
+	) -> Result<(HeaderIdOf<P>, ()), Error> {
 		Ok((id, ()))
 	}
 }

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

@@ -31,16 +31,18 @@ pub mod metrics;
 
 use std::time::Duration;
 
-pub use crate::chain::{
-	BlockWithJustification, CallOf, Chain, ChainWithBalances, TransactionSignScheme, TransactionStatusOf,
-	UnsignedTransaction, WeightToFeeOf,
+pub use crate::{
+	chain::{
+		BlockWithJustification, CallOf, Chain, ChainWithBalances, TransactionSignScheme,
+		TransactionStatusOf, UnsignedTransaction, WeightToFeeOf,
+	},
+	client::{Client, OpaqueGrandpaAuthoritiesSet, Subscription},
+	error::{Error, Result},
+	sync_header::SyncHeader,
 };
-pub use crate::client::{Client, OpaqueGrandpaAuthoritiesSet, Subscription};
-pub use crate::error::{Error, Result};
-pub use crate::sync_header::SyncHeader;
 pub use bp_runtime::{
-	AccountIdOf, AccountPublicOf, BalanceOf, BlockNumberOf, Chain as ChainBase, HashOf, HeaderOf, IndexOf, SignatureOf,
-	TransactionEra, TransactionEraOf,
+	AccountIdOf, AccountPublicOf, BalanceOf, BlockNumberOf, Chain as ChainBase, HashOf, HeaderOf,
+	IndexOf, SignatureOf, TransactionEra, TransactionEraOf,
 };
 
 /// Header id used by the chain.
@@ -59,11 +61,7 @@ pub struct ConnectionParams {
 
 impl Default for ConnectionParams {
 	fn default() -> Self {
-		ConnectionParams {
-			host: "localhost".into(),
-			port: 9944,
-			secure: false,
-		}
+		ConnectionParams { host: "localhost".into(), port: 9944, secure: false }
 	}
 }
 
@@ -73,7 +71,11 @@ impl Default for ConnectionParams {
 /// been mined for this period.
 ///
 /// Returns `None` if mortality period is `None`
-pub fn transaction_stall_timeout(mortality_period: Option<u32>, average_block_interval: Duration) -> Option<Duration> {
+pub fn transaction_stall_timeout(
+	mortality_period: Option<u32>,
+	average_block_interval: Duration,
+) -> Option<Duration> {
 	// 1 extra block for transaction to reach the pool && 1 for relayer to awake after it is mined
-	mortality_period.map(|mortality_period| average_block_interval.saturating_mul(mortality_period + 1 + 1))
+	mortality_period
+		.map(|mortality_period| average_block_interval.saturating_mul(mortality_period + 1 + 1))
 }

bridges/relays/client-substrate/src/metrics/float_storage_value.rs

@@ -14,8 +14,7 @@
 // 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 crate::chain::Chain;
-use crate::client::Client;
+use crate::{chain::Chain, client::Client};
 
 use async_std::sync::{Arc, RwLock};
 use async_trait::async_trait;
@@ -83,7 +82,8 @@ where
 			.await
 			.map(|maybe_storage_value| {
 				maybe_storage_value.or(self.maybe_default_value).map(|storage_value| {
-					storage_value.into_inner().unique_saturated_into() as f64 / T::DIV.unique_saturated_into() as f64
+					storage_value.into_inner().unique_saturated_into() as f64 /
+						T::DIV.unique_saturated_into() as f64
 				})
 			})
 			.map_err(drop);

bridges/relays/client-substrate/src/metrics/storage_proof_overhead.rs

@@ -14,12 +14,12 @@
 // 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 crate::chain::Chain;
-use crate::client::Client;
-use crate::error::Error;
+use crate::{chain::Chain, client::Client, error::Error};
 
 use async_trait::async_trait;
-use relay_utils::metrics::{metric_name, register, Gauge, PrometheusError, Registry, StandaloneMetrics, U64};
+use relay_utils::metrics::{
+	metric_name, register, Gauge, PrometheusError, Registry, StandaloneMetrics, U64,
+};
 use sp_core::storage::StorageKey;
 use sp_runtime::traits::Header as HeaderT;
 use sp_storage::well_known_keys::CODE;
@@ -40,10 +40,7 @@ pub struct StorageProofOverheadMetric<C: Chain> {
 
 impl<C: Chain> Clone for StorageProofOverheadMetric<C> {
 	fn clone(&self) -> Self {
-		StorageProofOverheadMetric {
-			client: self.client.clone(),
-			metric: self.metric.clone(),
-		}
+		StorageProofOverheadMetric { client: self.client.clone(), metric: self.metric.clone() }
 	}
 }
 
@@ -73,15 +70,15 @@ impl<C: Chain> StorageProofOverheadMetric<C> {
 			.await?;
 		let storage_proof_size: usize = storage_proof.clone().iter_nodes().map(|n| n.len()).sum();
 
-		let storage_value_reader =
-			bp_runtime::StorageProofChecker::<C::Hasher>::new(*best_header.state_root(), storage_proof)
-				.map_err(Error::StorageProofError)?;
-		let maybe_encoded_storage_value = storage_value_reader
-			.read_value(CODE)
-			.map_err(Error::StorageProofError)?;
-		let encoded_storage_value_size = maybe_encoded_storage_value
-			.ok_or(Error::MissingMandatoryCodeEntry)?
-			.len();
+		let storage_value_reader = bp_runtime::StorageProofChecker::<C::Hasher>::new(
+			*best_header.state_root(),
+			storage_proof,
+		)
+		.map_err(Error::StorageProofError)?;
+		let maybe_encoded_storage_value =
+			storage_value_reader.read_value(CODE).map_err(Error::StorageProofError)?;
+		let encoded_storage_value_size =
+			maybe_encoded_storage_value.ok_or(Error::MissingMandatoryCodeEntry)?.len();
 
 		Ok(storage_proof_size - encoded_storage_value_size)
 	}