Skip to content

x402agent/SolanaOS / skills/qedgen

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
Cargo.lockmanifest38.2 KB
Cargo.tomlmanifest347 B
LICENSEother1.0 KB
README.mdmarkdown4.1 KB
SKILL.mdskill md21.0 KB
claude.mdmarkdown9.7 KB
crates/qedgen/Cargo.tomlmanifest544 B
crates/qedgen/src/api.rsscript38.9 KB
crates/qedgen/src/asm2lean.rsscript26.2 KB
crates/qedgen/src/consolidate.rsscript6.2 KB
crates/qedgen/src/main.rsscript4.7 KB
crates/qedgen/src/project.rsscript3.0 KB
crates/qedgen/src/spec.rsscript19.4 KB
crates/qedgen/src/validate.rsscript5.6 KB
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.leanother292 B
crates/qedgen/templates/lean-toolchainother25 B
docs/CNAMEother10 B
docs/index.htmlother11.6 KB
docs/llms-full.txtmarkdown8.7 KB
docs/llms.txtmarkdown2.1 KB
docs/logo-dark.svgother648 B
docs/logo-light.svgother648 B
docs/qgn_demo.htmlother69.3 KB
docs/style.cssother8.1 KB
examples/rust/escrow/Anchor.tomlconfig353 B
examples/rust/escrow/Cargo.lockmanifest72.8 KB
examples/rust/escrow/Cargo.tomlmanifest215 B
examples/rust/escrow/migrations/deploy.tsscript428 B
examples/rust/escrow/package.jsonmanifest528 B
examples/rust/escrow/programs/escrow/Cargo.tomlmanifest376 B
examples/rust/escrow/programs/escrow/Xargo.tomlconfig62 B
examples/rust/escrow/programs/escrow/src/lib.rsscript6.7 KB
examples/rust/escrow/tests/escrow.tsscript8.6 KB
examples/rust/escrow/tsconfig.jsonconfig205 B
examples/rust/percolator/Cargo.lockmanifest8.5 KB
examples/rust/percolator/Cargo.tomlmanifest639 B
examples/rust/percolator/LICENSEother11.1 KB
examples/rust/percolator/README.mdmarkdown4.9 KB
examples/rust/percolator/examples/offsets.rsscript1.3 KB
examples/rust/percolator/scripts/audit-proof-strength.mdmarkdown6.4 KB
examples/rust/percolator/scripts/proof-strength-audit-results.mdmarkdown89.2 KB
examples/rust/percolator/scripts/run_kani_full_audit.shexecutablescript1.2 KB
examples/rust/percolator/spec.mdmarkdown108.4 KB
examples/rust/percolator/src/i128.rsscript20.4 KB
examples/rust/percolator/src/percolator.rsscript139.3 KB
examples/rust/percolator/src/wide_math.rsscript59.8 KB
examples/rust/percolator/tests/amm_tests.rsscript7.4 KB
examples/rust/percolator/tests/common/mod.rsscript4.7 KB
examples/rust/percolator/tests/fuzzing.proptest-regressionsother4.7 KB
examples/rust/percolator/tests/fuzzing.rsscript43.1 KB
examples/rust/percolator/tests/proofs_arithmetic.rsscript17.1 KB
examples/rust/percolator/tests/proofs_audit.rsscript35.0 KB
examples/rust/percolator/tests/proofs_instructions.rsscript64.8 KB
examples/rust/percolator/tests/proofs_invariants.rsscript21.0 KB
examples/rust/percolator/tests/proofs_lazy_ak.rsscript22.4 KB
examples/rust/percolator/tests/proofs_liveness.rsscript17.1 KB
examples/rust/percolator/tests/proofs_safety.rsscript104.2 KB
examples/rust/percolator/tests/proofs_v1131.rsscript25.4 KB
examples/rust/percolator/tests/unit_tests.rsscript93.8 KB
examples/sbpf/counter/src/counter.sother22.9 KB
examples/sbpf/slippage/src/asm-slippage/asm-slippage.sother698 B
examples/sbpf/transfer/src/transfer.sother2.4 KB
examples/sbpf/tree/src/tree.sother61.1 KB
install.shexecutablescript5.5 KB
lean_solana/QEDGen.leanother165 B
lean_solana/QEDGen/Solana.leanother165 B
lean_solana/QEDGen/Solana/Account.leanother4.0 KB
lean_solana/QEDGen/Solana/Authority.leanother285 B
lean_solana/QEDGen/Solana/Cpi.leanother9.0 KB
lean_solana/QEDGen/Solana/SBPF.leanother130 B
lean_solana/QEDGen/Solana/SBPF/Execute.leanother12.2 KB
lean_solana/QEDGen/Solana/SBPF/ISA.leanother5.1 KB
lean_solana/QEDGen/Solana/SBPF/Memory.leanother6.1 KB
lean_solana/QEDGen/Solana/SBPF/Tactic.leanother2.3 KB
lean_solana/QEDGen/Solana/State.leanother1.9 KB
lean_solana/QEDGen/Solana/Valid.leanother2.0 KB
lean_solana/README.mdmarkdown2.5 KB
lean_solana/lake-manifest.jsonconfig119 B
lean_solana/lakefile.leanother112 B
lean_solana/lean-toolchainother25 B
lean_solana/test_lemmas.leanother2.3 KB
package.jsonmanifest762 B
tools/qedgenexecutablescript357 B

examples/rust/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