implemented withdraw on the client side

src/bin/darkfid.rs

@@ -1,5 +1,5 @@
 use drk::blockchain::{rocks::columns, Rocks, RocksColumn, Slab};
-use drk::cli::TransferParams;
+use drk::cli::{TransferParams, WithdrawParams};
 use drk::cli::{Config, DarkfidCli, DarkfidConfig};
 use drk::crypto::{
     load_params,
@@ -209,14 +209,17 @@ async fn start(executor: Arc<Executor<'_>>, config: Arc<&DarkfidConfig>) -> Resu
     let gateway_slabs_sub: GatewaySlabsSubscriber =
         client.start_subscriber(sub_addr, executor.clone()).await?;
 
-    // Channels to handle transfer request from adapter
+    // channels to request transfer from adapter
     let (publish_tx_send, publish_tx_recv) = async_channel::unbounded::<TransferParams>();
 
-    // Channels to handle deposit request from adapter and send cashier public key
+    // channels to request deposit from adapter and send cashier public key
     let (deposit_send, deposit_recv) = async_channel::unbounded::<jubjub::SubgroupPoint>();
     let (cashier_deposit_addr_send, cashier_deposit_addr_recv) =
         async_channel::unbounded::<Option<bitcoin::util::address::Address>>();
 
+    // channel to request withdraw from adapter
+    let (withdraw_send, withdraw_recv) = async_channel::unbounded::<WithdrawParams>();
+    
     // start gateway client
     debug!(target: "fn::start client", "start() Client started");
     client.start().await?;
@@ -290,6 +293,7 @@ async fn start(executor: Arc<Executor<'_>>, config: Arc<&DarkfidConfig>) -> Resu
         wallet.clone(),
         publish_tx_send,
         (deposit_send, cashier_deposit_addr_recv),
+        withdraw_send,
     )?;
 
     // start the rpc server

src/rpc/adapter.rs

@@ -1,4 +1,4 @@
-use crate::cli::TransferParams;
+use crate::cli::{TransferParams, WithdrawParams};
 use crate::serial::serialize;
 use crate::service::btc::PubAddress;
 use crate::wallet::WalletDb;
@@ -18,19 +18,22 @@ pub struct RpcAdapter {
     pub wallet: Arc<WalletDb>,
     publish_tx_send: async_channel::Sender<TransferParams>,
     deposit_channel: DepositChannel, 
+    withdraw_channel: async_channel::Sender<WithdrawParams>,
 }
 
 impl RpcAdapter {
     pub fn new(
         wallet: Arc<WalletDb>,
         publish_tx_send: async_channel::Sender<TransferParams>,
-        deposit_channel: DepositChannel 
+        deposit_channel: DepositChannel,
+        withdraw_channel: async_channel::Sender<WithdrawParams>,
     ) -> Result<Self> {
         debug!(target: "ADAPTER", "new() [CREATING NEW WALLET]");
         Ok(Self {
             wallet,
             publish_tx_send,
             deposit_channel,
+            withdraw_channel,
         })
     }
 
@@ -93,9 +96,10 @@ impl RpcAdapter {
         Ok(())
     }
 
-    //pub async fn withdraw(&self, withdraw_params: WithdrawParams) -> Result<()> {
-    //    Ok(())
-    //}
+    pub async fn withdraw(&self, withdraw_params: WithdrawParams) -> Result<()> {
+        self.withdraw_channel.send(withdraw_params).await?;
+        Ok(())
+    }
 
     pub fn get_info(&self) {}
 

src/rpc/jsonserver.rs

@@ -246,10 +246,16 @@ impl RpcInterface {
             }
         });
 
-        io.add_method("withdraw", |params: jsonrpc_core::Params| async move {
-            let parsed: WithdrawParams = params.parse().unwrap();
-            println!("test withdraw params:  {:?}", parsed);
-            Ok(jsonrpc_core::Value::String("withdraw BTC to... ".into()))
+        let self1 = self.clone();
+        io.add_method("withdraw", move |params: jsonrpc_core::Params| {
+            let self2 = self1.clone();
+            async move {
+                let parsed: WithdrawParams = params.parse().unwrap();
+                let amount = parsed.amount.clone();
+                let address = parsed.pub_key.clone();
+                self2.adapter.withdraw(parsed).await?;
+                Ok(jsonrpc_core::Value::String(format!("withdrawing {} BTC to {}...", amount, address)))
+            }
         });
 
         debug!(target: "rpc", "JsonRpcInterface::handle_input() [END]");