Add endpoint to fetch Bill History (#685)

Author: zupzup

CHANGELOG.md

@@ -13,6 +13,9 @@
 * Print bech32 npub at startup
 * Use strongly typed `url::Url` for nostr relays
 * Use strong types for Date, Name, City, Address, Zip, Country, Identification, Email (breaking API change)
+* Re-Fetch Identity and Company chain endpoints
+* Add endpoint to fetch bill history `billApi.bill_history(bill_id)`
+* Fixed a bug where an anon user could request to recourse, but not actually do the recourse
 
 # 0.4.9
 

crates/bcr-ebill-api/src/external/bitcoin.rs

@@ -97,14 +97,14 @@ impl BitcoinClient {
     pub fn request_url(&self, path: &str) -> String {
         match get_config().bitcoin_network() {
             Network::Bitcoin => {
-                format!("{}/api{path}", get_config().esplora_base_url)
+                format!("{}api{path}", get_config().esplora_base_url)
             }
             Network::Regtest => {
-                format!("{}/regtest/api{path}", get_config().esplora_base_url)
+                format!("{}regtest/api{path}", get_config().esplora_base_url)
             }
             _ => {
                 // for testnet and testnet4
-                format!("{}/testnet/api{path}", get_config().esplora_base_url)
+                format!("{}testnet/api{path}", get_config().esplora_base_url)
             }
         }
     }
@@ -115,11 +115,11 @@ impl BitcoinClient {
                 format!("{}{path}", get_config().esplora_base_url)
             }
             Network::Regtest => {
-                format!("{}/regtest{path}", get_config().esplora_base_url)
+                format!("{}regtest{path}", get_config().esplora_base_url)
             }
             _ => {
                 // for testnet and testnet4
-                format!("{}/testnet{path}", get_config().esplora_base_url)
+                format!("{}testnet{path}", get_config().esplora_base_url)
             }
         }
     }

crates/bcr-ebill-api/src/lib.rs

@@ -15,6 +15,7 @@ pub mod util;
 
 pub use blockchain::Block;
 pub use blockchain::Blockchain;
+pub use blockchain::bill::BillOpCode;
 pub use persistence::DbContext;
 pub use persistence::Error as PersistenceError;
 pub use persistence::db::SurrealDbConfig;

crates/bcr-ebill-api/src/service/bill_service/blocks.rs

@@ -175,37 +175,38 @@ impl BillService {
                     timestamp,
                 )?
             }
-            // has to be ident to recourse
+            // can be anon to recourse
             BillAction::Recourse(recoursee, sum, currency, recourse_reason) => {
                 validate_node_id_network(&recoursee.node_id)?;
-                if let BillParticipant::Ident(signer) = signer_public_data {
-                    let reason = match *recourse_reason {
-                        RecourseReason::Accept => BillRecourseReasonBlockData::Accept,
-                        RecourseReason::Pay(_, _) => BillRecourseReasonBlockData::Pay,
-                    };
-                    let block_data = BillRecourseBlockData {
-                        recourser: signer.clone().into(),
-                        recoursee: recoursee.clone().into(),
-                        sum: *sum,
-                        currency: currency.to_owned(),
-                        recourse_reason: reason,
-                        signatory: signing_keys.signatory_identity,
-                        signing_timestamp: timestamp,
-                        signing_address: signer.postal_address.clone(),
-                    };
-                    block_data.validate()?;
-                    BillBlock::create_block_for_recourse(
-                        bill_id.to_owned(),
-                        previous_block,
-                        &block_data,
-                        &signing_keys.signatory_keys,
-                        signing_keys.company_keys.as_ref(),
-                        &BcrKeys::from_private_key(&bill_keys.private_key)?,
-                        timestamp,
-                    )?
-                } else {
-                    return Err(Error::Validation(ValidationError::SignerCantBeAnon));
-                }
+                let reason = match *recourse_reason {
+                    RecourseReason::Accept => BillRecourseReasonBlockData::Accept,
+                    RecourseReason::Pay(_, _) => BillRecourseReasonBlockData::Pay,
+                };
+                let block_data = BillRecourseBlockData {
+                    recourser: if holder_is_anon {
+                        // if holder is anon, we need to continue as anon
+                        signer_public_data.as_anon().into()
+                    } else {
+                        signer_public_data.clone().into()
+                    },
+                    recoursee: recoursee.clone().into(),
+                    sum: *sum,
+                    currency: currency.to_owned(),
+                    recourse_reason: reason,
+                    signatory: signing_keys.signatory_identity,
+                    signing_timestamp: timestamp,
+                    signing_address: signer_public_data.postal_address(),
+                };
+                block_data.validate()?;
+                BillBlock::create_block_for_recourse(
+                    bill_id.to_owned(),
+                    previous_block,
+                    &block_data,
+                    &signing_keys.signatory_keys,
+                    signing_keys.company_keys.as_ref(),
+                    &BcrKeys::from_private_key(&bill_keys.private_key)?,
+                    timestamp,
+                )?
             }
             // can be anon to mint
             BillAction::Mint(mint, sum, currency) => {

crates/bcr-ebill-api/src/service/bill_service/data_fetching.rs

@@ -148,7 +148,8 @@ impl BillService {
         let time_of_drawing = first_version_bill.signing_timestamp;
 
         let bill_participants = chain.get_all_nodes_from_bill(bill_keys)?;
-        let endorsements = chain.get_endorsements_for_bill(bill_keys);
+        let bill_history = chain.get_bill_history(bill_keys)?;
+        let endorsements = bill_history.get_endorsements();
         let endorsements_count = endorsements.len() as u64;
 
         let holder = match bill.endorsee {
@@ -595,6 +596,7 @@ impl BillService {
             data: bill_data,
             status,
             current_waiting_state,
+            history: bill_history,
         })
     }
 

crates/bcr-ebill-api/src/service/bill_service/mod.rs

@@ -12,7 +12,7 @@ use crate::data::{
 use crate::util::BcrKeys;
 use async_trait::async_trait;
 use bcr_ebill_core::ServiceTraitBounds;
-use bcr_ebill_core::bill::{BillAction, BillIssueData, PastPaymentResult};
+use bcr_ebill_core::bill::{BillAction, BillHistory, BillIssueData, PastPaymentResult};
 use bcr_ebill_core::blockchain::bill::chain::BillBlockPlaintextWrapper;
 
 pub use error::Error;
@@ -235,6 +235,14 @@ pub trait BillServiceApi: ServiceTraitBounds {
         signer_keys: &BcrKeys,
         court_node_id: &NodeId,
     ) -> Result<()>;
+
+    async fn get_bill_history(
+        &self,
+        bill_id: &BillId,
+        local_identity: &Identity,
+        current_identity_node_id: &NodeId,
+        current_timestamp: u64,
+    ) -> Result<BillHistory>;
 }
 
 #[cfg(test)]
@@ -6163,7 +6171,7 @@ pub mod tests {
     }
 
     #[tokio::test]
-    async fn recourse_bitcredit_bill_fails_for_anon() {
+    async fn recourse_bitcredit_bill_works_for_anon() {
         let mut ctx = get_ctx();
         let identity = get_baseline_identity();
         let mut bill = get_baseline_bill(&bill_id_test());
@@ -6219,6 +6227,9 @@ pub mod tests {
             .expect_send_bill_recourse_paid_event()
             .returning(|_, _| Ok(()));
 
+        // Populates identity block
+        expect_populates_identity_block(&mut ctx);
+
         let service = get_service(ctx);
 
         let res = service
@@ -6235,11 +6246,9 @@ pub mod tests {
                 1731593928,
             )
             .await;
-        assert!(res.is_err());
-        assert!(matches!(
-            res.as_ref().unwrap_err(),
-            Error::Validation(ValidationError::SignerCantBeAnon)
-        ));
+        assert!(res.is_ok());
+        assert_eq!(res.as_ref().unwrap().blocks().len(), 3);
+        assert_eq!(res.unwrap().blocks()[2].op_code, BillOpCode::Recourse);
     }
 
     #[test]
@@ -7360,4 +7369,40 @@ pub mod tests {
             Err(Error::Validation(ValidationError::InvalidNodeId))
         ));
     }
+
+    #[tokio::test]
+    async fn get_bill_history_baseline() {
+        let mut ctx = get_ctx();
+        let identity = get_baseline_identity();
+        let mut bill = get_baseline_bill(&bill_id_test());
+        bill.drawee = bill_identified_participant_only_node_id(identity.identity.node_id.clone());
+        let drawer_node_id = bill.drawer.node_id.clone();
+        ctx.bill_store.expect_exists().returning(|_| Ok(true));
+        ctx.bill_blockchain_store
+            .expect_get_chain()
+            .returning(move |_| Ok(get_genesis_chain(Some(bill.clone()))));
+        ctx.notification_service
+            .expect_get_active_bill_notification()
+            .with(eq(bill_id_test()))
+            .returning(|_| None);
+
+        let res = get_service(ctx)
+            .get_bill_history(
+                &bill_id_test(),
+                &identity.identity,
+                &identity.identity.node_id,
+                1731593928,
+            )
+            .await;
+        assert!(res.is_ok());
+        assert_eq!(res.as_ref().unwrap().blocks.len(), 1);
+        assert_eq!(
+            res.as_ref().unwrap().blocks[0].block_type,
+            BillOpCode::Issue
+        );
+        assert_eq!(
+            res.as_ref().unwrap().blocks[0].signed.data.node_id(),
+            drawer_node_id
+        );
+    }
 }

crates/bcr-ebill-api/src/service/bill_service/payment.rs

@@ -163,19 +163,33 @@ impl BillService {
                     debug!(
                         "bill {bill_id} is recourse-paid - creating recourse block if we're recourser"
                     );
-                    // If we are the recourser and a bill issuer and it's paid, we add a Recourse block
+                    // If we are the recourser and it's paid, we add a Recourse block
                     if payment_info.recourser.node_id() == identity.identity.node_id {
-                        if let Ok(signer_identity) =
-                            BillIdentParticipant::new(identity.identity.clone())
-                        {
-                            let reason = match payment_info.reason {
-                                BillRecourseReasonBlockData::Pay => RecourseReason::Pay(
-                                    payment_info.sum,
-                                    payment_info.currency.clone(),
-                                ),
-                                BillRecourseReasonBlockData::Accept => RecourseReason::Accept,
-                            };
-                            let _ = self
+                        let signer_identity = match identity.identity.t {
+                            IdentityType::Ident => {
+                                if let Ok(signer_identity) =
+                                    BillIdentParticipant::new(identity.identity.clone())
+                                {
+                                    BillParticipant::Ident(signer_identity)
+                                } else {
+                                    log::error!(
+                                        "Signer {} for bill {bill_id} is not a valid signer",
+                                        &identity.identity.node_id
+                                    );
+                                    return Ok(()); // return early
+                                }
+                            }
+                            IdentityType::Anon => BillParticipant::Anon(BillAnonParticipant::new(
+                                identity.identity.clone(),
+                            )),
+                        };
+                        let reason = match payment_info.reason {
+                            BillRecourseReasonBlockData::Pay => {
+                                RecourseReason::Pay(payment_info.sum, payment_info.currency.clone())
+                            }
+                            BillRecourseReasonBlockData::Accept => RecourseReason::Accept,
+                        };
+                        let _ = self
                             .execute_bill_action(
                                 bill_id,
                                 BillAction::Recourse(
@@ -189,17 +203,11 @@ impl BillService {
                                     payment_info.currency,
                                     reason,
                                 ),
-                                &BillParticipant::Ident(signer_identity),
+                                &signer_identity,
                                 &identity.key_pair,
                                 now,
                             )
                             .await?;
-                        } else {
-                            log::error!(
-                                "Signer {} for bill {bill_id} is not a valid signer",
-                                &identity.identity.node_id
-                            );
-                        }
                         return Ok(()); // return early
                     }
 
@@ -297,7 +305,7 @@ impl BillService {
                 // if offer to sell was paid, attempt to create sell block
                 if matches!(payment_state, PaymentState::PaidConfirmed(..)) {
                     debug!("bill {bill_id} got bought - creating sell block if we're seller");
-                    // If we are the seller and anon, or a bill issuer and it's paid, we add a Sell block
+                    // If we are the seller and it's paid, we add a Sell block
                     if payment_info.seller.node_id() == identity.identity.node_id {
                         let signer_identity = match identity.identity.t {
                             IdentityType::Ident => {

crates/bcr-ebill-api/src/service/bill_service/service.rs

@@ -32,8 +32,9 @@ use crate::util::file::UploadFileType;
 use crate::{external, util};
 use async_trait::async_trait;
 use bcr_ebill_core::bill::{
-    BillIssueData, BillValidateActionData, PastPaymentDataPayment, PastPaymentDataRecourse,
-    PastPaymentDataSell, PastPaymentResult, PastPaymentStatus, PaymentState,
+    BillHistory, BillIssueData, BillValidateActionData, PastPaymentDataPayment,
+    PastPaymentDataRecourse, PastPaymentDataSell, PastPaymentResult, PastPaymentStatus,
+    PaymentState,
 };
 use bcr_ebill_core::blockchain::bill::block::{
     BillParticipantBlockData, BillRequestRecourseBlockData,
@@ -1938,4 +1939,22 @@ impl BillServiceApi for BillService {
         );
         Ok(())
     }
+
+    async fn get_bill_history(
+        &self,
+        bill_id: &BillId,
+        local_identity: &Identity,
+        current_identity_node_id: &NodeId,
+        current_timestamp: u64,
+    ) -> Result<BillHistory> {
+        let detail = self
+            .get_detail(
+                bill_id,
+                local_identity,
+                current_identity_node_id,
+                current_timestamp,
+            )
+            .await?;
+        Ok(detail.history)
+    }
 }

crates/bcr-ebill-api/src/service/bill_service/test_utils.rs

@@ -158,6 +158,7 @@ pub fn get_baseline_cached_bill(id: BillId) -> BitcreditBillResult {
             last_block_time: 1731593928,
         },
         current_waiting_state: None,
+        history: BillHistory { blocks: vec![] },
     }
 }
 
@@ -380,14 +381,17 @@ pub fn recourse_block(
         id.to_owned(),
         first_block,
         &BillRecourseBlockData {
-            recourser: bill_identified_participant_only_node_id(node_id_test()).into(),
+            recourser: BillParticipant::Ident(bill_identified_participant_only_node_id(
+                node_id_test(),
+            ))
+            .into(),
             recoursee: recoursee.to_owned().into(),
             sum: 15000,
             currency: CURRENCY_SAT.to_string(),
             recourse_reason: BillRecourseReasonBlockData::Pay,
             signatory: None,
             signing_timestamp: first_block.timestamp + 1,
-            signing_address: empty_address(),
+            signing_address: Some(empty_address()),
         },
         &BcrKeys::from_private_key(&private_key_test()).unwrap(),
         None,