dark_pool

public struct DarkPoolVault<phantom T> has key {
    id: UID,
    label: String,
    binary_market_id: ID,            // Settlement<T> this vault trades against
    expiry_ms: u64,                  // cached expiry mirror
    balance_manager_id: ID,          // DeepBook V3 BalanceManager (off-vault)
    trade_cap_id: ID,                // DeepBook V3 TradeCap (held by keeper)
    balance: Balance<T>,              // idle collateral
    total_shares: u64,
    aggregate_cost_micro: u64,
    state: u8,                       // STATE_OPEN | STATE_SETTLED
    final_payout_micro: u64,
    keeper: address,
    min_deposit_micro: u64,
}

const STATE_OPEN: u8 = 0;
const STATE_SETTLED: u8 = 1;

public struct DepositReceipt<phantom T> has key, store {
    id: UID,
    vault_id: ID,
    shares: u64,
    encrypted_attribution_blob_id: vector<u8>,    // Walrus blob (optional)
    attribution_hash: vector<u8>,                  // sha256 of plaintext
    seal_policy_id: ID,                            // gates decryption
}

public fun create_vault<T>(
    label: String,
    binary_market_id: ID,
    expiry_ms: u64,
    balance_manager_id: ID,
    trade_cap_id: ID,
    min_deposit_micro: u64,
    ctx: &mut TxContext,
): VaultAdminCap

public fun deposit<T>(
    vault: &mut DarkPoolVault<T>,
    coin_in: Coin<T>,
    seal_policy: &AccessPolicy,
    encrypted_blob_id: vector<u8>,
    attribution_hash: vector<u8>,
    _clock: &Clock,
    ctx: &mut TxContext,
): DepositReceipt<T>

public fun pull_for_mint<T>(
    vault: &mut DarkPoolVault<T>,
    cap: &VaultAdminCap,
    amount: u64,
    ctx: &mut TxContext,
): Coin<T>

public fun record_mint<T>(
    vault: &mut DarkPoolVault<T>,
    cap: &VaultAdminCap,
    market_key_id: ID,
    qty: u64,
    cost_micro: u64,
    _ctx: &TxContext,
)

public fun receive_settlement<T>(
    vault: &mut DarkPoolVault<T>,
    cap: &VaultAdminCap,
    payout: Coin<T>,
    _ctx: &TxContext,
)

public fun redeem<T>(
    vault: &mut DarkPoolVault<T>,
    receipt: DepositReceipt<T>,
    ctx: &mut TxContext,
): Coin<T>

payout = (shares * vault.final_payout_micro) / vault.total_shares