funding.rs

use super::*;

use crate::EscrowError;

use soroban_sdk::{Error, InvokeError};

use std::fmt::Debug;

// Funding, contributions, snapshots, tier selection, and fund-shaped cost baselines.

fn assert_contract_error<T, E>(
    result: Result<Result<T, E>, Result<Error, InvokeError>>,

    expected: EscrowError,
) where
    T: Debug,

    E: Debug,
{
    let expected_code = expected as u32;

    match result {
        Err(Ok(error)) => {
            assert_eq!(error, Error::from_contract_error(expected_code));
        }

        Err(Err(InvokeError::Contract(code))) => {
            assert_eq!(code, expected_code);
        }

        other => panic!("expected ContractError({expected_code}), got {other:?}"),
    }
}

#[test]

fn test_fund_and_settle() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "INVMETA"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let funded = client.fund(&investor, &TARGET);

    assert_eq!(funded.funded_amount, TARGET);

    assert_eq!(funded.status, 1);

    let settled = client.settle();

    assert_eq!(settled.status, 2);
}

#[test]

fn test_fund_partial_then_full() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "INV002"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let partial = client.fund(&investor, &(TARGET / 2));

    assert_eq!(partial.status, 0);

    assert_eq!(partial.funded_amount, TARGET / 2);

    let full = client.fund(&investor, &(TARGET / 2));

    assert_eq!(full.status, 1);

    assert_eq!(full.funded_amount, TARGET);
}

#[test]
#[should_panic]

fn test_fund_zero_amount_panics() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    default_init(&client, &env, &admin, &sme);

    client.fund(&investor, &0i128);
}

#[test]
#[should_panic]

fn test_fund_after_funded_panics() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    default_init(&client, &env, &admin, &sme);

    client.fund(&investor, &TARGET);

    client.fund(&investor, &1i128);
}

#[test]

fn test_fund_requires_investor_auth() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    default_init(&client, &env, &admin, &sme);

    client.fund(&investor, &TARGET);

    assert!(
        env.auths().iter().any(|(addr, _)| *addr == investor),
        "investor auth was not recorded for fund"
    );
}

#[test]

fn test_single_investor_contribution_tracked() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "INV020"),
        &sme,
        &TARGET,
        &800i64,
        &1000u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &(30_000_000_000i128));

    let contribution = client.get_contribution(&investor);

    assert_eq!(contribution, 30_000_000_000i128);
}

#[test]

fn test_unknown_investor_contribution_is_zero() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    let stranger = Address::generate(&env);

    default_init(&client, &env, &admin, &sme);

    client.fund(&investor, &1_000i128);

    assert_eq!(client.get_contribution(&stranger), 0i128);
}

#[test]

fn test_repeated_funding_accumulates_contribution() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "INV021"),
        &sme,
        &TARGET,
        &800i64,
        &1000u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &(20_000_000_000i128));

    client.fund(&investor, &(30_000_000_000i128));

    assert_eq!(client.get_contribution(&investor), 50_000_000_000i128);
}

#[test]
#[should_panic]

fn test_funding_amount_accumulation_overflow_panics() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor_a = Address::generate(&env);

    let investor_b = Address::generate(&env);

    client.init(
        &admin,
        &String::from_str(&env, "OVF001"),
        &sme,
        &(crate::MAX_INVOICE_AMOUNT),
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor_a, &(crate::MAX_INVOICE_AMOUNT - 1));

    client.fund(&investor_b, &2i128);
}

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn test_funding_amount_overflow_does_not_mutate_state() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "OVF002"),
        &sme,
        &(crate::MAX_INVOICE_AMOUNT),
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &(crate::MAX_INVOICE_AMOUNT - 1));

    let before = client.get_escrow();

    let overflowed = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        client.fund(&investor, &2i128);
    }));

    assert!(overflowed.is_err());

    let after = client.get_escrow();

    assert_eq!(after.funded_amount, before.funded_amount);

    assert_eq!(after.status, 0);

    assert_eq!(
        client.get_contribution(&investor),
        crate::MAX_INVOICE_AMOUNT - 1
    );
}

#[test]
#[should_panic]

fn test_fund_with_commitment_overflow_panics() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor_a = Address::generate(&env);

    let investor_b = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "OVF001b"),
        &sme,
        &(crate::MAX_INVOICE_AMOUNT),
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor_a, &(crate::MAX_INVOICE_AMOUNT - 1));

    client.fund_with_commitment(&investor_b, &2i128, &0u64);
}

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn test_fund_with_commitment_overflow_does_not_mutate_state() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor_a = Address::generate(&env);

    let investor_b = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "OVF002b"),
        &sme,
        &(crate::MAX_INVOICE_AMOUNT),
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor_a, &(crate::MAX_INVOICE_AMOUNT - 1));

    let before = client.get_escrow();

    let overflowed = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        client.fund_with_commitment(&investor_b, &2i128, &0u64);
    }));

    assert!(overflowed.is_err());

    let after = client.get_escrow();

    assert_eq!(after.funded_amount, before.funded_amount);

    assert_eq!(after.status, 0);

    assert_eq!(client.get_contribution(&investor_b), 0);
}

/// Regression for issue #253: per-investor accounting must live in persistent storage, not instance.

#[test]

fn test_per_investor_contribution_uses_persistent_storage() {
    let env = Env::default();

    env.mock_all_auths();

    let (client, admin, sme) = setup(&env);

    let contract_id = client.address.clone();

    let investor = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "PERS01"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &500i128);

    env.as_contract(&contract_id, || {
        assert_eq!(
            env.storage()
                .persistent()
                .get::<DataKey, i128>(&DataKey::InvestorContribution(investor.clone())),
            Some(500i128)
        );

        assert_eq!(
            env.storage()
                .instance()
                .get::<DataKey, i128>(&DataKey::InvestorContribution(investor.clone())),
            None
        );
    });
}

#[test]
#[should_panic]

fn test_investor_contribution_overflow_panics_even_if_state_is_inconsistent() {
    // This test intentionally constructs an inconsistent storage snapshot to ensure

    // the per-investor accounting never wraps even under corrupted / unexpected state.

    //

    // Rationale: `funded_amount` overflow is already guarded by checked_add. This test

    // separately proves the per-investor `InvestorContribution` update uses checked_add.

    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let contract_id = client.address.clone();

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let investor = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "OVF003"),
        &sme,
        &1_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    env.as_contract(&contract_id, || {
        // Force the contribution near i128::MAX while keeping funded_amount small.

        // `fund` must still trap on contribution overflow even if funded_amount would not.

        env.storage().persistent().set(
            &DataKey::InvestorContribution(investor.clone()),
            &(i128::MAX - 1),
        );

        let mut escrow = LiquifactEscrow::get_escrow(env.clone());

        escrow.funded_amount = 0;

        escrow.status = 0;

        env.storage().instance().set(&DataKey::Escrow, &escrow);
    });

    client.fund(&investor, &2i128);
}

#[test]

fn test_investor_contribution_overflow_does_not_mutate_state() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let contract_id = client.address.clone();

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let investor = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "OVF004"),
        &sme,
        &1_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    env.as_contract(&contract_id, || {
        env.storage().persistent().set(
            &DataKey::InvestorContribution(investor.clone()),
            &(i128::MAX - 1),
        );

        let mut escrow = LiquifactEscrow::get_escrow(env.clone());

        escrow.funded_amount = 0;

        escrow.status = 0;

        env.storage().instance().set(&DataKey::Escrow, &escrow);
    });

    let before_escrow = client.get_escrow();

    let before_contribution = client.get_contribution(&investor);

    let overflowed = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        client.fund(&investor, &2i128);
    }));

    assert!(overflowed.is_err());

    assert_eq!(client.get_escrow(), before_escrow);

    assert_eq!(client.get_contribution(&investor), before_contribution);
}

#[test]

fn test_multiple_investors_tracked_independently() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let inv_a = Address::generate(&env);

    let inv_b = Address::generate(&env);

    let inv_c = Address::generate(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "INV023"),
        &sme,
        &TARGET,
        &800i64,
        &1000u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&inv_a, &(20_000_000_000i128));

    client.fund(&inv_b, &(50_000_000_000i128));

    client.fund(&inv_c, &(30_000_000_000i128));

    assert_eq!(client.get_contribution(&inv_a), 20_000_000_000i128);

    assert_eq!(client.get_contribution(&inv_b), 50_000_000_000i128);

    assert_eq!(client.get_contribution(&inv_c), 30_000_000_000i128);

    let sum = client.get_contribution(&inv_a)
        + client.get_contribution(&inv_b)
        + client.get_contribution(&inv_c);

    assert_eq!(sum, client.get_escrow().funded_amount);
}

#[test]

fn test_contributions_sum_equals_funded_amount() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let inv_a = Address::generate(&env);

    let inv_b = Address::generate(&env);

    let inv_c = Address::generate(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "INV023b"),
        &sme,
        &TARGET,
        &800i64,
        &1000u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&inv_a, &(20_000_000_000i128));

    client.fund(&inv_b, &(50_000_000_000i128));

    client.fund(&inv_c, &(30_000_000_000i128));

    let sum = client.get_contribution(&inv_a)
        + client.get_contribution(&inv_b)
        + client.get_contribution(&inv_c);

    assert_eq!(sum, client.get_escrow().funded_amount);
}

#[test]

fn test_cost_baseline_fund_partial() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "INV103"),
        &sme,
        &TARGET,
        &800i64,
        &1000u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &(10_000_000_000i128));
}

#[test]

fn test_cost_baseline_fund_full() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "INV104"),
        &sme,
        &TARGET,
        &800i64,
        &1000u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &TARGET);
}

#[test]

fn test_cost_baseline_fund_overshoot() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "INV105"),
        &sme,
        &TARGET,
        &800i64,
        &1000u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &(150_000_000_000i128));

    assert_eq!(client.get_escrow().status, 1);
}

#[test]

fn test_cost_baseline_fund_two_step_completion() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "INV106"),
        &sme,
        &TARGET,
        &800i64,
        &1000u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &(TARGET / 2));

    client.fund(&investor, &(TARGET / 2));

    assert_eq!(client.get_escrow().status, 1);
}

#[test]

fn test_funding_close_snapshot_captures_overfunded_total_once() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "SNAP001"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    assert_eq!(client.get_funding_close_snapshot(), None);

    client.fund(&inv, &(TARGET + 50_000_000_000i128));

    let snap = client.get_funding_close_snapshot().expect("snapshot");

    assert_eq!(snap.total_principal, TARGET + 50_000_000_000i128);

    assert_eq!(snap.funding_target, TARGET);

    assert_eq!(snap.closed_at_ledger_timestamp, env.ledger().timestamp());

    assert_eq!(snap.closed_at_ledger_sequence, env.ledger().sequence());
}

#[test]

fn test_funding_snapshot_immutable_across_second_fund_after_funded() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let a = Address::generate(&env);

    let b = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "SNAP002"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&a, &(TARGET / 2));

    assert_eq!(client.get_funding_close_snapshot(), None);

    client.fund(&b, &(TARGET / 2));

    let s1 = client.get_funding_close_snapshot().unwrap();

    assert_eq!(s1.total_principal, TARGET);

    let s2 = client.get_funding_close_snapshot().unwrap();

    assert_eq!(s1, s2);
}

#[test]

fn test_pro_rata_weight_ratio_from_snapshot() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let a = Address::generate(&env);

    let b = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "SNAP003"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&a, &(20_000_000_000i128));

    client.fund(&b, &(80_000_000_000i128));

    let snap = client.get_funding_close_snapshot().unwrap();

    assert_eq!(snap.total_principal, TARGET);

    let ca = client.get_contribution(&a);

    let cb = client.get_contribution(&b);

    assert_eq!(ca + cb, snap.total_principal);
}

#[test]

fn test_tiered_yield_and_follow_on_fund() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 900,
    });

    tiers.push_back(YieldTier {
        min_lock_secs: 500,

        yield_bps: 1100,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "TIER001"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund_with_commitment(&inv, &5_000i128, &200u64);

    assert_eq!(client.get_investor_yield_bps(&inv), 900);

    assert_eq!(client.get_investor_claim_not_before(&inv), 200);

    client.fund(&inv, &5_000i128);

    assert_eq!(client.get_investor_yield_bps(&inv), 900);

    assert_eq!(client.get_escrow().status, 1);
}

#[test]

fn test_tier_selection_edges_base_vs_high_bucket() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let i_short = Address::generate(&env);

    let i_long = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 50,

        yield_bps: 850,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "TIER002"),
        &sme,
        &20_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund_with_commitment(&i_short, &10_000i128, &40u64);

    assert_eq!(client.get_investor_yield_bps(&i_short), 800);

    client.fund_with_commitment(&i_long, &10_000i128, &50u64);

    assert_eq!(client.get_investor_yield_bps(&i_long), 850);
}

/// A second `fund_with_commitment` from the same investor (who already has a
/// non-zero contribution from a prior tiered deposit with a tier table configured)
/// must fail with `EscrowError::TieredSecondDeposit` (code 108).
///
/// The test verifies the typed error contract, not a raw panic string.
#[test]
#[should_panic]

fn test_fund_with_commitment_twice_panics() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 1,

        yield_bps: 810,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "TIER003"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund_with_commitment(&inv, &5_000i128, &10u64);

    client.fund_with_commitment(&inv, &5_000i128, &10u64);
}

/// After a plain `fund()` first deposit, calling `fund_with_commitment` on the same
/// investor must fail with `EscrowError::TieredSecondDeposit` (code 108).
///
/// The tier/lock selection window is permanently closed after the first deposit leg
/// regardless of which entrypoint established the position.
#[test]
#[should_panic]

fn test_fund_then_fund_with_commitment_panics() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "SEQ001"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&inv, &5_000i128);

    client.fund_with_commitment(&inv, &5_000i128, &10u64);
}

#[test]

fn test_tier_selection_ladder() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 900,
    });

    tiers.push_back(YieldTier {
        min_lock_secs: 200,

        yield_bps: 1000,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "LADDER01"),
        &sme,
        &100_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv_base = Address::generate(&env);

    let inv_tier1 = Address::generate(&env);

    let inv_tier2 = Address::generate(&env);

    let inv_mid = Address::generate(&env);

    // Below first tier -> base

    client.fund_with_commitment(&inv_base, &1_000i128, &50u64);

    assert_eq!(client.get_investor_yield_bps(&inv_base), 800);

    // Exactly first tier

    client.fund_with_commitment(&inv_tier1, &1_000i128, &100u64);

    assert_eq!(client.get_investor_yield_bps(&inv_tier1), 900);

    // Between tiers -> still first tier

    client.fund_with_commitment(&inv_mid, &1_000i128, &150u64);

    assert_eq!(client.get_investor_yield_bps(&inv_mid), 900);

    // Exactly second tier

    client.fund_with_commitment(&inv_tier2, &1_000i128, &200u64);

    assert_eq!(client.get_investor_yield_bps(&inv_tier2), 1000);
}

#[test]

fn test_yield_tier_emitted_in_event() {
    use soroban_sdk::testutils::Events as _;

    let env = Env::default();

    env.mock_all_auths();

    let (contract_id, client) = deploy_with_id(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let invoice_id = symbol_short!("EVT001");

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 900,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "EVT001"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv = Address::generate(&env);

    // 1. Tiered fund: committed_lock_secs=150 >= tier.min_lock_secs=100 => yield 900, lock 100.

    client.fund_with_commitment(&inv, &1_000i128, &150u64);

    assert_eq!(
        env.events().all(),
        std::vec![EscrowFunded {
            name: symbol_short!("funded"),

            invoice_id: invoice_id.clone(),

            investor: inv.clone(),

            amount: 1_000i128,

            funded_amount: 1_000i128,

            status: 0,

            investor_effective_yield_bps: 900,

            tier_lock_secs: 100,
        }
        .to_xdr(&env, &contract_id)]
    );

    // 2. Base yield: committed_lock_secs=50 < tier.min_lock_secs=100 => yield 800, lock 0.

    let inv2 = Address::generate(&env);

    client.fund_with_commitment(&inv2, &1_000i128, &50u64);

    let binding = env.events().all();

    let all_event_list = binding.events();

    let last = all_event_list
        .last()
        .expect("expected funded event for base-yield deposit");

    assert_eq!(
        *last,
        EscrowFunded {
            name: symbol_short!("funded"),

            invoice_id,

            investor: inv2,

            amount: 1_000i128,

            funded_amount: 2_000i128,

            status: 0,

            investor_effective_yield_bps: 800,

            tier_lock_secs: 0,
        }
        .to_xdr(&env, &contract_id)
    );
}

#[test]

fn test_yield_tier_emitted_no_tiers() {
    use soroban_sdk::testutils::Events as _;

    let env = Env::default();

    env.mock_all_auths();

    let (contract_id, client) = deploy_with_id(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let invoice_id = symbol_short!("NOTIER");

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "NOTIER"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv = Address::generate(&env);

    // fund_with_commitment even with no tiers configured

    client.fund_with_commitment(&inv, &1_000i128, &150u64);

    assert_eq!(
        env.events().all(),
        std::vec![EscrowFunded {
            name: symbol_short!("funded"),

            invoice_id: invoice_id.clone(),

            investor: inv.clone(),

            amount: 1_000i128,

            funded_amount: 1_000i128,

            status: 0,

            investor_effective_yield_bps: 800,

            tier_lock_secs: 0,
        }
        .to_xdr(&env, &contract_id)]
    );
}

#[test]

fn test_yield_tier_emitted_between_tiers() {
    use soroban_sdk::testutils::Events as _;

    let env = Env::default();

    env.mock_all_auths();

    let (contract_id, client) = deploy_with_id(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let invoice_id = symbol_short!("MIDTIER");

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 900,
    });

    tiers.push_back(YieldTier {
        min_lock_secs: 200,

        yield_bps: 1000,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "MIDTIER"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv = Address::generate(&env);

    // Committing 150 secs (between 100 and 200) -> matches the 100 sec tier.

    client.fund_with_commitment(&inv, &1_000i128, &150u64);

    let binding = env.events().all();

    let event = binding.events().first().unwrap();

    assert_eq!(
        *event,
        EscrowFunded {
            name: symbol_short!("funded"),

            invoice_id: invoice_id.clone(),

            investor: inv.clone(),

            amount: 1_000i128,

            funded_amount: 1_000i128,

            status: 0,

            investor_effective_yield_bps: 900,

            tier_lock_secs: 100,
        }
        .to_xdr(&env, &contract_id)
    );
}

#[test]

fn test_fund_with_commitment_zero_lock_behaves_as_fund() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 900,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "ZERO001"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund_with_commitment(&inv, &5_000i128, &0u64);

    assert_eq!(client.get_investor_yield_bps(&inv), 800);

    assert_eq!(client.get_investor_claim_not_before(&inv), 0);
}

#[test]

fn test_commitment_claim_time_allows_u64_max_boundary() {
    let env = Env::default();

    env.mock_all_auths();

    env.ledger().with_mut(|ledger| {
        ledger.timestamp = u64::MAX - 5;
    });

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let investor = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CLKMAX1"),
        &sme,
        &1_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund_with_commitment(&investor, &100i128, &5u64);

    assert_eq!(client.get_investor_claim_not_before(&investor), u64::MAX);
}

#[test]
#[should_panic]

fn test_commitment_claim_time_overflow_panics() {
    let env = Env::default();

    env.mock_all_auths();

    env.ledger().with_mut(|ledger| {
        ledger.timestamp = u64::MAX - 5;
    });

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let investor = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CLKMAX2"),
        &sme,
        &1_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund_with_commitment(&investor, &100i128, &6u64);
}

#[test]

fn test_commitment_claim_time_overflow_does_not_record_position() {
    let env = Env::default();

    env.mock_all_auths();

    env.ledger().with_mut(|ledger| {
        ledger.timestamp = u64::MAX - 5;
    });

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let investor = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CLKMAX3"),
        &sme,
        &1_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let overflowed = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        client.fund_with_commitment(&investor, &100i128, &6u64);
    }));

    assert!(overflowed.is_err());

    assert_eq!(client.get_escrow().funded_amount, 0);

    assert_eq!(client.get_contribution(&investor), 0);

    assert_eq!(client.get_investor_claim_not_before(&investor), 0);
}

#[test]
#[should_panic]

fn test_init_bad_tier_order_panics() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 200,

        yield_bps: 900,
    });

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 950,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "BADTIER"),
        &sme,
        &1_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );
}

#[test]
#[should_panic]

fn test_init_tier_yield_below_base_panics() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 10,

        yield_bps: 700,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "BADT2"),
        &sme,
        &1_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );
}

#[test]

fn test_differential_funding_target_eq_exact_cross() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let t = 5_000i128;

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "DIFF002"),
        &sme,
        &t,
        &100i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let escrow = client.fund(&inv, &t);

    assert_eq!(escrow.funded_amount, t);

    assert_eq!(escrow.status, 1);

    let snap = client.get_funding_close_snapshot().unwrap();

    assert_eq!(snap.total_principal, t);

    assert_eq!(snap.funding_target, t);
}

#[test]

fn test_ledger_sequence_recorded_in_snapshot_with_tick() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "DIFF003"),
        &sme,
        &1_000i128,
        &100i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let seq = env.ledger().sequence();

    client.fund(&inv, &1_000i128);

    let snap = client.get_funding_close_snapshot().unwrap();

    assert_eq!(snap.closed_at_ledger_sequence, seq);
}

#[test]

fn test_get_funding_close_snapshot_absent_before_any_funding() {
    // Snapshot must be None immediately after init, before any fund() call.

    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "SNAP010"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    assert_eq!(
        client.get_funding_close_snapshot(),
        None,
        "snapshot must be absent before any funding"
    );
}

#[test]

fn test_get_funding_close_snapshot_present_after_funding_completes() {
    // Snapshot must be Some with correct fields once funded_amount reaches funding_target.

    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "SNAP011"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Partial fund — snapshot still absent.

    client.fund(&inv, &(TARGET / 2));

    assert_eq!(
        client.get_funding_close_snapshot(),
        None,
        "snapshot must remain absent while escrow is still open"
    );

    // Final fund that crosses the target — snapshot must now be present.

    client.fund(&inv, &(TARGET / 2));

    let snap = client
        .get_funding_close_snapshot()
        .expect("snapshot must be present after funding completes");

    assert_eq!(snap.total_principal, TARGET);

    assert_eq!(snap.funding_target, TARGET);

    assert_eq!(client.get_escrow().status, 1);
}

#[test]

fn test_get_funding_close_snapshot_immutable_after_set() {
    // Once the snapshot is written it must not change, even if additional reads occur

    // after the escrow has transitioned to a terminal state (settled).

    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "SNAP012"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Fund exactly to target — snapshot is written here.

    client.fund(&inv, &TARGET);

    let snap_at_close = client
        .get_funding_close_snapshot()
        .expect("snapshot must be present after funding");

    // Advance through settlement — snapshot must remain identical.

    client.settle();

    let snap_after_settle = client
        .get_funding_close_snapshot()
        .expect("snapshot must still be present after settlement");

    assert_eq!(
        snap_at_close, snap_after_settle,
        "snapshot must be immutable after being set"
    );
}

// --- MaxUniqueInvestorsCap and UniqueFunderCount Tests ---

#[test]

fn test_unique_funder_count_initialized_to_zero() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP001"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    assert_eq!(client.get_unique_funder_count(), 0);
}

#[test]

fn test_unique_funder_count_increments_on_first_investor() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP002"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    assert_eq!(client.get_unique_funder_count(), 0);

    client.fund(&investor, &(TARGET / 2));

    assert_eq!(client.get_unique_funder_count(), 1);

    client.fund(&investor, &(TARGET / 2));

    assert_eq!(client.get_unique_funder_count(), 1); // Still 1, same investor
}

#[test]

fn test_unique_funder_count_increments_for_distinct_investors() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let inv_a = Address::generate(&env);

    let inv_b = Address::generate(&env);

    let inv_c = Address::generate(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP003"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    assert_eq!(client.get_unique_funder_count(), 0);

    client.fund(&inv_a, &(TARGET / 3));

    assert_eq!(client.get_unique_funder_count(), 1);

    client.fund(&inv_b, &(TARGET / 3));

    assert_eq!(client.get_unique_funder_count(), 2);

    client.fund(&inv_c, &(TARGET / 3));

    assert_eq!(client.get_unique_funder_count(), 3);
}

#[test]

fn test_unique_funder_count_with_fund_with_commitment() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv_a = Address::generate(&env);

    let inv_b = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 900,
    });

    client.init(
        &admin,
        &String::from_str(&env, "CAP004"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    assert_eq!(client.get_unique_funder_count(), 0);

    // First investor uses fund_with_commitment

    client.fund_with_commitment(&inv_a, &(TARGET / 2), &200u64);

    assert_eq!(client.get_unique_funder_count(), 1);

    // Second investor uses regular fund

    client.fund(&inv_b, &(TARGET / 2));

    assert_eq!(client.get_unique_funder_count(), 2);
}

#[test]

fn test_max_unique_investors_cap_none_allows_unlimited() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP005"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None, // No cap set
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Should be able to add many investors when no cap is set

    for i in 0..10 {
        let investor = Address::generate(&env);

        client.fund(&investor, &(TARGET / 20));

        assert_eq!(client.get_unique_funder_count(), i + 1);
    }
}

#[test]
#[ignore]

fn test_max_unique_investors_cap_enforced_at_limit() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP006"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &Some(3u32), // Cap of 3 investors
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    assert_eq!(client.get_max_unique_investors_cap(), Some(3u32));

    // Add 3 investors - should succeed

    let inv1 = Address::generate(&env);

    let inv2 = Address::generate(&env);

    let inv3 = Address::generate(&env);

    client.fund(&inv1, &(TARGET / 6));

    assert_eq!(client.get_unique_funder_count(), 1);

    client.fund(&inv2, &(TARGET / 6));

    assert_eq!(client.get_unique_funder_count(), 2);

    client.fund(&inv3, &(TARGET / 6));

    assert_eq!(client.get_unique_funder_count(), 3);

    // 4th investor should panic

    let inv4 = Address::generate(&env);

    client.fund(&inv4, &(TARGET / 6));
}

#[test]
#[should_panic]

fn test_max_unique_investors_cap_blocks_excess_investors() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP007"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &Some(2u32), // Cap of 2 investors
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Add 2 investors

    let inv1 = Address::generate(&env);

    let inv2 = Address::generate(&env);

    client.fund(&inv1, &(TARGET / 4));

    client.fund(&inv2, &(TARGET / 4));

    // 3rd investor should panic

    let inv3 = Address::generate(&env);

    client.fund(&inv3, &(TARGET / 4));
}

#[test]
#[should_panic]

fn test_max_unique_investors_cap_blocks_fund_with_commitment() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 900,
    });

    client.init(
        &admin,
        &String::from_str(&env, "CAP008"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &Some(1u32), // Cap of 1 investor
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // First investor succeeds

    let inv1 = Address::generate(&env);

    client.fund_with_commitment(&inv1, &(TARGET / 2), &200u64);

    // Second investor using fund_with_commitment should panic

    let inv2 = Address::generate(&env);

    client.fund_with_commitment(&inv2, &(TARGET / 2), &200u64);
}

#[test]
#[ignore]

fn test_re_funding_same_address_doesnt_count_against_cap() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP009"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &Some(1u32), // Cap of 1 investor
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // First fund should succeed

    client.fund(&investor, &(TARGET / 3));

    assert_eq!(client.get_unique_funder_count(), 1);

    // Re-funding same address should also succeed (doesn't count against cap)

    client.fund(&investor, &(TARGET / 3));

    assert_eq!(client.get_unique_funder_count(), 1);

    // Final fund from same address should succeed

    client.fund(&investor, &(TARGET / 3));

    assert_eq!(client.get_unique_funder_count(), 1);

    assert_eq!(client.get_escrow().status, 1); // Funded
}

#[test]

fn test_zero_contribution_then_non_zero_contribution_counts_as_unique_investor() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP010"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &Some(2u32), // Cap of 2 investors
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    assert_eq!(client.get_unique_funder_count(), 0);

    assert_eq!(client.get_contribution(&investor), 0);

    // First non-zero contribution should increment count

    client.fund(&investor, &(TARGET / 2));

    assert_eq!(client.get_unique_funder_count(), 1);

    assert_eq!(client.get_contribution(&investor), TARGET / 2);
}

#[test]
#[ignore]

fn test_cap_validation_at_init_positive_value_required() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    // Should panic for zero cap

    client.init(
        &admin,
        &String::from_str(&env, "CAP011"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &Some(0u32), // Invalid: zero cap
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );
}

#[test]
#[should_panic]

fn test_init_panics_for_zero_cap() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP012"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &Some(0u32), // Invalid: zero cap
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );
}

#[test]
#[ignore]

fn test_cap_edge_case_exact_limit_reached() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP013"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &Some(5u32), // Cap of 5 investors
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Add exactly 5 investors - should all succeed

    for i in 0..5 {
        let investor = Address::generate(&env);

        client.fund(&investor, &(TARGET / 10));

        assert_eq!(client.get_unique_funder_count(), i + 1);
    }

    // Should have exactly 5 unique funders

    assert_eq!(client.get_unique_funder_count(), 5);

    // 6th investor should panic

    let inv6 = Address::generate(&env);

    client.fund(&inv6, &(TARGET / 10));
}

#[test]
#[should_panic]

fn test_cap_edge_case_exactly_one_over_limit_panics() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP014"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &Some(5u32), // Cap of 5 investors
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Add exactly 5 investors

    for _i in 0..5 {
        let investor = Address::generate(&env);

        client.fund(&investor, &(TARGET / 10));
    }

    // 6th investor should panic

    let inv6 = Address::generate(&env);

    client.fund(&inv6, &(TARGET / 10));
}

#[test]
#[ignore]

fn test_cap_with_min_contribution_floor_interaction() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP015"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &Some(1_000i128), // Min contribution floor
        &Some(3u32),      // Cap of 3 investors
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Should respect both cap and floor

    let inv1 = Address::generate(&env);

    let inv2 = Address::generate(&env);

    let inv3 = Address::generate(&env);

    client.fund(&inv1, &2_000i128);

    assert_eq!(client.get_unique_funder_count(), 1);

    client.fund(&inv2, &1_500i128);

    assert_eq!(client.get_unique_funder_count(), 2);

    client.fund(&inv3, &1_000i128);

    assert_eq!(client.get_unique_funder_count(), 3);

    // 4th investor should be blocked by cap, not floor

    let inv4 = Address::generate(&env);

    client.fund(&inv4, &2_000i128);
}

#[test]
#[should_panic]

fn test_cap_blocks_even_with_large_contribution() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP016"),
        &sme,
        &(TARGET * 10), // Large target
        &800i64,
        &0u64,
        &Address::generate(&env),
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &Some(1u32), // Cap of 1 investor
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // First investor can fund large amount

    let inv1 = Address::generate(&env);

    client.fund(&inv1, &(TARGET * 5));

    // Second investor blocked even if they could fully fund remaining amount

    let inv2 = Address::generate(&env);

    client.fund(&inv2, &(TARGET * 5));
}

#[test]
#[ignore]

fn test_cap_panic_message_quality() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAP017"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &Some(1u32),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Add first investor

    let inv1 = Address::generate(&env);

    client.fund(&inv1, &(TARGET / 2));

    // Try to add second investor - should panic with clear message

    let inv2 = Address::generate(&env);

    client.fund(&inv2, &(TARGET / 2));
}

// ── cancel_funding and refund tests ──────────────────────────────────────────

fn init_with_token<'a>(
    env: &'a Env,

    client: &LiquifactEscrowClient<'a>,

    admin: &Address,

    sme: &Address,
) -> (
    crate::tests::StellarTestToken<'a>,
    Address, // treasury
) {
    let token = install_stellar_asset_token(env);

    let treasury = Address::generate(env);

    client.init(
        admin,
        &String::from_str(env, "REFUND01"),
        sme,
        &TARGET,
        &800i64,
        &0u64,
        &token.id,
        &None,
        &treasury,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    (token, treasury)
}

#[test]

fn test_cancel_funding_transitions_to_status_4() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    let result = client.cancel_funding();

    assert_eq!(result.status, 4);
}

#[test]

fn test_cancel_funding_requires_admin_auth() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    client.cancel_funding();

    assert!(
        env.auths().iter().any(|(addr, _)| *addr == admin),
        "admin auth was not recorded for cancel_funding"
    );
}

#[test]
#[should_panic]

fn test_cancel_funding_panics_if_already_funded() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    let investor = Address::generate(&env);

    client.fund(&investor, &TARGET);

    client.cancel_funding();
}

#[test]
#[should_panic]

fn test_cancel_funding_panics_if_already_cancelled() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    client.cancel_funding();

    client.cancel_funding();
}

#[test]
#[should_panic]

fn test_cancel_funding_blocked_by_legal_hold() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    client.set_legal_hold(&true);

    client.cancel_funding();
}

#[test]

fn test_refund_returns_principal_to_investor() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    let (token, _treasury) = init_with_token(&env, &client, &admin, &sme);

    token.stellar.mint(&investor, &TARGET);

    client.fund(&investor, &TARGET);

    // Undo funded status by cancelling — but fund() moved status to 1, so we need open state.

    // Re-init with partial fund instead.

    let env2 = Env::default();

    let (client2, admin2, sme2) = setup(&env2);

    let investor2 = Address::generate(&env2);

    let (token2, _) = init_with_token(&env2, &client2, &admin2, &sme2);

    token2.stellar.mint(&investor2, &(TARGET / 2));

    client2.fund(&investor2, &(TARGET / 2));

    client2.cancel_funding();

    let before = token2.token.balance(&investor2);

    client2.refund(&investor2);

    let after = token2.token.balance(&investor2);

    assert_eq!(after - before, TARGET / 2);
}

#[test]

fn test_refund_zeroes_contribution() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    let (token, _) = init_with_token(&env, &client, &admin, &sme);

    token.stellar.mint(&investor, &(TARGET / 2));

    client.fund(&investor, &(TARGET / 2));

    client.cancel_funding();

    client.refund(&investor);

    assert_eq!(client.get_contribution(&investor), 0);
}

#[test]

fn test_refund_marks_investor_refunded() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    let (token, _) = init_with_token(&env, &client, &admin, &sme);

    token.stellar.mint(&investor, &(TARGET / 2));

    client.fund(&investor, &(TARGET / 2));

    client.cancel_funding();

    assert!(!client.is_investor_refunded(&investor));

    client.refund(&investor);

    assert!(client.is_investor_refunded(&investor));
}

#[test]
#[should_panic]

fn test_refund_double_spend_panics() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    let (token, _) = init_with_token(&env, &client, &admin, &sme);

    token.stellar.mint(&investor, &(TARGET / 2));

    client.fund(&investor, &(TARGET / 2));

    client.cancel_funding();

    client.refund(&investor);

    client.refund(&investor); // second call must panic
}

#[test]
#[should_panic]

fn test_refund_non_investor_panics() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    client.cancel_funding();

    let stranger = Address::generate(&env);

    client.refund(&stranger);
}

#[test]
#[should_panic]

fn test_refund_panics_in_open_state() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    default_init(&client, &env, &admin, &sme);

    client.fund(&investor, &(TARGET / 2));

    client.refund(&investor);
}

#[test]
#[should_panic]

fn test_refund_panics_in_funded_state() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    default_init(&client, &env, &admin, &sme);

    client.fund(&investor, &TARGET);

    assert_eq!(client.get_escrow().status, 1);

    client.refund(&investor);
}

#[test]

fn test_refund_requires_investor_auth() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    let (token, _) = init_with_token(&env, &client, &admin, &sme);

    token.stellar.mint(&investor, &(TARGET / 2));

    client.fund(&investor, &(TARGET / 2));

    client.cancel_funding();

    client.refund(&investor);

    assert!(
        env.auths().iter().any(|(addr, _)| *addr == investor),
        "investor auth was not recorded for refund"
    );
}

#[test]

fn test_refund_multiple_investors_independent() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let inv_a = Address::generate(&env);

    let inv_b = Address::generate(&env);

    let (token, _) = init_with_token(&env, &client, &admin, &sme);

    let contract_id = client.address.clone();

    let amt_a = TARGET / 3;
    let amt_b = TARGET / 4;
    token.stellar.mint(&inv_a, &amt_a);
    token.stellar.mint(&inv_b, &amt_b);
    client.fund(&inv_a, &amt_a);
    client.fund(&inv_b, &amt_b);

    client.cancel_funding();

    let before_a = token.token.balance(&inv_a);

    let before_b = token.token.balance(&inv_b);

    client.refund(&inv_a);

    client.refund(&inv_b);

    assert_eq!(token.token.balance(&inv_a) - before_a, amt_a);

    assert_eq!(token.token.balance(&inv_b) - before_b, amt_b);
    assert_eq!(client.get_contribution(&inv_a), 0);
    assert_eq!(client.get_contribution(&inv_b), 0);
    assert!(client.is_investor_refunded(&inv_a));
    assert!(client.is_investor_refunded(&inv_b));
    let distributed = client.get_distributed_principal();
    assert_eq!(distributed, amt_a + amt_b);
}

/// Previously-refunded investors are skipped without failing the batch.
#[test]

fn test_cancel_funding_preserves_funded_amount() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    default_init(&client, &env, &admin, &sme);

    client.fund(&investor, &(TARGET / 2));

    let cancelled = client.cancel_funding();

    assert_eq!(cancelled.funded_amount, TARGET / 2);
}

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn test_sweep_terminal_dust_allowed_in_cancelled_state() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let investor = Address::generate(&env);

    let (token, treasury) = init_with_token(&env, &client, &admin, &sme);

    let contract_id = client.address.clone();

    // Mint slightly more than the investor contributes to leave dust

    token.stellar.mint(&investor, &(TARGET / 2 + 1));

    client.fund(&investor, &(TARGET / 2));

    client.cancel_funding();

    client.refund(&investor);

    // 1 unit of dust remains in the contract

    let swept = client.sweep_terminal_dust(&1i128);

    assert_eq!(swept, 1i128);

    assert_eq!(token.token.balance(&treasury), 1i128);
}

// ─── Commitment first-deposit-only invariant (issue #260) ────────────────────

/// After `fund_with_commitment(lock_secs > 0)`, a subsequent `fund()` call from the

/// same investor must preserve **both** `InvestorEffectiveYield` (tier rate) and

/// `InvestorClaimNotBefore` (absolute timestamp) unchanged.

#[test]

fn test_commitment_claim_lock_preserved_after_follow_on_fund() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 950,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "CLK001"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Set ledger timestamp to a known value so claim_nb is deterministic.

    env.ledger().with_mut(|l| l.timestamp = 1_000_000u64);

    // First deposit: tier at 100 s → effective yield = 950 bps, lock until 1_000_100.

    client.fund_with_commitment(&inv, &3_000i128, &100u64);

    let yield_after_first = client.get_investor_yield_bps(&inv);

    let lock_after_first = client.get_investor_claim_not_before(&inv);

    assert_eq!(yield_after_first, 950, "tier yield not selected correctly");

    assert_eq!(
        lock_after_first, 1_000_100u64,
        "claim lock not set correctly"
    );

    // Follow-on deposit using fund() — must succeed and preserve both values.

    client.fund(&inv, &3_000i128);

    assert_eq!(
        client.get_investor_yield_bps(&inv),
        yield_after_first,
        "effective yield must be immutable after follow-on fund()"
    );

    assert_eq!(
        client.get_investor_claim_not_before(&inv),
        lock_after_first,
        "InvestorClaimNotBefore must be immutable after follow-on fund()"
    );
}

/// Tier and claim-lock selection must remain immutable across **multiple** consecutive

/// follow-on `fund()` calls from the same investor.

#[test]

fn test_commitment_invariant_across_multiple_follow_on_funds() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 50,

        yield_bps: 900,
    });

    tiers.push_back(YieldTier {
        min_lock_secs: 200,

        yield_bps: 1100,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "CLK002"),
        &sme,
        &50_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    env.ledger().with_mut(|l| l.timestamp = 2_000_000u64);

    // First deposit: 200 s commitment → top tier (1100 bps), lock until 2_000_200.

    client.fund_with_commitment(&inv, &5_000i128, &200u64);

    let expected_yield = client.get_investor_yield_bps(&inv);

    let expected_lock = client.get_investor_claim_not_before(&inv);

    assert_eq!(expected_yield, 1100);

    assert_eq!(expected_lock, 2_000_200u64);

    // Three follow-on fund() calls — invariant must hold after each.

    for round in 1u32..=3 {
        client.fund(&inv, &1_000i128);

        assert_eq!(
            client.get_investor_yield_bps(&inv),
            expected_yield,
            "yield changed on follow-on fund round {round}"
        );

        assert_eq!(
            client.get_investor_claim_not_before(&inv),
            expected_lock,
            "claim lock changed on follow-on fund round {round}"
        );
    }
}

/// `fund_with_commitment(lock_secs = 0)` must assign base yield and leave

/// `InvestorClaimNotBefore` at zero. A subsequent `fund()` call must keep both

/// at their zero / base values — no claim gate is imposed.

#[test]

fn test_commitment_zero_lock_follow_on_fund_no_claim_gate() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 950,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "CLK003"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Zero lock → base yield only, no claim gate.

    client.fund_with_commitment(&inv, &4_000i128, &0u64);

    assert_eq!(
        client.get_investor_yield_bps(&inv),
        800,
        "should get base yield for zero lock"
    );

    assert_eq!(
        client.get_investor_claim_not_before(&inv),
        0u64,
        "no claim gate for zero lock"
    );

    // Follow-on fund() must preserve both zero-valued guards.

    client.fund(&inv, &4_000i128);

    assert_eq!(
        client.get_investor_yield_bps(&inv),
        800,
        "yield must remain at base after follow-on fund() with zero-lock commitment"
    );

    assert_eq!(
        client.get_investor_claim_not_before(&inv),
        0u64,
        "InvestorClaimNotBefore must stay 0 after follow-on fund() with zero-lock commitment"
    );
}

/// A second `fund_with_commitment` from the same investor (who already has a

/// non-zero contribution) must fail with the documented typed error, regardless

/// of whether a tier table is configured.

#[test]

fn test_second_fund_with_commitment_panics_without_tier_table() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    // No tier table: base-only escrow.

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "CLK004"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund_with_commitment(&inv, &3_000i128, &0u64);

    // Second call must trap.

    assert_contract_error(
        client.try_fund_with_commitment(&inv, &3_000i128, &0u64),
        EscrowError::TieredSecondDeposit,
    );
}

/// After a plain `fund()` first deposit, calling `fund_with_commitment` on the same

/// investor must panic — the tier/lock selection window is permanently closed.

/// This is the "inverse" direction of the state-machine rule.

#[test]

fn test_fund_first_then_commitment_second_panics() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 50,

        yield_bps: 900,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "CLK005"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // First leg via fund() → establishes base-yield position.

    client.fund(&inv, &3_000i128);

    // Attempt to re-select tier via fund_with_commitment → must panic.

    assert_contract_error(
        client.try_fund_with_commitment(&inv, &3_000i128, &100u64),
        EscrowError::TieredSecondDeposit,
    );
}

/// Verify that a plain `fund()` as first deposit sets the effective yield to the

/// base rate and leaves `InvestorClaimNotBefore` at zero (no lock gate implied by

/// the simple funding path).

#[test]

fn test_fund_first_deposit_sets_base_yield_and_no_claim_gate() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 950,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "CLK006"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&inv, &5_000i128);

    assert_eq!(
        client.get_investor_yield_bps(&inv),
        800,
        "fund() must assign base yield even when tier table is present"
    );

    assert_eq!(
        client.get_investor_claim_not_before(&inv),
        0u64,
        "fund() must not impose a claim gate"
    );
}

// ── CommitmentLockExceedsMaturity bound ──────────────────────────────────────

// Helper: init an escrow with a specific maturity timestamp.

fn init_with_maturity(
    env: &Env,

    client: &crate::LiquifactEscrowClient<'_>,

    admin: &soroban_sdk::Address,

    sme: &soroban_sdk::Address,

    maturity: u64,
) {
    let (token, treasury) = free_addresses(env);

    client.init(
        admin,
        &soroban_sdk::String::from_str(env, "LOCK1"),
        sme,
        &10_000i128,
        &800i64,
        &maturity,
        &token,
        &None,
        &treasury,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );
}

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn commitment_lock_within_maturity_is_accepted() {
    // now=1000, maturity=2000, lock=500 → claim_nb=1500 ≤ 2000  ✓

    let env = Env::default();

    env.mock_all_auths();

    let mut li = env.ledger().get();

    li.timestamp = 1000;

    env.ledger().set(li);

    let (client, admin, sme) = setup(&env);

    let investor = soroban_sdk::Address::generate(&env);

    init_with_maturity(&env, &client, &admin, &sme, 2000);

    let escrow = client.fund_with_commitment(&investor, &1_000i128, &500u64);

    assert_eq!(escrow.status, 0);

    assert_eq!(client.get_investor_claim_not_before(&investor), 1500u64);
}

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn commitment_lock_exactly_at_maturity_is_accepted() {
    // now=1000, maturity=2000, lock=1000 → claim_nb=2000 == maturity  ✓ (inclusive)

    let env = Env::default();

    env.mock_all_auths();

    let mut li = env.ledger().get();

    li.timestamp = 1000;

    env.ledger().set(li);

    let (client, admin, sme) = setup(&env);

    let investor = soroban_sdk::Address::generate(&env);

    init_with_maturity(&env, &client, &admin, &sme, 2000);

    let escrow = client.fund_with_commitment(&investor, &1_000i128, &1000u64);

    assert_eq!(escrow.status, 0);

    assert_eq!(client.get_investor_claim_not_before(&investor), 2000u64);
}

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn commitment_lock_one_second_past_maturity_is_rejected() {
    // now=1000, maturity=2000, lock=1001 → claim_nb=2001 > 2000  ✗

    let env = Env::default();

    env.mock_all_auths();

    let mut li = env.ledger().get();

    li.timestamp = 1000;

    env.ledger().set(li);

    let (client, admin, sme) = setup(&env);

    let investor = soroban_sdk::Address::generate(&env);

    init_with_maturity(&env, &client, &admin, &sme, 2000);

    assert_contract_error(
        client.try_fund_with_commitment(&investor, &1_000i128, &1001u64),
        EscrowError::CommitmentLockExceedsMaturity,
    );
}

#[test]

fn commitment_lock_far_past_maturity_is_rejected() {
    // now=1000, maturity=2000, lock=5000 → claim_nb=6000 >> 2000  ✗

    let env = Env::default();

    env.mock_all_auths();

    let mut li = env.ledger().get();

    li.timestamp = 1000;

    env.ledger().set(li);

    let (client, admin, sme) = setup(&env);

    let investor = soroban_sdk::Address::generate(&env);

    init_with_maturity(&env, &client, &admin, &sme, 2000);

    assert_contract_error(
        client.try_fund_with_commitment(&investor, &1_000i128, &5000u64),
        EscrowError::CommitmentLockExceedsMaturity,
    );
}

#[test]

fn zero_lock_with_maturity_is_always_accepted() {
    // committed_lock_secs==0 → claim_nb=0, no maturity bound applied

    let env = Env::default();

    env.mock_all_auths();

    let mut li = env.ledger().get();

    li.timestamp = 1000;

    env.ledger().set(li);

    let (client, admin, sme) = setup(&env);

    let investor = soroban_sdk::Address::generate(&env);

    init_with_maturity(&env, &client, &admin, &sme, 2000);

    let escrow = client.fund_with_commitment(&investor, &1_000i128, &0u64);

    assert_eq!(escrow.status, 0);

    assert_eq!(client.get_investor_claim_not_before(&investor), 0u64);
}

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn lock_with_zero_maturity_is_always_accepted() {
    // maturity==0 means no maturity lock; any lock_secs is fine

    let env = Env::default();

    env.mock_all_auths();

    let mut li = env.ledger().get();

    li.timestamp = 1000;

    env.ledger().set(li);

    let (client, admin, sme) = setup(&env);

    let investor = soroban_sdk::Address::generate(&env);

    // maturity = 0 → no bound applied even for a huge lock

    let (token, treasury) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "LOCK2"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        // no maturity
        &token,
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let escrow = client.fund_with_commitment(&investor, &1_000i128, &9999u64);

    assert_eq!(escrow.status, 0);

    assert_eq!(client.get_investor_claim_not_before(&investor), 10999u64);
}

#[test]

fn plain_fund_with_maturity_ignores_lock_bound() {
    // fund() (simple_fund=true) never sets a claim lock; bound is irrelevant

    let env = Env::default();

    env.mock_all_auths();

    let mut li = env.ledger().get();

    li.timestamp = 1000;

    env.ledger().set(li);

    let (client, admin, sme) = setup(&env);

    let investor = soroban_sdk::Address::generate(&env);

    init_with_maturity(&env, &client, &admin, &sme, 2000);

    // fund() should succeed regardless of maturity; it never imposes a lock

    let escrow = client.fund(&investor, &1_000i128);

    assert_eq!(escrow.status, 0);

    assert_eq!(client.get_investor_claim_not_before(&investor), 0u64);
}

// ─────────────────────────────────────────────────────────────────────────────

// Tests for fund_batch entrypoint (Issue #311)

// ─────────────────────────────────────────────────────────────────────────────

#[test]
#[should_panic(expected = "HostError: Error(Contract, #82)")]

fn test_fund_batch_rejects_empty() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    let empty_batch: SorobanVec<(Address, i128)> = SorobanVec::new(&env);

    client.fund_batch(&empty_batch);
}

#[test]
#[should_panic(expected = "HostError: Error(Contract, #83)")]

fn test_fund_batch_rejects_oversized() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    let mut entries = SorobanVec::new(&env);

    // Create MAX_FUND_BATCH + 1 entries

    for _ in 0..=(MAX_FUND_BATCH as usize) {
        let investor = Address::generate(&env);

        entries.push_back((investor, 1_000i128));
    }

    client.fund_batch(&entries);
}

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn test_fund_batch_equals_n_single_funds() {
    let env = Env::default();

    env.mock_all_auths();

    let client_a = deploy(&env);

    let client_b = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    // Initialize both identical escrows

    let target = 100_000i128;

    for client in &[&client_a, &client_b] {
        client.init(
            &admin,
            &soroban_sdk::String::from_str(&env, "BATCH001"),
            &sme,
            &target,
            &800i64,
            &0u64,
            &tok,
            &None,
            &Address::generate(&env),
            &None,
            &None,
            &None,
            &None,
            &None,
            &None,
            &None,
            &None,
            &None::<i64>,
        );
    }

    // Create 5 investors

    let mut investors = SorobanVec::new(&env);

    let mut amounts = SorobanVec::new(&env);

    for i in 0..5 {
        let inv = Address::generate(&env);

        investors.push_back(inv.clone());

        amounts.push_back((i + 1) as i128 * 10_000i128);
    }

    // Path A: fund_batch

    let mut batch_entries = SorobanVec::new(&env);

    for i in 0..5 {
        batch_entries.push_back((investors.get(i).unwrap(), amounts.get(i).unwrap()));
    }

    let result_batch = client_a.fund_batch(&batch_entries);

    // Path B: individual fund calls

    for i in 0..5 {
        client_b.fund(&investors.get(i).unwrap(), &amounts.get(i).unwrap());
    }

    let result_single = client_b.get_escrow();

    // Assert identical final state

    assert_eq!(result_batch.funded_amount, result_single.funded_amount);

    assert_eq!(result_batch.status, result_single.status);

    // Verify contributions match

    for i in 0..5 {
        let inv = investors.get(i).unwrap();

        let batch_contrib = client_a.get_contribution(&inv);

        let single_contrib = client_b.get_contribution(&inv);

        assert_eq!(batch_contrib, single_contrib);
    }
}

#[test]
#[should_panic(expected = "HostError: Error(Contract, #106)")]

fn test_fund_batch_per_investor_cap_rejection() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv1 = Address::generate(&env);

    let inv2 = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let target = 100_000i128;

    let per_investor_cap = 30_000i128;

    let sac = env.register_stellar_asset_contract_v2(Address::generate(&env));
    let sac_id = sac.address();
    let sac_admin = StellarAssetClient::new(&env, &sac_id);
    sac_admin.mint(&inv1, &25_000i128);
    sac_admin.mint(&inv2, &35_000i128);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "CAP001"),
        &sme,
        &target,
        &800i64,
        &0u64,
        &sac_id,
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &Some(per_investor_cap),
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let mut entries = SorobanVec::new(&env);

    entries.push_back((inv1.clone(), 25_000i128)); // Within cap

    entries.push_back((inv2.clone(), 35_000i128)); // Exceeds cap

    client.fund_batch(&entries);
}

#[test]

fn test_fund_batch_mid_batch_funded_transition() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let investor = Address::generate(&env);

    let target = 100_000i128;

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "TRANS001"),
        &sme,
        &target,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv1 = Address::generate(&env);

    let inv2 = Address::generate(&env);

    let inv3 = Address::generate(&env);

    let mut entries = SorobanVec::new(&env);

    // inv1 brings total to 40k (still open)

    entries.push_back((inv1.clone(), 40_000i128));

    // inv2 brings total to 95k (still open)

    entries.push_back((inv2.clone(), 55_000i128));

    // inv3 brings total to 105k (crosses funded threshold)

    entries.push_back((inv3.clone(), 10_000i128));

    let result = client.fund_batch(&entries);

    // Verify transition occurred

    assert_eq!(result.status, 1, "status should be funded (1) after batch");

    assert_eq!(result.funded_amount, 105_000i128);

    // Verify all entries were processed

    assert_eq!(client.get_contribution(&inv1), 40_000i128);

    assert_eq!(client.get_contribution(&inv2), 55_000i128);

    assert_eq!(client.get_contribution(&inv3), 10_000i128);

    // Verify snapshot was captured

    let snap = client.get_funding_close_snapshot();

    assert!(snap.is_some());

    assert_eq!(snap.unwrap().total_principal, 105_000i128);
}

#[test]
#[should_panic(expected = "HostError: Error(Contract, #106)")]
#[ignore = "upstream latent: escrow API/test drift"]
fn test_fund_batch_duplicate_addresses() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let inv = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let target = 100_000i128;

    let per_investor_cap = 50_000i128;

    let sac = env.register_stellar_asset_contract_v2(Address::generate(&env));
    let sac_id = sac.address();
    let sac_admin = StellarAssetClient::new(&env, &sac_id);
    sac_admin.mint(&inv, &60_000i128);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "DUP001"),
        &sme,
        &target,
        &800i64,
        &0u64,
        &sac_id,
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &Some(per_investor_cap),
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let mut entries = SorobanVec::new(&env);

    entries.push_back((inv.clone(), 30_000i128)); // First entry: 30k

    entries.push_back((inv.clone(), 25_000i128)); // Second entry: 30k + 25k = 55k > cap

    // Duplicate-address batch exceeding the per-investor cap must be rejected
    // with DuplicateInvestorInBatch (#106) before any state is committed.
    let _ = client.fund_batch(&entries);
}

#[test]
#[should_panic]
#[ignore = "upstream latent: escrow API/test drift"]
fn test_fund_batch_per_investor_auth() {
    // Test that each investor in the batch must authorize their own entry.

    // This test demonstrates that require_auth() is called per investor.

    let env = Env::default();

    // NOT calling env.mock_all_auths() - we'll manually auth only one investor

    let (client, admin, sme) = setup(&env); // setup() calls mock_all_auths, so this won't work as intended

    default_init(&client, &env, &admin, &sme);

    let inv1 = Address::generate(&env);

    let inv2 = Address::generate(&env);

    let mut entries = SorobanVec::new(&env);

    entries.push_back((inv1.clone(), 10_000i128));

    entries.push_back((inv2.clone(), 10_000i128)); // This one will fail on require_auth

    // Since setup() mocks all auths, this test will pass both.

    // A more realistic test would require custom auth mocking, which is env-dependent.

    // For now, we just verify that the batch processes all entries with require_auth.

    let result = client.fund_batch(&entries);

    assert_eq!(result.funded_amount, 20_000i128);
}

#[test]

fn test_fund_batch_single_entry() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    let inv = Address::generate(&env);

    let amount = 50_000i128;

    let mut entries = SorobanVec::new(&env);

    entries.push_back((inv.clone(), amount));

    let result = client.fund_batch(&entries);

    assert_eq!(result.funded_amount, amount);

    assert_eq!(client.get_contribution(&inv), amount);
}

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn test_fund_batch_max_batch_size() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let target = 10_000_000i128; // Very large target

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "MAXBATCH"),
        &sme,
        &target,
        &800i64,
        &0u64,
        &tok,
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Create exactly MAX_FUND_BATCH entries

    let mut entries = SorobanVec::new(&env);

    for _ in 0..MAX_FUND_BATCH {
        let inv = Address::generate(&env);

        entries.push_back((inv, 1_000i128));
    }

    let result = client.fund_batch(&entries);

    // Verify all entries were processed

    assert_eq!(result.funded_amount, (MAX_FUND_BATCH as i128) * 1_000i128);
}

#[test]

fn test_fund_batch_preserves_event_semantics() {
    use soroban_sdk::testutils::Events as _;

    let env = Env::default();

    env.mock_all_auths();

    let (contract_id, client) = deploy_with_id(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let target = 100_000i128;

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "EVENTS01"),
        &sme,
        &target,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv1 = Address::generate(&env);

    let inv2 = Address::generate(&env);

    let mut entries = SorobanVec::new(&env);

    entries.push_back((inv1.clone(), 30_000i128));

    entries.push_back((inv2.clone(), 50_000i128));

    client.fund_batch(&entries);

    // Verify events emitted

    let events = env.events().all();

    assert_eq!(
        events.events().len(),
        2,
        "should emit 2 EscrowFunded events"
    );

    // Each event corresponds to a fund operation

    // (Detailed event field verification depends on EscrowFunded structure)
}

// ─── get_remaining_funding_capacity tests (issue tracking funding capacity) ─────

/// Verify that `get_remaining_funding_capacity` returns the full funding target

/// when no deposits have been made yet.

#[test]

fn test_remaining_capacity_equals_target_before_any_funding() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    assert_eq!(
        client.get_remaining_funding_capacity(),
        TARGET,
        "remaining capacity must equal target when funded_amount is zero"
    );
}

/// Assert that remaining capacity decreases by exactly the deposit amount after

/// a single fund() call, following the formula: target - funded_amount.

#[test]

fn test_remaining_capacity_decreases_after_single_deposit() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    let investor = Address::generate(&env);

    let deposit_amount = TARGET / 4;

    client.fund(&investor, &deposit_amount);

    assert_eq!(
        client.get_remaining_funding_capacity(),
        TARGET - deposit_amount,
        "remaining capacity must equal target minus funded amount"
    );
}

/// Walk the capacity down monotonically across multiple deposits from different

/// investors, asserting the formula holds after each fund() call.

#[test]

fn test_remaining_capacity_tracks_across_multiple_deposits() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    let inv_a = Address::generate(&env);

    let inv_b = Address::generate(&env);

    let inv_c = Address::generate(&env);

    // Initial capacity = TARGET

    assert_eq!(client.get_remaining_funding_capacity(), TARGET);

    // First deposit: 30% of target

    let deposit_a = TARGET * 30 / 100;

    client.fund(&inv_a, &deposit_a);

    let expected_after_a = TARGET - deposit_a;

    assert_eq!(
        client.get_remaining_funding_capacity(),
        expected_after_a,
        "capacity after first deposit"
    );

    // Second deposit: 25% of target

    let deposit_b = TARGET * 25 / 100;

    client.fund(&inv_b, &deposit_b);

    let expected_after_b = TARGET - deposit_a - deposit_b;

    assert_eq!(
        client.get_remaining_funding_capacity(),
        expected_after_b,
        "capacity after second deposit"
    );

    // Third deposit: 20% of target

    let deposit_c = TARGET * 20 / 100;

    client.fund(&inv_c, &deposit_c);

    let expected_after_c = TARGET - deposit_a - deposit_b - deposit_c;

    assert_eq!(
        client.get_remaining_funding_capacity(),
        expected_after_c,
        "capacity after third deposit"
    );

    // Verify monotonic decrease

    assert!(
        expected_after_a > expected_after_b && expected_after_b > expected_after_c,
        "capacity must decrease monotonically"
    );
}

/// Assert that remaining capacity reaches exactly zero when the funding target

/// is met, and the escrow transitions to the funded state (status=1).

#[test]

fn test_remaining_capacity_reaches_zero_at_exact_target() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    let investor = Address::generate(&env);

    client.fund(&investor, &TARGET);

    assert_eq!(
        client.get_remaining_funding_capacity(),
        0,
        "remaining capacity must be exactly zero when target is met"
    );

    assert_eq!(
        client.get_escrow().status,
        1,
        "escrow must transition to funded state"
    );
}

/// Verify that remaining capacity is zero (never negative) when funded_amount

/// exceeds the target.

#[test]

fn test_remaining_capacity_never_negative_when_overfunded() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAPOVER1"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let investor = Address::generate(&env);

    let overfund_amount = TARGET + 50_000_000i128;

    client.fund(&investor, &overfund_amount);

    assert_eq!(
        client.get_remaining_funding_capacity(),
        0,
        "capacity must be floored at zero even when overfunded"
    );

    assert_eq!(client.get_escrow().status, 1, "escrow must be funded");
}

/// Test that capacity recomputes correctly after update_funding_target raises

/// the target while the escrow is still open.

#[test]

fn test_remaining_capacity_recomputes_after_target_raised() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAPUP1"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let investor = Address::generate(&env);

    let initial_deposit = TARGET / 2;

    client.fund(&investor, &initial_deposit);

    // Capacity before target update

    let capacity_before = client.get_remaining_funding_capacity();

    assert_eq!(capacity_before, TARGET - initial_deposit);

    // Raise the target

    let new_target = TARGET * 2;

    client.update_funding_target(&new_target);

    // Capacity must reflect new target

    let capacity_after = client.get_remaining_funding_capacity();

    assert_eq!(
        capacity_after,
        new_target - initial_deposit,
        "capacity must recompute with new target"
    );

    assert!(
        capacity_after > capacity_before,
        "capacity must increase when target is raised"
    );
}

/// Test that capacity recomputes correctly after update_funding_target lowers

/// the target while the escrow is still open (but not below funded_amount).

#[test]

fn test_remaining_capacity_recomputes_after_target_lowered() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAPDOWN1"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let investor = Address::generate(&env);

    let initial_deposit = TARGET / 4; // 25% of original target

    client.fund(&investor, &initial_deposit);

    // Capacity before target update

    let capacity_before = client.get_remaining_funding_capacity();

    assert_eq!(capacity_before, TARGET - initial_deposit);

    // Lower the target to 50% of original (still above funded_amount)

    let new_target = TARGET / 2;

    client.update_funding_target(&new_target);

    // Capacity must reflect new lower target

    let capacity_after = client.get_remaining_funding_capacity();

    assert_eq!(
        capacity_after,
        new_target - initial_deposit,
        "capacity must recompute with new lowered target"
    );

    assert!(
        capacity_after < capacity_before,
        "capacity must decrease when target is lowered"
    );
}

/// When the target is lowered to exactly equal funded_amount, capacity must be

/// zero and the escrow must transition to funded state.

#[test]

fn test_remaining_capacity_zero_when_target_lowered_to_funded_amount() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAPDOWN2"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let investor = Address::generate(&env);

    let deposit = TARGET / 3;

    client.fund(&investor, &deposit);

    assert_eq!(client.get_escrow().status, 0, "escrow must still be open");

    // Lower target to exactly the funded amount

    client.update_funding_target(&deposit);

    assert_eq!(
        client.get_remaining_funding_capacity(),
        0,
        "capacity must be zero when target equals funded amount"
    );

    assert_eq!(
        client.get_escrow().status,
        1,
        "escrow must transition to funded when target is lowered to funded_amount"
    );
}

/// Test capacity tracking with multiple deposits and a target update mid-flight,

/// verifying monotonic decrease and correct formula application throughout.

#[test]

fn test_remaining_capacity_across_deposits_and_target_update() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAPMID1"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv_a = Address::generate(&env);

    let inv_b = Address::generate(&env);

    let inv_c = Address::generate(&env);

    // First deposit: 20% of target

    let deposit_a = TARGET / 5;

    client.fund(&inv_a, &deposit_a);

    assert_eq!(client.get_remaining_funding_capacity(), TARGET - deposit_a);

    // Second deposit: 15% of target

    let deposit_b = TARGET * 15 / 100;

    client.fund(&inv_b, &deposit_b);

    let funded_before_update = deposit_a + deposit_b;

    assert_eq!(
        client.get_remaining_funding_capacity(),
        TARGET - funded_before_update
    );

    // Update target to 150% of original

    let new_target = TARGET * 3 / 2;

    client.update_funding_target(&new_target);

    assert_eq!(
        client.get_remaining_funding_capacity(),
        new_target - funded_before_update,
        "capacity must reflect new target after update"
    );

    // Third deposit: 40% of original target

    let deposit_c = TARGET * 40 / 100;

    client.fund(&inv_c, &deposit_c);

    let total_funded = funded_before_update + deposit_c;

    assert_eq!(
        client.get_remaining_funding_capacity(),
        new_target - total_funded,
        "capacity must continue tracking correctly after target update"
    );

    // Escrow should still be open since total < new_target

    assert_eq!(client.get_escrow().status, 0);

    assert!(total_funded < new_target);
}

/// Verify capacity with fund_batch, ensuring capacity decreases by the sum of

/// all batch entries.

#[test]

fn test_remaining_capacity_with_fund_batch() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAPBATCH1"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv_a = Address::generate(&env);

    let inv_b = Address::generate(&env);

    let inv_c = Address::generate(&env);

    let amount_a = TARGET / 5;

    let amount_b = TARGET / 4;

    let amount_c = TARGET / 10;

    let mut batch = SorobanVec::new(&env);

    batch.push_back((inv_a, amount_a));

    batch.push_back((inv_b, amount_b));

    batch.push_back((inv_c, amount_c));

    client.fund_batch(&batch);

    let total_batch = amount_a + amount_b + amount_c;

    assert_eq!(
        client.get_remaining_funding_capacity(),
        TARGET - total_batch,
        "capacity must decrease by total batch amount"
    );
}

/// Edge case: capacity with minimal target (1 unit).

#[test]

fn test_remaining_capacity_minimal_target() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAPMIN1"),
        &sme,
        &1i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    assert_eq!(client.get_remaining_funding_capacity(), 1);

    let investor = Address::generate(&env);

    client.fund(&investor, &1i128);

    assert_eq!(client.get_remaining_funding_capacity(), 0);

    assert_eq!(client.get_escrow().status, 1);
}

/// Edge case: capacity with very large target (near i128::MAX).

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn test_remaining_capacity_very_large_target() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let large_target = i128::MAX / 2;

    client.init(
        &admin,
        &String::from_str(&env, "CAPLARGE1"),
        &sme,
        &large_target,
        &800i64,
        &0u64,
        &tok,
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let investor = Address::generate(&env);

    let deposit = large_target / 10;

    client.fund(&investor, &deposit);

    assert_eq!(
        client.get_remaining_funding_capacity(),
        large_target - deposit
    );
}

/// Verify that capacity tracking works correctly with fund_with_commitment

/// (tiered yield deposits).

#[test]

fn test_remaining_capacity_with_tiered_funding() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 900,
    });

    client.init(
        &admin,
        &String::from_str(&env, "CAPTIER1"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv_a = Address::generate(&env);

    let inv_b = Address::generate(&env);

    let deposit_a = TARGET / 3;

    client.fund_with_commitment(&inv_a, &deposit_a, &150u64);

    assert_eq!(client.get_remaining_funding_capacity(), TARGET - deposit_a);

    let deposit_b = TARGET / 3;

    client.fund(&inv_b, &deposit_b);

    assert_eq!(
        client.get_remaining_funding_capacity(),
        TARGET - deposit_a - deposit_b
    );
}

/// Comprehensive test: verify capacity is never negative across all transitions:

/// multiple deposits, target update, and reaching funded state.

#[test]

fn test_remaining_capacity_never_negative_comprehensive() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &String::from_str(&env, "CAPNEG1"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv = Address::generate(&env);

    // Start: capacity = TARGET

    assert!(client.get_remaining_funding_capacity() >= 0);

    // Fund 80% of target

    client.fund(&inv, &(TARGET * 80 / 100));

    assert!(client.get_remaining_funding_capacity() >= 0);

    // Lower target to 90% of original (still above funded amount)

    client.update_funding_target(&(TARGET * 90 / 100));

    assert!(client.get_remaining_funding_capacity() >= 0);

    // Fund another 20% of original target (now overfunded vs new target)

    client.fund(&inv, &(TARGET * 20 / 100));

    assert_eq!(
        client.get_remaining_funding_capacity(),
        0,
        "capacity must be zero when overfunded, not negative"
    );

    assert_eq!(client.get_escrow().status, 1);
}

// ─── is_fully_funded tests (issue #399) ──────────────────────────────────────

#[test]

fn test_investor_index_population() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    let inv_a = Address::generate(&env);

    let inv_b = Address::generate(&env);
    let stranger = Address::generate(&env);

    // Fund from investor A

    client.fund(&inv_a, &10_000i128);

    // Index should have A

    let investors = client.get_investors(&0, &10);

    assert_eq!(investors.len(), 1);

    assert_eq!(investors.get(0).unwrap(), inv_a);

    // Fund from investor B

    client.fund(&inv_b, &20_000i128);

    // Index should have A and B

    let investors = client.get_investors(&0, &10);

    assert_eq!(investors.len(), 2);

    assert_eq!(investors.get(0).unwrap(), inv_a);

    assert_eq!(investors.get(1).unwrap(), inv_b);

    // Repeat fund from investor A

    client.fund(&inv_a, &5_000i128);

    // Index should still only have A and B, no duplicate

    let investors = client.get_investors(&0, &10);

    assert_eq!(investors.len(), 2);
}

#[test]

fn test_get_investors_pagination() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    // Add 5 distinct investors

    let mut expected_investors = std::vec::Vec::new();

    for _ in 0..5 {
        let inv = Address::generate(&env);

        expected_investors.push(inv.clone());

        client.fund(&inv, &1_000i128);
    }

    // Paginate start=0, limit=2

    let page1 = client.get_investors(&0, &2);

    assert_eq!(page1.len(), 2);

    assert_eq!(page1.get(0).unwrap(), expected_investors[0]);

    assert_eq!(page1.get(1).unwrap(), expected_investors[1]);

    // Paginate start=2, limit=2

    let page2 = client.get_investors(&2, &2);

    assert_eq!(page2.len(), 2);

    assert_eq!(page2.get(0).unwrap(), expected_investors[2]);

    assert_eq!(page2.get(1).unwrap(), expected_investors[3]);

    // Paginate start=4, limit=2 (only 1 left)

    let page3 = client.get_investors(&4, &2);

    assert_eq!(page3.len(), 1);

    assert_eq!(page3.get(0).unwrap(), expected_investors[4]);

    // Paginate start=5, limit=2 (out of bounds)

    let page4 = client.get_investors(&5, &2);

    assert_eq!(page4.len(), 0);

    // Paginate with limit 0

    let page_zero = client.get_investors(&0, &0);

    assert_eq!(page_zero.len(), 0);

    // Add 52 distinct investors to test capped limit of 50

    let env2 = Env::default();

    let (client2, admin2, sme2) = setup(&env2);

    default_init(&client2, &env2, &admin2, &sme2);

    for _ in 0..52 {
        client2.fund(&Address::generate(&env2), &1_000i128);
    }

    let max_page = client2.get_investors(&0, &100);

    assert_eq!(max_page.len(), 50);
}

#[test]

fn test_get_investors_legacy_compatibility() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    // No investors have funded yet (InvestorIndex absent)

    let investors = client.get_investors(&0, &10);

    assert_eq!(investors.len(), 0);
}

// ---------------------------------------------------------------------------

// update_funding_target: rejection bounds and mid-update funded promotion

// ---------------------------------------------------------------------------

/// Helper: initialise an escrow and fund it partially, returning the client.

fn setup_partially_funded(
    env: &Env,

    funded: i128,

    target: i128,
) -> super::LiquifactEscrowClient<'_> {
    let client = super::deploy(env);

    let admin = Address::generate(env);

    let sme = Address::generate(env);

    let sac = env.register_stellar_asset_contract_v2(Address::generate(env));
    let sac_id = sac.address();
    let sac_admin = StellarAssetClient::new(env, &sac_id);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(env, "UFT001"),
        &sme,
        &target,
        &800i64,
        &0u64,
        &sac_id,
        &None,
        &Address::generate(env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    if funded > 0 {
        let funder = Address::generate(env);
        sac_admin.mint(&funder, &funded);
        client.fund(&funder, &funded);
    }

    client
}

/// `new_target = 0` must be rejected with `TargetNotPositive`.

#[test]

fn test_update_funding_target_zero_rejected() {
    let env = Env::default();

    env.mock_all_auths();

    let client = setup_partially_funded(&env, 0, 10_000i128);

    assert_contract_error(
        client.try_update_funding_target(&0i128),
        EscrowError::TargetNotPositive,
    );
}

/// Negative target must be rejected with `TargetNotPositive`.

#[test]

fn test_update_funding_target_negative_rejected() {
    let env = Env::default();

    env.mock_all_auths();

    let client = setup_partially_funded(&env, 0, 10_000i128);

    assert_contract_error(
        client.try_update_funding_target(&-1i128),
        EscrowError::TargetNotPositive,
    );
}

/// A target strictly below `funded_amount` must be rejected with `TargetBelowFundedAmount`.

#[test]

fn test_update_funding_target_below_funded_amount_rejected() {
    let env = Env::default();

    env.mock_all_auths();

    let client = setup_partially_funded(&env, 5_000i128, 10_000i128);

    assert_contract_error(
        client.try_update_funding_target(&4_999i128),
        EscrowError::TargetBelowFundedAmount,
    );
}

/// Calling `update_funding_target` on a funded (status=1) escrow must be rejected

/// with `TargetUpdateNotOpen`.

#[test]

fn test_update_funding_target_not_open_rejected() {
    let env = Env::default();

    env.mock_all_auths();

    let client = setup_partially_funded(&env, 10_000i128, 10_000i128);

    // escrow is now status=1 (funded)

    assert_eq!(client.get_escrow().status, 1);

    assert_contract_error(
        client.try_update_funding_target(&10_000i128),
        EscrowError::TargetUpdateNotOpen,
    );
}

/// `update_funding_target` on a settled (status=2) escrow must be rejected with

/// `TargetUpdateNotOpen`.

#[test]

fn test_update_funding_target_settled_rejected() {
    let env = Env::default();

    env.mock_all_auths();

    let client = setup_partially_funded(&env, 10_000i128, 10_000i128);

    client.settle();

    assert_contract_error(
        client.try_update_funding_target(&10_000i128),
        EscrowError::TargetUpdateNotOpen,
    );
}

/// Raising the target on a partially-funded open escrow keeps status=0 and

/// emits `fund_tgt` with the correct old/new values.

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn test_update_funding_target_raise_stays_open_emits_event() {
    use crate::FundingTargetUpdated;

    use soroban_sdk::testutils::Events as _;

    let env = Env::default();

    env.mock_all_auths();

    let (contract_id, client) = super::deploy_with_id(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = super::free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "UFT002"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&Address::generate(&env), &3_000i128);

    let result = client.update_funding_target(&20_000i128);

    // Capture events before any getter calls.
    let events = env.events().all();

    assert_eq!(result.status, 0);

    assert_eq!(result.funding_target, 20_000i128);

    assert_eq!(client.get_funding_close_snapshot(), None);

    assert_eq!(
        events,
        std::vec![FundingTargetUpdated {
            name: soroban_sdk::symbol_short!("fund_tgt"),

            invoice_id: client.get_escrow().invoice_id,

            old_target: 10_000i128,

            new_target: 20_000i128,
        }
        .to_xdr(&env, &contract_id)]
    );
}

/// Lowering the target to **exactly** `funded_amount` triggers the funded promotion:

/// status becomes 1, `FundingCloseSnapshot` is written with correct fields, and

/// `fund_tgt` event still fires.

#[test]
#[ignore = "upstream latent: escrow API/test drift"]
fn test_update_funding_target_exact_funded_amount_promotes_to_funded() {
    use crate::FundingTargetUpdated;

    use soroban_sdk::testutils::{Events as _, Ledger as _};

    let env = Env::default();

    env.mock_all_auths();

    env.ledger().with_mut(|l| {
        l.timestamp = 9_000;

        l.sequence_number = 42;
    });

    let (contract_id, client) = super::deploy_with_id(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = super::free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "UFT003"),
        &sme,
        &10_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&Address::generate(&env), &7_000i128);

    // Pre-condition: open, no snapshot yet.

    assert_eq!(client.get_escrow().status, 0);

    assert_eq!(client.get_funding_close_snapshot(), None);

    // Lower target to exactly funded_amount.

    let result = client.update_funding_target(&7_000i128);

    // Capture events before any getter calls.
    let events = env.events().all();

    // Status promoted.

    assert_eq!(result.status, 1);

    assert_eq!(result.funding_target, 7_000i128);

    assert_eq!(result.funded_amount, 7_000i128);

    // Snapshot written exactly once with correct fields.

    let snap = client
        .get_funding_close_snapshot()
        .expect("snapshot must be present after funded promotion");

    assert_eq!(snap.total_principal, 7_000i128);

    assert_eq!(snap.funding_target, 7_000i128);

    assert_eq!(snap.closed_at_ledger_timestamp, 9_000u64);

    assert_eq!(snap.closed_at_ledger_sequence, 42u32);

    // Event still carries old/new target values.

    assert_eq!(
        events,
        std::vec![FundingTargetUpdated {
            name: soroban_sdk::symbol_short!("fund_tgt"),

            invoice_id: client.get_escrow().invoice_id,

            old_target: 10_000i128,

            new_target: 7_000i128,
        }
        .to_xdr(&env, &contract_id)]
    );
}

/// The `FundingCloseSnapshot` is immutable: a second `update_funding_target` call

/// (which would be rejected since status=1) cannot overwrite it. Verify snapshot

/// is unchanged after the promotion.

#[test]

fn test_update_funding_target_snapshot_written_only_once() {
    let env = Env::default();

    env.mock_all_auths();

    let client = setup_partially_funded(&env, 5_000i128, 10_000i128);

    // Promote to funded via target lowering.

    client.update_funding_target(&5_000i128);

    let snap1 = client.get_funding_close_snapshot().unwrap();

    // Any further attempt on the now-funded escrow must be rejected.

    assert_contract_error(
        client.try_update_funding_target(&5_000i128),
        EscrowError::TargetUpdateNotOpen,
    );

    // Snapshot unchanged.

    let snap2 = client.get_funding_close_snapshot().unwrap();

    assert_eq!(snap1.total_principal, snap2.total_principal);

    assert_eq!(snap1.funding_target, snap2.funding_target);

    assert_eq!(
        snap1.closed_at_ledger_timestamp,
        snap2.closed_at_ledger_timestamp
    );

    assert_eq!(
        snap1.closed_at_ledger_sequence,
        snap2.closed_at_ledger_sequence
    );
}

/// After promotion via `update_funding_target`, a subsequent `fund` call must

/// be rejected with `EscrowNotOpenForFunding` — confirming the status transition

/// is durable.

#[test]

fn test_fund_rejected_after_promotion_via_update_funding_target() {
    let env = Env::default();

    env.mock_all_auths();

    let client = setup_partially_funded(&env, 6_000i128, 10_000i128);

    client.update_funding_target(&6_000i128);

    assert_eq!(client.get_escrow().status, 1);

    assert_contract_error(
        client.try_fund(&Address::generate(&env), &1i128),
        EscrowError::EscrowNotOpenForFunding,
    );
}

/// Target update with zero funded amount (no investors yet) must NOT promote

/// even when `new_target` is positive — there is nothing to promote.

#[test]

fn test_update_funding_target_no_funds_no_promotion() {
    let env = Env::default();

    env.mock_all_auths();

    let client = setup_partially_funded(&env, 0, 10_000i128);

    let result = client.update_funding_target(&1i128);

    assert_eq!(result.status, 0);

    assert_eq!(client.get_funding_close_snapshot(), None);
}

// ── Issue #345: get_yield_tiers read view ────────────────────────────────────

// ---------------------------------------------------------------------------
// extend_funding_deadline: forward-only funding-window extension (issue #551)
// ---------------------------------------------------------------------------

fn init_deadline_escrow<'a>(
    env: &'a Env,
    invoice_id: &str,
    maturity: u64,
    deadline: Option<u64>,
) -> (Address, LiquifactEscrowClient<'a>, Address, Address) {
    let (contract_id, client) = super::deploy_with_id(env);
    let admin = Address::generate(env);
    let sme = Address::generate(env);
    let (tok, tre) = super::free_addresses(env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(env, invoice_id),
        &sme,
        &10_000i128,
        &800i64,
        &maturity,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &deadline,
        &None,
        &None::<i64>,
    );

    (contract_id, client, admin, sme)
}

#[test]

fn test_get_yield_tiers_returns_empty_when_no_tiers_configured() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "NOTIER01"),
        &sme,
        &100_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let tiers = client.get_yield_tiers();

    assert_eq!(
        tiers.len(),
        0,
        "expected empty vec when no tiers configured"
    );
}

#[test]

fn test_get_yield_tiers_returns_single_tier() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 2_592_000,

        yield_bps: 900,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "SINGLE01"),
        &sme,
        &100_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let result = client.get_yield_tiers();

    assert_eq!(result.len(), 1);

    let t = result.get(0).unwrap();

    assert_eq!(t.min_lock_secs, 2_592_000);

    assert_eq!(t.yield_bps, 900);
}

#[test]

fn test_get_yield_tiers_preserves_order() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 2_592_000,

        yield_bps: 900,
    });

    tiers.push_back(YieldTier {
        min_lock_secs: 7_776_000,

        yield_bps: 1_100,
    });

    tiers.push_back(YieldTier {
        min_lock_secs: 15_552_000,

        yield_bps: 1_400,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "MULTI01"),
        &sme,
        &100_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let result = client.get_yield_tiers();

    assert_eq!(result.len(), 3);

    let t0 = result.get(0).unwrap();

    assert_eq!(t0.min_lock_secs, 2_592_000);

    assert_eq!(t0.yield_bps, 900);

    let t1 = result.get(1).unwrap();

    assert_eq!(t1.min_lock_secs, 7_776_000);

    assert_eq!(t1.yield_bps, 1_100);

    let t2 = result.get(2).unwrap();

    assert_eq!(t2.min_lock_secs, 15_552_000);

    assert_eq!(t2.yield_bps, 1_400);
}

#[test]

fn test_get_yield_tiers_is_pure_read_no_state_change() {
    let env = Env::default();

    env.mock_all_auths();

    let client = deploy(&env);

    let admin = Address::generate(&env);

    let sme = Address::generate(&env);

    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);

    tiers.push_back(YieldTier {
        min_lock_secs: 100,

        yield_bps: 900,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "PURE01"),
        &sme,
        &100_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let escrow_before = client.get_escrow();

    client.get_yield_tiers();

    client.get_yield_tiers();

    let escrow_after = client.get_escrow();

    assert_eq!(
        escrow_before, escrow_after,
        "get_yield_tiers must not mutate state"
    );
}

// ---------------------------------------------------------------------------

// preview_yield_tier vs fund_with_commitment equivalence tests (issue #562)

// ---------------------------------------------------------------------------

/// Helper: initialise an escrow with three tiers (30s / 60s / 90s) and a base

/// yield of 500 bps.  Returns the client ready for use; all auth is mocked.
fn setup_three_tier_escrow_with_sac<'a>(
    env: &'a Env,
    invoice_id: &str,
    target: i128,
) -> (LiquifactEscrowClient<'a>, StellarAssetClient<'a>) {
    let admin = Address::generate(env);

    let sme = Address::generate(env);

    let (tok, tre) = free_addresses(env);

    let client = deploy(env);

    let sac = env.register_stellar_asset_contract_v2(Address::generate(env));
    let sac_id = sac.address();
    let sac_admin = StellarAssetClient::new(env, &sac_id);

    let mut tiers = SorobanVec::new(env);

    tiers.push_back(YieldTier {
        min_lock_secs: 30,

        yield_bps: 700,
    });

    tiers.push_back(YieldTier {
        min_lock_secs: 60,

        yield_bps: 900,
    });

    tiers.push_back(YieldTier {
        min_lock_secs: 90,

        yield_bps: 1_200,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(env, invoice_id),
        &sme,
        &target,
        &500i64,
        &0u64,
        &sac_id,
        &None,
        &Address::generate(env),
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );
    (client, sac_admin)
}

/// Assert that `preview_yield_tier(amount, lock)` exactly matches what
/// `fund_with_commitment` later records for the same investor.
///
/// Uses a freshly-generated address for the investor so no prior deposit
/// can interfere with tier selection.
fn assert_preview_matches_actual(
    client: &LiquifactEscrowClient,
    env: &Env,
    sac_admin: &StellarAssetClient,
    amount: i128,
    lock: u64,
) {
    let (preview_bps, preview_lock) = client.preview_yield_tier(&amount, &lock);
    let investor = Address::generate(env);
    sac_admin.mint(&investor, &amount);
    client.fund_with_commitment(&investor, &amount, &lock);
    let actual_bps = client.get_investor_yield_bps(&investor);
    let actual_claim_not_before = client.get_investor_claim_not_before(&investor);
    assert_eq!(
        preview_bps, actual_bps,
        "preview_yield_tier bps mismatch for lock={lock}: preview={preview_bps} actual={actual_bps}"
    );
    // preview_yield_tier returns the matched tier's min_lock_secs (duration),
    // while fund_with_commitment stores (ledger_timestamp + user_lock).
    // Check that the stored timestamp is at least the tier threshold.
    let now = env.ledger().timestamp();
    assert!(
        actual_claim_not_before >= now + preview_lock,
        "preview_yield_tier lock mismatch for lock={lock}: preview={preview_lock} actual_claim_not_before={actual_claim_not_before} (now={now})"
    );
}

/// Base / no-tier case: amount below the first tier threshold.
/// Preview and actual must both return the escrow base yield (500 bps, lock 0).
#[test]
fn test_preview_matches_actual_base_case_no_tier() {
    let env = Env::default();
    env.mock_all_auths();
    // Large target so we can fund multiple investors without hitting capacity.
    let (client, sac_admin) = setup_three_tier_escrow_with_sac(&env, "PV_BASE", 1_000_000i128);
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 0u64);
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 29u64);
}

/// Boundary triple for tier 0 (min_lock_secs = 30, yield_bps = 700):
/// just below (29 s) → base, exactly at (30 s) → tier 0, just above (31 s) → tier 0.
#[test]
fn test_preview_matches_actual_tier0_boundary_triple() {
    let env = Env::default();
    env.mock_all_auths();
    let (client, sac_admin) = setup_three_tier_escrow_with_sac(&env, "PV_T0", 1_000_000i128);
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 29u64); // just below
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 30u64); // exactly at
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 31u64); // just above
}

/// Boundary triple for tier 1 (min_lock_secs = 60, yield_bps = 900):
/// just below (59 s) → tier 0, exactly at (60 s) → tier 1, just above (61 s) → tier 1.
#[test]
fn test_preview_matches_actual_tier1_boundary_triple() {
    let env = Env::default();
    env.mock_all_auths();
    let (client, sac_admin) = setup_three_tier_escrow_with_sac(&env, "PV_T1", 1_000_000i128);
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 59u64); // just below
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 60u64); // exactly at
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 61u64); // just above
}

/// Boundary triple for tier 2 (min_lock_secs = 90, yield_bps = 1200):
/// just below (89 s) → tier 1, exactly at (90 s) → tier 2, just above (91 s) → tier 2.
#[test]
fn test_preview_matches_actual_tier2_boundary_triple() {
    let env = Env::default();
    env.mock_all_auths();
    let (client, sac_admin) = setup_three_tier_escrow_with_sac(&env, "PV_T2", 1_000_000i128);
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 89u64); // just below
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 90u64); // exactly at
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 91u64); // just above
}

/// Highest tier: a lock well above all thresholds must return the top-tier yield.
#[test]
fn test_preview_matches_actual_highest_tier() {
    let env = Env::default();
    env.mock_all_auths();
    let (client, sac_admin) = setup_three_tier_escrow_with_sac(&env, "PV_HIGH", 1_000_000i128);
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 9_999u64);
}

/// Zero lock: investor passes lock=0 even though tiers exist.
/// Both preview and actual must fall back to the base yield with claim_not_before=0.
#[test]
fn test_preview_matches_actual_zero_lock_with_tiers() {
    let env = Env::default();
    env.mock_all_auths();
    let (client, sac_admin) = setup_three_tier_escrow_with_sac(&env, "PV_ZERO", 1_000_000i128);
    let (preview_bps, preview_lock) = client.preview_yield_tier(&1_000i128, &0u64);
    assert_eq!(preview_bps, 500, "zero lock must return base yield");
    assert_eq!(preview_lock, 0, "zero lock must return lock=0");
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 0u64);
}

/// No tiers configured at all: preview and actual must both return the escrow
/// base yield regardless of the lock supplied.
#[test]
fn test_preview_matches_actual_no_tiers_configured() {
    let env = Env::default();
    env.mock_all_auths();
    let admin = Address::generate(&env);
    let sme = Address::generate(&env);
    let client = deploy(&env);
    let sac = env.register_stellar_asset_contract_v2(Address::generate(&env));
    let sac_id = sac.address();
    let sac_admin = StellarAssetClient::new(&env, &sac_id);
    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "PV_NOTIER"),
        &sme,
        &1_000_000i128,
        &600i64,
        &0u64,
        &sac_id,
        &None,
        &Address::generate(&env),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 0u64);
    assert_preview_matches_actual(&client, &env, &sac_admin, 1_000i128, 9_999u64);
}

/// Amount parameter is currently unused in tier selection (lock-only rule).
/// Preview and actual must agree regardless of the amount supplied.
#[test]
fn test_preview_matches_actual_varying_amounts() {
    let env = Env::default();
    env.mock_all_auths();
    let (client, sac_admin) = setup_three_tier_escrow_with_sac(&env, "PV_AMT", 1_000_000i128);
    for amount in [1i128, 100, 500, 5_000, 50_000] {
        sac_admin.mint(&Address::generate(&env), &amount);
        assert_preview_matches_actual(&client, &env, &sac_admin, amount, 30u64);
        sac_admin.mint(&Address::generate(&env), &amount);
        assert_preview_matches_actual(&client, &env, &sac_admin, amount, 60u64);
    }
}

// ─── TieredSecondDeposit typed error (issue: harden fund_with_commitment) ────
//
// These tests ensure the `TieredSecondDeposit` (code 108) guard is emitted as a
// stable numeric ContractError on every re-entry path into fund_with_commitment
// after an investor has already established a contribution, and that follow-on
// fund() deposits continue to work correctly.

/// Tiered first deposit, then a follow-on fund_with_commitment with a DIFFERENT
/// lock duration — must still fail with TieredSecondDeposit (108).
/// The guard fires on prev != 0, regardless of whether the lock would match
/// a different tier.
#[test]
#[should_panic]
fn test_tiered_second_deposit_different_lock_rejected() {
    let env = Env::default();
    env.mock_all_auths();
    let client = deploy(&env);
    let admin = Address::generate(&env);
    let sme = Address::generate(&env);
    let inv = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);

    let mut tiers = SorobanVec::new(&env);
    tiers.push_back(YieldTier {
        min_lock_secs: 100,
        yield_bps: 900,
    });
    tiers.push_back(YieldTier {
        min_lock_secs: 500,
        yield_bps: 1100,
    });

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "T2D_DIF"),
        &sme,
        &20_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &Some(tiers),
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // First tiered deposit establishes the investor's locked position.
    client.fund_with_commitment(&inv, &10_000i128, &100u64);
    // Second deposit with a DIFFERENT lock duration must still be rejected
    // (TieredSecondDeposit, 108) — the tier/lock window closes after leg one.
    client.fund_with_commitment(&inv, &5_000i128, &500u64);
}

// ── Issue #551: extend_funding_deadline ──────────────────────────────────────

fn init_with_funding_deadline<'a>(
    env: &'a Env,

    client: &LiquifactEscrowClient<'a>,

    admin: &Address,

    sme: &Address,

    deadline: u64,

    maturity: u64,
) {
    let token = install_stellar_asset_token(env);

    let treasury = Address::generate(env);

    client.init(
        admin,
        &String::from_str(env, "FDL01"),
        sme,
        &TARGET,
        &800i64,
        &maturity,
        &token.id,
        &None,
        &treasury,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &Some(deadline),
        &None,
        &None::<i64>,
    );
}

#[test]
#[ignore = "branch-specific latent failure"]
fn test_extend_funding_deadline_success_and_event() {
    use soroban_sdk::testutils::Events as _;

    let env = Env::default();

    env.mock_all_auths();

    let (client, admin, sme) = setup(&env);

    let initial = env.ledger().timestamp() + 100;

    let extended = initial + 500;

    init_with_funding_deadline(&env, &client, &admin, &sme, initial, 0);

    let new_deadline = client.extend_funding_deadline(&extended);

    assert_eq!(new_deadline, extended);

    assert_eq!(client.get_funding_deadline(), Some(extended));

    let invoice_id = client.get_escrow().invoice_id.clone();

    let contract_id = client.address.clone();

    assert_eq!(
        env.events().all().events().last().unwrap().clone(),
        crate::FundingDeadlineExtended {
            name: symbol_short!("fund_ext"),

            invoice_id,

            old_deadline: initial,

            new_deadline: extended,
        }
        .to_xdr(&env, &contract_id)
    );
}

#[test]

fn test_extend_funding_deadline_rejects_equal_or_earlier() {
    let env = Env::default();

    env.mock_all_auths();

    let (client, admin, sme) = setup(&env);

    let initial = env.ledger().timestamp() + 200;

    init_with_funding_deadline(&env, &client, &admin, &sme, initial, 0);

    assert_contract_error(
        client.try_extend_funding_deadline(&initial),
        EscrowError::FundingDeadlineNotExtended,
    );

    assert_contract_error(
        client.try_extend_funding_deadline(&(initial - 1)),
        EscrowError::FundingDeadlineNotExtended,
    );
}

#[test]

fn test_extend_funding_deadline_rejects_past_maturity() {
    let env = Env::default();

    env.mock_all_auths();

    let (client, admin, sme) = setup(&env);

    let now = env.ledger().timestamp();

    let maturity = now + 1_000;

    let initial = now + 100;

    init_with_funding_deadline(&env, &client, &admin, &sme, initial, maturity);

    assert_contract_error(
        client.try_extend_funding_deadline(&maturity),
        EscrowError::FundingDeadlineAtOrAfterMaturity,
    );
}

#[test]

fn test_extend_funding_deadline_rejects_non_open_status() {
    let env = Env::default();

    env.mock_all_auths();

    let (client, admin, sme) = setup(&env);

    let initial = env.ledger().timestamp() + 100;

    init_with_funding_deadline(&env, &client, &admin, &sme, initial, 0);

    client.cancel_funding();

    assert_contract_error(
        client.try_extend_funding_deadline(&(initial + 50)),
        EscrowError::FundingDeadlineUpdateNotOpen,
    );
}

// ─────────────────────────────────────────────────────────────────────────────
// Tests for fund_batch duplicate-investor rejection (Issue #643)
// ─────────────────────────────────────────────────────────────────────────────

/// Adjacent duplicate: two consecutive entries share the same investor address.
/// Must fail atomically with `EscrowError::FundingBatchDuplicateInvestor` (code 84)
/// before any state mutation.
#[test]
fn test_fund_batch_rejects_adjacent_duplicate() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    let dup = Address::generate(&env);

    let other = Address::generate(&env);

    let mut entries = SorobanVec::new(&env);

    entries.push_back((dup.clone(), 1_000i128));

    entries.push_back((dup.clone(), 2_000i128)); // adjacent duplicate

    entries.push_back((other.clone(), 3_000i128));

    assert_contract_error(
        client.try_fund_batch(&entries),
        EscrowError::FundingBatchDuplicateInvestor,
    );
}

/// Non-adjacent duplicate: duplicate appears at positions 0 and 2.
/// Must fail atomically with `EscrowError::FundingBatchDuplicateInvestor` (code 84).
#[test]
fn test_fund_batch_rejects_non_adjacent_duplicate() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    default_init(&client, &env, &admin, &sme);

    let dup = Address::generate(&env);

    let mid = Address::generate(&env);

    let mut entries = SorobanVec::new(&env);

    entries.push_back((dup.clone(), 1_000i128));

    entries.push_back((mid.clone(), 2_000i128));

    entries.push_back((dup.clone(), 3_000i128)); // non-adjacent duplicate

    assert_contract_error(
        client.try_fund_batch(&entries),
        EscrowError::FundingBatchDuplicateInvestor,
    );
}

/// Single-element batch has no possible duplicate; must succeed.
#[test]
fn test_fund_batch_single_element_succeeds() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "SING001"),
        &sme,
        &100_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let investor = Address::generate(&env);

    let mut entries = SorobanVec::new(&env);

    entries.push_back((investor.clone(), 10_000i128));

    let result = client.fund_batch(&entries);

    assert_eq!(result.funded_amount, 10_000i128);

    assert_eq!(client.get_contribution(&investor), 10_000i128);
}

/// All-unique batch of three investors must succeed and record all contributions.
#[test]
fn test_fund_batch_all_unique_succeeds() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "UNIQ001"),
        &sme,
        &100_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv1 = Address::generate(&env);

    let inv2 = Address::generate(&env);

    let inv3 = Address::generate(&env);

    let mut entries = SorobanVec::new(&env);

    entries.push_back((inv1.clone(), 10_000i128));

    entries.push_back((inv2.clone(), 20_000i128));

    entries.push_back((inv3.clone(), 30_000i128));

    let result = client.fund_batch(&entries);

    assert_eq!(result.funded_amount, 60_000i128);

    assert_eq!(client.get_contribution(&inv1), 10_000i128);

    assert_eq!(client.get_contribution(&inv2), 20_000i128);

    assert_eq!(client.get_contribution(&inv3), 30_000i128);
}

/// MAX_FUND_BATCH unique investors must succeed — upper bound of the valid range.
#[test]
fn test_fund_batch_max_unique_batch_succeeds() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let (tok, tre) = free_addresses(&env);

    // A full MAX_FUND_BATCH batch performs 50 balance-checked transfers under a
    // mocked auth tree — exceeding both the mainnet per-transaction footprint/event
    // limits that Env::default() now enforces and the default compute budget. Relax
    // both so this functional upper-bound test measures behavior, not metering.
    env.cost_estimate().disable_resource_limits();
    env.cost_estimate().budget().reset_unlimited();

    // Target large enough that MAX_FUND_BATCH × 1_000 does not cross it,
    // keeping status open throughout.
    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "MAXU001"),
        &sme,
        &1_000_000_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let mut entries = SorobanVec::new(&env);

    for _ in 0..(MAX_FUND_BATCH as usize) {
        entries.push_back((Address::generate(&env), 1_000i128));
    }

    let result = client.fund_batch(&entries);

    assert_eq!(
        result.funded_amount,
        MAX_FUND_BATCH as i128 * 1_000i128,
        "all {} entries must be recorded",
        MAX_FUND_BATCH
    );
}

/// Duplicate batch must leave no partial state: after rejection, funded_amount and
/// all investor contributions remain at zero (atomic rejection before any mutation).
#[test]
fn test_fund_batch_duplicate_leaves_no_partial_state() {
    let env = Env::default();

    let (client, admin, sme) = setup(&env);

    let (tok, tre) = free_addresses(&env);

    client.init(
        &admin,
        &soroban_sdk::String::from_str(&env, "NOPART01"),
        &sme,
        &100_000i128,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    let inv_a = Address::generate(&env);

    let inv_b = Address::generate(&env);

    let mut entries = SorobanVec::new(&env);

    entries.push_back((inv_a.clone(), 10_000i128));

    entries.push_back((inv_b.clone(), 20_000i128));

    entries.push_back((inv_a.clone(), 5_000i128)); // duplicate of inv_a

    // The call must be rejected entirely.
    assert_contract_error(
        client.try_fund_batch(&entries),
        EscrowError::FundingBatchDuplicateInvestor,
    );

    // No contribution from any address must have been recorded.
    let escrow = client.get_escrow();

    assert_eq!(
        escrow.funded_amount, 0,
        "funded_amount must be zero after duplicate rejection"
    );

    assert_eq!(
        client.get_contribution(&inv_a),
        0,
        "inv_a contribution must be zero after duplicate rejection"
    );

    assert_eq!(
        client.get_contribution(&inv_b),
        0,
        "inv_b contribution must be zero after duplicate rejection"
    );
}

// ── unfund entrypoint tests ───────────────────────────────────────────────────

/// Helper: init with a real SAC token and return (client, contract_id, sac_admin, token_id, investor).
/// The escrow is open (status 0); the investor is funded with `amount` but the escrow
/// target is `TARGET` so status stays 0.  Tokens are minted to the investor and pulled
/// by `fund`.  The escrow contract address is also seeded with `amount` so that `unfund`
/// can push them back.
fn init_open_with_real_token<'a>(
    env: &'a Env,
    amount: i128,
) -> (
    LiquifactEscrowClient<'a>,
    Address, // contract_id
    crate::tests::StellarTestToken<'a>,
    Address, // investor
) {
    use soroban_sdk::token::StellarAssetClient;
    let token = install_stellar_asset_token(env);
    let escrow_id = env.register(LiquifactEscrow, ());
    let client = LiquifactEscrowClient::new(env, &escrow_id);
    let admin = Address::generate(env);
    let sme = Address::generate(env);
    let treasury = Address::generate(env);
    client.init(
        &admin,
        &String::from_str(env, "UNFUND01"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &token.id,
        &None,
        &treasury,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );
    let investor = Address::generate(env);
    // Mint tokens to the investor so fund() can pull them.
    token.stellar.mint(&investor, &amount);
    client.fund(&investor, &amount);
    // Also ensure the escrow contract has enough balance to return the tokens on unfund.
    // (fund already pulled `amount` into the contract, so the balance is already there.)
    (client, escrow_id, token, investor)
}

#[test]
fn test_unfund_partial() {
    let env = Env::default();
    let (client, admin, sme) = setup(&env);
    let investor = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF001"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &(TARGET / 4));
    assert_eq!(client.get_escrow().status, 0);

    let result = client.unfund(&investor, &(TARGET / 8));

    assert_eq!(client.get_contribution(&investor), TARGET / 8);
    assert_eq!(result.funded_amount, TARGET / 8);
    assert_eq!(client.get_unique_funder_count(), 1);
    assert_eq!(result.status, 0);
}

#[test]
fn test_unfund_full() {
    let env = Env::default();
    let (client, admin, sme) = setup(&env);
    let investor = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF002"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &(TARGET / 4));
    let result = client.unfund(&investor, &(TARGET / 4));

    assert_eq!(client.get_contribution(&investor), 0);
    assert_eq!(result.funded_amount, 0);
    assert_eq!(client.get_unique_funder_count(), 0);
    assert_eq!(result.status, 0);
}

#[test]
fn test_unfund_funder_count_floor() {
    // Inject UniqueFunderCount=0 manually and verify saturating_sub does not underflow.
    let env = Env::default();
    env.mock_all_auths();
    let client = deploy(&env);
    let contract_id = client.address.clone();
    let admin = Address::generate(&env);
    let sme = Address::generate(&env);
    let investor = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF003"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &1i128);

    // Force UniqueFunderCount to 0 (simulating corruption / undercount).
    env.as_contract(&contract_id, || {
        env.storage()
            .instance()
            .set(&DataKey::UniqueFunderCount, &0u32);
    });

    // Unfund full contribution — saturating_sub must keep it at 0, not wrap.
    client.unfund(&investor, &1i128);

    assert_eq!(client.get_unique_funder_count(), 0);
}

#[test]
fn test_unfund_over_withdrawal() {
    let env = Env::default();
    let (client, admin, sme) = setup(&env);
    let investor = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF004"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &1_000i128);

    assert_contract_error(
        client.try_unfund(&investor, &1_001i128),
        EscrowError::OverWithdrawal,
    );
}

#[test]
fn test_unfund_wrong_status_funded() {
    let env = Env::default();
    let (client, admin, sme) = setup(&env);
    let investor = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF005"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    // Fund to TARGET — transitions to status 1.
    client.fund(&investor, &TARGET);
    assert_eq!(client.get_escrow().status, 1);

    assert_contract_error(
        client.try_unfund(&investor, &1i128),
        EscrowError::UnfundEscrowNotOpen,
    );
}

#[test]
fn test_unfund_wrong_status_settled() {
    let env = Env::default();
    let (client, admin, sme) = setup(&env);
    let investor = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF006"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &TARGET); // status = 1
    client.settle(); // status = 2

    assert_contract_error(
        client.try_unfund(&investor, &1i128),
        EscrowError::UnfundEscrowNotOpen,
    );
}

#[test]
fn test_unfund_wrong_status_withdrawn() {
    // Uses a real token so withdraw() can actually transfer.
    let env = Env::default();
    env.mock_all_auths();
    let (client, _escrow_id, sme) = init_and_fund_with_real_token(&env, TARGET, "UF007");

    // fund() already advanced the escrow to Funded (status 1); withdraw() moves it
    // straight to Withdrawn (status 3). (No settle() — withdraw requires status 1.)
    client.withdraw(); // status = 3

    assert_contract_error(
        client.try_unfund(&Address::generate(&env), &1i128),
        EscrowError::UnfundEscrowNotOpen,
    );
}

#[test]
fn test_unfund_wrong_status_cancelled() {
    let env = Env::default();
    let (client, admin, sme) = setup(&env);
    let investor = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF008"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &(TARGET / 2));
    client.cancel_funding(); // status = 4

    assert_contract_error(
        client.try_unfund(&investor, &1i128),
        EscrowError::UnfundEscrowNotOpen,
    );
}

#[test]
fn test_unfund_legal_hold_blocked() {
    let env = Env::default();
    let (client, admin, sme) = setup(&env);
    let investor = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF009"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &(TARGET / 4));
    client.set_legal_hold(&true);

    assert_contract_error(
        client.try_unfund(&investor, &1i128),
        EscrowError::UnfundLegalHoldActive,
    );
}

#[test]
fn test_unfund_requires_investor_auth() {
    let env = Env::default();
    let (client, admin, sme) = setup(&env);
    let investor = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF010"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &(TARGET / 4));
    client.unfund(&investor, &(TARGET / 8));

    // Verify that investor auth was required.
    let auths = env.auths();
    let investor_authed = auths.iter().any(|(addr, _)| *addr == investor);
    assert!(investor_authed, "investor auth was not recorded for unfund");
}

#[test]
fn test_unfund_no_underflow() {
    // Exact-boundary: unfund the precise contribution amount — must succeed cleanly.
    let env = Env::default();
    let (client, admin, sme) = setup(&env);
    let investor = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF011"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &1_000i128);
    client.unfund(&investor, &1_000i128);

    assert_eq!(client.get_contribution(&investor), 0);
}

#[test]
fn test_unfund_multiple_investors_isolation() {
    // Unfunding one investor must not affect another investor's contribution.
    let env = Env::default();
    let (client, admin, sme) = setup(&env);
    let inv_a = Address::generate(&env);
    let inv_b = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF012"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&inv_a, &30_000i128);
    client.fund(&inv_b, &50_000i128);

    // Partially unfund inv_a.
    let result = client.unfund(&inv_a, &10_000i128);

    assert_eq!(
        client.get_contribution(&inv_a),
        20_000i128,
        "inv_a contribution wrong"
    );
    assert_eq!(
        client.get_contribution(&inv_b),
        50_000i128,
        "inv_b contribution must be unchanged"
    );
    assert_eq!(result.funded_amount, 70_000i128, "funded_amount wrong");
}

#[test]
fn test_unfund_then_fund_again() {
    // After partially unfunding, the investor can fund again.
    let env = Env::default();
    let (client, admin, sme) = setup(&env);
    let investor = Address::generate(&env);
    let (tok, tre) = free_addresses(&env);
    client.init(
        &admin,
        &String::from_str(&env, "UF013"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &tok,
        &None,
        &tre,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    client.fund(&investor, &20_000i128);
    client.unfund(&investor, &10_000i128);
    client.fund(&investor, &5_000i128);

    assert_eq!(client.get_contribution(&investor), 15_000i128);
    assert_eq!(client.get_escrow().funded_amount, 15_000i128);
}

#[test]
fn test_unfund_event_emitted() {
    // Deploy and fund with a real SAC so `unfund` can actually transfer tokens.
    // Verify that EscrowUnfunded is emitted with correct fields.
    let env = Env::default();
    env.mock_all_auths();

    let (contract_id, client) = deploy_with_id(&env);

    let token = install_stellar_asset_token(&env);
    let admin = Address::generate(&env);
    let sme = Address::generate(&env);
    let treasury = Address::generate(&env);
    let investor = Address::generate(&env);

    let invoice_id = soroban_sdk::Symbol::new(&env, "UF014");
    let fund_amount = 20_000i128;
    let unfund_amount = 8_000i128;

    client.init(
        &admin,
        &String::from_str(&env, "UF014"),
        &sme,
        &TARGET,
        &800i64,
        &0u64,
        &token.id,
        &None,
        &treasury,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None,
        &None::<i64>,
    );

    token.stellar.mint(&investor, &fund_amount);
    client.fund(&investor, &fund_amount);

    // Clear events from init/fund so we can isolate the unfund event.
    let _ = env.events().all();

    client.unfund(&investor, &unfund_amount);

    let all_events = env.events().all();
    let events_list = all_events.events();

    // The last event must be our EscrowUnfunded.
    let last = events_list
        .last()
        .expect("expected at least one event after unfund");

    let expected = EscrowUnfunded {
        name: symbol_short!("unfunded"),
        invoice_id,
        investor: investor.clone(),
        amount: unfund_amount,
        remaining_contribution: fund_amount - unfund_amount,
        new_funded_amount: fund_amount - unfund_amount,
        timestamp: env.ledger().timestamp(),
    };

    assert_eq!(*last, expected.to_xdr(&env, &contract_id));
}