Run cargo fmt on the whole code base (#9394)

* Run cargo fmt on the whole code base * Second run * Add CI check * Fix compilation * More unnecessary braces * Handle weights * Use --all * Use correct attributes... * Fix UI tests * AHHHHHHHHH * 🤦 * Docs * Fix compilation * 🤷 * Please stop * 🤦 x 2 * More * make rustfmt.toml consistent with polkadot Co-authored-by: André Silva <andrerfosilva@gmail.com>
2026-06-12 08:51:09 +00:00 · 2021-07-21 16:32:32 +02:00
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
@@ -17,19 +17,21 @@

 //! Types that should only be used for testing!

-use sp_core::crypto::KeyTypeId;
 use sp_core::{
-	crypto::{Pair, Public, CryptoTypePublicPair},
-	ed25519, sr25519, ecdsa,
+	crypto::{CryptoTypePublicPair, KeyTypeId, Pair, Public},
+	ecdsa, ed25519, sr25519,
 };

 use crate::{
-	{CryptoStore, SyncCryptoStorePtr, Error, SyncCryptoStore},
-	vrf::{VRFTranscriptData, VRFSignature, make_transcript},
+	vrf::{make_transcript, VRFSignature, VRFTranscriptData},
+	CryptoStore, Error, SyncCryptoStore, SyncCryptoStorePtr,
 };
-use std::{collections::{HashMap, HashSet}, sync::Arc};
-use parking_lot::RwLock;
 use async_trait::async_trait;
+use parking_lot::RwLock;
+use std::{
+	collections::{HashMap, HashSet},
+	sync::Arc,
+};

 /// A keystore implementation usable in tests.
 #[derive(Default)]
@@ -45,29 +47,28 @@ impl KeyStore {
 	}

 	fn sr25519_key_pair(&self, id: KeyTypeId, pub_key: &sr25519::Public) -> Option<sr25519::Pair> {
-		self.keys.read().get(&id)
-			.and_then(|inner|
-				inner.get(pub_key.as_slice())
-					.map(|s| sr25519::Pair::from_string(s, None).expect("`sr25519` seed slice is valid"))
-			)
+		self.keys.read().get(&id).and_then(|inner| {
+			inner.get(pub_key.as_slice()).map(|s| {
+				sr25519::Pair::from_string(s, None).expect("`sr25519` seed slice is valid")
+			})
+		})
 	}

 	fn ed25519_key_pair(&self, id: KeyTypeId, pub_key: &ed25519::Public) -> Option<ed25519::Pair> {
-		self.keys.read().get(&id)
-			.and_then(|inner|
-				inner.get(pub_key.as_slice())
-					.map(|s| ed25519::Pair::from_string(s, None).expect("`ed25519` seed slice is valid"))
-			)
+		self.keys.read().get(&id).and_then(|inner| {
+			inner.get(pub_key.as_slice()).map(|s| {
+				ed25519::Pair::from_string(s, None).expect("`ed25519` seed slice is valid")
+			})
+		})
 	}

 	fn ecdsa_key_pair(&self, id: KeyTypeId, pub_key: &ecdsa::Public) -> Option<ecdsa::Pair> {
-		self.keys.read().get(&id)
-			.and_then(|inner|
-				inner.get(pub_key.as_slice())
-					.map(|s| ecdsa::Pair::from_string(s, None).expect("`ecdsa` seed slice is valid"))
-			)
+		self.keys.read().get(&id).and_then(|inner| {
+			inner
+				.get(pub_key.as_slice())
+				.map(|s| ecdsa::Pair::from_string(s, None).expect("`ecdsa` seed slice is valid"))
+		})
 	}
-
 }

 #[async_trait]
@@ -158,28 +159,32 @@ impl CryptoStore for KeyStore {

 impl SyncCryptoStore for KeyStore {
 	fn keys(&self, id: KeyTypeId) -> Result<Vec<CryptoTypePublicPair>, Error> {
-		self.keys.read()
+		self.keys
+			.read()
 			.get(&id)
 			.map(|map| {
-				Ok(map.keys()
-					.fold(Vec::new(), |mut v, k| {
-						v.push(CryptoTypePublicPair(sr25519::CRYPTO_ID, k.clone()));
-						v.push(CryptoTypePublicPair(ed25519::CRYPTO_ID, k.clone()));
-						v.push(CryptoTypePublicPair(ecdsa::CRYPTO_ID, k.clone()));
-						v
-					}))
+				Ok(map.keys().fold(Vec::new(), |mut v, k| {
+					v.push(CryptoTypePublicPair(sr25519::CRYPTO_ID, k.clone()));
+					v.push(CryptoTypePublicPair(ed25519::CRYPTO_ID, k.clone()));
+					v.push(CryptoTypePublicPair(ecdsa::CRYPTO_ID, k.clone()));
+					v
+				}))
 			})
 			.unwrap_or_else(|| Ok(vec![]))
 	}

 	fn sr25519_public_keys(&self, id: KeyTypeId) -> Vec<sr25519::Public> {
-		self.keys.read().get(&id)
-			.map(|keys|
+		self.keys
+			.read()
+			.get(&id)
+			.map(|keys| {
 				keys.values()
-					.map(|s| sr25519::Pair::from_string(s, None).expect("`sr25519` seed slice is valid"))
+					.map(|s| {
+						sr25519::Pair::from_string(s, None).expect("`sr25519` seed slice is valid")
+					})
 					.map(|p| p.public())
 					.collect()
-			)
+			})
 			.unwrap_or_default()
 	}

@@ -190,27 +195,40 @@ impl SyncCryptoStore for KeyStore {
 	) -> Result<sr25519::Public, Error> {
 		match seed {
 			Some(seed) => {
-				let pair = sr25519::Pair::from_string(seed, None)
-					.map_err(|_| Error::ValidationError("Generates an `sr25519` pair.".to_owned()))?;
-				self.keys.write().entry(id).or_default().insert(pair.public().to_raw_vec(), seed.into());
+				let pair = sr25519::Pair::from_string(seed, None).map_err(|_| {
+					Error::ValidationError("Generates an `sr25519` pair.".to_owned())
+				})?;
+				self.keys
+					.write()
+					.entry(id)
+					.or_default()
+					.insert(pair.public().to_raw_vec(), seed.into());
 				Ok(pair.public())
 			},
 			None => {
 				let (pair, phrase, _) = sr25519::Pair::generate_with_phrase(None);
-				self.keys.write().entry(id).or_default().insert(pair.public().to_raw_vec(), phrase);
+				self.keys
+					.write()
+					.entry(id)
+					.or_default()
+					.insert(pair.public().to_raw_vec(), phrase);
 				Ok(pair.public())
-			}
+			},
 		}
 	}

 	fn ed25519_public_keys(&self, id: KeyTypeId) -> Vec<ed25519::Public> {
-		self.keys.read().get(&id)
-			.map(|keys|
+		self.keys
+			.read()
+			.get(&id)
+			.map(|keys| {
 				keys.values()
-					.map(|s| ed25519::Pair::from_string(s, None).expect("`ed25519` seed slice is valid"))
+					.map(|s| {
+						ed25519::Pair::from_string(s, None).expect("`ed25519` seed slice is valid")
+					})
 					.map(|p| p.public())
 					.collect()
-			)
+			})
 			.unwrap_or_default()
 	}

@@ -221,27 +239,40 @@ impl SyncCryptoStore for KeyStore {
 	) -> Result<ed25519::Public, Error> {
 		match seed {
 			Some(seed) => {
-				let pair = ed25519::Pair::from_string(seed, None)
-					.map_err(|_| Error::ValidationError("Generates an `ed25519` pair.".to_owned()))?;
-				self.keys.write().entry(id).or_default().insert(pair.public().to_raw_vec(), seed.into());
+				let pair = ed25519::Pair::from_string(seed, None).map_err(|_| {
+					Error::ValidationError("Generates an `ed25519` pair.".to_owned())
+				})?;
+				self.keys
+					.write()
+					.entry(id)
+					.or_default()
+					.insert(pair.public().to_raw_vec(), seed.into());
 				Ok(pair.public())
 			},
 			None => {
 				let (pair, phrase, _) = ed25519::Pair::generate_with_phrase(None);
-				self.keys.write().entry(id).or_default().insert(pair.public().to_raw_vec(), phrase);
+				self.keys
+					.write()
+					.entry(id)
+					.or_default()
+					.insert(pair.public().to_raw_vec(), phrase);
 				Ok(pair.public())
-			}
+			},
 		}
 	}

 	fn ecdsa_public_keys(&self, id: KeyTypeId) -> Vec<ecdsa::Public> {
-		self.keys.read().get(&id)
-			.map(|keys|
+		self.keys
+			.read()
+			.get(&id)
+			.map(|keys| {
 				keys.values()
-					.map(|s| ecdsa::Pair::from_string(s, None).expect("`ecdsa` seed slice is valid"))
+					.map(|s| {
+						ecdsa::Pair::from_string(s, None).expect("`ecdsa` seed slice is valid")
+					})
 					.map(|p| p.public())
 					.collect()
-			)
+			})
 			.unwrap_or_default()
 	}

@@ -254,24 +285,38 @@ impl SyncCryptoStore for KeyStore {
 			Some(seed) => {
 				let pair = ecdsa::Pair::from_string(seed, None)
 					.map_err(|_| Error::ValidationError("Generates an `ecdsa` pair.".to_owned()))?;
-				self.keys.write().entry(id).or_default().insert(pair.public().to_raw_vec(), seed.into());
+				self.keys
+					.write()
+					.entry(id)
+					.or_default()
+					.insert(pair.public().to_raw_vec(), seed.into());
 				Ok(pair.public())
 			},
 			None => {
 				let (pair, phrase, _) = ecdsa::Pair::generate_with_phrase(None);
-				self.keys.write().entry(id).or_default().insert(pair.public().to_raw_vec(), phrase);
+				self.keys
+					.write()
+					.entry(id)
+					.or_default()
+					.insert(pair.public().to_raw_vec(), phrase);
 				Ok(pair.public())
-			}
+			},
 		}
 	}

 	fn insert_unknown(&self, id: KeyTypeId, suri: &str, public: &[u8]) -> Result<(), ()> {
-		self.keys.write().entry(id).or_default().insert(public.to_owned(), suri.to_string());
+		self.keys
+			.write()
+			.entry(id)
+			.or_default()
+			.insert(public.to_owned(), suri.to_string());
 		Ok(())
 	}

 	fn has_keys(&self, public_keys: &[(Vec<u8>, KeyTypeId)]) -> bool {
-		public_keys.iter().all(|(k, t)| self.keys.read().get(&t).and_then(|s| s.get(k)).is_some())
+		public_keys
+			.iter()
+			.all(|(k, t)| self.keys.read().get(&t).and_then(|s| s.get(k)).is_some())
 	}

 	fn supported_keys(
@@ -295,24 +340,24 @@ impl SyncCryptoStore for KeyStore {

 		match key.0 {
 			ed25519::CRYPTO_ID => {
-				let key_pair = self
-					.ed25519_key_pair(id, &ed25519::Public::from_slice(key.1.as_slice()));
+				let key_pair =
+					self.ed25519_key_pair(id, &ed25519::Public::from_slice(key.1.as_slice()));

 				key_pair.map(|k| k.sign(msg).encode()).map(Ok).transpose()
-			}
+			},
 			sr25519::CRYPTO_ID => {
-				let key_pair = self
-					.sr25519_key_pair(id, &sr25519::Public::from_slice(key.1.as_slice()));
+				let key_pair =
+					self.sr25519_key_pair(id, &sr25519::Public::from_slice(key.1.as_slice()));

 				key_pair.map(|k| k.sign(msg).encode()).map(Ok).transpose()
-			}
+			},
 			ecdsa::CRYPTO_ID => {
-				let key_pair = self
-					.ecdsa_key_pair(id, &ecdsa::Public::from_slice(key.1.as_slice()));
+				let key_pair =
+					self.ecdsa_key_pair(id, &ecdsa::Public::from_slice(key.1.as_slice()));

 				key_pair.map(|k| k.sign(msg).encode()).map(Ok).transpose()
-			}
-			_ => Err(Error::KeyNotSupported(id))
+			},
+			_ => Err(Error::KeyNotSupported(id)),
 		}
 	}

@@ -323,17 +368,11 @@ impl SyncCryptoStore for KeyStore {
 		transcript_data: VRFTranscriptData,
 	) -> Result<Option<VRFSignature>, Error> {
 		let transcript = make_transcript(transcript_data);
-		let pair = if let Some(k) = self.sr25519_key_pair(key_type, public) {
-			k
-		} else {
-			return Ok(None)
-		};
+		let pair =
+			if let Some(k) = self.sr25519_key_pair(key_type, public) { k } else { return Ok(None) };

 		let (inout, proof, _) = pair.as_ref().vrf_sign(transcript);
-		Ok(Some(VRFSignature {
-			output: inout.to_output(),
-			proof,
-		}))
+		Ok(Some(VRFSignature { output: inout.to_output(), proof }))
 	}

 	fn ecdsa_sign_prehashed(
@@ -362,15 +401,18 @@ impl Into<Arc<dyn CryptoStore>> for KeyStore {
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use sp_core::{sr25519, testing::{ED25519, SR25519, ECDSA}};
-	use crate::{SyncCryptoStore, vrf::VRFTranscriptValue};
+	use crate::{vrf::VRFTranscriptValue, SyncCryptoStore};
+	use sp_core::{
+		sr25519,
+		testing::{ECDSA, ED25519, SR25519},
+	};

 	#[test]
 	fn store_key_and_extract() {
 		let store = KeyStore::new();

-		let public = SyncCryptoStore::ed25519_generate_new(&store, ED25519, None)
-			.expect("Generates key");
+		let public =
+			SyncCryptoStore::ed25519_generate_new(&store, ED25519, None).expect("Generates key");

 		let public_keys = SyncCryptoStore::keys(&store, ED25519).unwrap();

@@ -384,12 +426,8 @@ mod tests {
 		let secret_uri = "//Alice";
 		let key_pair = sr25519::Pair::from_string(secret_uri, None).expect("Generates key pair");

-		SyncCryptoStore::insert_unknown(
-			&store,
-			SR25519,
-			secret_uri,
-			key_pair.public().as_ref(),
-		).expect("Inserts unknown key");
+		SyncCryptoStore::insert_unknown(&store, SR25519, secret_uri, key_pair.public().as_ref())
+			.expect("Inserts unknown key");

 		let public_keys = SyncCryptoStore::keys(&store, SR25519).unwrap();

@@ -409,7 +447,7 @@ mod tests {
 				("one", VRFTranscriptValue::U64(1)),
 				("two", VRFTranscriptValue::U64(2)),
 				("three", VRFTranscriptValue::Bytes("test".as_bytes().to_vec())),
-			]
+			],
 		};

 		let result = SyncCryptoStore::sr25519_vrf_sign(
@@ -420,19 +458,11 @@ mod tests {
 		);
 		assert!(result.unwrap().is_none());

-		SyncCryptoStore::insert_unknown(
-			&store,
-			SR25519,
-			secret_uri,
-			key_pair.public().as_ref(),
-		).expect("Inserts unknown key");
+		SyncCryptoStore::insert_unknown(&store, SR25519, secret_uri, key_pair.public().as_ref())
+			.expect("Inserts unknown key");

-		let result = SyncCryptoStore::sr25519_vrf_sign(
-			&store,
-			SR25519,
-			&key_pair.public(),
-			transcript_data,
-		);
+		let result =
+			SyncCryptoStore::sr25519_vrf_sign(&store, SR25519, &key_pair.public(), transcript_data);

 		assert!(result.unwrap().is_some());
 	}
@@ -445,16 +475,19 @@ mod tests {
 		let pair = ecdsa::Pair::from_string(suri, None).unwrap();

 		let msg = sp_core::keccak_256(b"this should be a hashed message");
-		
+
 		// no key in key store
-		let res = SyncCryptoStore::ecdsa_sign_prehashed(&store, ECDSA, &pair.public(), &msg).unwrap();
+		let res =
+			SyncCryptoStore::ecdsa_sign_prehashed(&store, ECDSA, &pair.public(), &msg).unwrap();
 		assert!(res.is_none());

 		// insert key, sign again
-		let res = SyncCryptoStore::insert_unknown(&store, ECDSA, suri, pair.public().as_ref()).unwrap();
+		let res =
+			SyncCryptoStore::insert_unknown(&store, ECDSA, suri, pair.public().as_ref()).unwrap();
 		assert_eq!((), res);

-		let res = SyncCryptoStore::ecdsa_sign_prehashed(&store, ECDSA, &pair.public(), &msg).unwrap();
-		assert!(res.is_some());		
+		let res =
+			SyncCryptoStore::ecdsa_sign_prehashed(&store, ECDSA, &pair.public(), &msg).unwrap();
+		assert!(res.is_some());
 	}
 }