Merge branch 'main' into feat

Author: maramina

contracts/invoice/src/errors.rs

@@ -26,4 +26,5 @@ pub enum InvoiceError {
     UntrustedSigner = 21,
     AlreadyAttested = 22,
     VerificationRequired = 23,
+    CrossContractCallFailed = 24,
 }

contracts/invoice/src/lib.rs

@@ -558,7 +558,6 @@ impl InvoiceContract {
             .instance()
             .set(&DataKey::Counter, &next_counter);
 
-        let now = env.ledger().timestamp();
         let mut hash_input = Bytes::new(&env);
         let issuer_xdr = issuer.clone().to_xdr(&env);
         let buyer_xdr = buyer.clone().to_xdr(&env);
@@ -1062,6 +1061,8 @@ impl InvoiceContract {
     /// * `InvoiceError::NotFound` if the invoice cannot be found, or if the invoice has no
     ///   recorded funding pool or funding timestamp.
     /// * `InvoiceError::InvalidStatusTransition` if invoice status is not `Funded`, `Active`, or `Confirmed`.
+    /// * `InvoiceError::CrossContractCallFailed` if escrow or pool repayment accounting
+    ///   returns `false`.
     ///
     /// # Returns
     /// * `bool` - `true` when repayment is completed.
@@ -1131,20 +1132,26 @@ impl InvoiceContract {
         let mut escrow_args = Vec::new(&env);
         escrow_args.push_back(invoice_id.clone().into_val(&env));
         escrow_args.push_back(face_value.into_val(&env));
-        let _: bool =
+        let escrow_released: bool =
             env.invoke_contract(&escrow, &Symbol::new(&env, "release_to_pool"), escrow_args);
+        if !escrow_released {
+            panic_with_error!(&env, InvoiceError::CrossContractCallFailed);
+        }
 
         // Step 3: notify pool to update its internal accounting
         let mut args = Vec::new(&env);
         args.push_back(invoice_id.clone().into_val(&env));
         args.push_back(face_value.into_val(&env));
         args.push_back(refund_to_buyer.into_val(&env));
         args.push_back(buyer.into_val(&env));
-        let _: bool = env.invoke_contract(
+        let repayment_recorded: bool = env.invoke_contract(
             &pool,
             &Symbol::new(&env, "receive_repayment_with_refund"),
             args,
         );
+        if !repayment_recorded {
+            panic_with_error!(&env, InvoiceError::CrossContractCallFailed);
+        }
 
         let mut updated = invoice;
         updated.status = InvoiceStatus::Repaid;
@@ -1173,6 +1180,8 @@ impl InvoiceContract {
     ///
     /// * `InvoiceError::NotFound` if the invoice, pool, or funding timestamp does not exist.
     /// * `InvoiceError::InvalidStatusTransition` if the invoice is not in the `Confirmed` status or if `now >= due_date`.
+    /// * `InvoiceError::CrossContractCallFailed` if escrow or pool repayment accounting
+    ///   returns `false`.
     ///
     /// # Returns
     ///
@@ -1242,20 +1251,26 @@ impl InvoiceContract {
         let mut escrow_args = Vec::new(&env);
         escrow_args.push_back(invoice_id.clone().into_val(&env));
         escrow_args.push_back(face_value.into_val(&env));
-        let _: bool =
+        let escrow_released: bool =
             env.invoke_contract(&escrow, &Symbol::new(&env, "release_to_pool"), escrow_args);
+        if !escrow_released {
+            panic_with_error!(&env, InvoiceError::CrossContractCallFailed);
+        }
 
         // Step 3: notify pool to update its internal accounting
         let mut args = Vec::new(&env);
         args.push_back(invoice_id.clone().into_val(&env));
         args.push_back(face_value.into_val(&env));
         args.push_back(refund_to_buyer.into_val(&env));
         args.push_back(buyer.into_val(&env));
-        let _: bool = env.invoke_contract(
+        let repayment_recorded: bool = env.invoke_contract(
             &pool,
             &Symbol::new(&env, "receive_repayment_with_refund"),
             args,
         );
+        if !repayment_recorded {
+            panic_with_error!(&env, InvoiceError::CrossContractCallFailed);
+        }
 
         let mut updated = invoice;
         updated.status = InvoiceStatus::Repaid;
@@ -1293,6 +1308,8 @@ impl InvoiceContract {
     /// * `InvoiceError::InvalidStatusTransition` if invoice is not `Funded`, `Active`, or `Confirmed`.
     /// * `InvoiceError::DueDateNotPassed` if `now < due_date` — the due date
     ///   has not yet been reached.
+    /// * `InvoiceError::CrossContractCallFailed` if the pool returns `false` from
+    ///   `handle_default`.
     ///
     /// # Returns
     /// * `bool` - `true` when default processing succeeds.
@@ -1307,9 +1324,10 @@ impl InvoiceContract {
     /// and has no awareness of, the escrow contract's own
     /// `DEFAULT_MIN_LOCK_SECONDS` grace period (60s from the escrow lock
     /// timestamp, roughly `funded_at`). If `due_date` is reached less than
-    /// that window after the invoice was funded, this call sets the invoice's
-    /// local status to `Defaulted` and then transitively invokes
-    /// `escrow.handle_default()` (via `pool.handle_default`), which panics
+    /// that window after the invoice was funded, the downstream default call
+    /// may panic from the escrow constraint. The whole transaction reverts, so
+    /// the invoice remains unchanged. The call transitively invokes
+    /// `escrow.handle_default()` (via `pool.handle_default`), which may panic
     /// with `EscrowError::NotAuthorized`. The whole transaction reverts, so
     /// there is no persistent state inconsistency, but the caller sees a
     /// revert originating from a constraint this contract does not itself
@@ -1336,19 +1354,31 @@ impl InvoiceContract {
         }
 
         let prev_status = invoice.status;
-        invoice.status = InvoiceStatus::Defaulted;
-        Self::save_invoice(&env, inv_key, &invoice);
-        Self::extend_instance_ttl(&env);
-
-        move_status_index(&env, &invoice_id, prev_status, InvoiceStatus::Defaulted);
 
         let pool: Address = invoice
             .funding_pool
+            .clone()
             .unwrap_or_else(|| panic_with_error!(&env, InvoiceError::NotFound));
         let mut args = Vec::new(&env);
         args.push_back(invoice_id.clone().into_val(&env));
-        let _: bool = env.invoke_contract(&pool, &Symbol::new(&env, "handle_default"), args);
-        events::invoice_defaulted(&env, &invoice_id);
+        let default_handled: bool =
+            env.invoke_contract(&pool, &Symbol::new(&env, "handle_default"), args);
+        if !default_handled {
+            panic_with_error!(&env, InvoiceError::CrossContractCallFailed);
+        }
+
+        let current: Invoice = env
+            .storage()
+            .persistent()
+            .get(&inv_key)
+            .unwrap_or_else(|| panic_with_error!(&env, InvoiceError::NotFound));
+        if current.status == prev_status {
+            invoice.status = InvoiceStatus::Defaulted;
+            Self::save_invoice(&env, inv_key, &invoice);
+            Self::extend_instance_ttl(&env);
+            move_status_index(&env, &invoice_id, prev_status, InvoiceStatus::Defaulted);
+            events::invoice_defaulted(&env, &invoice_id);
+        }
         true
     }
 

contracts/invoice/src/test.rs

@@ -10,7 +10,10 @@ use soroban_sdk::{
     Address, BytesN, Env, IntoVal, String, Symbol, TryFromVal,
 };
 
-use crate::{InvoiceContract, InvoiceContractClient, InvoiceStatus, TTL_EXTEND_TO, TTL_THRESHOLD};
+use crate::{
+    InvoiceContract, InvoiceContractClient, InvoiceStatus, MAX_FACE_VALUE, TTL_EXTEND_TO,
+    TTL_THRESHOLD,
+};
 
 // Default invoice parameters used across tests.
 // These computed constants eliminate magic numbers in test assertions
@@ -92,8 +95,20 @@ pub struct MockPool;
 
 #[contractimpl]
 impl MockPool {
-    pub fn handle_default(_env: Env, _invoice_id: BytesN<32>) -> bool {
-        true
+    pub fn set_return_values(env: Env, handle_default: bool, repayment: bool) {
+        env.storage()
+            .instance()
+            .set(&Symbol::new(&env, "handle_default"), &handle_default);
+        env.storage()
+            .instance()
+            .set(&Symbol::new(&env, "repayment"), &repayment);
+    }
+
+    pub fn handle_default(env: Env, _invoice_id: BytesN<32>) -> bool {
+        env.storage()
+            .instance()
+            .get(&Symbol::new(&env, "handle_default"))
+            .unwrap_or(true)
     }
 
     pub fn receive_repayment(_env: Env, _invoice_id: BytesN<32>, _amount: u128) -> bool {
@@ -114,7 +129,10 @@ impl MockPool {
     ) -> bool {
         let key = Symbol::new(&env, "last_refund");
         env.storage().instance().set(&key, &refund);
-        true
+        env.storage()
+            .instance()
+            .get(&Symbol::new(&env, "repayment"))
+            .unwrap_or(true)
     }
 
     pub fn get_last_refund(env: Env) -> u128 {
@@ -701,6 +719,26 @@ fn test_create_fails_zero_face_value() {
     client.create(&issuer, &buyer, &0, &due_date, &usdc);
 }
 
+#[test]
+fn test_create_succeeds_at_max_face_value() {
+    let (env, client, issuer, buyer, _, usdc) = setup();
+    let due_date = env.ledger().timestamp() + DEFAULT_DUE_OFFSET;
+
+    let invoice_id = client.create(&issuer, &buyer, &MAX_FACE_VALUE, &due_date, &usdc);
+
+    assert_eq!(client.get(&invoice_id).face_value, MAX_FACE_VALUE);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #16)")]
+fn test_create_fails_above_max_face_value() {
+    let (env, client, issuer, buyer, _, usdc) = setup();
+    let due_date = env.ledger().timestamp() + DEFAULT_DUE_OFFSET;
+    let above_max = MAX_FACE_VALUE.checked_add(1).unwrap();
+
+    client.create(&issuer, &buyer, &above_max, &due_date, &usdc);
+}
+
 #[test]
 #[should_panic(expected = "Error(Contract, #7)")]
 fn test_create_fails_past_due_date() {
@@ -2232,6 +2270,12 @@ impl MockEscrow {
             .set(&Symbol::new(&env, "asset"), &asset);
     }
 
+    pub fn set_release_result(env: Env, result: bool) {
+        env.storage()
+            .instance()
+            .set(&Symbol::new(&env, "release_result"), &result);
+    }
+
     /// Minimal stub: transfers `amount` from escrow to pool.
     /// No pool auth required — mirrors the real escrow's updated behavior
     /// where the invoice contract (not the pool) is the caller.
@@ -2251,7 +2295,10 @@ impl MockEscrow {
         let token_client = token::Client::new(&env, &asset);
         token_client.transfer(&escrow_addr, &pool, &(amount as i128));
 
-        true
+        env.storage()
+            .instance()
+            .get(&Symbol::new(&env, "release_result"))
+            .unwrap_or(true)
     }
 }
 
@@ -2264,6 +2311,33 @@ fn mock_escrow_for_pool(env: &Env, pool_id: &Address, asset: &Address) -> Addres
     escrow_id
 }
 
+fn setup_confirmed_invoice() -> (
+    Env,
+    InvoiceContractClient<'static>,
+    Address,
+    BytesN<32>,
+    Address,
+    Address,
+) {
+    let (env, client, issuer, buyer, _, usdc) = setup();
+    let due_date = env.ledger().timestamp() + DEFAULT_DUE_OFFSET;
+    let invoice_id = client.create(&issuer, &buyer, &DEFAULT_FACE_VALUE, &due_date, &usdc);
+    attest(&env, &client, &invoice_id);
+    client.list_for_financing(&invoice_id, &DEFAULT_DISCOUNT_BPS);
+
+    let pool = mock_pool_with_asset(&env, &usdc);
+    client.set_pool_contract(&pool);
+    let escrow = mock_escrow_for_pool(&env, &pool, &usdc);
+    client.set_escrow_contract(&escrow);
+    client.mark_funded(&invoice_id, &pool, &usdc, &DEFAULT_FUNDED_AMOUNT);
+    client.mark_shipped(&invoice_id);
+    client.confirm_delivery(&invoice_id, &issuer);
+    client.confirm_delivery(&invoice_id, &buyer);
+    assert_eq!(client.get(&invoice_id).status, InvoiceStatus::Confirmed);
+
+    (env, client, buyer, invoice_id, pool, escrow)
+}
+
 // ============== SUPPORTED ASSET TESTS ==============
 
 #[test]
@@ -2288,6 +2362,107 @@ fn test_add_supported_asset() {
 
 // ============================== REPAY TESTS ==============================
 
+#[test]
+fn test_repay_rejects_false_escrow_result() {
+    let (env, client, buyer, invoice_id, _pool, escrow) = setup_confirmed_invoice();
+    MockEscrowClient::new(&env, &escrow).set_release_result(&false);
+    mint_tokens(
+        &env,
+        &client.get_funding_asset(&invoice_id),
+        &buyer,
+        DEFAULT_FACE_VALUE as i128,
+    );
+
+    let result = env.try_invoke_contract::<bool, soroban_sdk::Error>(
+        &client.address,
+        &Symbol::new(&env, "repay"),
+        (invoice_id.clone(),).into_val(&env),
+    );
+
+    assert!(result.is_err());
+    assert_eq!(client.get(&invoice_id).status, InvoiceStatus::Confirmed);
+}
+
+#[test]
+fn test_repay_rejects_false_pool_result() {
+    let (env, client, buyer, invoice_id, pool, _escrow) = setup_confirmed_invoice();
+    MockPoolClient::new(&env, &pool).set_return_values(&true, &false);
+    mint_tokens(
+        &env,
+        &client.get_funding_asset(&invoice_id),
+        &buyer,
+        DEFAULT_FACE_VALUE as i128,
+    );
+
+    let result = env.try_invoke_contract::<bool, soroban_sdk::Error>(
+        &client.address,
+        &Symbol::new(&env, "repay"),
+        (invoice_id.clone(),).into_val(&env),
+    );
+
+    assert!(result.is_err());
+    assert_eq!(client.get(&invoice_id).status, InvoiceStatus::Confirmed);
+}
+
+#[test]
+fn test_repay_early_rejects_false_escrow_result() {
+    let (env, client, buyer, invoice_id, _pool, escrow) = setup_confirmed_invoice();
+    MockEscrowClient::new(&env, &escrow).set_release_result(&false);
+    mint_tokens(
+        &env,
+        &client.get_funding_asset(&invoice_id),
+        &buyer,
+        DEFAULT_FACE_VALUE as i128,
+    );
+
+    let result = env.try_invoke_contract::<bool, soroban_sdk::Error>(
+        &client.address,
+        &Symbol::new(&env, "repay_early"),
+        (invoice_id.clone(),).into_val(&env),
+    );
+
+    assert!(result.is_err());
+    assert_eq!(client.get(&invoice_id).status, InvoiceStatus::Confirmed);
+}
+
+#[test]
+fn test_repay_early_rejects_false_pool_result() {
+    let (env, client, buyer, invoice_id, pool, _escrow) = setup_confirmed_invoice();
+    MockPoolClient::new(&env, &pool).set_return_values(&true, &false);
+    mint_tokens(
+        &env,
+        &client.get_funding_asset(&invoice_id),
+        &buyer,
+        DEFAULT_FACE_VALUE as i128,
+    );
+
+    let result = env.try_invoke_contract::<bool, soroban_sdk::Error>(
+        &client.address,
+        &Symbol::new(&env, "repay_early"),
+        (invoice_id.clone(),).into_val(&env),
+    );
+
+    assert!(result.is_err());
+    assert_eq!(client.get(&invoice_id).status, InvoiceStatus::Confirmed);
+}
+
+#[test]
+fn test_trigger_default_rejects_false_pool_result() {
+    let (env, client, _buyer, invoice_id, pool, _escrow) = setup_confirmed_invoice();
+    MockPoolClient::new(&env, &pool).set_return_values(&false, &true);
+    let due_date = client.get(&invoice_id).due_date;
+    env.ledger().set_timestamp(due_date);
+
+    let result = env.try_invoke_contract::<bool, soroban_sdk::Error>(
+        &client.address,
+        &Symbol::new(&env, "trigger_default"),
+        (invoice_id.clone(),).into_val(&env),
+    );
+
+    assert!(result.is_err());
+    assert_eq!(client.get(&invoice_id).status, InvoiceStatus::Confirmed);
+}
+
 #[test]
 fn test_repay_from_confirmed() {
     let (env, client, issuer, buyer, _, usdc) = setup();