minor changes and clean up

src/bin/cashierd.rs

@@ -450,7 +450,7 @@ impl Cashierd {
             if mint_address_opt.is_none() {
                 mint_address = "";
             }
-            let drk_pub_key = Address::from_str(drk_pub_key.into())?;
+            let drk_pub_key = Address::from_str(drk_pub_key)?;
             let drk_pub_key: PublicKey = PublicKey::try_from(drk_pub_key)?;
 
             // check if the drk public key already exist

src/bin/darkfid.rs

@@ -228,7 +228,7 @@ impl Darkfid {
 
             let mut bytes = [0u8; 32];
             let bytes_vec: Vec<u8> = serde_json::from_str(&keypair_str)?;
-            bytes.copy_from_slice(&bytes_vec.as_slice());
+            bytes.copy_from_slice(bytes_vec.as_slice());
 
             let secret: SecretKey = SecretKey::from_bytes(&bytes)?;
             let public: PublicKey = PublicKey::from_secret(secret);
@@ -292,7 +292,7 @@ impl Darkfid {
         let addr_str = args.unwrap()[0].as_str().unwrap();
 
         let result: Result<()> = async {
-            let public = PublicKey::try_from(Address::from_str(addr_str.into())?)?;
+            let public = PublicKey::try_from(Address::from_str(addr_str)?)?;
             self.client.lock().await.set_default_keypair(&public).await?;
             Ok(())
         }
@@ -566,7 +566,7 @@ impl Darkfid {
                 let cashier_public = cashier_public.result.as_str().unwrap();
 
                 let cashier_public: PublicKey =
-                    PublicKey::try_from(Address::from_str(cashier_public.into())?)?;
+                    PublicKey::try_from(Address::from_str(cashier_public)?)?;
 
                 self.client
                     .lock()
@@ -649,7 +649,7 @@ impl Darkfid {
         }
 
         let result: Result<()> = async {
-            let drk_address: PublicKey = PublicKey::try_from(Address::from_str(address.into())?)?;
+            let drk_address: PublicKey = PublicKey::try_from(Address::from_str(address)?)?;
 
             let decimals: usize = 8;
             let amount = decode_base10(amount, decimals, true)?;
@@ -685,7 +685,7 @@ async fn start(
     let mut cashier_keys = Vec::new();
 
     if let Some(cpub) = local_cashier {
-        let cashier_public: PublicKey = PublicKey::try_from(Address::from_str(cpub.into())?)?;
+        let cashier_public: PublicKey = PublicKey::try_from(Address::from_str(&cpub)?)?;
 
         cashiers.push(Cashier {
             name: "localCashier".into(),
@@ -701,7 +701,7 @@ async fn start(
             }
 
             let cashier_public: PublicKey =
-                PublicKey::try_from(Address::from_str(cashier.public_key.into())?)?;
+                PublicKey::try_from(Address::from_str(&cashier.public_key)?)?;
 
             cashiers.push(Cashier {
                 name: cashier.name,

src/util/address.rs

@@ -1,4 +1,4 @@
-use std::io;
+use std::{io, str::FromStr};
 
 use sha2::Digest;
 
@@ -16,22 +16,11 @@ enum AddressType {
 pub struct Address(pub [u8; 37]);
 
 impl Address {
-    pub fn from_str(address: String) -> Result<Self> {
-        let bytes = bs58::decode(&address).into_vec();
-        if bytes.is_ok() && Self::is_valid_address(bytes.as_ref().unwrap().clone()) {
-            let mut bytes_arr = [0u8; 37];
-            bytes_arr.copy_from_slice(bytes.unwrap().as_slice());
-            Ok(Self(bytes_arr))
-        } else {
-            return Err(Error::InvalidAddress)
-        }
-    }
-
     fn is_valid_address(address: Vec<u8>) -> bool {
         if address.starts_with(&[AddressType::Payment as u8]) && address.len() == 37 {
             // hash the version + publickey to check the checksum
             let mut hasher = sha2::Sha256::new();
-            hasher.update(address[..33].to_vec());
+            hasher.update(&address[..33]);
             let payload_hash = hasher.finalize().to_vec();
 
             payload_hash[..4] == address[33..]
@@ -49,6 +38,21 @@ impl std::fmt::Display for Address {
     }
 }
 
+impl FromStr for Address {
+    type Err = Error;
+
+    fn from_str(address: &str) -> Result<Self> {
+        let bytes = bs58::decode(&address).into_vec();
+        if bytes.is_ok() && Self::is_valid_address(bytes.as_ref().unwrap().clone()) {
+            let mut bytes_arr = [0u8; 37];
+            bytes_arr.copy_from_slice(bytes.unwrap().as_slice());
+            Ok(Self(bytes_arr))
+        } else {
+            Err(Error::InvalidAddress)
+        }
+    }
+}
+
 impl From<PublicKey> for Address {
     fn from(publickey: PublicKey) -> Self {
         let mut publickey = publickey.to_bytes().to_vec();
@@ -105,7 +109,7 @@ mod tests {
 
         // from/to string
         let address_str = address.to_string();
-        let from_str = Address::from_str(address_str.clone())?;
+        let from_str = Address::from_str(&address_str)?;
         assert_eq!(from_str, address);
 
         Ok(())