Skip to content

x402agent/SolanaOS / skills/solana-formal-verification

qedgen

Flagged

Formally verify programs by writing Lean 4 proofs. Trigger this skill whenever the user wants to formally verify code, generate Lean 4 proofs, prove properties about algorithms or smart contracts, verify invariants, convert program logic into formal specifications, or anything involving Lean 4 and formal verification. Also trigger when the user mentions "qedgen", "lean proof", "formal proof", "verify my code", "prove correctness", "formal verification", or wants mathematical guarantees about their implementation.

FileKindSize
.gitignoreother753 B
.npmignoreother352 B
Cargo.lockmanifest46.3 KB
Cargo.tomlmanifest307 B
LICENSEother1.0 KB
README.mdmarkdown3.7 KB
SKILL.mdskill md10.8 KB
bin/leanstralexecutablescript6.2 MB
claude.mdmarkdown6.8 KB
crates/qedgen/Cargo.tomlmanifest544 B
crates/qedgen/lean_support/QEDGen.leanother166 B
crates/qedgen/lean_support/QEDGen/Solana.leanother166 B
crates/qedgen/lean_support/QEDGen/Solana/Account.leanother4.0 KB
crates/qedgen/lean_support/QEDGen/Solana/Authority.leanother285 B
crates/qedgen/lean_support/QEDGen/Solana/Cpi.leanother3.3 KB
crates/qedgen/lean_support/QEDGen/Solana/State.leanother1.9 KB
crates/qedgen/lean_support/QEDGen/Solana/Token.leanother1.4 KB
crates/qedgen/lean_support/QEDGen/Solana/Valid.leanother2.0 KB
crates/qedgen/lean_support/README.mdmarkdown2.8 KB
crates/qedgen/lean_support/lake-manifest.jsonconfig119 B
crates/qedgen/lean_support/lakefile.leanother112 B
crates/qedgen/lean_support/lean-toolchainother25 B
crates/qedgen/lean_support/test_lemmas.leanother1.2 KB
crates/qedgen/src/api.rsscript32.3 KB
crates/qedgen/src/consolidate.rsscript6.9 KB
crates/qedgen/src/main.rsscript4.1 KB
crates/qedgen/src/project.rsscript3.1 KB
crates/qedgen/src/spec.rsscript19.3 KB
crates/qedgen/src/validate.rsscript5.6 KB
crates/qedgen/templates/.gitignoreother29 B
crates/qedgen/templates/Main.leanother154 B
crates/qedgen/templates/PROMPT_TEMPLATE.mdmarkdown3.2 KB
crates/qedgen/templates/README.lean.mdmarkdown1.6 KB
crates/qedgen/templates/lakefile.leanother293 B
crates/qedgen/templates/lean-toolchainother25 B
docs/CNAMEother10 B
docs/index.htmlother10.9 KB
docs/llms-full.txtmarkdown8.7 KB
docs/llms.txtmarkdown2.1 KB
docs/logo-dark.svgother648 B
docs/logo-light.svgother648 B
docs/style.cssother7.6 KB
example/escrow/.gitignoreother67 B
example/escrow/.prettierignoreother61 B
example/escrow/Anchor.tomlconfig353 B
example/escrow/Cargo.lockmanifest72.8 KB
example/escrow/Cargo.tomlmanifest215 B
example/escrow/migrations/deploy.tsscript428 B
example/escrow/package.jsonmanifest528 B
example/escrow/programs/escrow/Cargo.tomlmanifest376 B
example/escrow/programs/escrow/Xargo.tomlconfig62 B
example/escrow/programs/escrow/src/lib.rsscript6.7 KB
example/escrow/tests/escrow.tsscript8.6 KB
example/escrow/tsconfig.jsonconfig205 B
example/percolator/.cargo/config.tomlconfig33 B
example/percolator/.gitignoreother320 B
example/percolator/Cargo.lockmanifest8.5 KB
example/percolator/Cargo.tomlmanifest639 B
example/percolator/LICENSEother11.1 KB
example/percolator/README.mdmarkdown4.9 KB
example/percolator/examples/offsets.rsscript1.3 KB
example/percolator/scripts/audit-proof-strength.mdmarkdown6.4 KB
example/percolator/scripts/proof-strength-audit-results.mdmarkdown89.2 KB
example/percolator/scripts/run_kani_full_audit.shexecutablescript1.2 KB
example/percolator/spec.mdmarkdown108.4 KB
example/percolator/src/i128.rsscript20.4 KB
example/percolator/src/percolator.rsscript139.2 KB
example/percolator/src/wide_math.rsscript59.8 KB
example/percolator/tests/amm_tests.rsscript7.4 KB
example/percolator/tests/common/mod.rsscript4.7 KB
example/percolator/tests/fuzzing.proptest-regressionsother4.7 KB
example/percolator/tests/fuzzing.rsscript43.1 KB
example/percolator/tests/proofs_arithmetic.rsscript17.1 KB
example/percolator/tests/proofs_audit.rsscript35.0 KB
example/percolator/tests/proofs_instructions.rsscript64.8 KB
example/percolator/tests/proofs_invariants.rsscript21.0 KB
example/percolator/tests/proofs_lazy_ak.rsscript22.4 KB
example/percolator/tests/proofs_liveness.rsscript17.1 KB
example/percolator/tests/proofs_safety.rsscript104.2 KB
example/percolator/tests/proofs_v1131.rsscript25.4 KB
example/percolator/tests/unit_tests.rsscript93.8 KB
install.shexecutablescript4.9 KB
package.jsonmanifest1.1 KB

example/percolator/tests/proofs_invariants.rs

View on GitHub
//! Sections 1-2 — Global inductive invariants
//!
//! Conservation, PnL tracking, side counts, haircut ratio.

#![cfg(kani)]

mod common;
use common::*;

// ============================================================================
// T0.3: set_pnl_aggregate_update_is_exact
// ============================================================================

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t0_3_set_pnl_aggregate_exact() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    let old_pnl: i16 = kani::any();
    kani::assume(old_pnl > i16::MIN);
    engine.set_pnl(idx as usize, old_pnl as i128);

    let new_pnl: i16 = kani::any();
    kani::assume(new_pnl > i16::MIN);
    engine.set_pnl(idx as usize, new_pnl as i128);

    let expected = if new_pnl > 0 { new_pnl as u128 } else { 0u128 };
    let actual = engine.pnl_pos_tot;
    assert!(actual == expected);
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t0_3_sat_all_sign_transitions() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    let old: i16 = kani::any();
    let new: i16 = kani::any();
    kani::assume(old > i16::MIN && new > i16::MIN);

    let transition: u8 = kani::any();
    kani::assume(transition < 4);
    match transition {
        0 => kani::assume(old <= 0 && new <= 0),
        1 => kani::assume(old <= 0 && new > 0),
        2 => kani::assume(old > 0 && new <= 0),
        3 => kani::assume(old > 0 && new > 0),
        _ => unreachable!(),
    }

    engine.set_pnl(idx as usize, old as i128);
    engine.set_pnl(idx as usize, new as i128);

    let expected = if new > 0 { new as u128 } else { 0u128 };
    let actual = engine.pnl_pos_tot;
    assert!(actual == expected, "pnl_pos_tot mismatch after transition");
}

// ============================================================================
// T0.4: conservation_check_handles_overflow
// ============================================================================

#[kani::proof]
#[kani::unwind(1)]
#[kani::solver(cadical)]
fn t0_4_conservation_check_handles_overflow() {
    // Use u128 inputs directly to cover the full value range,
    // including cases where c_tot + insurance may overflow u128.
    let c_tot: u128 = kani::any();
    let insurance: u128 = kani::any();
    let vault: u128 = kani::any();
    let deposit: u64 = kani::any();

    let deposit_128 = deposit as u128;

    // The conservation check uses checked_add, which may return None
    let sum = c_tot.checked_add(insurance);
    match sum {
        Some(s) => {
            // Non-overflow case: verify deposit preserves the invariant
            if vault >= s {
                // After deposit: vault + deposit and c_tot + deposit
                let vault_new = vault.checked_add(deposit_128);
                let c_tot_new = c_tot.checked_add(deposit_128);
                if let (Some(vn), Some(cn)) = (vault_new, c_tot_new) {
                    // Conservation: vault_new >= c_tot_new + insurance
                    let sum_new = cn.checked_add(insurance);
                    if let Some(sn) = sum_new {
                        assert!(vn >= sn,
                            "deposit preserves conservation when no overflow");
                    }
                }
            }
        }
        None => {
            // c_tot + insurance overflows u128 → conservation check
            // must detect this as a deficit / corrupt state.
            kani::cover!(true, "overflow branch reachable");
        }
    }
}

// ============================================================================
// Inductive proofs from kani.rs
// ============================================================================

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_top_up_insurance_preserves_accounting() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    let dep: u32 = kani::any();
    kani::assume(dep > 0 && dep <= 1_000_000);
    engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
    assert!(engine.check_conservation());

    let ins_amt: u32 = kani::any();
    kani::assume(ins_amt <= 1_000_000);
    engine.top_up_insurance_fund(ins_amt as u128, DEFAULT_SLOT).unwrap();
    assert!(engine.check_conservation());
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_set_capital_decrease_preserves_accounting() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    let dep: u32 = kani::any();
    kani::assume(dep >= 1000 && dep <= 1_000_000);
    engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
    assert!(engine.check_conservation());

    let new_cap: u32 = kani::any();
    kani::assume(new_cap <= dep);
    engine.set_capital(idx as usize, new_cap as u128);
    assert!(engine.check_conservation());
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_set_pnl_preserves_pnl_pos_tot_delta() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let a = engine.add_user(0).unwrap();
    let b = engine.add_user(0).unwrap();

    let pnl_a: i32 = kani::any();
    kani::assume(pnl_a > i32::MIN);
    engine.set_pnl(a as usize, pnl_a as i128);

    let pnl_b: i32 = kani::any();
    kani::assume(pnl_b > i32::MIN);
    engine.set_pnl(b as usize, pnl_b as i128);

    let pos_a: u128 = if pnl_a > 0 { pnl_a as u128 } else { 0 };
    let pos_b: u128 = if pnl_b > 0 { pnl_b as u128 } else { 0 };
    assert!(engine.pnl_pos_tot == pos_a + pos_b);
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_deposit_preserves_accounting() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    let dep: u32 = kani::any();
    kani::assume(dep >= 1 && dep <= 1_000_000);
    engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
    assert!(engine.check_conservation());
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_withdraw_preserves_accounting() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    let dep: u32 = kani::any();
    kani::assume(dep >= 1000 && dep <= 1_000_000);
    engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();

    // Run keeper_crank to satisfy fresh-crank requirement for withdraw
    let _ = engine.keeper_crank(DEFAULT_SLOT, DEFAULT_ORACLE, &[], 0);

    let w: u32 = kani::any();
    kani::assume(w >= 1 && w <= dep);
    let result = engine.withdraw(idx, w as u128, DEFAULT_ORACLE, DEFAULT_SLOT);
    if result.is_ok() {
        assert!(engine.check_conservation());
    }
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_settle_loss_preserves_accounting() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    let dep: u32 = kani::any();
    kani::assume(dep >= 1000 && dep <= 1_000_000);
    engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
    assert!(engine.check_conservation());

    let loss: i32 = kani::any();
    kani::assume(loss < 0 && loss > i32::MIN);
    kani::assume((-loss as u32) <= dep);
    engine.set_pnl(idx as usize, loss as i128);

    // touch_account_full settles losses from principal (step 9)
    let _ = engine.touch_account_full(idx as usize, DEFAULT_ORACLE, DEFAULT_SLOT);
    assert!(engine.check_conservation());
}

// ============================================================================
// Property proofs from kani.rs
// ============================================================================

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn prop_pnl_pos_tot_agrees_with_recompute() {
    let mut engine = RiskEngine::new(zero_fee_params());

    let a = engine.add_user(0).unwrap();
    let b = engine.add_user(0).unwrap();

    let pnl_a: i32 = kani::any();
    kani::assume(pnl_a > i32::MIN);
    engine.set_pnl(a as usize, pnl_a as i128);

    let pnl_b: i32 = kani::any();
    kani::assume(pnl_b > i32::MIN);
    engine.set_pnl(b as usize, pnl_b as i128);

    let pos_a: u128 = if pnl_a > 0 { pnl_a as u128 } else { 0 };
    let pos_b: u128 = if pnl_b > 0 { pnl_b as u128 } else { 0 };
    let expected = pos_a + pos_b;

    assert!(engine.pnl_pos_tot == expected);
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn prop_conservation_holds_after_all_ops() {
    let mut engine = RiskEngine::new(zero_fee_params());

    let idx = engine.add_user(0).unwrap();

    let dep: u32 = kani::any();
    kani::assume(dep > 0 && dep <= 5_000_000);
    engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
    assert!(engine.check_conservation());

    let ins_amt: u32 = kani::any();
    kani::assume(ins_amt <= 1_000_000);
    engine.top_up_insurance_fund(ins_amt as u128, DEFAULT_SLOT).unwrap();
    assert!(engine.check_conservation());

    let loss: u32 = kani::any();
    kani::assume(loss <= dep);
    engine.set_pnl(idx as usize, -(loss as i128));
    assert!(engine.check_conservation());

    let cap_before = engine.accounts[idx as usize].capital.get();
    let pnl_abs = if loss > 0 { loss as u128 } else { 0 };
    let pay = core::cmp::min(pnl_abs, cap_before);
    if pay > 0 {
        engine.set_capital(idx as usize, cap_before - pay);
        let new_pnl_val = -(loss as i128) + (pay as i128);
        engine.set_pnl(idx as usize, new_pnl_val);
    }
    assert!(engine.check_conservation());
}

// ============================================================================
// set_pnl proofs from kani.rs
// ============================================================================

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
#[kani::should_panic]
fn proof_set_pnl_rejects_i128_min() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();
    engine.set_pnl(idx as usize, i128::MIN);
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_set_pnl_maintains_pnl_pos_tot() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    let pnl1: i32 = kani::any();
    kani::assume(pnl1 > i32::MIN);
    engine.set_pnl(idx as usize, pnl1 as i128);

    let expected1 = if pnl1 > 0 { pnl1 as u128 } else { 0u128 };
    assert!(engine.pnl_pos_tot == expected1);

    let pnl2: i32 = kani::any();
    kani::assume(pnl2 > i32::MIN);
    engine.set_pnl(idx as usize, pnl2 as i128);

    let expected2 = if pnl2 > 0 { pnl2 as u128 } else { 0u128 };
    assert!(engine.pnl_pos_tot == expected2);
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_set_pnl_underflow_safety() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    engine.set_pnl(idx as usize, 1000i128);
    assert!(engine.pnl_pos_tot == 1000u128);

    engine.set_pnl(idx as usize, -500i128);
    assert!(engine.pnl_pos_tot == 0u128);

    engine.set_pnl(idx as usize, 0i128);
    assert!(engine.pnl_pos_tot == 0u128);
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_set_pnl_clamps_reserved_pnl() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    // Set PNL to 5000 first → reserved_pnl = 5000 (reserve-first increase)
    engine.set_pnl(idx as usize, 5000i128);
    assert!(engine.accounts[idx as usize].reserved_pnl == 5000u128);

    // Decrease PNL to 3000 → reserve clamped via saturating_sub
    engine.set_pnl(idx as usize, 3000i128);
    assert!(engine.accounts[idx as usize].reserved_pnl == 3000u128);

    // Decrease PNL to -100 → reserve clamped to 0
    engine.set_pnl(idx as usize, -100i128);
    assert!(engine.accounts[idx as usize].reserved_pnl == 0u128);
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_set_capital_maintains_c_tot() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    let initial: u32 = kani::any();
    kani::assume(initial > 0 && initial <= 1_000_000);
    engine.deposit(idx, initial as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();

    assert!(engine.c_tot.get() == engine.accounts[idx as usize].capital.get());

    let new_cap: u32 = kani::any();
    kani::assume((new_cap as u64) <= (initial as u64) * 2);
    engine.set_capital(idx as usize, new_cap as u128);

    assert!(engine.c_tot.get() == new_cap as u128);
}

// ============================================================================
// check_conservation / haircut from kani.rs
// ============================================================================

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_check_conservation_basic() {
    let mut engine = RiskEngine::new(zero_fee_params());

    engine.vault = U128::new(100);
    engine.c_tot = U128::new(60);
    engine.insurance_fund.balance = U128::new(30);
    assert!(engine.check_conservation());

    engine.insurance_fund.balance = U128::new(50);
    assert!(!engine.check_conservation());
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_haircut_ratio_no_division_by_zero() {
    let mut engine = RiskEngine::new(zero_fee_params());

    // Empty engine → (1, 1) since pnl_matured_pos_tot == 0
    let (num, den) = engine.haircut_ratio();
    assert!(num == 1u128);
    assert!(den == 1u128);

    // Set pnl_matured_pos_tot (v11.21 uses this as denominator, not pnl_pos_tot)
    engine.pnl_pos_tot = 1000u128;
    engine.pnl_matured_pos_tot = 1000u128;
    engine.vault = U128::new(2000);
    engine.c_tot = U128::new(500);
    engine.insurance_fund.balance = U128::new(300);
    let (num2, den2) = engine.haircut_ratio();
    assert!(den2 == 1000u128, "denominator must be pnl_matured_pos_tot");
    // residual = 2000 - 500 - 300 = 1200 > 1000, so h_num = min(1200, 1000) = 1000
    assert!(num2 == 1000u128);
    assert!(num2 <= den2);
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_absorb_protocol_loss_respects_floor() {
    let mut engine = RiskEngine::new(zero_fee_params());

    let floor: u32 = kani::any();
    kani::assume(floor <= 10_000);
    engine.insurance_floor = floor as u128;

    let balance: u32 = kani::any();
    kani::assume(balance >= floor && balance <= 100_000);
    engine.insurance_fund.balance = U128::new(balance as u128);

    let loss: u32 = kani::any();
    kani::assume(loss > 0 && loss <= 100_000);
    engine.absorb_protocol_loss(loss as u128);

    assert!(engine.insurance_fund.balance.get() >= floor as u128);
}

// ============================================================================
// Position / side tracking from kani.rs
// ============================================================================

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_set_position_basis_q_count_tracking() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    assert!(engine.stored_pos_count_long == 0);

    engine.set_position_basis_q(idx as usize, POS_SCALE as i128);
    assert!(engine.stored_pos_count_long == 1);

    let neg = -(POS_SCALE as i128);
    engine.set_position_basis_q(idx as usize, neg);
    assert!(engine.stored_pos_count_long == 0);
    assert!(engine.stored_pos_count_short == 1);

    engine.set_position_basis_q(idx as usize, 0i128);
    assert!(engine.stored_pos_count_short == 0);
    assert!(engine.stored_pos_count_long == 0);
}

#[kani::proof]
#[kani::unwind(70)]
#[kani::solver(cadical)]
fn proof_side_mode_gating() {
    let mut engine = RiskEngine::new(zero_fee_params());
    engine.last_crank_slot = DEFAULT_SLOT;

    let a = engine.add_user(0).unwrap();
    let b = engine.add_user(0).unwrap();
    engine.deposit(a, 5_000_000, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
    engine.deposit(b, 5_000_000, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();

    engine.side_mode_long = SideMode::DrainOnly;

    let size_q = POS_SCALE as i128;
    let result = engine.execute_trade(a, b, DEFAULT_ORACLE, DEFAULT_SLOT, size_q, DEFAULT_ORACLE);
    assert!(result == Err(RiskError::SideBlocked));

    engine.side_mode_long = SideMode::Normal;
    engine.side_mode_short = SideMode::ResetPending;
    engine.stale_account_count_short = 1;

    let neg_size = -(POS_SCALE as i128);
    let result2 = engine.execute_trade(a, b, DEFAULT_ORACLE, DEFAULT_SLOT, neg_size, DEFAULT_ORACLE);
    assert!(result2 == Err(RiskError::SideBlocked));
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_account_equity_net_nonnegative() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let a = engine.add_user(0).unwrap();
    let b = engine.add_user(0).unwrap();

    let cap_a: u16 = kani::any();
    kani::assume(cap_a > 0 && cap_a <= 10_000);
    let cap_b: u16 = kani::any();
    kani::assume(cap_b > 0 && cap_b <= 10_000);

    engine.set_capital(a as usize, cap_a as u128);
    engine.set_capital(b as usize, cap_b as u128);

    // Vault has excess beyond c_tot so Residual > 0 and haircut is non-trivial
    let excess: u16 = kani::any();
    kani::assume(excess <= 5_000);
    let c_tot = (cap_a as u128) + (cap_b as u128);
    engine.vault = U128::new(c_tot + (excess as u128));

    let pnl_val: i16 = kani::any();
    kani::assume(pnl_val as i32 > i16::MIN as i32);
    engine.set_pnl(a as usize, pnl_val as i128);

    // Set pnl_matured_pos_tot to exercise h < 1 in haircut_ratio (v11.21)
    let matured: u16 = kani::any();
    kani::assume(matured <= 20_000);
    engine.pnl_matured_pos_tot = core::cmp::min(matured as u128, engine.pnl_pos_tot);

    // Exercise both positive PnL (haircut path) and negative PnL
    let eq = engine.account_equity_net(&engine.accounts[a as usize], DEFAULT_ORACLE);
    assert!(eq >= 0,
        "flat account equity must be non-negative for any haircut level");
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_effective_pos_q_epoch_mismatch_returns_zero() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    engine.accounts[idx as usize].position_basis_q = POS_SCALE as i128;
    engine.accounts[idx as usize].adl_a_basis = ADL_ONE;
    engine.accounts[idx as usize].adl_epoch_snap = 0;
    engine.stored_pos_count_long = 1;

    engine.adl_epoch_long = 1;
    let eff = engine.effective_pos_q(idx as usize);
    assert!(eff == 0);

    engine.accounts[idx as usize].position_basis_q = -(POS_SCALE as i128);
    engine.accounts[idx as usize].adl_epoch_snap = 0;
    engine.adl_epoch_short = 1;
    let eff2 = engine.effective_pos_q(idx as usize);
    assert!(eff2 == 0);
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_effective_pos_q_flat_is_zero() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    assert!(engine.accounts[idx as usize].position_basis_q == 0);
    let eff = engine.effective_pos_q(idx as usize);
    assert!(eff == 0);
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_attach_effective_position_updates_side_counts() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();

    assert!(engine.stored_pos_count_long == 0);
    assert!(engine.stored_pos_count_short == 0);

    let pos = POS_SCALE as i128;
    engine.attach_effective_position(idx as usize, pos);
    assert!(engine.stored_pos_count_long == 1);
    assert!(engine.stored_pos_count_short == 0);

    engine.attach_effective_position(idx as usize, 0i128);
    assert!(engine.stored_pos_count_long == 0);
    assert!(engine.stored_pos_count_short == 0);

    let neg = -(POS_SCALE as i128);
    engine.attach_effective_position(idx as usize, neg);
    assert!(engine.stored_pos_count_long == 0);
    assert!(engine.stored_pos_count_short == 1);
}

// ============================================================================
// NEW: proof_fee_credits_never_i128_min
// ============================================================================

/// fee_debt_u128_checked safely handles all fee_credits values including i128::MIN.
/// Verifies: checked_sub boundary behavior and fee_debt extraction never panics.
/// The settle_maintenance_fee path uses checked_sub which can produce i128::MIN,
/// but fee_debt_u128_checked uses unsigned_abs() which safely returns 2^127.
#[kani::proof]
#[kani::unwind(2)]
#[kani::solver(cadical)]
fn proof_fee_credits_never_i128_min() {
    // Part 1: fee_debt_u128_checked is safe for ALL i128 values
    let fc: i32 = kani::any();
    let debt = fee_debt_u128_checked(fc as i128);
    if fc < 0 {
        assert!(debt == (fc as i128).unsigned_abs());
    } else {
        assert!(debt == 0);
    }

    // Part 2: checked_sub boundary — if fee_credits - due overflows, it returns None
    let credits: i32 = kani::any();
    let due: u16 = kani::any();
    kani::assume(due > 0);
    let due_i128: i128 = due as i128;
    let result = (credits as i128).checked_sub(due_i128);
    match result {
        Some(new_fc) => {
            // Didn't overflow — fee_debt_u128_checked must still be safe
            let _ = fee_debt_u128_checked(new_fc);
        }
        None => {
            // Overflow — implementation would return Err(Overflow)
        }
    }
}
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall