Merge branch 'master' of github.com:darkrenaissance/darkfi

src/bin/cashierd.rs

@@ -26,7 +26,7 @@ async fn start(executor: Arc<Executor<'_>>, config: Arc<CashierdConfig>) -> Resu
 
     let wallet = Arc::new(CashierDb::new("cashier.db", config.password.clone())?);
 
-    // TODO add to config 
+    // TODO add to config
     let client_wallet_path = "cashier_client_wallet.db";
 
     debug!(target: "cashierd", "starting cashier service");
@@ -41,7 +41,8 @@ async fn start(executor: Arc<Executor<'_>>, config: Arc<CashierdConfig>) -> Resu
             PathBuf::from("cashier_spend.params"),
         ),
         PathBuf::from(client_wallet_path),
-    ).await?;
+    )
+    .await?;
 
     cashier.start(ex.clone()).await?;
 

src/client/mod.rs

@@ -25,19 +25,15 @@ impl fmt::Display for ClientFailed {
             }
             ClientFailed::UnvalidAddress(i) => {
                 write!(f, "Unvalid Address {}", i)
-            }            
+            }
             ClientFailed::UnvalidAmount(i) => {
                 write!(f, "Unvalid Amount {}", i)
             }
-            ClientFailed::UnableToGetDepositAddress => {
-                f.write_str("Unable to get deposit address")
-            }
+            ClientFailed::UnableToGetDepositAddress => f.write_str("Unable to get deposit address"),
             ClientFailed::UnableToGetWithdrawAddress => {
                 f.write_str("Unable to get withdraw address")
             }
-            ClientFailed::EmptyPassword => {
-                f.write_str("Password is empty. Cannot create database")
-            }
+            ClientFailed::EmptyPassword => f.write_str("Password is empty. Cannot create database"),
             ClientFailed::ClientError(i) => {
                 write!(f, "ClientError: {}", i)
             }

src/error.rs

@@ -1,8 +1,8 @@
 use jsonrpc_core::*;
 use std::fmt;
 
-use crate::state;
 use crate::client;
+use crate::state;
 use crate::vm::ZkVmError;
 
 pub type Result<T> = std::result::Result<T, Error>;

src/service/btc.rs

@@ -2,17 +2,15 @@ use crate::{Error, Result};
 use rand::distributions::Alphanumeric;
 use rand::{thread_rng, Rng};
 
-use async_executor::Executor;
 use async_std::sync::Arc;
 use bitcoin::blockdata::script::Script;
 use bitcoin::network::constants::Network;
 use bitcoin::util::address::Address;
 use bitcoin::util::ecdsa::{PrivateKey, PublicKey};
-use electrum_client::{Client as ElectrumClient, ElectrumApi};
+use electrum_client::{Client as ElectrumClient, ElectrumApi, GetBalanceRes};
 use log::*;
 use secp256k1::key::SecretKey;
 
-
 // Swap out these types for any future non bitcoin-rs types
 pub type PubAddress = Address;
 pub type PubKey = PublicKey;
@@ -66,49 +64,38 @@ impl BitcoinKeys {
         }))
     }
 
-    pub async fn start_subscribe(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "BTC", "Subscribe");
-
+    pub async fn start_subscribe(self: Arc<Self>) -> Result<Option<GetBalanceRes>> {
+        debug!(target: "deposit", "BTC: Subscribe to scriptpubkey");
+        let client = &self.btc_client;
         // Check if script is already subscribed
-        if let Some(status) = self.btc_client.script_subscribe(&self.script).unwrap() {
-            let subscribe_status_task =
-                executor.spawn(self.subscribe_status_loop(status, executor.clone()));
-            debug!(target: "BTC", "Subscribed to scripthash");
-            let _ = subscribe_status_task.cancel().await;
-            Ok(())
-        } else {
-            return Err(Error::ServicesError("received wrong command"));
-        }
-    }
-
-    async fn subscribe_status_loop(
-        self: Arc<Self>,
-        status_start: electrum_client::ScriptStatus,
-        _executor: Arc<Executor<'_>>,
-    ) -> Result<Option<electrum_client::GetBalanceRes>> {
-        loop {
-            let check = self.btc_client.script_pop(&self.script).unwrap();
-            match check {
-
-                Some(status) => {
-                    // Script has a notification update
-                    if status != status_start {
-                        let balance = self.btc_client.script_get_balance(&self.script).unwrap();
-                        if balance.confirmed > 0 {
-                            return Ok(Some(balance))
+        if let Some(status_start) = client.script_subscribe(&self.script)? {
+            loop {
+                match client.script_pop(&self.script)? {
+                    Some(status) => {
+                        // Script has a notification update
+                        if status != status_start {
+                            let balance = client.script_get_balance(&self.script)?;
+                            if balance.confirmed > 0 {
+                                debug!(target: "deposit", "BTC Balance: Confirmed!");
+                                return Ok(Some(balance));
+                            } else {
+                                debug!(target: "deposit", "BTC Balance: Unconfirmed!");
+                                continue;
+                            }
                         } else {
-                            continue
+                            debug!(target: "deposit", "ScriptPubKey status has not changed");
+                            continue;
                         }
-
-                    } else {
-                        continue
                     }
-                }
-
-                None => break,
-            }
+                    None => {
+                        debug!(target: "deposit", "Scriptpubkey does not yet exist in script notifications!");
+                        continue;
+                    }
+                };
+            } // Endloop
+        } else {
+            return Err(Error::ServicesError("Did not subscribe to scriptpubkey"));
         }
-        Ok(None)
     }
 
     // This should do a db lookup to return the same obj

src/service/cashier.rs

@@ -61,11 +61,11 @@ impl CashierService {
         let rocks = Rocks::new(&cashier_database_path)?;
 
         let client = Client::new(
-            cashier_secret,
-            rocks,
-            gateway_addrs,
-            params_paths,
-            client_wallet_path.clone(),
+                cashier_secret,
+                rocks,
+                gateway_addrs,
+                params_paths,
+                client_wallet_path.clone(),
         )?;
 
         let client = Arc::new(Mutex::new(client));
@@ -89,25 +89,25 @@ impl CashierService {
         let btc_client = self.btc_client.clone();
 
         let handle_request_task = executor.spawn(Self::handle_request_loop(
-            send.clone(),
-            recv.clone(),
-            wallet.clone(),
-            btc_client.clone(),
-            executor.clone(),
+                send.clone(),
+                recv.clone(),
+                wallet.clone(),
+                btc_client.clone(),
+                executor.clone(),
         ));
 
         self.client.lock().await.start().await?;
 
         // this for test
         let client_wallet = Arc::new(WalletDb::new(
-            &PathBuf::from("cashier_client_wallet.db"),
-            "123".into(),
+                &PathBuf::from("cashier_client_wallet.db"),
+                "123".into(),
         )?);
 
         let cashier_client_subscriber_task = executor.spawn(Client::connect_to_subscriber(
-            self.client.clone(),
-            executor.clone(),
-            client_wallet,
+                self.client.clone(),
+                executor.clone(),
+                client_wallet,
         ));
 
         protocol.run(executor.clone()).await?;
@@ -163,14 +163,13 @@ impl CashierService {
                 Ok(msg) => {
                     let _ = executor
                         .spawn(Self::handle_request(
-                            msg,
-                            btc_client.clone(),
-                            wallet.clone(),
-                            send_queue.clone(),
-                            executor.clone(),
+                                msg,
+                                btc_client.clone(),
+                                wallet.clone(),
+                                send_queue.clone(),
                         ))
                         .detach();
-                }
+                    }
                 Err(_) => {
                     break;
                 }
@@ -183,7 +182,6 @@ impl CashierService {
         btc_client: Arc<ElectrumClient>,
         cashier_wallet: CashierDbPtr,
         send_queue: async_channel::Sender<(PeerId, Reply)>,
-        executor: Arc<Executor<'_>>,
     ) -> Result<()> {
         let request = msg.1;
         let peer = msg.0;
@@ -193,11 +191,11 @@ impl CashierService {
                 // Exchange zk_pubkey for bitcoin address
                 let zkpub = request.get_payload();
 
-                //check if key has already been issued
+                //TODO: check if key has already been issued
                 let _check = cashier_wallet.get_keys_by_dkey(&zkpub);
 
                 // Generate bitcoin Address
-                let btc_keys = BitcoinKeys::new(btc_client).unwrap();
+                let btc_keys = BitcoinKeys::new(btc_client)?;
 
                 let btc_pub = btc_keys.get_pubkey();
                 let btc_priv = btc_keys.get_privkey();
@@ -218,7 +216,7 @@ impl CashierService {
                 // start scheduler for checking balance
                 debug!(target: "BTC", "Subscribing");
 
-                let _ = btc_keys.start_subscribe(executor.clone()).await?;
+                let _ = btc_keys.start_subscribe().await?;
 
                 //self.mint_dbtc(deserialize(&zkpub).unwrap(), 100);
 

src/util.rs

@@ -17,4 +17,3 @@ pub fn join_config_path(file: &PathBuf) -> Result<PathBuf> {
 
     Ok(path)
 }
-

src/wallet/cashierdb.rs

@@ -1,9 +1,9 @@
+use crate::client::ClientFailed;
 use crate::serial;
 use crate::serial::{deserialize, serialize, Decodable, Encodable};
 use crate::service::btc::{PrivKey, PubKey};
 use crate::util::join_config_path;
 use crate::{Error, Result};
-use crate::client::ClientFailed;
 
 use async_std::sync::Arc;
 use ff::Field;

src/wallet/walletdb.rs

@@ -1,10 +1,10 @@
+use crate::client::ClientFailed;
 use crate::crypto::{
     coin::Coin, merkle::IncrementalWitness, merkle_node::MerkleNode, note::Note, OwnCoins,
 };
 use crate::serial;
 use crate::serial::{deserialize, serialize, Decodable, Encodable};
 use crate::{Error, Result};
-use crate::client::ClientFailed;
 
 use async_std::sync::{Arc, Mutex};
 use ff::Field;