bitcoin-spv          zk-verifier
     │                    │
     └──────────┬──────────┘
                │
          commitment-tree  ←──  private-lend

pub fn verify_groth16(
    env: Env,
    circuit: CircuitType,
    proof: Groth16Proof,
    public_signals: Vec<Bytes32>,
) -> bool

// Deposit: verify SPV + ZK, create commitment. Returns the new commitment.
pub fn deposit(depositor: Address, /* SPV proof args */, zk_proof: Proof, public_signals: Vec<BytesN<32>>, enc_note: Bytes) -> Result<BytesN<32>, CommitmentTreeError>

// Insert a pending commitment into the Merkle tree (admin/relayer in Phase 1). Emits `insert_leaf`.
pub fn insert_commitment(caller: Address, commitment: BytesN<32>, new_root: BytesN<32>) -> Result<(), CommitmentTreeError>

// Borrow: ZK proof + oracle price → USDC transferred to borrower.
pub fn borrow(borrower: Address, zk_proof: Proof, public_signals: Vec<BytesN<32>>, enc_note: Bytes) -> Result<(), CommitmentTreeError>

// Repay: ZK proof → outstanding debt reduced.
pub fn repay(repayer: Address, zk_proof: Proof, public_signals: Vec<BytesN<32>>, enc_note: Bytes) -> Result<(), CommitmentTreeError>

// Liquidate: ZK undercollateral proof → keeper collects proven debt amount.
pub fn liquidate(keeper: Address, zk_proof: Proof, public_signals: Vec<BytesN<32>>) -> Result<(), CommitmentTreeError>

// Supply USDC to the pool.
pub fn supply_usdc(supplier: Address, amount: i128) -> Result<(), CommitmentTreeError>

// Withdraw USDC supply.
pub fn withdraw_supply(supplier: Address, amount: i128) -> Result<(), CommitmentTreeError>

// Deposit: verifies SPV directly, creates a transparent position keyed by txid.
pub fn deposit(depositor: Address, /* SPV proof args */, p2wsh_script_pubkey: Bytes, timelock_height: u32, user_pubkey: BytesN<33>) -> Result<BytesN<32>, PrivateLendError>

// Borrow: checks collateral ratio at current oracle price → USDC transferred.
pub fn borrow(borrower: Address, txid: BytesN<32>, usdc_amount: i128) -> Result<(), PrivateLendError>

// Repay: reduces outstanding debt. Emits `repay`, and `repay_full` additionally when the debt reaches zero.
pub fn repay(repayer: Address, txid: BytesN<32>, usdc_amount: i128) -> Result<(), PrivateLendError>

// Liquidate: the designated keeper, or anyone once the keeper is stale - checks oracle undercollateralization.
pub fn liquidate(keeper: Address, txid: BytesN<32>) -> Result<(), PrivateLendError>

utilization = total_borrowed_usdc / total_supplied_usdc

if utilization ≤ Uoptimal (75%):
    borrow_rate = base_rate + (utilization / Uoptimal) × slope1
else:
    borrow_rate = base_rate + slope1 + ((utilization − Uoptimal) / (1 − Uoptimal)) × slope2

// commitment-tree
pub fn refresh_nullifier_ttl(env: Env, nullifier: BytesN<32>) -> bool
pub fn refresh_commitment_ttl(env: Env, txid: BytesN<32>) -> bool
pub fn refresh_merkle_root_ttl(env: Env)
pub fn refresh_pool_ttl(env: Env)
pub fn refresh_supply_balance_ttl(env: Env, lender: Address) -> bool
pub fn refresh_instance_ttl(env: Env)

// private-lend
pub fn refresh_position_ttl(env: Env, txid: BytesN<32>) -> bool
pub fn refresh_supply_balance_ttl(env: Env, lender: Address) -> bool
pub fn refresh_protocol_ttl(env: Env)
pub fn refresh_release_psbt_ttl(env: Env, txid: BytesN<32>) -> bool

// bitcoin-spv
pub fn refresh_ttl(env: Env)  // extends Config and Checkpoint together

// zk-verifier
pub fn refresh_ttl(env: Env)  // extends Admin and every set circuit's VerificationKey together

User (browser)
    │
    │  1. generate ZK deposit proof locally (circom WASM)
    │  2. assemble SPV proof bundle (relayer API or Esplora)
    │
    ▼
commitment-tree.deposit(spv_proof, zk_proof)
    │
    ├──► bitcoin-spv.verify_transaction(headers, merkle_proof, tx_index, raw_tx, 6)
    │         returns: SpvVerificationResult { txid, block_hash, confirmations }
    │
    ├──► zk-verifier.verify_groth16(Deposit, proof, [commitment, txid])
    │         returns: bool (true = valid)
    │
    ├── store: pending_commitment[txid] = commitment
    └── emit: DepositVerified { txid, commitment }

Admin/relayer calls:
commitment-tree.insert_commitment(commitment)
    ├── compute new Merkle root (Poseidon hash of commitment + siblings)
    ├── store: merkle_root = new_root
    └── emit: CommitmentInserted { commitment, new_root, leaf_index }