check mint status for quote,add cronjob, add to changelog,add cancel to mint (#524)

Author: zupzup

CHANGELOG.md

@@ -4,9 +4,12 @@
     * Add default mint configuration options
         * `default_mint_url`
         * `default_mint_node_id`
+    * Implement `request_to_mint`
     * Add minting status flag to bill
     * Add endpoint to fetch minting status for a bill
-* Implement `request_to_mint`
+    * Add logic for checking mint request status on the mint
+    * Add cronjob to check mint requests
+    * Add endpoint to cancel mint requests
 * Change bitcoin addresses and descriptor to p2wpkh
 * Suppress logging from crates we don't control
 

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

@@ -3,10 +3,10 @@ use bcr_ebill_core::{
     PostalAddress, ServiceTraitBounds,
     bill::BitcreditBill,
     contact::{BillAnonParticipant, BillIdentParticipant, BillParticipant, ContactType},
-    util::BcrKeys,
+    util::{BcrKeys, date::DateTimeUtc},
 };
-use bcr_wdc_webapi::quotes::{BillInfo, EnquireReply, EnquireRequest};
-use cashu::nut01 as cdk01;
+use bcr_wdc_webapi::quotes::{BillInfo, EnquireReply, EnquireRequest, StatusReply};
+use cashu::{nut01 as cdk01, nut02 as cdk02};
 use thiserror::Error;
 
 /// Generic result type
@@ -38,13 +38,20 @@ use crate::util;
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait MintClientApi: ServiceTraitBounds {
+    /// Request to mint a bill with a given mint
     async fn enquire_mint_quote(
         &self,
         mint_url: &str,
         requester_keys: &BcrKeys,
         bill: &BitcreditBill,
         endorsees: &[BillParticipant],
     ) -> Result<String>;
+    /// Look up a quote for a mint
+    async fn lookup_quote_for_mint(
+        &self,
+        mint_url: &str,
+        quote_id: &str,
+    ) -> Result<QuoteStatusReply>;
 }
 
 #[derive(Debug, Clone, Default)]
@@ -113,6 +120,54 @@ impl MintClientApi for MintClient {
         let reply: EnquireReply = res.json().await.map_err(Error::from)?;
         Ok(reply.id.to_string())
     }
+
+    async fn lookup_quote_for_mint(
+        &self,
+        mint_url: &str,
+        quote_id: &str,
+    ) -> Result<QuoteStatusReply> {
+        let url = format!("{}/v1/mint/credit/quote/{quote_id}", mint_url);
+        let res = self.cl.get(&url).send().await.map_err(Error::from)?;
+        let reply: StatusReply = res.json().await.map_err(Error::from)?;
+        Ok(reply.into())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum QuoteStatusReply {
+    Pending,
+    Denied,
+    Offered {
+        keyset_id: cdk02::Id,
+        expiration_date: DateTimeUtc,
+        discounted: bitcoin::Amount,
+    },
+    Accepted {
+        keyset_id: cdk02::Id,
+    },
+    Rejected {
+        tstamp: DateTimeUtc,
+    },
+}
+
+impl From<StatusReply> for QuoteStatusReply {
+    fn from(value: StatusReply) -> Self {
+        match value {
+            StatusReply::Pending => QuoteStatusReply::Pending,
+            StatusReply::Denied => QuoteStatusReply::Denied,
+            StatusReply::Offered {
+                keyset_id,
+                expiration_date,
+                discounted,
+            } => QuoteStatusReply::Offered {
+                keyset_id,
+                expiration_date,
+                discounted,
+            },
+            StatusReply::Accepted { keyset_id } => QuoteStatusReply::Accepted { keyset_id },
+            StatusReply::Rejected { tstamp } => QuoteStatusReply::Rejected { tstamp },
+        }
+    }
 }
 
 // These are needed for now, because we use different `bcr-ebill-core` versions in wildcat and here

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

@@ -62,6 +62,10 @@ pub enum Error {
     #[error("Can not get recoursee identity from contacts.")]
     RecourseeNotInContacts,
 
+    /// errors that stem from trying to cancel a mint request that's not pending
+    #[error("Mint request can only be cancelled if it's pending.")]
+    CancelMintRequestNotPending,
+
     /// errors that stem from bill validation errors
     #[error("bill validation error {0}")]
     Validation(#[from] bcr_ebill_core::ValidationError),

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

@@ -187,6 +187,19 @@ pub trait BillServiceApi: ServiceTraitBounds {
         current_identity_node_id: &str,
     ) -> Result<Vec<MintRequestState>>;
 
+    /// Cancel a pending request to mint
+    async fn cancel_request_to_mint(
+        &self,
+        mint_request_id: &str,
+        current_identity_node_id: &str,
+    ) -> Result<()>;
+
+    /// Check mint state for a given bill
+    async fn check_mint_state(&self, bill_id: &str, current_identity_node_id: &str) -> Result<()>;
+
+    /// Check mint state for all bills
+    async fn check_mint_state_for_all_bills(&self) -> Result<()>;
+
     /// Clear the bill cache
     async fn clear_bill_cache(&self) -> Result<()>;
 }

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

@@ -14,7 +14,7 @@ use crate::data::{
     identity::Identity,
 };
 use crate::external::bitcoin::BitcoinClientApi;
-use crate::external::mint::MintClientApi;
+use crate::external::mint::{MintClientApi, QuoteStatusReply};
 use crate::get_config;
 use crate::persistence::bill::BillChainStoreApi;
 use crate::persistence::bill::BillStoreApi;
@@ -36,7 +36,7 @@ use bcr_ebill_core::constants::{
 };
 use bcr_ebill_core::contact::{BillAnonParticipant, BillParticipant, Contact};
 use bcr_ebill_core::identity::{IdentityType, IdentityWithAll};
-use bcr_ebill_core::mint::{MintRequestState, MintRequestStatus};
+use bcr_ebill_core::mint::{MintRequest, MintRequestState, MintRequestStatus};
 use bcr_ebill_core::notification::ActionType;
 use bcr_ebill_core::util::currency;
 use bcr_ebill_core::{ServiceTraitBounds, Validate, ValidationError};
@@ -276,6 +276,86 @@ impl BillService {
         }
         Ok(())
     }
+
+    /// Checks a given mint quote and updates the bill mint state, if there was a change
+    pub(super) async fn check_mint_quote_and_update_bill_mint_state(
+        &self,
+        mint_request: &MintRequest,
+    ) -> Result<()> {
+        debug!(
+            "Checking mint request for quote {}",
+            &mint_request.mint_request_id
+        );
+        // if it doesn't have a 'finished' state, we check the quote at the mint
+        if !matches!(
+            mint_request.status,
+            MintRequestStatus::Cancelled
+                | MintRequestStatus::Rejected
+                | MintRequestStatus::Expired
+                | MintRequestStatus::Denied
+                | MintRequestStatus::Accepted
+        ) {
+            let mint_cfg = &get_config().mint_config;
+            // for now, we only support the default mint
+            if mint_request.mint_node_id == mint_cfg.default_mint_node_id {
+                let updated_status = self
+                    .mint_client
+                    .lookup_quote_for_mint(
+                        &mint_cfg.default_mint_url,
+                        &mint_request.mint_request_id,
+                    )
+                    .await?;
+                // only update, if changed
+                match updated_status {
+                        QuoteStatusReply::Pending => {
+                            if !matches!(mint_request.status, MintRequestStatus::Pending) {
+                                self.mint_store
+                                    .update_request(
+                                        &mint_request.mint_request_id,
+                                        &MintRequestStatus::Pending,
+                                    )
+                                    .await?;
+                            }
+                        }
+                        QuoteStatusReply::Denied => {
+                            // checked above, that it's not denied
+                            self.mint_store
+                                .update_request(&mint_request.mint_request_id, &MintRequestStatus::Denied)
+                                .await?;
+                        }
+                        QuoteStatusReply::Offered {
+                            ..
+                            // keyset_id,
+                            // expiration_date,
+                            // discounted,
+                        } => {
+                            if !matches!(mint_request.status, MintRequestStatus::Offered) {
+                                // TODO next task: if not offered yet, persist offer
+                                self.mint_store
+                                    .update_request(
+                                        &mint_request.mint_request_id,
+                                        &MintRequestStatus::Offered,
+                                    )
+                                    .await?;
+                            }
+                        }
+                        QuoteStatusReply::Accepted { .. } => {
+                            // checked above, that it's not accepted
+                            self.mint_store
+                                .update_request(&mint_request.mint_request_id, &MintRequestStatus::Accepted)
+                                .await?;
+                        }
+                        QuoteStatusReply::Rejected { .. } => {
+                            // checked above, that it's not rejected
+                            self.mint_store
+                                .update_request(&mint_request.mint_request_id, &MintRequestStatus::Rejected)
+                                .await?;
+                        }
+                    };
+            }
+        }
+        Ok(())
+    }
 }
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -691,7 +771,7 @@ impl BillServiceApi for BillService {
             .mint_store
             .get_requests(&signer_public_data.node_id(), bill_id, mint_node_id)
             .await?;
-        // If there are any active (i.e. pending, accepted or offered) requests, we can't make another one
+        // If there are any active, or accepted (i.e. pending, accepted or offered) requests, we can't make another one
         if requests_to_mint_for_bill_and_mint.iter().any(|rtm| {
             matches!(
                 rtm.status,
@@ -1118,6 +1198,66 @@ impl BillServiceApi for BillService {
             .collect())
     }
 
+    async fn cancel_request_to_mint(
+        &self,
+        mint_request_id: &str,
+        current_identity_node_id: &str,
+    ) -> Result<()> {
+        debug!("trying to cancel request to mint {mint_request_id}");
+        match self.mint_store.get_request(mint_request_id).await {
+            Ok(Some(req)) => {
+                if req.requester_node_id == current_identity_node_id {
+                    if matches!(req.status, MintRequestStatus::Pending) {
+                        // TODO next task: call endpoint on mint to cancel
+                        self.mint_store
+                            .update_request(mint_request_id, &MintRequestStatus::Cancelled)
+                            .await?;
+                        Ok(())
+                    } else {
+                        Err(Error::CancelMintRequestNotPending)
+                    }
+                } else {
+                    Err(Error::NotFound)
+                }
+            }
+            Ok(None) => Err(Error::NotFound),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    async fn check_mint_state(&self, bill_id: &str, current_identity_node_id: &str) -> Result<()> {
+        debug!("checking mint requests for bill {bill_id}");
+        let requests = self
+            .mint_store
+            .get_requests_for_bill(current_identity_node_id, bill_id)
+            .await?;
+        for req in requests {
+            if let Err(e) = self.check_mint_quote_and_update_bill_mint_state(&req).await {
+                error!(
+                    "Could not check mint state for {}: {e}",
+                    &req.mint_request_id
+                );
+            }
+        }
+        Ok(())
+    }
+
+    async fn check_mint_state_for_all_bills(&self) -> Result<()> {
+        debug!("checking all active mint requests");
+        // get all active (offered, pending) requests
+        let requests = self.mint_store.get_all_active_requests().await?;
+        debug!("checking all active mint requests ({})", requests.len());
+        for req in requests {
+            if let Err(e) = self.check_mint_quote_and_update_bill_mint_state(&req).await {
+                error!(
+                    "Could not check mint state for {}: {e}",
+                    &req.mint_request_id
+                );
+            }
+        }
+        Ok(())
+    }
+
     async fn clear_bill_cache(&self) -> Result<()> {
         self.store.clear_bill_cache().await?;
         Ok(())

crates/bcr-ebill-api/src/tests/mod.rs

@@ -14,7 +14,7 @@ pub mod tests {
         company::{Company, CompanyKeys},
         contact::{BillIdentParticipant, BillParticipant, Contact, ContactType},
         identity::{ActiveIdentityState, Identity, IdentityType, IdentityWithAll},
-        mint::MintRequest,
+        mint::{MintRequest, MintRequestStatus},
         nostr_contact::{HandshakeStatus, NostrContact, TrustLevel},
         notification::{ActionType, Notification, NotificationType},
         util::crypto::BcrKeys,
@@ -59,6 +59,7 @@ pub mod tests {
         #[async_trait]
         impl MintStoreApi for MintStore {
             async fn exists_for_bill(&self, requester_node_id: &str, bill_id: &str) -> Result<bool>;
+            async fn get_all_active_requests(&self) -> Result<Vec<MintRequest>>;
             async fn get_requests(
                 &self,
                 requester_node_id: &str,
@@ -78,6 +79,12 @@ pub mod tests {
                 mint_request_id: &str,
                 timestamp: u64,
             ) -> Result<()>;
+            async fn get_request(&self, mint_request_id: &str) -> Result<Option<MintRequest>>;
+            async fn update_request(
+                &self,
+                mint_request_id: &str,
+                new_status: &MintRequestStatus,
+            ) -> Result<()>;
         }
     }
 

crates/bcr-ebill-persistence/src/constants.rs

@@ -21,7 +21,11 @@ pub const DB_OP_CODE: &str = "op_code";
 
 pub const DB_COMPANY_ID: &str = "company_id";
 pub const DB_BILL_ID: &str = "bill_id";
+pub const DB_STATUS: &str = "status";
+pub const DB_STATUS_OFFERED: &str = "status_offered";
+pub const DB_STATUS_PENDING: &str = "status_pending";
 pub const DB_MINT_NODE_ID: &str = "mint_node_id";
+pub const DB_MINT_REQUEST_ID: &str = "mint_request_id";
 pub const DB_MINT_REQUESTER_NODE_ID: &str = "requester_node_id";
 pub const DB_SEARCH_TERM: &str = "search_term";