converting PublicKey to String using Address type

src/bin/cashierd.rs

@@ -27,7 +27,7 @@ use drk::{
     service::{bridge, bridge::Bridge},
     state::State,
     types::DrkTokenId,
-    util::{expand_path, generate_id2, join_config_path, parse::truncate, NetworkName},
+    util::{expand_path, generate_id2, join_config_path, parse::truncate, Address, NetworkName},
     wallet::{
         cashierdb::{CashierDb, TokenKey},
         walletdb::WalletDb,
@@ -450,8 +450,8 @@ impl Cashierd {
             if mint_address_opt.is_none() {
                 mint_address = "";
             }
-            let drk_pub_key = bs58::decode(&drk_pub_key).into_vec()?;
-            let drk_pub_key: PublicKey = deserialize(&drk_pub_key)?;
+            let drk_pub_key = Address::from_str(drk_pub_key.into())?;
+            let drk_pub_key: PublicKey = PublicKey::from(drk_pub_key);
 
             // check if the drk public key already exist
             let check = self
@@ -603,7 +603,7 @@ impl Cashierd {
                     .await?;
             }
 
-            let cashier_public_str = bs58::encode(serialize(&cashier_public)).into_string();
+            let cashier_public_str = Address::from(cashier_public).to_string();
             Ok(cashier_public_str)
         }
         .await;
@@ -695,7 +695,7 @@ async fn start(
     let nullifiers = RocksColumn::<columns::Nullifiers>::new(rocks);
 
     let cashier_public = client.main_keypair.public;
-    let cashier_public_str = bs58::encode(&serialize(&cashier_public)).into_string();
+    let cashier_public_str = Address::from(cashier_public).to_string();
     cashierd.public_key = cashier_public_str.clone();
 
     let cashier_public_keys = vec![cashier_public];

src/bin/darkfid.rs

@@ -24,12 +24,11 @@ use drk::{
         },
         rpcserver::{listen_and_serve, RequestHandler, RpcServerConfig},
     },
-    serial::{deserialize, serialize},
     state::{ProgramState, State},
     types::DrkTokenId,
     util::{
-        assign_id, decode_base10, encode_base10, expand_path, join_config_path, DrkTokenList,
-        NetworkName, TokenList,
+        assign_id, decode_base10, encode_base10, expand_path, join_config_path, Address,
+        DrkTokenList, NetworkName, TokenList,
     },
     wallet::walletdb::WalletDb,
     Error, Result,
@@ -165,8 +164,8 @@ impl Darkfid {
     // <-- {"result": "vdNS7oBj7KvsMWWmo9r96SV4SqATLrGsH2a3PGpCfJC"}
     async fn get_key(&self, id: Value, _params: Value) -> JsonResult {
         let pk = self.client.lock().await.main_keypair.public;
-        let b58 = bs58::encode(serialize(&pk)).into_string();
-        JsonResult::Resp(jsonresp(json!(b58), id))
+        let addr = Address::from(pk).to_string();
+        JsonResult::Resp(jsonresp(json!(addr), id))
     }
 
     // --> {"method": "get_keys", "params": []}
@@ -385,10 +384,8 @@ impl Darkfid {
             Err(e) => return JsonResult::Err(jsonerr(InternalError, Some(e.to_string()), id)),
         };
 
-        // TODO: Optional sanity checking here, but cashier *must* do so too.
-
         let pk = self.client.lock().await.main_keypair.public;
-        let pubkey = bs58::encode(serialize(&pk)).into_string();
+        let pubkey = Address::from(pk).to_string();
 
         // Send request to cashier. If the cashier supports the requested network
         // (and token), it shall return a valid address where tokens can be deposited.
@@ -488,7 +485,7 @@ impl Darkfid {
                 let cashier_public = cashier_public.result.as_str().unwrap();
 
                 let cashier_public: PublicKey =
-                    deserialize(&bs58::decode(cashier_public).into_vec()?)?;
+                    PublicKey::from(Address::from_str(cashier_public.into())?);
 
                 self.client
                     .lock()
@@ -571,8 +568,7 @@ impl Darkfid {
         }
 
         let result: Result<()> = async {
-            let drk_address = bs58::decode(&address).into_vec()?;
-            let drk_address: PublicKey = deserialize(&drk_address)?;
+            let drk_address: PublicKey = PublicKey::from(Address::from_str(address.into())?);
 
             let decimals: usize = 8;
             let amount = decode_base10(amount, decimals, true)?;
@@ -608,7 +604,7 @@ async fn start(
     let mut cashier_keys = Vec::new();
 
     if let Some(cpub) = local_cashier {
-        let cashier_public: PublicKey = deserialize(&bs58::decode(cpub).into_vec()?)?;
+        let cashier_public: PublicKey = PublicKey::from(Address::from_str(cpub.into())?);
 
         cashiers.push(Cashier {
             name: "localCashier".into(),
@@ -624,7 +620,7 @@ async fn start(
             }
 
             let cashier_public: PublicKey =
-                deserialize(&bs58::decode(cashier.public_key).into_vec()?)?;
+                PublicKey::from(Address::from_str(cashier.public_key.into())?);
 
             cashiers.push(Cashier {
                 name: cashier.name,

src/client.rs

@@ -15,11 +15,12 @@ use crate::{
         proof::ProvingKey,
         OwnCoin,
     },
-    serial::{serialize, Decodable, Encodable},
+    serial::{Decodable, Encodable},
     service::GatewayClient,
     state::{state_transition, State, StateUpdate},
     tx,
     types::DrkTokenId,
+    util::Address,
     wallet::{
         cashierdb::CashierDbPtr,
         walletdb::{Balances, WalletPtr},
@@ -103,7 +104,7 @@ impl Client {
         }
 
         let main_keypair = wallet.get_default_keypair().await?;
-        info!("Main keypair: {}", bs58::encode(&serialize(&main_keypair.public)).into_string());
+        info!("Main keypair: {}", Address::from(main_keypair.public).to_string());
 
         trace!("Creating GatewayClient");
         let slabstore = RocksColumn::<columns::Slabs>::new(rocks);