pass btc address as String instead of bitcoin::Address type in withdraw

process

src/bin/darkfid.rs

@@ -153,7 +153,7 @@ pub async fn futures_broker(
     gateway_slabs_sub: async_channel::Receiver<Slab>,
     deposit_req: async_channel::Receiver<jubjub::SubgroupPoint>,
     deposit_rep: async_channel::Sender<Option<bitcoin::util::address::Address>>,
-    withdraw_req: async_channel::Receiver<bitcoin::util::address::Address>,
+    withdraw_req: async_channel::Receiver<String>,
     withdraw_rep: async_channel::Sender<Option<jubjub::SubgroupPoint>>,
     publish_tx_recv: async_channel::Receiver<TransferParams>,
 ) -> Result<()> {
@@ -296,7 +296,7 @@ async fn start(executor: Arc<Executor<'_>>, config: Arc<&DarkfidConfig>) -> Resu
         async_channel::unbounded::<Option<bitcoin::util::address::Address>>();
 
     // channel to request withdraw from adapter, send BTC key and receive DRK key
-    let (withdraw_req_send, withdraw_req_recv) = async_channel::unbounded::<bitcoin::Address>();
+    let (withdraw_req_send, withdraw_req_recv) = async_channel::unbounded::<String>();
     let (withdraw_rep_send, withdraw_rep_recv) =
         async_channel::unbounded::<Option<jubjub::SubgroupPoint>>();
 

src/rpc/adapters/user_adapter.rs

@@ -3,7 +3,6 @@ use crate::serial::serialize;
 use crate::service::btc::PubAddress;
 use crate::wallet::WalletDb;
 use crate::{Error, Result};
-use std::str::FromStr;
 use std::string::ToString;
 
 use log::*;
@@ -16,7 +15,7 @@ pub type DepositChannel = (
     async_channel::Receiver<Option<bitcoin::util::address::Address>>,
 );
 pub type WithdrawChannel = (
-    async_channel::Sender<bitcoin::util::address::Address>,
+    async_channel::Sender<String>,
     async_channel::Receiver<Option<jubjub::SubgroupPoint>>,
 );
 
@@ -195,9 +194,8 @@ impl UserAdapter {
 
     pub async fn withdraw(&self, withdraw_params: WithdrawParams) -> Result<()> {
         debug!(target: "withdraw", "withdraw: START");
-        let btc_address = bitcoin::util::address::Address::from_str(&withdraw_params.pub_key)?;
         // do the key exchange
-        self.withdraw_channel.0.send(btc_address).await?;
+        self.withdraw_channel.0.send(withdraw_params.pub_key).await?;
         // send the drk
         if let Some(key) = self.withdraw_channel.1.recv().await? {
             let mut transfer_params = TransferParams::new();

src/service/cashier.rs

@@ -7,7 +7,6 @@ use electrum_client::{Client, ElectrumApi};
 
 use super::GatewayClient;
 use crate::blockchain::Slab;
-
 use crate::crypto::load_params;
 use crate::serial::{deserialize, serialize, Encodable};
 use crate::tx;
@@ -18,9 +17,12 @@ use bellman::groth16;
 use bls12_381::Bls12;
 
 use async_executor::Executor;
+
 use async_std::sync::Arc;
 use log::*;
+
 use std::net::SocketAddr;
+use std::str::FromStr;
 
 #[repr(u8)]
 enum CashierError {
@@ -192,13 +194,16 @@ impl CashierService {
                 info!("Waiting for address balance");
             }
             1 => {
-                let _btc_address = request.get_payload();
+                let btc_address = request.get_payload();
+                let btc_address: String = deserialize(&btc_address)?;
+                let _btc_address = bitcoin::util::address::Address::from_str(&btc_address)?;
 
-                let address = cashier_wallet.get_cashier_public()?;
+                let cashier_secret = cashier_wallet.get_cashier_private()?;
+                let cashier_public = zcash_primitives::constants::SPENDING_KEY_GENERATOR * cashier_secret;
 
                 let mut reply = Reply::from(&request, CashierError::NoError as u32, vec![]);
 
-                reply.set_payload(serialize(&address));
+                reply.set_payload(serialize(&cashier_public));
 
                 send_queue.send((peer, reply)).await?;
 
@@ -232,14 +237,14 @@ impl CashierClient {
 
     pub async fn withdraw(
         &mut self,
-        _btc_address: bitcoin::Address,
+        btc_address: String,
     ) -> Result<Option<jubjub::SubgroupPoint>> {
         let handle_error = Arc::new(handle_error);
         let rep = self
             .protocol
             .request(
                 CashierCommand::Withdraw as u8,
-                vec![], //TODO convert btc_address to bytes,
+                serialize(&btc_address),
                 handle_error,
             )
             .await?;