app_crypto_pair::from_seed(&Seed) should take ownership of seed

bin/node/testing/src/bench.rs

@@ -520,7 +520,7 @@ impl BenchKeyring {
 					(account_id, BenchPair::Sr25519(pair))
 				},
 				KeyTypes::Ed25519 => {
-					let pair = ed25519::Pair::from_seed(&blake2_256(seed.as_bytes()));
+					let pair = ed25519::Pair::from_seed(blake2_256(seed.as_bytes()));
 					let account_id = AccountPublic::from(pair.public()).into_account();
 					(account_id, BenchPair::Ed25519(pair))
 				},

client/cli/src/commands/vanity.rs

@@ -93,14 +93,14 @@ where
 			next_seed(seed.as_mut());
 		}
 
-		let p = Pair::from_seed(&seed);
+		let p = Pair::from_seed(seed.clone());
 		let ss58 = p.public().into_account().to_ss58check_with_version(network_override);
 		let score = calculate_score(&desired, &ss58);
 		if score > best || desired.len() < 2 {
 			best = score;
 			if best >= top {
 				println!("best: {} == top: {}", best, top);
-				return Ok(utils::format_seed::<Pair>(seed.clone()))
+				return Ok(utils::format_seed::<Pair>(seed))
 			}
 		}
 		done += 1;

client/consensus/babe/src/tests.rs

@@ -642,7 +642,7 @@ fn propose_and_import_block<Transaction: Send + 'static>(
 	let seal = {
 		// sign the pre-sealed hash of the block and then
 		// add it to a digest item.
-		let pair = AuthorityPair::from_seed(&[1; 32]);
+		let pair = AuthorityPair::from_seed([1; 32]);
 		let pre_hash = block.header.hash();
 		let signature = pair.sign(pre_hash.as_ref());
 		Item::babe_seal(signature)

client/executor/src/integration_tests/mod.rs

@@ -314,7 +314,7 @@ test_wasm_execution!(ed25519_verify_should_work);
 fn ed25519_verify_should_work(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
-	let key = ed25519::Pair::from_seed(&blake2_256(b"test"));
+	let key = ed25519::Pair::from_seed(blake2_256(b"test"));
 	let sig = key.sign(b"all ok!");
 	let mut calldata = vec![];
 	calldata.extend_from_slice(key.public().as_ref());
@@ -340,7 +340,7 @@ test_wasm_execution!(sr25519_verify_should_work);
 fn sr25519_verify_should_work(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 	let mut ext = ext.ext();
-	let key = sr25519::Pair::from_seed(&blake2_256(b"test"));
+	let key = sr25519::Pair::from_seed(blake2_256(b"test"));
 	let sig = key.sign(b"all ok!");
 	let mut calldata = vec![];
 	calldata.extend_from_slice(key.public().as_ref());

frame/babe/src/mock.rs

@@ -370,7 +370,7 @@ pub fn new_test_ext_with_pairs(
 	authorities_len: usize,
 ) -> (Vec<AuthorityPair>, sp_io::TestExternalities) {
 	let pairs = (0..authorities_len)
-		.map(|i| AuthorityPair::from_seed(&U256::from(i).into()))
+		.map(|i| AuthorityPair::from_seed(U256::from(i).into()))
 		.collect::<Vec<_>>();
 
 	let public = pairs.iter().map(|p| p.public()).collect();

primitives/application-crypto/src/lib.rs

@@ -135,7 +135,7 @@ macro_rules! app_crypto_pair {
 			) -> Result<(Self, Option<Self::Seed>), Self::DeriveError> {
 				self.0.derive(path, seed).map(|x| (Self(x.0), x.1))
 			}
-			fn from_seed(seed: &Self::Seed) -> Self {
+			fn from_seed(seed: Self::Seed) -> Self {
 				Self(<$pair>::from_seed(seed))
 			}
 			fn from_seed_slice(seed: &[u8]) -> Result<Self, $crate::SecretStringError> {

primitives/core/src/crypto.rs

@@ -927,7 +927,7 @@ mod dummy {
 		) -> Result<(Self, Option<Dummy>), Self::DeriveError> {
 			Ok((Self, None))
 		}
-		fn from_seed(_: &Self::Seed) -> Self {
+		fn from_seed(_: Self::Seed) -> Self {
 			Self
 		}
 		fn from_seed_slice(_: &[u8]) -> Result<Self, SecretStringError> {
@@ -978,7 +978,7 @@ pub trait Pair: CryptoType + Sized + Clone + Send + Sync + 'static {
 	fn generate() -> (Self, Self::Seed) {
 		let mut seed = Self::Seed::default();
 		OsRng.fill_bytes(seed.as_mut());
-		(Self::from_seed(&seed), seed)
+		(Self::from_seed_slice(seed.as_ref()).expect("seed has valid length; qed"), seed)
 	}
 
 	/// Generate new secure (random) key pair and provide the recovery phrase.
@@ -1008,7 +1008,7 @@ pub trait Pair: CryptoType + Sized + Clone + Send + Sync + 'static {
 	///
 	/// @WARNING: THIS WILL ONLY BE SECURE IF THE `seed` IS SECURE. If it can be guessed
 	/// by an attacker then they can also derive your key.
-	fn from_seed(seed: &Self::Seed) -> Self;
+	fn from_seed(seed: Self::Seed) -> Self;
 
 	/// Make a new key pair from secret seed material. The slice must be the correct size or
 	/// it will return `None`.
@@ -1077,7 +1077,10 @@ pub trait Pair: CryptoType + Sized + Clone + Send + Sync + 'static {
 					let mut seed = Self::Seed::default();
 					if seed.as_ref().len() == seed_vec.len() {
 						seed.as_mut().copy_from_slice(&seed_vec);
-						Some((Self::from_seed(&seed), seed))
+						Some((
+							Self::from_seed_slice(&seed_vec).expect("seed has valid length; qed"),
+							seed,
+						))
 					} else {
 						None
 					}
@@ -1358,8 +1361,8 @@ mod tests {
 				None,
 			))
 		}
-		fn from_seed(_seed: &<TestPair as Pair>::Seed) -> Self {
-			TestPair::Seed(_seed.as_ref().to_owned())
+		fn from_seed(seed: <TestPair as Pair>::Seed) -> Self {
+			TestPair::Seed(seed.as_ref().to_owned())
 		}
 		fn sign(&self, _message: &[u8]) -> Self::Signature {
 			[]

primitives/core/src/ecdsa.rs

@@ -466,8 +466,10 @@ impl TraitPair for Pair {
 	/// Make a new key pair from secret seed material.
 	///
 	/// You should never need to use this; generate(), generate_with_phrase
-	fn from_seed(seed: &Seed) -> Pair {
-		Self::from_seed_slice(&seed[..]).expect("seed has valid length; qed")
+	fn from_seed(seed: Seed) -> Pair {
+		let secret = SecretKey::parse(&seed).expect("seed has valid length; qed");
+		let public = PublicKey::from_secret_key(&secret);
+		Pair { public, secret }
 	}
 
 	/// Make a new key pair from secret seed material. The slice must be 32 bytes long or it
@@ -494,7 +496,7 @@ impl TraitPair for Pair {
 				DeriveJunction::Hard(cc) => acc = derive_hard_junction(&acc, &cc),
 			}
 		}
-		Ok((Self::from_seed(&acc), Some(acc)))
+		Ok((Self::from_seed(acc.clone()), Some(acc)))
 	}
 
 	/// Get the public key.
@@ -561,7 +563,7 @@ impl Pair {
 			let mut padded_seed: Seed = [b' '; 32];
 			let len = s.len().min(32);
 			padded_seed[..len].copy_from_slice(&s.as_bytes()[..len]);
-			Self::from_seed(&padded_seed)
+			Self::from_seed(padded_seed)
 		})
 	}
 
@@ -658,7 +660,7 @@ mod test {
 	#[test]
 	fn seed_and_derive_should_work() {
 		let seed = hex!("9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60");
-		let pair = Pair::from_seed(&seed);
+		let pair = Pair::from_seed(seed.clone());
 		assert_eq!(pair.seed(), seed);
 		let path = vec![DeriveJunction::Hard([0u8; 32])];
 		let derived = pair.derive(path.into_iter(), None).ok().unwrap();
@@ -670,7 +672,7 @@ mod test {
 
 	#[test]
 	fn test_vector_should_work() {
-		let pair = Pair::from_seed(&hex!(
+		let pair = Pair::from_seed(hex!(
 			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
 		));
 		let public = pair.public();
@@ -720,7 +722,7 @@ mod test {
 
 	#[test]
 	fn seeded_pair_should_work() {
-		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let pair = Pair::from_seed(*b"12345678901234567890123456789012");
 		let public = pair.public();
 		assert_eq!(
 			public,
@@ -761,7 +763,7 @@ mod test {
 
 	#[test]
 	fn ss58check_roundtrip_works() {
-		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let pair = Pair::from_seed(*b"12345678901234567890123456789012");
 		let public = pair.public();
 		let s = public.to_ss58check();
 		println!("Correct: {}", s);
@@ -772,7 +774,7 @@ mod test {
 	#[test]
 	fn ss58check_format_check_works() {
 		use crate::crypto::Ss58AddressFormat;
-		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let pair = Pair::from_seed(*b"12345678901234567890123456789012");
 		let public = pair.public();
 		let format = Ss58AddressFormat::Reserved46;
 		let s = public.to_ss58check_with_version(format);
@@ -782,7 +784,7 @@ mod test {
 	#[test]
 	fn ss58check_full_roundtrip_works() {
 		use crate::crypto::Ss58AddressFormat;
-		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let pair = Pair::from_seed(*b"12345678901234567890123456789012");
 		let public = pair.public();
 		let format = Ss58AddressFormat::PolkadotAccount;
 		let s = public.to_ss58check_with_version(format);
@@ -833,7 +835,7 @@ mod test {
 
 	#[test]
 	fn signature_serialization_works() {
-		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let pair = Pair::from_seed(*b"12345678901234567890123456789012");
 		let message = b"Something important";
 		let signature = pair.sign(&message[..]);
 		let serialized_signature = serde_json::to_string(&signature).unwrap();

primitives/core/src/ed25519.rs

@@ -474,15 +474,15 @@ impl TraitPair for Pair {
 
 	/// Make a new key pair from secret seed material.
 	///
-	/// You should never need to use this; generate(), generate_with_phrase
-	fn from_seed(seed: &Seed) -> Pair {
+	/// You should never need to use this directly; generate(), generate_with_phrase
+	fn from_seed(seed: Seed) -> Pair {
 		Self::from_seed_slice(&seed[..]).expect("seed has valid length; qed")
 	}
 
 	/// Make a new key pair from secret seed material. The slice must be 32 bytes long or it
 	/// will return `None`.
 	///
-	/// You should never need to use this; generate(), generate_with_phrase
+	/// You should never need to use this directly; generate(), generate_with_phrase
 	fn from_seed_slice(seed_slice: &[u8]) -> Result<Pair, SecretStringError> {
 		let secret = ed25519_dalek::SecretKey::from_bytes(seed_slice)
 			.map_err(|_| SecretStringError::InvalidSeedLength)?;
@@ -503,7 +503,7 @@ impl TraitPair for Pair {
 				DeriveJunction::Hard(cc) => acc = derive_hard_junction(&acc, &cc),
 			}
 		}
-		Ok((Self::from_seed(&acc), Some(acc)))
+		Ok((Self::from_seed(acc.clone()), Some(acc)))
 	}
 
 	/// Get the public key.
@@ -564,7 +564,7 @@ impl Pair {
 			let mut padded_seed: Seed = [b' '; 32];
 			let len = s.len().min(32);
 			padded_seed[..len].copy_from_slice(&s.as_bytes()[..len]);
-			Self::from_seed(&padded_seed)
+			Self::from_seed(padded_seed)
 		})
 	}
 }
@@ -604,7 +604,7 @@ mod test {
 	#[test]
 	fn seed_and_derive_should_work() {
 		let seed = hex!("9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60");
-		let pair = Pair::from_seed(&seed);
+		let pair = Pair::from_seed(seed);
 		assert_eq!(pair.seed(), &seed);
 		let path = vec![DeriveJunction::Hard([0u8; 32])];
 		let derived = pair.derive(path.into_iter(), None).ok().unwrap().0;
@@ -616,7 +616,7 @@ mod test {
 
 	#[test]
 	fn test_vector_should_work() {
-		let pair = Pair::from_seed(&hex!(
+		let pair = Pair::from_seed(hex!(
 			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
 		));
 		let public = pair.public();
@@ -666,7 +666,7 @@ mod test {
 
 	#[test]
 	fn seeded_pair_should_work() {
-		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let pair = Pair::from_seed(*b"12345678901234567890123456789012");
 		let public = pair.public();
 		assert_eq!(
 			public,
@@ -707,7 +707,7 @@ mod test {
 
 	#[test]
 	fn ss58check_roundtrip_works() {
-		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let pair = Pair::from_seed(*b"12345678901234567890123456789012");
 		let public = pair.public();
 		let s = public.to_ss58check();
 		println!("Correct: {}", s);
@@ -717,7 +717,7 @@ mod test {
 
 	#[test]
 	fn signature_serialization_works() {
-		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let pair = Pair::from_seed(*b"12345678901234567890123456789012");
 		let message = b"Something important";
 		let signature = pair.sign(&message[..]);
 		let serialized_signature = serde_json::to_string(&signature).unwrap();

primitives/core/src/sr25519.rs

@@ -485,7 +485,7 @@ impl TraitPair for Pair {
 	/// This is generated using schnorrkel's Mini-Secret-Keys.
 	///
 	/// A MiniSecretKey is literally what Ed25519 calls a SecretKey, which is just 32 random bytes.
-	fn from_seed(seed: &Seed) -> Pair {
+	fn from_seed(seed: Seed) -> Pair {
 		Self::from_seed_slice(&seed[..]).expect("32 bytes can always build a key; qed")
 	}
 
@@ -754,7 +754,7 @@ mod test {
 
 	#[test]
 	fn derive_soft_should_work() {
-		let pair = Pair::from_seed(&hex!(
+		let pair = Pair::from_seed(hex!(
 			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
 		));
 		let derive_1 = pair.derive(Some(DeriveJunction::soft(1)).into_iter(), None).unwrap().0;
@@ -766,7 +766,7 @@ mod test {
 
 	#[test]
 	fn derive_hard_should_work() {
-		let pair = Pair::from_seed(&hex!(
+		let pair = Pair::from_seed(hex!(
 			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
 		));
 		let derive_1 = pair.derive(Some(DeriveJunction::hard(1)).into_iter(), None).unwrap().0;
@@ -778,7 +778,7 @@ mod test {
 
 	#[test]
 	fn derive_soft_public_should_work() {
-		let pair = Pair::from_seed(&hex!(
+		let pair = Pair::from_seed(hex!(
 			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
 		));
 		let path = Some(DeriveJunction::soft(1));
@@ -789,7 +789,7 @@ mod test {
 
 	#[test]
 	fn derive_hard_public_should_fail() {
-		let pair = Pair::from_seed(&hex!(
+		let pair = Pair::from_seed(hex!(
 			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
 		));
 		let path = Some(DeriveJunction::hard(1));
@@ -798,7 +798,7 @@ mod test {
 
 	#[test]
 	fn sr_test_vector_should_work() {
-		let pair = Pair::from_seed(&hex!(
+		let pair = Pair::from_seed(hex!(
 			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
 		));
 		let public = pair.public();
@@ -845,7 +845,7 @@ mod test {
 
 	#[test]
 	fn seeded_pair_should_work() {
-		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let pair = Pair::from_seed(*b"12345678901234567890123456789012");
 		let public = pair.public();
 		assert_eq!(
 			public,
@@ -874,7 +874,7 @@ mod test {
 		// schnorrkel-js.
 		//
 		// This is to make sure that the wasm library is compatible.
-		let pk = Pair::from_seed(&hex!(
+		let pk = Pair::from_seed(hex!(
 			"0000000000000000000000000000000000000000000000000000000000000000"
 		));
 		let public = pk.public();
@@ -887,7 +887,7 @@ mod test {
 
 	#[test]
 	fn signature_serialization_works() {
-		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let pair = Pair::from_seed(*b"12345678901234567890123456789012");
 		let message = b"Something important";
 		let signature = pair.sign(&message[..]);
 		let serialized_signature = serde_json::to_string(&signature).unwrap();