Formatting

bin/node/executor/tests/submit_transaction.rs

@@ -33,7 +33,8 @@ fn should_submit_unsigned_transaction() {
 	t.register_extension(TransactionPoolExt::new(pool));
 
 	t.execute_with(|| {
-		let signature = pallet_im_online::sr25519::AuthoritySignature::try_from(vec![0; 64]).unwrap();
+		let signature =
+			pallet_im_online::sr25519::AuthoritySignature::try_from(vec![0; 64]).unwrap();
 		let heartbeat_data = pallet_im_online::Heartbeat {
 			block_number: 1,
 			network_state: Default::default(),

client/cli/src/commands/insert_key.rs

@@ -99,7 +99,7 @@ fn to_vec<P: sp_core::Pair>(uri: &str, pass: Option<SecretString>) -> Result<Vec
 mod tests {
 	use super::*;
 	use sc_service::{ChainSpec, ChainType, GenericChainSpec, NoExtension};
-	use sp_core::{sr25519::Pair, Pair as _, ByteArray};
+	use sp_core::{sr25519::Pair, ByteArray, Pair as _};
 	use structopt::StructOpt;
 	use tempfile::TempDir;
 

client/cli/src/commands/verify.rs

@@ -19,7 +19,7 @@
 //! implementation of the `verify` subcommand
 
 use crate::{error, utils, with_crypto_scheme, CryptoSchemeFlag};
-use sp_core::crypto::{Ss58Codec, ByteArray};
+use sp_core::crypto::{ByteArray, Ss58Codec};
 use structopt::StructOpt;
 
 /// The `verify` command
@@ -63,12 +63,13 @@ impl VerifyCmd {
 	}
 }
 
-fn verify<Pair>(sig_data: Vec<u8>, message: Vec<u8>, uri: &str) -> error::Result<()> where
+fn verify<Pair>(sig_data: Vec<u8>, message: Vec<u8>, uri: &str) -> error::Result<()>
+where
 	Pair: sp_core::Pair,
-	Pair::Signature: for <'a> std::convert::TryFrom<&'a [u8]>,
+	Pair::Signature: for<'a> std::convert::TryFrom<&'a [u8]>,
 {
-	let signature = Pair::Signature::try_from(&sig_data)
-		.map_err(|_| error::Error::SignatureFormatInvalid)?;
+	let signature =
+		Pair::Signature::try_from(&sig_data).map_err(|_| error::Error::SignatureFormatInvalid)?;
 
 	let pubkey = if let Ok(pubkey_vec) = hex::decode(uri) {
 		Pair::Public::from_slice(pubkey_vec.as_slice())

client/consensus/aura/src/lib.rs

@@ -57,7 +57,7 @@ use sp_consensus::{
 	BlockOrigin, CanAuthorWith, Environment, Error as ConsensusError, Proposer, SelectChain,
 };
 use sp_consensus_slots::Slot;
-use sp_core::crypto::{Pair, Public, ByteArray};
+use sp_core::crypto::{ByteArray, Pair, Public};
 use sp_inherents::CreateInherentDataProviders;
 use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
 use sp_runtime::{

client/consensus/babe/src/verification.rs

@@ -31,7 +31,7 @@ use sp_consensus_babe::{
 	make_transcript, AuthorityId, AuthorityPair, AuthoritySignature,
 };
 use sp_consensus_slots::Slot;
-use sp_core::{Pair, ByteArray};
+use sp_core::{ByteArray, Pair};
 use sp_runtime::{traits::Header, DigestItem};
 
 /// BABE verification parameters

client/finality-grandpa/src/authorities.rs

@@ -1493,8 +1493,10 @@ mod tests {
 			None,
 		);
 
-		let invalid_authorities_weight =
-			vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 5), (AuthorityId::from_slice(&[2; 32]).unwrap(), 0)];
+		let invalid_authorities_weight = vec![
+			(AuthorityId::from_slice(&[1; 32]).unwrap(), 5),
+			(AuthorityId::from_slice(&[2; 32]).unwrap(), 0),
+		];
 
 		// authority weight of zero is invalid
 		assert_eq!(AuthoritySet::<(), ()>::genesis(invalid_authorities_weight.clone()), None);
@@ -1510,7 +1512,8 @@ mod tests {
 		);
 
 		let mut authority_set =
-			AuthoritySet::<(), u64>::genesis(vec![(AuthorityId::unchecked_from([1; 32]), 5)]).unwrap();
+			AuthoritySet::<(), u64>::genesis(vec![(AuthorityId::unchecked_from([1; 32]), 5)])
+				.unwrap();
 
 		let invalid_change_empty_authorities = PendingChange {
 			next_authorities: vec![],

client/finality-grandpa/src/aux_schema.rs

@@ -498,7 +498,7 @@ pub(crate) fn load_authorities<B: AuxStore, H: Decode, N: Decode + Clone + Ord>(
 #[cfg(test)]
 mod test {
 	use super::*;
-	use sp_core::{H256, crypto::UncheckedFrom};
+	use sp_core::{crypto::UncheckedFrom, H256};
 	use sp_finality_grandpa::AuthorityId;
 	use substrate_test_runtime_client;
 

client/finality-grandpa/src/communication/gossip.rs

@@ -2555,7 +2555,8 @@ mod tests {
 
 		assert_eq!(val.inner().read().authorities, a1);
 
-		let a2 = vec![UncheckedFrom::unchecked_from([1; 32]), UncheckedFrom::unchecked_from([2; 32])];
+		let a2 =
+			vec![UncheckedFrom::unchecked_from([1; 32]), UncheckedFrom::unchecked_from([2; 32])];
 		val.note_set(SetId(1), a2.clone(), |_, _| {});
 
 		assert_eq!(val.inner().read().authorities, a2);

client/finality-grandpa/src/lib.rs

@@ -763,7 +763,8 @@ where
 			let events = telemetry_on_connect.for_each(move |_| {
 				let current_authorities = authorities.current_authorities();
 				let set_id = authorities.set_id();
-				let maybe_authority_id = local_authority_id(&current_authorities, conf.keystore.as_ref());
+				let maybe_authority_id =
+					local_authority_id(&current_authorities, conf.keystore.as_ref());
 
 				let authorities =
 					current_authorities.iter().map(|(id, _)| id.to_string()).collect::<Vec<_>>();
@@ -916,7 +917,8 @@ where
 	fn rebuild_voter(&mut self) {
 		debug!(target: "afg", "{}: Starting new voter with set ID {}", self.env.config.name(), self.env.set_id);
 
-		let maybe_authority_id = local_authority_id(&self.env.voters, self.env.config.keystore.as_ref());
+		let maybe_authority_id =
+			local_authority_id(&self.env.voters, self.env.config.keystore.as_ref());
 		let authority_id = maybe_authority_id.map_or("".into(), |s| s.to_string());
 
 		telemetry!(

client/finality-grandpa/src/until_imported.rs

@@ -562,8 +562,8 @@ mod tests {
 	use futures_timer::Delay;
 	use sc_client_api::BlockImportNotification;
 	use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
-	use sp_core::crypto::UncheckedFrom;
 	use sp_consensus::BlockOrigin;
+	use sp_core::crypto::UncheckedFrom;
 	use substrate_test_runtime_client::runtime::{Block, Hash, Header};
 
 	#[derive(Clone)]

client/keystore/src/local.rs

@@ -21,7 +21,9 @@ use async_trait::async_trait;
 use parking_lot::RwLock;
 use sp_application_crypto::{ecdsa, ed25519, sr25519, AppKey, AppPair, IsWrappedBy};
 use sp_core::{
-	crypto::{CryptoTypePublicPair, ExposeSecret, KeyTypeId, Pair as PairT, ByteArray, SecretString},
+	crypto::{
+		ByteArray, CryptoTypePublicPair, ExposeSecret, KeyTypeId, Pair as PairT, SecretString,
+	},
 	sr25519::{Pair as Sr25519Pair, Public as Sr25519Public},
 	Encode,
 };
@@ -226,7 +228,11 @@ impl SyncCryptoStore for LocalKeystore {
 		self.0
 			.read()
 			.raw_public_keys(key_type)
-			.map(|v| v.into_iter().filter_map(|k| sr25519::Public::from_slice(k.as_slice()).ok()).collect())
+			.map(|v| {
+				v.into_iter()
+					.filter_map(|k| sr25519::Public::from_slice(k.as_slice()).ok())
+					.collect()
+			})
 			.unwrap_or_default()
 	}
 
@@ -249,7 +255,11 @@ impl SyncCryptoStore for LocalKeystore {
 		self.0
 			.read()
 			.raw_public_keys(key_type)
-			.map(|v| v.into_iter().filter_map(|k| ed25519::Public::from_slice(k.as_slice()).ok()).collect())
+			.map(|v| {
+				v.into_iter()
+					.filter_map(|k| ed25519::Public::from_slice(k.as_slice()).ok())
+					.collect()
+			})
 			.unwrap_or_default()
 	}
 
@@ -272,7 +282,11 @@ impl SyncCryptoStore for LocalKeystore {
 		self.0
 			.read()
 			.raw_public_keys(key_type)
-			.map(|v| v.into_iter().filter_map(|k| ecdsa::Public::from_slice(k.as_slice()).ok()).collect())
+			.map(|v| {
+				v.into_iter()
+					.filter_map(|k| ecdsa::Public::from_slice(k.as_slice()).ok())
+					.collect()
+			})
 			.unwrap_or_default()
 	}
 
@@ -564,8 +578,9 @@ mod tests {
 		}
 
 		fn public_keys<Public: AppPublic>(&self) -> Result<Vec<Public>> {
-			self.raw_public_keys(Public::ID)
-				.map(|v| v.into_iter().filter_map(|k| Public::from_slice(k.as_slice()).ok()).collect())
+			self.raw_public_keys(Public::ID).map(|v| {
+				v.into_iter().filter_map(|k| Public::from_slice(k.as_slice()).ok()).collect()
+			})
 		}
 
 		fn generate<Pair: AppPair>(&mut self) -> Result<Pair> {

client/rpc/src/author/tests.rs

@@ -24,7 +24,7 @@ use futures::executor;
 use sc_transaction_pool::{BasicPool, FullChainApi};
 use sp_core::{
 	blake2_256,
-	crypto::{CryptoTypePublicPair, Pair, ByteArray},
+	crypto::{ByteArray, CryptoTypePublicPair, Pair},
 	ed25519,
 	hexdisplay::HexDisplay,
 	sr25519,
@@ -40,8 +40,12 @@ use substrate_test_runtime_client::{
 };
 
 fn uxt(sender: AccountKeyring, nonce: u64) -> Extrinsic {
-	let tx =
-		Transfer { amount: Default::default(), nonce, from: sender.into(), to: AccountKeyring::Bob.into() };
+	let tx = Transfer {
+		amount: Default::default(),
+		nonce,
+		from: sender.into(),
+		to: AccountKeyring::Bob.into(),
+	};
 	tx.into_signed_tx()
 }
 

client/transaction-pool/src/graph/pool.rs

@@ -588,11 +588,7 @@ mod tests {
 
 	fn uxt(transfer: Transfer) -> Extrinsic {
 		let signature = TryFrom::try_from(&[0; 64][..]).unwrap();
-		Extrinsic::Transfer {
-			transfer,
-			signature,
-			exhaust_resources_when_not_first: false,
-		}
+		Extrinsic::Transfer { transfer, signature, exhaust_resources_when_not_first: false }
 	}
 
 	fn pool() -> Pool<TestApi> {

frame/authorship/src/lib.rs

@@ -310,7 +310,10 @@ impl<T: Config> Pallet<T> {
 
 		let digest = <frame_system::Pallet<T>>::digest();
 		let pre_runtime_digests = digest.logs.iter().filter_map(|d| d.as_pre_runtime());
-		T::FindAuthor::find_author(pre_runtime_digests).map(|a| { <Author<T>>::put(&a); a })
+		T::FindAuthor::find_author(pre_runtime_digests).map(|a| {
+			<Author<T>>::put(&a);
+			a
+		})
 	}
 
 	fn verify_and_import_uncles(new_uncles: Vec<T::Header>) -> dispatch::DispatchResult {

frame/benchmarking/src/utils.rs

@@ -322,11 +322,7 @@ pub trait BenchmarkingSetup<T, I = ()> {
 }
 
 /// Grab an account, seeded by a name and index.
-pub fn account<AccountId: Decode>(
-	name: &'static str,
-	index: u32,
-	seed: u32,
-) -> AccountId {
+pub fn account<AccountId: Decode>(name: &'static str, index: u32, seed: u32) -> AccountId {
 	let entropy = (name, index, seed).using_encoded(blake2_256);
 	Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
 		.expect("infinite length input; no invalid inputs for type; qed")

frame/elections-phragmen/src/lib.rs

@@ -161,11 +161,7 @@ pub struct Voter<AccountId, Balance> {
 
 impl<AccountId, Balance: Default> Default for Voter<AccountId, Balance> {
 	fn default() -> Self {
-		Self {
-			votes: vec![],
-			stake: Default::default(),
-			deposit: Default::default(),
-		}
+		Self { votes: vec![], stake: Default::default(), deposit: Default::default() }
 	}
 }
 

frame/examples/parallel/src/lib.rs

@@ -109,11 +109,9 @@ impl EnlistedParticipant {
 		use sp_runtime::traits::Verify;
 
 		match sp_core::sr25519::Signature::try_from(&self.signature[..]) {
-			Ok(signature) => {
-				match sp_core::sr25519::Public::from_slice(self.account.as_ref()) {
-					Err(()) => false,
-					Ok(signer) => signature.verify(event_id, &signer),
-				}
+			Ok(signature) => match sp_core::sr25519::Public::from_slice(self.account.as_ref()) {
+				Err(()) => false,
+				Ok(signer) => signature.verify(event_id, &signer),
 			},
 			_ => false,
 		}

frame/examples/parallel/src/tests.rs

@@ -98,8 +98,7 @@ fn it_can_enlist() {
 
 		let event_name = b"test";
 
-		Example::run_event(test_origin(1), event_name.to_vec())
-			.expect("Failed to enlist");
+		Example::run_event(test_origin(1), event_name.to_vec()).expect("Failed to enlist");
 
 		let participants = vec![
 			EnlistedParticipant {
@@ -130,8 +129,7 @@ fn one_wrong_will_not_enlist_anyone() {
 
 		let event_name = b"test";
 
-		Example::run_event(test_origin(1), event_name.to_vec())
-			.expect("Failed to enlist");
+		Example::run_event(test_origin(1), event_name.to_vec()).expect("Failed to enlist");
 
 		let participants = vec![
 			EnlistedParticipant {
@@ -149,8 +147,7 @@ fn one_wrong_will_not_enlist_anyone() {
 			},
 		];
 
-		Example::enlist_participants(test_origin(1), participants)
-			.expect("Failed to enlist");
+		Example::enlist_participants(test_origin(1), participants).expect("Failed to enlist");
 
 		assert_eq!(Example::participants().len(), 0);
 	});

frame/multisig/src/lib.rs

@@ -63,7 +63,10 @@ use frame_support::{
 use frame_system::{self as system, RawOrigin};
 use scale_info::TypeInfo;
 use sp_io::hashing::blake2_256;
-use sp_runtime::{DispatchError, traits::{Dispatchable, TrailingZeroInput, Zero}};
+use sp_runtime::{
+	traits::{Dispatchable, TrailingZeroInput, Zero},
+	DispatchError,
+};
 use sp_std::prelude::*;
 pub use weights::WeightInfo;
 

frame/proxy/src/lib.rs

@@ -44,7 +44,10 @@ use frame_support::{
 use frame_system::{self as system};
 use scale_info::TypeInfo;
 use sp_io::hashing::blake2_256;
-use sp_runtime::{DispatchResult, traits::{Dispatchable, Hash, Saturating, TrailingZeroInput, Zero}};
+use sp_runtime::{
+	traits::{Dispatchable, Hash, Saturating, TrailingZeroInput, Zero},
+	DispatchResult,
+};
 use sp_std::{convert::TryInto, prelude::*};
 pub use weights::WeightInfo;
 

frame/staking/src/benchmarking.rs

@@ -29,7 +29,7 @@ use frame_support::{
 	traits::{Currency, CurrencyToVote, Get, Imbalance},
 };
 use sp_runtime::{
-	traits::{Bounded, One, StaticLookup, Zero, TrailingZeroInput},
+	traits::{Bounded, One, StaticLookup, TrailingZeroInput, Zero},
 	Perbill, Percent,
 };
 use sp_staking::SessionIndex;

frame/staking/src/pallet/impls.rs

@@ -1264,7 +1264,10 @@ impl<T: Config> VoteWeightProvider<T::AccountId> for Pallet<T> {
 		let active: BalanceOf<T> = weight.try_into().map_err(|_| ()).unwrap();
 		let ledger = match Self::ledger(who) {
 			None => StakingLedger::default_from(who.clone()),
-			Some(mut l) => { l.active = active; l },
+			Some(mut l) => {
+				l.active = active;
+				l
+			},
 		};
 		<Ledger<T>>::insert(who, ledger);
 		<Bonded<T>>::insert(who, who);

frame/tips/src/lib.rs

@@ -60,7 +60,10 @@ mod tests;
 pub mod migrations;
 pub mod weights;
 
-use sp_runtime::{Percent, RuntimeDebug, traits::{AccountIdConversion, BadOrigin, Hash, TrailingZeroInput, Zero}};
+use sp_runtime::{
+	traits::{AccountIdConversion, BadOrigin, Hash, TrailingZeroInput, Zero},
+	Percent, RuntimeDebug,
+};
 use sp_std::prelude::*;
 
 use codec::{Decode, Encode};
@@ -577,7 +580,8 @@ impl<T: Config> Pallet<T> {
 
 		use frame_support::{migration::storage_key_iter, Twox64Concat};
 
-		let zero_account = T::AccountId::decode(&mut TrailingZeroInput::new(&[][..])).expect("infinite input; qed");
+		let zero_account = T::AccountId::decode(&mut TrailingZeroInput::new(&[][..]))
+			.expect("infinite input; qed");
 
 		for (hash, old_tip) in storage_key_iter::<
 			T::Hash,

frame/transaction-payment/asset-tx-payment/src/lib.rs

@@ -265,7 +265,8 @@ where
 				let actual_fee = pallet_transaction_payment::Pallet::<T>::compute_actual_fee(
 					len as u32, info, post_info, tip,
 				);
-				let who = who.ok_or(TransactionValidityError::Invalid(InvalidTransaction::Custom(255)))?;
+				let who =
+					who.ok_or(TransactionValidityError::Invalid(InvalidTransaction::Custom(255)))?;
 				T::OnChargeAssetTransaction::correct_and_deposit_fee(
 					&who,
 					info,