small perf improvements and mempool link (#390)

* small perf improvements
* add mempool link

Author: zupzup

src/blockchain/mod.rs

@@ -26,6 +26,10 @@ pub enum Error {
     #[error("Blockchain is invalid")]
     BlockchainInvalid,
 
+    /// If there is an error deserializing and decrypting blocks
+    #[error("Could not parse and decrypt blockchain")]
+    BlockchainParse,
+
     /// If certain block is not valid and can't be added
     #[error("Block is invalid")]
     BlockInvalid,

src/external/bitcoin.rs

@@ -56,6 +56,8 @@ pub trait BitcoinClientApi: Send + Sync {
         pkey: &bitcoin::PrivateKey,
         pkey_to_combine: &bitcoin::PrivateKey,
     ) -> Result<String>;
+
+    fn get_mempool_link_for_address(&self, address: &str) -> String;
 }
 
 #[derive(Clone)]
@@ -76,6 +78,17 @@ impl BitcoinClient {
             }
         }
     }
+
+    pub fn link_url(&self, path: &str) -> String {
+        match CONFIG.bitcoin_network() {
+            Network::Bitcoin => {
+                format!("https://blockstream.info{path}")
+            }
+            _ => {
+                format!("https://blockstream.info/testnet{path}")
+            }
+        }
+    }
 }
 
 #[async_trait]
@@ -169,6 +182,10 @@ impl BitcoinClientApi for BitcoinClient {
             .map_err(Error::from)?;
         Ok(bitcoin::PrivateKey::new(private_key_bill, CONFIG.bitcoin_network()).to_string())
     }
+
+    fn get_mempool_link_for_address(&self, address: &str) -> String {
+        self.link_url(&format!("/address/{address}"))
+    }
 }
 
 /// Fields documented at https://github.com/Blockstream/esplora/blob/master/API.md#addresses

src/external/time.rs

@@ -10,7 +10,7 @@ pub struct TimeApi {
 
 impl TimeApi {
     pub async fn get_atomic_time() -> Self {
-        match reqwest::get("https://api.timezonedb.com/v2.1/get-time-zone?key=RQ6ZFDOXPVLR&format=json&by=zone&zone=Europe/Vienna")
+        match reqwest::get("https://vip.timezonedb.com/v2.1/get-time-zone?key=AY3Q7V1JPPNX&format=json&fields=timestamp&by=zone&zone=UTC")
             .await
             {
                 Err(e) => {

src/persistence/db/notification.rs

@@ -314,8 +314,10 @@ mod tests {
             .await
             .expect("could not create notification");
 
-        let mut filter = NotificationFilter::default();
-        filter.active = Some(true);
+        let filter = NotificationFilter {
+            active: Some(true),
+            ..Default::default()
+        };
         let all = store
             .list(filter.clone())
             .await

src/service/bill_service.rs

@@ -41,6 +41,7 @@ use crate::{error, CONFIG};
 use async_trait::async_trait;
 use borsh::to_vec;
 use borsh_derive::{BorshDeserialize, BorshSerialize};
+use futures::future::try_join_all;
 use log::info;
 #[cfg(test)]
 use mockall::automock;
@@ -934,13 +935,30 @@ impl BillService {
             .await?;
         let first_version_bill = chain.get_first_version_bill(&bill_keys)?;
         let time_of_drawing = first_version_bill.signing_timestamp;
-        let bill_participants = chain.get_all_nodes_from_bill(&bill_keys)?;
-        let endorsements_count = chain.get_endorsements_count();
 
+        // handle expensive deserialization and decryption logic in parallel on a blocking thread
+        // pool as not to block the task queue
+        let chain_clone = chain.clone();
+        let keys_clone = bill_keys.clone();
+        let bill_participants_handle =
+            tokio::task::spawn_blocking(move || chain_clone.get_all_nodes_from_bill(&keys_clone));
+        let chain_clone = chain.clone();
+        let keys_clone = bill_keys.clone();
+        let chain_to_return_handle = tokio::task::spawn_blocking(move || {
+            BillBlockchainToReturn::new(chain_clone, &keys_clone)
+        });
+        let (bill_participants_res, chain_to_return_res) =
+            tokio::try_join!(bill_participants_handle, chain_to_return_handle).map_err(|e| {
+                error!("couldn't get data from bill chain blocks {bill_id}: {e}");
+                Error::Blockchain(blockchain::Error::BlockchainParse)
+            })?;
+        let bill_participants = bill_participants_res?;
+        let chain_to_return = chain_to_return_res?;
+
+        let endorsements_count = chain.get_endorsements_count();
         let mut in_recourse = false;
         let mut link_to_pay_recourse = "".to_string();
         let mut link_for_buy = "".to_string();
-        let chain_to_return = BillBlockchainToReturn::new(chain.clone(), &bill_keys)?;
         let endorsed = chain.block_with_operation_code_exists(BillOpCode::Endorse);
         let accepted = chain.block_with_operation_code_exists(BillOpCode::Accept);
         let last_offer_to_sell_block_waiting_for_payment =
@@ -1038,6 +1056,9 @@ impl BillService {
         let address_to_pay = self
             .bitcoin_client
             .get_address_to_pay(&bill_keys.public_key, holder_public_key)?;
+        let mempool_link_for_address_to_pay = self
+            .bitcoin_client
+            .get_mempool_link_for_address(&address_to_pay);
         let mut paid = false;
         if requested_to_pay {
             paid = self.store.is_paid(&bill.id).await?;
@@ -1083,6 +1104,7 @@ impl BillService {
             recoursee,
             link_to_pay_recourse,
             address_to_pay,
+            mempool_link_for_address_to_pay,
             chain_of_blocks: chain_to_return,
             files: bill.files,
             active_notification,
@@ -1838,50 +1860,57 @@ impl BillServiceApi for BillService {
     }
 
     async fn get_bills_from_all_identities(&self) -> Result<Vec<BitcreditBillToReturn>> {
-        let mut res = vec![];
         let bill_ids = self.store.get_ids().await?;
         let identity = self.identity_store.get().await?;
-        let current_timestamp = external::time::TimeApi::get_atomic_time().await.timestamp;
-
-        for bill_id in bill_ids {
-            let bill = self
-                .get_full_bill(&bill_id, &identity, &identity.node_id, current_timestamp)
-                .await?;
-            res.push(bill)
-        }
+        let current_timestamp = util::date::now().timestamp() as u64;
+
+        let tasks = bill_ids.iter().map(|id| {
+            let identity_clone = identity.clone();
+            async move {
+                self.get_full_bill(
+                    id,
+                    &identity_clone,
+                    &identity_clone.node_id,
+                    current_timestamp,
+                )
+                .await
+            }
+        });
+        let bills = try_join_all(tasks).await?;
 
-        Ok(res)
+        Ok(bills)
     }
 
     async fn get_bills(
         &self,
         current_identity_node_id: &str,
     ) -> Result<Vec<BitcreditBillToReturn>> {
-        let mut res = vec![];
         let bill_ids = self.store.get_ids().await?;
         let identity = self.identity_store.get().await?;
-        let current_timestamp = external::time::TimeApi::get_atomic_time().await.timestamp;
-
-        for bill_id in bill_ids {
-            let bill = self
-                .get_full_bill(
-                    &bill_id,
-                    &identity,
+        let current_timestamp = util::date::now().timestamp() as u64;
+
+        let tasks = bill_ids.iter().map(|id| {
+            let identity_clone = identity.clone();
+            async move {
+                self.get_full_bill(
+                    id,
+                    &identity_clone,
                     current_identity_node_id,
                     current_timestamp,
                 )
-                .await?;
-            // filter for currently active identity
-            if bill
-                .bill_participants
-                .iter()
-                .any(|p| p == current_identity_node_id)
-            {
-                res.push(bill);
+                .await
             }
-        }
-
-        Ok(res)
+        });
+        let bills = try_join_all(tasks).await?;
+
+        Ok(bills
+            .into_iter()
+            .filter(|b| {
+                b.bill_participants
+                    .iter()
+                    .any(|p| p == current_identity_node_id)
+            })
+            .collect())
     }
 
     async fn get_combined_bitcoin_key_for_bill(
@@ -3233,6 +3262,7 @@ pub struct BitcreditBillToReturn {
     pub link_to_pay: String,
     pub link_to_pay_recourse: String,
     pub address_to_pay: String,
+    pub mempool_link_for_address_to_pay: String,
     pub chain_of_blocks: BillBlockchainToReturn,
     pub files: Vec<File>,
     /// The currently active notification for this bill if any
@@ -3479,6 +3509,13 @@ pub mod tests {
         bitcoin_client
             .expect_get_address_to_pay()
             .returning(|_, _| Ok(String::from("1Jfn2nZcJ4T7bhE8FdMRz8T3P3YV4LsWn2")));
+        bitcoin_client
+            .expect_get_mempool_link_for_address()
+            .returning(|_| {
+                String::from(
+                    "http://blockstream.info/testnet/address/1Jfn2nZcJ4T7bhE8FdMRz8T3P3YV4LsWn2",
+                )
+            });
         bitcoin_client.expect_generate_link_to_pay().returning(|_,_,_| String::from("bitcoin:1Jfn2nZcJ4T7bhE8FdMRz8T3P3YV4LsWn2?amount=0.01&message=Payment in relation to bill some bill"));
         BillService::new(
             Client::new(

src/service/contact_service.rs

@@ -63,6 +63,7 @@ pub trait ContactServiceApi: Send + Sync {
     ) -> Result<Contact>;
 
     /// Returns whether a given npub (as hex) is in our contact list.
+    #[allow(dead_code)]
     async fn is_known_npub(&self, npub: &str) -> Result<bool>;
 
     /// opens and decrypts the attached file from the given contact

src/service/notification_service/default_service.rs

@@ -782,8 +782,10 @@ mod tests {
         let mut mock_store = MockNotificationStoreApi::new();
         let result = Notification::new_bill_notification("bill_id", "node_id", "desc", None);
         let returning = result.clone();
-        let mut filter = NotificationFilter::default();
-        filter.active = Some(true);
+        let filter = NotificationFilter {
+            active: Some(true),
+            ..Default::default()
+        };
         mock_store
             .expect_list()
             .with(eq(filter.clone()))

src/web/handlers/bill.rs

@@ -310,7 +310,7 @@ pub async fn bill_detail(
     state: &State<ServiceContext>,
     id: &str,
 ) -> Result<Json<BitcreditBillToReturn>> {
-    let current_timestamp = external::time::TimeApi::get_atomic_time().await.timestamp;
+    let current_timestamp = util::date::now().timestamp() as u64;
     let identity = state.identity_service.get_identity().await?;
     let bill_detail = state
         .bill_service