Replace parse_address with FromStr::from_str

Author: kseo

codechain/config/mod.rs

@@ -228,10 +228,10 @@ impl Operating {
 impl Mining {
     pub fn overwrite_with(&mut self, matches: &clap::ArgMatches) -> Result<(), String> {
         if let Some(author) = matches.value_of("author") {
-            self.author = Some(parse_address(author)?);
+            self.author = Some(author.parse()?);
         }
         if let Some(engine_signer) = matches.value_of("engine-signer") {
-            self.engine_signer = Some(parse_address(engine_signer)?);
+            self.engine_signer = Some(engine_signer.parse()?);
         }
         if let Some(password_path) = matches.value_of("password-path") {
             self.password_path = Some(password_path.to_string());
@@ -361,7 +361,7 @@ impl ShardValidator {
         }
 
         if let Some(account) = matches.value_of("shard-validator") {
-            self.account = Some(parse_address(account)?)
+            self.account = Some(account.parse()?)
         }
         if let Some(password_path) = matches.value_of("shard-validator-password-path") {
             self.password_path = Some(password_path.to_string());
@@ -388,11 +388,3 @@ pub fn load_config(matches: &clap::ArgMatches) -> Result<Config, String> {
 
     Ok(config)
 }
-
-fn parse_address(value: &str) -> Result<Address, String> {
-    if value.starts_with("0x") {
-        Address::from_str(&value[2..])
-    } else {
-        Address::from_str(value)
-    }.map_err(|_| "Invalid address".to_string())
-}

key/src/address.rs

@@ -24,7 +24,6 @@ use bech32::Bech32;
 use heapsize::HeapSizeOf;
 use primitives::H160;
 use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
-use rustc_hex::FromHexError;
 use serde::de::{Error as SerdeError, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
@@ -97,11 +96,22 @@ impl Decodable for Address {
     }
 }
 
+/// Return `s` without the `0x` at the beginning of it, if any.
+pub fn clean_0x(s: &str) -> &str {
+    if s.starts_with("0x") {
+        &s[2..]
+    } else {
+        s
+    }
+}
+
 impl FromStr for Address {
-    type Err = FromHexError;
+    type Err = String;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(Address(H160::from_str(s)?))
+        let s = clean_0x(s);
+        let a = H160::from_str(s).map_err(|_| format!("Invalid address {}", s))?;
+        Ok(Address(a))
     }
 }