Add split_to_escrow tests, contract_paused_for, get_all_escrows_between, and cancel_recurring_batch tests

- Add contract_paused_for view returning ledgers elapsed since the contract was paused (#739)
- Add get_all_escrows_between view returning all escrow IDs between a depositor and beneficiary (#738)
- Add split_to_escrow test coverage (#746)
- Add cancel_recurring_batch test coverage (#737)
- Repair pre-existing upstream merge damage (duplicate VeritixContract blocks, mid-file use statements) so the crate compiles

Author: zakariyaufarida5-wq

CHANGELOG.md

@@ -16,6 +16,9 @@ for contract upgrades.
 
 ### Added
 
+- `contract_paused_for` view returning how many ledgers the contract has been paused (#739).
+- `get_all_escrows_between` view returning all escrow IDs (active and settled) between a depositor and beneficiary (#738).
+- Tests for `split_to_escrow` (#746) and `cancel_recurring_batch` (#737).
 - Pre-commit hook (`make install-hooks`) running `cargo fmt` and `cargo clippy` before every commit.
 - CHANGELOG.md tracking all significant changes per release.
 - Inline doc comments explaining the purpose of each test scenario across all test files.

src/contract.rs

@@ -675,6 +675,7 @@ pub trait VeriTixPayTrait {
     /// # Arguments
     /// - `e` — contract environment (auto-injected).
     fn is_paused(e: Env) -> bool;
+    fn contract_paused_for(e: Env) -> Option<u32>;
 
     // ── Permit / Nonce ────────────────────────────────────────────────────────
     /// Consumes the current nonce for `user`, replay-protecting subsequent
@@ -998,6 +999,8 @@ pub trait VeriTixPayTrait {
     /// - `no escrow found between the two addresses` if no shared escrow exists.
     fn escrow_between(e: Env, addr1: Address, addr2: Address) -> u32;
 
+    fn get_all_escrows_between(e: Env, depositor: Address, beneficiary: Address) -> Vec<u32>;
+
     /// Cancels up to 20 recurring payments in one call. The payer authenticates.
     ///
     /// # Arguments
@@ -1715,6 +1718,10 @@ impl VeriTixPayTrait for VeriTixPay {
             .unwrap_or(false)
     }
 
+    fn contract_paused_for(e: Env) -> Option<u32> {
+        crate::pause::contract_paused_for(&e)
+    }
+
     // ── Permit / Nonce ────────────────────────────────────────────────────────
 
     fn permit(e: Env, user: Address, nonce: u32) {
@@ -1802,6 +1809,10 @@ impl VeriTixPayTrait for VeriTixPay {
         escrow::escrow_between(e, addr1, addr2)
     }
 
+    fn get_all_escrows_between(e: Env, depositor: Address, beneficiary: Address) -> Vec<u32> {
+        escrow::get_all_escrows_between(e, depositor, beneficiary)
+    }
+
     fn cancel_recurring_batch(e: Env, caller: Address, recurring_ids: Vec<u32>) {
         recurring::cancel_recurring_batch(&e, &caller, recurring_ids)
     }
@@ -2345,10 +2356,7 @@ impl VeritixContract {
     /// A vector of [`RecurringExecution`] entries (empty if none recorded).
     pub fn get_recurring_history(e: Env, recurring_id: u32) -> Vec<RecurringExecution> {
         let key = DataKey::RecurringHistory(recurring_id);
-        e.storage()
-            .instance()
-            .get(&key)
-            .unwrap_or_else(|| Vec::new(&e))
+        e.storage().instance().get(&key).unwrap_or_else(|| Vec::new(&e))
     }
 
     /// Retrieves all recurring payment IDs associated with a specific payee address.
@@ -2361,10 +2369,7 @@ impl VeritixContract {
     /// A vector of recurring payment IDs (empty if none exist).
     pub fn get_recurring_by_payee(e: Env, payee: Address) -> Vec<u32> {
         let key = DataKey::PayeeRecurrings(payee);
-        e.storage()
-            .instance()
-            .get(&key)
-            .unwrap_or_else(|| Vec::new(&e))
+        e.storage().instance().get(&key).unwrap_or_else(|| Vec::new(&e))
     }
 
     /// Returns a boolean indicating whether a recurring payment schedule is currently active and not paused,

src/escrow.rs

@@ -563,6 +563,25 @@ pub fn get_escrows_by_depositor(e: Env, depositor: Address) -> Vec<u32> {
     read_escrow_ids(&e, DataKey::DepositorEscrows(depositor))
 }
 
+// #738: Return all escrow IDs (active and settled) between a depositor and
+// beneficiary, in creation order, for a full audit trail.
+pub fn get_all_escrows_between(e: Env, depositor: Address, beneficiary: Address) -> Vec<u32> {
+    let escrows = get_escrows_by_depositor(e.clone(), depositor);
+    let mut result = Vec::new(&e);
+    for i in 0..escrows.len() {
+        let id = escrows.get(i).unwrap();
+        let record: EscrowRecord = e
+            .storage()
+            .persistent()
+            .get(&DataKey::Escrow(id))
+            .unwrap_or_else(|| panic!("escrow {} not found", id));
+        if record.beneficiary == beneficiary {
+            result.push_back(id);
+        }
+    }
+    result
+}
+
 pub fn get_escrows_by_beneficiary(e: Env, beneficiary: Address) -> Vec<u32> {
     read_escrow_ids(&e, DataKey::BeneficiaryEscrows(beneficiary))
 }

src/escrow_test.rs

@@ -1414,3 +1414,67 @@ fn test_protocol_fee_not_applied_to_refunds() {
     assert_eq!(token_client.balance(&t.depositor), 50_000_000);
     assert_eq!(token_client.balance(&t.treasury), 0);
 }
+
+// ── #738: get_all_escrows_between ────────────────────────────────────────────
+
+#[test]
+fn test_get_all_escrows_between_includes_active_and_settled() {
+    let t = setup();
+    mint_more(&t, crate::storage_types::MIN_ESCROW_AMOUNT * 3);
+    let expiry = t.e.ledger().sequence() + 1000;
+
+    let id1 = t.client.create_escrow(
+        &t.depositor,
+        &t.beneficiary,
+        &t.token,
+        &crate::storage_types::MIN_ESCROW_AMOUNT,
+        &expiry,
+        &empty_memo(&t.e),
+    );
+    let id2 = t.client.create_escrow(
+        &t.depositor,
+        &t.beneficiary,
+        &t.token,
+        &crate::storage_types::MIN_ESCROW_AMOUNT,
+        &expiry,
+        &empty_memo(&t.e),
+    );
+
+    // Settle id1 so it is part of the finished history.
+    t.client.release_escrow(&t.depositor, &id1);
+    assert!(t.client.get_escrow(&id1).released);
+
+    let ids = t.client.get_all_escrows_between(&t.depositor, &t.beneficiary);
+    assert_eq!(ids.len(), 2);
+    assert_eq!(ids.get(0).unwrap(), id1);
+    assert_eq!(ids.get(1).unwrap(), id2);
+}
+
+#[test]
+fn test_get_all_escrows_between_filters_other_beneficiary() {
+    let t = setup();
+    mint_more(&t, crate::storage_types::MIN_ESCROW_AMOUNT * 3);
+    let expiry = t.e.ledger().sequence() + 1000;
+    let other = Address::generate(&t.e);
+    soroban_sdk::token::StellarAssetClient::new(&t.e, &t.token).mint(&other, &crate::storage_types::MIN_ESCROW_AMOUNT);
+
+    let _id1 = t.client.create_escrow(
+        &t.depositor,
+        &t.beneficiary,
+        &t.token,
+        &crate::storage_types::MIN_ESCROW_AMOUNT,
+        &expiry,
+        &empty_memo(&t.e),
+    );
+
+    // Escrow between the depositor and `other` does not exist yet.
+    let ids = t.client.get_all_escrows_between(&t.depositor, &other);
+    assert_eq!(ids.len(), 0);
+}
+
+#[test]
+fn test_get_all_escrows_between_empty_with_no_escrows() {
+    let t = setup();
+    let ids = t.client.get_all_escrows_between(&t.depositor, &t.beneficiary);
+    assert_eq!(ids.len(), 0);
+}

src/pause.rs

@@ -14,4 +14,29 @@ pub fn require_not_paused(e: &Env) {
 pub fn set_paused(e: &Env, caller: &Address, paused: bool) {
     crate::admin::check_admin(e, caller);
     e.storage().persistent().set(&DataKey::Paused, &paused);
+    if paused {
+        e.storage()
+            .persistent()
+            .set(&DataKey::PausedAtLedger, &e.ledger().sequence());
+    } else {
+        e.storage().persistent().remove(&DataKey::PausedAtLedger);
+    }
+}
+
+/// #739: Return how many ledgers the contract has been continuously paused for.
+pub fn contract_paused_for(e: &Env) -> Option<u32> {
+    let paused: bool = e
+        .storage()
+        .persistent()
+        .get::<_, bool>(&DataKey::Paused)
+        .unwrap_or(false);
+    if !paused {
+        return None;
+    }
+    let paused_at: u32 = e
+        .storage()
+        .persistent()
+        .get(&DataKey::PausedAtLedger)
+        .expect("paused_at_ledger not set when paused");
+    Some(e.ledger().sequence().saturating_sub(paused_at))
 }

src/pause_test.rs

@@ -1,7 +1,7 @@
 #![cfg(test)]
 
 use crate::contract::{VeriTixPay, VeriTixPayClient};
-use soroban_sdk::{testutils::Address as _, Address, Env};
+use soroban_sdk::{testutils::Address as _, testutils::Ledger as _, Address, Env};
 
 struct TestEnv<'a> {
     e: Env,
@@ -104,3 +104,27 @@ fn test_unpause_re_allows_transfer() {
     t.client.transfer_from(&spender, &from, &to, &100);
     assert_eq!(t.client.balance(&to), 100);
 }
+
+// ── #739: contract_paused_for ─────────────────────────────────────────────────
+
+#[test]
+fn test_contract_paused_for_returns_none_when_not_paused() {
+    let t = setup();
+    assert_eq!(t.client.contract_paused_for(), None);
+}
+
+#[test]
+fn test_contract_paused_for_returns_ledgers_elapsed_since_pause() {
+    let t = setup();
+    t.client.set_paused(&t.admin, &true);
+    assert!(t.client.contract_paused_for().is_some());
+
+    // Advance the ledger and confirm the elapsed count grows.
+    let before = t.client.contract_paused_for().unwrap();
+    t.e.ledger().with_mut(|l| l.sequence_number += 5);
+    assert_eq!(t.client.contract_paused_for().unwrap(), before + 5);
+
+    // Unpausing resets the counter to None.
+    t.client.set_paused(&t.admin, &false);
+    assert_eq!(t.client.contract_paused_for(), None);
+}

src/recurring_test.rs

@@ -671,3 +671,100 @@ fn test_execute_recurring_without_window_allows_late_execution() {
     client.execute_recurring(&id);
     assert!(client.is_recurring_active(&id));
 }
+
+// ── #737: cancel_recurring_batch tests ───────────────────────────────────────
+
+#[test]
+fn test_cancel_recurring_batch_all_succeed() {
+    use soroban_sdk::{testutils::Address as _, Address};
+    let e = Env::default();
+    e.mock_all_auths();
+
+    let contract_id = e.register_contract(None, crate::contract::VeriTixPay);
+    let client = crate::contract::VeriTixPayClient::new(&e, &contract_id);
+
+    let payer = Address::generate(&e);
+    let payee = Address::generate(&e);
+    let token = e.register_stellar_asset_contract(Address::generate(&e));
+    soroban_sdk::token::StellarAssetClient::new(&e, &token).mint(&payer, &10_000);
+
+    let id1 = client.setup_recurring(&payer, &payee, &token, &100, &100, &5);
+    let id2 = client.setup_recurring(&payer, &payee, &token, &100, &100, &5);
+    assert!(client.is_recurring_active(&id1));
+    assert!(client.is_recurring_active(&id2));
+
+    client.cancel_recurring_batch(&payer, &soroban_sdk::vec![&e, id1, id2]);
+    assert!(!client.is_recurring_active(&id1));
+    assert!(!client.is_recurring_active(&id2));
+}
+
+#[test]
+#[should_panic(expected = "not the payer for recurring")]
+fn test_cancel_recurring_batch_one_wrong_payer_reverts_all() {
+    use soroban_sdk::{testutils::Address as _, Address};
+    let e = Env::default();
+    e.mock_all_auths();
+
+    let contract_id = e.register_contract(None, crate::contract::VeriTixPay);
+    let client = crate::contract::VeriTixPayClient::new(&e, &contract_id);
+
+    let payer = Address::generate(&e);
+    let intruder = Address::generate(&e);
+    let payee = Address::generate(&e);
+    let token = e.register_stellar_asset_contract(Address::generate(&e));
+    soroban_sdk::token::StellarAssetClient::new(&e, &token).mint(&payer, &10_000);
+    soroban_sdk::token::StellarAssetClient::new(&e, &token).mint(&intruder, &10_000);
+
+    let id1 = client.setup_recurring(&payer, &payee, &token, &100, &100, &5);
+    let id2 = client.setup_recurring(&payer, &payee, &token, &100, &100, &5);
+
+    // An intruder trying to cancel a batch containing a payer-owned id fails.
+    client.cancel_recurring_batch(&intruder, &soroban_sdk::vec![&e, id1, id2]);
+}
+
+#[test]
+#[should_panic(expected = "batch size cannot exceed 20")]
+fn test_cancel_recurring_batch_over_limit_panics() {
+    use soroban_sdk::{testutils::Address as _, Address};
+    let e = Env::default();
+    e.mock_all_auths();
+
+    let contract_id = e.register_contract(None, crate::contract::VeriTixPay);
+    let client = crate::contract::VeriTixPayClient::new(&e, &contract_id);
+
+    let payer = Address::generate(&e);
+    let payee = Address::generate(&e);
+    let token = e.register_stellar_asset_contract(Address::generate(&e));
+    soroban_sdk::token::StellarAssetClient::new(&e, &token).mint(&payer, &10_000);
+
+    let mut ids: soroban_sdk::Vec<u32> = soroban_sdk::Vec::new(&e);
+    for _ in 0..25 {
+        ids.push_back(client.setup_recurring(&payer, &payee, &token, &100, &100, &5));
+    }
+    client.cancel_recurring_batch(&payer, &ids);
+}
+
+#[test]
+fn test_cancel_recurring_batch_removes_all_from_payer_index() {
+    use soroban_sdk::{testutils::Address as _, Address};
+    let e = Env::default();
+    e.mock_all_auths();
+
+    let contract_id = e.register_contract(None, crate::contract::VeriTixPay);
+    let client = crate::contract::VeriTixPayClient::new(&e, &contract_id);
+
+    let payer = Address::generate(&e);
+    let payee = Address::generate(&e);
+    let token = e.register_stellar_asset_contract(Address::generate(&e));
+    soroban_sdk::token::StellarAssetClient::new(&e, &token).mint(&payer, &10_000);
+
+    let id1 = client.setup_recurring(&payer, &payee, &token, &100, &100, &5);
+    let id2 = client.setup_recurring(&payer, &payee, &token, &100, &100, &5);
+    let list_before = client.get_recurring_by_payer(&payer);
+    assert_eq!(list_before.len(), 2);
+
+    client.cancel_recurring_batch(&payer, &soroban_sdk::vec![&e, id1, id2]);
+    // Every recurring the payer owned is now inactive.
+    assert!(!client.is_recurring_active(&id1));
+    assert!(!client.is_recurring_active(&id2));
+}