req to pay before maturity date (#495)

Author: zupzup

CHANGELOG.md

@@ -1,3 +1,15 @@
+# 0.3.10
+
+* Change behaviour of request to pay
+    * it's now possible to req to pay before the maturity date
+    * The actual payment expiry still only happens 2 workdays after the end of the maturity date,
+    or end of the req to pay end of day if that was after the maturity date
+    * the `request_to_pay_timed_out` flag is set after payment expired, not after the req to pay expired
+    * The waiting state for payment is only active during the req to pay (while it's blocked)
+      * Afterwards, the bill is not blocked anymore, can still be rejected to pay and paid
+      * But recourse is only possible after the payment expired (after maturity date)
+    * An expired req to pay, which expired before the maturity date does not show up in `past_payments`
+
 # 0.3.9
 
 * Add possibility to use a local regtest esplora setup for payment

crates/bcr-ebill-api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bcr-ebill-api"
-version = "0.3.9"
+version = "0.3.10"
 edition = "2024"
 
 [lib]

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

@@ -2,7 +2,7 @@ use crate::util;
 
 use super::service::BillService;
 use super::{Error, Result};
-use bcr_ebill_core::bill::validation::get_deadline_base_for_req_to_pay;
+use bcr_ebill_core::bill::validation::get_expiration_deadline_base_for_req_to_pay;
 use bcr_ebill_core::constants::RECOURSE_DEADLINE_SECONDS;
 use bcr_ebill_core::contact::Contact;
 use bcr_ebill_core::{
@@ -152,8 +152,10 @@ impl BillService {
             time_of_request_to_pay = Some(req_to_pay_block.timestamp);
             paid = self.store.is_paid(&bill.id).await?;
             rejected_to_pay = chain.block_with_operation_code_exists(BillOpCode::RejectToPay);
-            let deadline_base =
-                get_deadline_base_for_req_to_pay(req_to_pay_block.timestamp, &bill.maturity_date)?;
+            let deadline_base = get_expiration_deadline_base_for_req_to_pay(
+                req_to_pay_block.timestamp,
+                &bill.maturity_date,
+            )?;
             if !paid
                 && !rejected_to_pay
                 && util::date::check_if_deadline_has_passed(
@@ -162,6 +164,7 @@ impl BillService {
                     PAYMENT_DEADLINE_SECONDS,
                 )
             {
+                // this is true, if the payment is expired (after maturity date)
                 request_to_pay_timed_out = true;
             }
         }
@@ -325,7 +328,14 @@ impl BillService {
                     // it's paid - we're not waiting anymore
                     None
                 } else if request_to_pay_timed_out {
-                    // it timed out, we're not waiting anymore
+                    // payment expired, we're not waiting anymore
+                    None
+                } else if util::date::check_if_deadline_has_passed(
+                    last_block.timestamp,
+                    current_timestamp,
+                    PAYMENT_DEADLINE_SECONDS,
+                ) {
+                    // the request timed out, we're not waiting anymore, but the payment isn't expired
                     None
                 } else {
                     // we're waiting, collect data
@@ -508,17 +518,26 @@ impl BillService {
         let payment = &bill.status.payment;
         if payment.requested_to_pay && !payment.paid && !payment.rejected_to_pay {
             if let Some(time_of_request_to_pay) = payment.time_of_request_to_pay {
-                let deadline_base = get_deadline_base_for_req_to_pay(
+                let deadline_base = get_expiration_deadline_base_for_req_to_pay(
                     time_of_request_to_pay,
                     &bill.data.maturity_date,
                 )?;
+                // payment has expired (after maturity date)
                 if util::date::check_if_deadline_has_passed(
                     deadline_base,
                     current_timestamp,
                     PAYMENT_DEADLINE_SECONDS,
                 ) {
                     invalidate_and_recalculate = true;
                 }
+                // req to pay has expired (after maturity date)
+                if util::date::check_if_deadline_has_passed(
+                    time_of_request_to_pay,
+                    current_timestamp,
+                    PAYMENT_DEADLINE_SECONDS,
+                ) {
+                    invalidate_and_recalculate = true;
+                }
             }
         }
 

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

@@ -4244,12 +4244,24 @@ pub mod tests {
                 .check_requests_for_expiration(&bill_payment, 1531593929)
                 .unwrap()
         );
-        // 2 days after req to pay, but not yet 2 days after end of day maturity date
+        // 2 days after req to pay, but not yet 2 days after end of day maturity date, req expired
         assert!(
-            !service
+            service
                 .check_requests_for_expiration(&bill_payment, 1531780429)
                 .unwrap()
         );
+        // after req to pay, and after end of day maturity date, payment expired
+        assert!(
+            service
+                .check_requests_for_expiration(&bill_payment, 1831593928)
+                .unwrap()
+        );
+        // 1 sec after req to pay, not expired at all
+        assert!(
+            !service
+                .check_requests_for_expiration(&bill_payment, 1531593929)
+                .unwrap()
+        );
 
         let mut bill_acceptance = get_baseline_cached_bill(TEST_BILL_ID.to_string());
         bill_acceptance.status.acceptance = BillAcceptanceStatus {

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

@@ -24,7 +24,7 @@ use crate::persistence::identity::{IdentityChainStoreApi, IdentityStoreApi};
 use crate::util::BcrKeys;
 use crate::{external, util};
 use async_trait::async_trait;
-use bcr_ebill_core::bill::validation::get_deadline_base_for_req_to_pay;
+use bcr_ebill_core::bill::validation::get_expiration_deadline_base_for_req_to_pay;
 use bcr_ebill_core::bill::{
     BillIssueData, BillValidateActionData, PastPaymentDataPayment, PastPaymentDataRecourse,
     PastPaymentDataSell, PastPaymentResult, PastPaymentStatus,
@@ -724,8 +724,12 @@ impl BillServiceApi for BillService {
                     .bitcoin_client
                     .get_mempool_link_for_address(&address_to_pay);
 
-                let deadline_base =
-                    get_deadline_base_for_req_to_pay(req_to_pay.timestamp, &bill.maturity_date)?;
+                // we check for the payment expiration, not the request expiration
+                // if the request expired, but the payment deadline hasn't, it's not a past payment
+                let deadline_base = get_expiration_deadline_base_for_req_to_pay(
+                    req_to_pay.timestamp,
+                    &bill.maturity_date,
+                )?;
                 let is_expired = util::date::check_if_deadline_has_passed(
                     deadline_base,
                     timestamp,
@@ -756,9 +760,7 @@ impl BillServiceApi for BillService {
                             };
                             PastPaymentStatus::Rejected(ts)
                         } else {
-                            PastPaymentStatus::Expired(
-                                req_to_pay.timestamp + PAYMENT_DEADLINE_SECONDS,
-                            )
+                            PastPaymentStatus::Expired(deadline_base + PAYMENT_DEADLINE_SECONDS)
                         },
                     }));
                 }

crates/bcr-ebill-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bcr-ebill-core"
-version = "0.3.9"
+version = "0.3.10"
 edition = "2024"
 
 [lib]

crates/bcr-ebill-core/src/bill/validation.rs

@@ -151,12 +151,6 @@ impl Validate for BillValidateActionData {
                 self.bill_is_blocked()?;
                 self.bill_can_only_be_recoursed()?;
                 // not already requested to pay - checked above already
-                // maturity date must have started
-                let maturity_date_start =
-                    util::date::date_string_to_timestamp(&self.maturity_date, None)?;
-                if self.timestamp < maturity_date_start {
-                    return Err(ValidationError::BillRequestedToPayBeforeMaturityDate);
-                }
                 // the caller has to be the bill holder
                 if self.signer_node_id != holder_node_id {
                     return Err(ValidationError::CallerIsNotHolder);
@@ -217,8 +211,8 @@ impl Validate for BillValidateActionData {
                         {
                             // only if the bill is not paid already - checked above
 
-                            // only if the request to pay expired or was rejected
-                            let deadline_base = get_deadline_base_for_req_to_pay(
+                            // only if the deadline to pay expired or was rejected
+                            let deadline_base = get_expiration_deadline_base_for_req_to_pay(
                                 req_to_pay.timestamp,
                                 &self.maturity_date,
                             )?;
@@ -428,18 +422,20 @@ impl Validate for BillValidateActionData {
 }
 
 /// calculates the base for the expiration deadline of a request to pay - if it was before the
-/// maturity date, we take the end of the day of the maturity date, otherwise the req to pay
-/// timestamp
-pub fn get_deadline_base_for_req_to_pay(
+/// maturity date, we take the end of the day of the maturity date, otherwise the end of
+/// day of the req to pay timestamp
+pub fn get_expiration_deadline_base_for_req_to_pay(
     req_to_pay_ts: u64,
     bill_maturity_date: &str,
 ) -> Result<u64, ValidationError> {
     let maturity_date = util::date::date_string_to_timestamp(bill_maturity_date, None)?;
+    // we calculate from the end of the day
     let maturity_date_end_of_day = util::date::end_of_day_as_timestamp(maturity_date);
-    let mut deadline_base = req_to_pay_ts;
+    // we calculate from the end of the day of the request to pay
+    let mut deadline_base = util::date::end_of_day_as_timestamp(req_to_pay_ts);
     // requested to pay after maturity date - deadline base is req to pay
     if deadline_base < maturity_date_end_of_day {
-        // requested to pay before end of maturity date - deadline base is maturity
+        // requested to pay before end of day of maturity date - deadline base is maturity
         // date end of day
         deadline_base = maturity_date_end_of_day;
     }
@@ -476,7 +472,7 @@ impl BillValidateActionData {
                     .blockchain
                     .get_last_version_block_with_op_code(BillOpCode::RequestToPay)
                 {
-                    let deadline_base = get_deadline_base_for_req_to_pay(
+                    let deadline_base = get_expiration_deadline_base_for_req_to_pay(
                         req_to_pay_block.timestamp,
                         &self.maturity_date,
                     )?;
@@ -551,17 +547,16 @@ impl BillValidateActionData {
         Ok(())
     }
 
+    /// active req to pay, calculated from the start of the request
     fn bill_waiting_for_req_to_pay(&self) -> Result<(), ValidationError> {
         if self.blockchain.get_latest_block().op_code == BillOpCode::RequestToPay {
             if let Some(req_to_pay) = self
                 .blockchain
                 .get_last_version_block_with_op_code(BillOpCode::RequestToPay)
             {
-                let deadline_base =
-                    get_deadline_base_for_req_to_pay(req_to_pay.timestamp, &self.maturity_date)?;
                 if !self.is_paid
                     && !util::date::check_if_deadline_has_passed(
-                        deadline_base,
+                        req_to_pay.timestamp, // calculated from start of request
                         self.timestamp,
                         PAYMENT_DEADLINE_SECONDS,
                     )
@@ -593,7 +588,10 @@ mod tests {
             TEST_PRIVATE_KEY_SECP, TEST_PUB_KEY_SECP, VALID_PAYMENT_ADDRESS_TESTNET, valid_address,
             valid_identity_public_data, valid_other_identity_public_data,
         },
-        util::{BcrKeys, date::now},
+        util::{
+            BcrKeys,
+            date::{format_date_string, now},
+        },
     };
 
     use super::*;
@@ -1000,6 +998,8 @@ mod tests {
 
     #[rstest]
     #[case::req_to_pay(BillValidateActionData { signer_node_id: OTHER_TEST_PUB_KEY_SECP.into(), bill_action: BillAction::RequestToPay("sat".into()), ..valid_bill_validate_action_data(valid_bill_blockchain_issue( valid_bill_issue_block_data(),)) }, Ok(()))]
+    #[case::req_to_pay_after_maturity(BillValidateActionData { maturity_date: "2022-11-12".into(), signer_node_id: OTHER_TEST_PUB_KEY_SECP.into(), bill_action: BillAction::RequestToPay("sat".into()), ..valid_bill_validate_action_data(valid_bill_blockchain_issue( valid_bill_issue_block_data(),)) }, Ok(()))]
+    #[case::req_to_pay_before_maturity(BillValidateActionData { maturity_date: "2099-11-12".into(), signer_node_id: OTHER_TEST_PUB_KEY_SECP.into(), bill_action: BillAction::RequestToPay("sat".into()), ..valid_bill_validate_action_data(valid_bill_blockchain_issue( valid_bill_issue_block_data() ,)) }, Ok(()))]
     fn test_validate_bill_req_to_pay_valid(
         #[case] input: BillValidateActionData,
         #[case] expected: Result<(), ValidationError>,
@@ -1019,7 +1019,6 @@ mod tests {
     #[case::payment_expired_only_recourse(BillValidateActionData { bill_action: BillAction::RequestToPay("sat".into()), timestamp: now().timestamp() as u64 + (PAYMENT_DEADLINE_SECONDS * 2), ..valid_bill_validate_action_data(add_req_to_pay_block(valid_bill_blockchain_issue( valid_bill_issue_block_data(),))) }, Err(ValidationError::BillPaymentExpired))]
     #[case::acceptance_expired_only_recourse(BillValidateActionData { bill_action: BillAction::RequestToPay("sat".into()), timestamp: now().timestamp() as u64 + (ACCEPT_DEADLINE_SECONDS * 2), ..valid_bill_validate_action_data(add_req_to_accept_block(valid_bill_blockchain_issue( valid_bill_issue_block_data(),))) }, Err(ValidationError::BillAcceptanceExpired))]
     #[case::req_to_pay_not_holder(BillValidateActionData { bill_action: BillAction::RequestToPay("sat".into()), signer_node_id: TEST_PUB_KEY_SECP.into(), ..valid_bill_validate_action_data(valid_bill_blockchain_issue( valid_bill_issue_block_data(),)) }, Err(ValidationError::CallerIsNotHolder))]
-    #[case::req_to_pay_before_maturity_date(BillValidateActionData { maturity_date: "2099-01-01".into(), bill_action: BillAction::RequestToPay("sat".into()), ..valid_bill_validate_action_data(valid_bill_blockchain_issue( valid_bill_issue_block_data(),)) }, Err(ValidationError::BillRequestedToPayBeforeMaturityDate))]
     #[case::req_to_pay_already_req_to_payed(BillValidateActionData { bill_action: BillAction::RequestToPay("sat".into()), ..valid_bill_validate_action_data(add_req_to_pay_block(valid_bill_blockchain_issue( valid_bill_issue_block_data(),))) }, Err(ValidationError::BillIsRequestedToPayAndWaitingForPayment))]
     fn test_validate_bill_req_to_pay_errors(
         #[case] input: BillValidateActionData,
@@ -1173,6 +1172,7 @@ mod tests {
 
     #[rstest]
     #[case::offer_to_sell(BillValidateActionData { bill_action: BillAction::OfferToSell(valid_other_identity_public_data(), 500, "sat".into()), signer_node_id: OTHER_TEST_PUB_KEY_SECP.into(), ..valid_bill_validate_action_data(valid_bill_blockchain_issue( valid_bill_issue_block_data(),)) }, Ok(()))]
+    #[case::offer_to_sell_req_to_pay_expired_before_maturity(BillValidateActionData { maturity_date: "2099-11-12".into(), timestamp: now().timestamp() as u64 + (PAYMENT_DEADLINE_SECONDS * 2) ,bill_action: BillAction::OfferToSell(valid_other_identity_public_data(), 500, "sat".into()), signer_node_id: OTHER_TEST_PUB_KEY_SECP.into(), ..valid_bill_validate_action_data(add_req_to_pay_block(valid_bill_blockchain_issue( valid_bill_issue_block_data(),))) }, Ok(()))]
     fn test_validate_bill_offer_to_sell_valid(
         #[case] input: BillValidateActionData,
         #[case] expected: Result<(), ValidationError>,
@@ -1200,7 +1200,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::sell_invalid_data_buyer(BillValidateActionData { bill_action: BillAction::Sell(valid_identity_public_data(), 500, "sat".into(), VALID_PAYMENT_ADDRESS_TESTNET.into()), signer_node_id: OTHER_TEST_PUB_KEY_SECP.into(), ..valid_bill_validate_action_data(add_offer_to_sell_block(valid_bill_blockchain_issue( valid_bill_issue_block_data(),))) }, Ok(()))]
+    #[case::sell(BillValidateActionData { bill_action: BillAction::Sell(valid_identity_public_data(), 500, "sat".into(), VALID_PAYMENT_ADDRESS_TESTNET.into()), signer_node_id: OTHER_TEST_PUB_KEY_SECP.into(), ..valid_bill_validate_action_data(add_offer_to_sell_block(valid_bill_blockchain_issue( valid_bill_issue_block_data(),))) }, Ok(()))]
+    // minus 8 seconds so timestamp is before offer to sell expiry and after req to pay expiry
+    // as every block adds 1 sec to issue block, which is now() - 10
+    #[case::sell_req_to_pay_expired_before_maturity(BillValidateActionData { maturity_date: "2099-11-12".into(), timestamp: now().timestamp() as u64 + (PAYMENT_DEADLINE_SECONDS - 8), bill_action: BillAction::Sell(valid_identity_public_data(), 500, "sat".into(), VALID_PAYMENT_ADDRESS_TESTNET.into()), signer_node_id: OTHER_TEST_PUB_KEY_SECP.into(), ..valid_bill_validate_action_data(add_offer_to_sell_block(add_req_to_pay_block(valid_bill_blockchain_issue( valid_bill_issue_block_data(),)))) }, Ok(()))]
     fn test_validate_bill_sell_valid(
         #[case] input: BillValidateActionData,
         #[case] expected: Result<(), ValidationError>,
@@ -1291,7 +1294,8 @@ mod tests {
     }
 
     #[rstest]
-    #[case::reject_to_pay_expired(BillValidateActionData { bill_action: BillAction::RejectPayment, ..valid_bill_validate_action_data(add_req_to_pay_block(valid_bill_blockchain_issue( valid_bill_issue_block_data(),))) }, Ok(()))]
+    #[case::reject_to_pay(BillValidateActionData { bill_action: BillAction::RejectPayment, ..valid_bill_validate_action_data(add_req_to_pay_block(valid_bill_blockchain_issue( valid_bill_issue_block_data(),))) }, Ok(()))]
+    #[case::reject_to_pay_maturity_not_expired(BillValidateActionData { maturity_date: format_date_string(now()),  bill_action: BillAction::RejectPayment, ..valid_bill_validate_action_data(add_req_to_pay_block(valid_bill_blockchain_issue( valid_bill_issue_block_data(),))) }, Ok(()))]
     fn test_validate_bill_reject_payment_valid(
         #[case] input: BillValidateActionData,
         #[case] expected: Result<(), ValidationError>,

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

@@ -317,10 +317,6 @@ pub enum ValidationError {
     #[error("Bill request to pay did not expire and was not rejected")]
     BillRequestToPayDidNotExpireAndWasNotRejected,
 
-    /// error returned if the bill was requested to pay before the maturity date started
-    #[error("Bill requested to pay before maturity date started")]
-    BillRequestedToPayBeforeMaturityDate,
-
     /// error returned if the bill was not requester to recourse, e.g. when rejecting to pay for
     /// recourse
     #[error("Bill was not requested to recourse")]

crates/bcr-ebill-persistence/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bcr-ebill-persistence"
-version = "0.3.9"
+version = "0.3.10"
 edition = "2024"
 
 [lib]

crates/bcr-ebill-transport/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bcr-ebill-transport"
-version = "0.3.9"
+version = "0.3.10"
 edition = "2024"
 
 [lib]