diff --git a/bin/node/testing/src/bench.rs b/bin/node/testing/src/bench.rs index a1f9bc8710565..3f5d2291306ee 100644 --- a/bin/node/testing/src/bench.rs +++ b/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)) }, diff --git a/client/cli/src/commands/vanity.rs b/client/cli/src/commands/vanity.rs index daeb81e86a1a1..7acb73947c04a 100644 --- a/client/cli/src/commands/vanity.rs +++ b/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::(seed.clone())) + return Ok(utils::format_seed::(seed)) } } done += 1; diff --git a/client/consensus/babe/src/tests.rs b/client/consensus/babe/src/tests.rs index c033f4535be0b..36d6147c442e8 100644 --- a/client/consensus/babe/src/tests.rs +++ b/client/consensus/babe/src/tests.rs @@ -642,7 +642,7 @@ fn propose_and_import_block( 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) diff --git a/client/executor/src/integration_tests/mod.rs b/client/executor/src/integration_tests/mod.rs index dabead4799dc8..c4dfe84d6aeb0 100644 --- a/client/executor/src/integration_tests/mod.rs +++ b/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()); diff --git a/frame/babe/src/mock.rs b/frame/babe/src/mock.rs index f4f1310e83566..07c13c54f554e 100644 --- a/frame/babe/src/mock.rs +++ b/frame/babe/src/mock.rs @@ -370,7 +370,7 @@ pub fn new_test_ext_with_pairs( authorities_len: usize, ) -> (Vec, 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::>(); let public = pairs.iter().map(|p| p.public()).collect(); diff --git a/primitives/application-crypto/src/lib.rs b/primitives/application-crypto/src/lib.rs index 43a14e29f4ee5..2fad011b167cb 100644 --- a/primitives/application-crypto/src/lib.rs +++ b/primitives/application-crypto/src/lib.rs @@ -135,7 +135,7 @@ macro_rules! app_crypto_pair { ) -> Result<(Self, Option), 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 { diff --git a/primitives/core/src/crypto.rs b/primitives/core/src/crypto.rs index 5346ea66fe8ae..35aab90b303a8 100644 --- a/primitives/core/src/crypto.rs +++ b/primitives/core/src/crypto.rs @@ -927,7 +927,7 @@ mod dummy { ) -> Result<(Self, Option), Self::DeriveError> { Ok((Self, None)) } - fn from_seed(_: &Self::Seed) -> Self { + fn from_seed(_: Self::Seed) -> Self { Self } fn from_seed_slice(_: &[u8]) -> Result { @@ -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: &::Seed) -> Self { - TestPair::Seed(_seed.as_ref().to_owned()) + fn from_seed(seed: ::Seed) -> Self { + TestPair::Seed(seed.as_ref().to_owned()) } fn sign(&self, _message: &[u8]) -> Self::Signature { [] diff --git a/primitives/core/src/ecdsa.rs b/primitives/core/src/ecdsa.rs index 147569d52b89f..2815e8712ae68 100644 --- a/primitives/core/src/ecdsa.rs +++ b/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(); diff --git a/primitives/core/src/ed25519.rs b/primitives/core/src/ed25519.rs index be70da31e641d..f9537e49aa033 100644 --- a/primitives/core/src/ed25519.rs +++ b/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 { 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(); diff --git a/primitives/core/src/sr25519.rs b/primitives/core/src/sr25519.rs index 4c5122162d65d..2e21d40bb5265 100644 --- a/primitives/core/src/sr25519.rs +++ b/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();