Create an account for chain=dev (#5612)

* implement From<&'static str> for Secret

* Dev account.

* Fix Secret semantics.

ethkey/src/brain.rs

@@ -38,7 +38,7 @@ impl Generator for Brain {
 			match i > 16384 {
 				false => i += 1,
 				true => {
-					if let Ok(secret) = Secret::from_slice(&secret) {
+					if let Ok(secret) = Secret::from_unsafe_slice(&secret) {
 						let result = KeyPair::from_secret(secret);
 						if result.as_ref().ok().map_or(false, |r| r.address()[0] == 0) {
 							return result;

ethkey/src/extended.rs

@@ -99,8 +99,7 @@ impl ExtendedSecret {
 	pub fn derive<T>(&self, index: Derivation<T>) -> ExtendedSecret where T: Label {
 		let (derived_key, next_chain_code) = derivation::private(*self.secret, self.chain_code, index);
 
-		let derived_secret = Secret::from_slice(&*derived_key)
-			.expect("Derivation always produced a valid private key; qed");
+		let derived_secret = Secret::from_slice(&*derived_key);
 
 		ExtendedSecret::with_code(derived_secret, next_chain_code)
 	}
@@ -181,7 +180,7 @@ impl ExtendedKeyPair {
 	pub fn with_seed(seed: &[u8]) -> Result<ExtendedKeyPair, DerivationError> {
 		let (master_key, chain_code) = derivation::seed_pair(seed);
 		Ok(ExtendedKeyPair::with_secret(
-			Secret::from_slice(&*master_key).map_err(|_| DerivationError::InvalidSeed)?,
+			Secret::from_unsafe_slice(&*master_key).map_err(|_| DerivationError::InvalidSeed)?,
 			chain_code,
 		))
 	}
@@ -402,7 +401,7 @@ mod tests {
 
 	fn test_extended<F>(f: F, test_private: H256) where F: Fn(ExtendedSecret) -> ExtendedSecret {
 		let (private_seed, chain_code) = master_chain_basic();
-		let extended_secret = ExtendedSecret::with_code(Secret::from_slice(&*private_seed).unwrap(), chain_code);
+		let extended_secret = ExtendedSecret::with_code(Secret::from_slice(&*private_seed), chain_code);
 		let derived = f(extended_secret);
 		assert_eq!(**derived.as_raw(), test_private);
 	}

ethkey/src/keypair.rs

@@ -62,7 +62,7 @@ impl KeyPair {
 	}
 
 	pub fn from_secret_slice(slice: &[u8]) -> Result<KeyPair, Error> {
-		Self::from_secret(Secret::from_slice(slice)?)
+		Self::from_secret(Secret::from_unsafe_slice(slice)?)
 	}
 
 	pub fn from_keypair(sec: key::SecretKey, publ: key::PublicKey) -> Self {

ethkey/src/secret.rs

@@ -33,7 +33,7 @@ impl fmt::Debug for Secret {
 }
 
 impl Secret {
-	fn from_slice_unchecked(key: &[u8]) -> Self {
+	pub fn from_slice(key: &[u8]) -> Self {
 		assert_eq!(32, key.len(), "Caller should provide 32-byte length slice");
 
 		let mut h = H256::default();
@@ -41,11 +41,17 @@ impl Secret {
 		Secret { inner: h }
 	}
 
-	pub fn from_slice(key: &[u8]) -> Result<Self, Error> {
+	/// Imports and validates the key.
+	pub fn from_unsafe_slice(key: &[u8]) -> Result<Self, Error> {
 		let secret = key::SecretKey::from_slice(&super::SECP256K1, key)?;
 		Ok(secret.into())
 	}
 
+	/// Checks validity of this key.
+	pub fn check_validity(&self) -> Result<(), Error> {
+		self.to_secp256k1_secret().map(|_| ())
+	}
+
 	/// Inplace add one secret key to another (scalar + scalar)
 	pub fn add(&mut self, other: &Secret) -> Result<(), Error> {
 		let mut key_secret = self.to_secp256k1_secret()?;
@@ -121,14 +127,25 @@ impl Secret {
 impl FromStr for Secret {
 	type Err = Error;
 	fn from_str(s: &str) -> Result<Self, Self::Err> {
-		let hash = H256::from_str(s).map_err(|e| Error::Custom(format!("{:?}", e)))?;
-		Self::from_slice(&hash)
+		Ok(H256::from_str(s).map_err(|e| Error::Custom(format!("{:?}", e)))?.into())
+	}
+}
+
+impl From<H256> for Secret {
+	fn from(s: H256) -> Self {
+		Secret::from_slice(&s)
+	}
+}
+
+impl From<&'static str> for Secret {
+	fn from(s: &'static str) -> Self {
+		s.parse().expect(&format!("invalid string literal for {}: '{}'", stringify!(Self), s))
 	}
 }
 
 impl From<key::SecretKey> for Secret {
 	fn from(key: key::SecretKey) -> Self {
-		Self::from_slice_unchecked(&key[0..32])
+		Self::from_slice(&key[0..32])
 	}
 }