@win-trader/bindings 0.0.2 → 0.0.4

package/vault/dist/index.d.ts

@@ -29,61 +29,29 @@ export declare const VaultError: {
     8: {
         message: string;
     };
-    /**
-     * Reservation would exceed total vault assets.
-     */
     9: {
         message: string;
     };
     /**
-     * claim_fees_to amount exceeds available unclaimed fees.
+     * `upgrade` called with no pending proposal.
      */
     10: {
         message: string;
     };
     /**
-     * `record_absorbed_collateral` saw a vault balance delta that differs from
-     * the supplied `amount` — PM and Vault disagree on what actually moved.
-     */
-    12: {
-        message: string;
-    };
-    /**
-     * `deposit`/`mint` only accept self-deposits: receiver, from, and operator
-     * must all match.
-     */
-    13: {
-        message: string;
-    };
-    /**
-     * `upgrade` rejected — no `propose_upgrade` was made before commit.
-     */
-    14: {
-        message: string;
-    };
-    /**
-     * `upgrade` rejected — timelock has not elapsed yet.
+     * `upgrade` called before the proposal's timelock eta.
      */
-    15: {
+    11: {
         message: string;
     };
     /**
-     * `upgrade` rejected — `new_wasm_hash` does not match the proposed
-     * `PendingUpgrade.wasm_hash`.
+     * `upgrade` called with a hash that differs from the proposal.
      */
-    16: {
-        message: string;
-    };
-    /**
-     * `withdraw`/`redeem` rejected — positions are open and the PM-synced
-     * `NetGlobalTraderPnl` is older than `PNL_SYNC_MAX_AGE_SECS`, so
-     * `free_liquidity` cannot be trusted to cover open trader profits.
-     */
-    17: {
+    12: {
         message: string;
     };
 };
-export type VaultDataKey = {
+export type Key = {
     tag: "Initialized";
     values: void;
 } | {
@@ -93,26 +61,17 @@ export type VaultDataKey = {
     tag: "PositionManager";
     values: void;
 } | {
-    tag: "ReservedUsdc";
+    tag: "RequestRouter";
     values: void;
 } | {
-    tag: "UnclaimedFees";
+    tag: "LpConfig";
     values: void;
 } | {
-    tag: "NetGlobalTraderPnl";
-    values: void;
-} | {
-    tag: "LastPnlSyncTime";
-    values: void;
-} | {
-    tag: "IsPaused";
+    tag: "Paused";
     values: void;
 } | {
     tag: "Version";
     values: void;
-} | {
-    tag: "LockupExpiresAt";
-    values: readonly [string];
 };
 export interface OwnerTokensKey {
     index: u32;
@@ -1187,105 +1146,235 @@ export interface AllowanceData {
     live_until_ledger: u32;
 }
 /**
- * Represents a single trader's open leveraged position.
+ * Authoritative per-market state: the side aggregates, the funding indices,
+ * the funding EMA, and the market configuration.
+ *
+ * Soroban limits UDT field names to 30 characters, so where a doc glossary
+ * term is longer the field drops the redundant qualifier and its doc
+ * comment carries the full term (e.g. `receiver_backed_index_long` is the
+ * doc's `receiver_backed_payer_index` for the long side).
  */
-export interface Position {
+export interface Market {
+    config: MarketConfig;
     /**
-   * USDC collateral deposited by the trader.
+   * `INDEX_PRECISION`-scaled bps/day payer rate as of the last refresh.
    */
-    collateral: i128;
+    current_payer_rate: i128;
+    current_payer_side: PayerSide;
+    last_funding_checkpoint: u64;
+    long: MarketSide;
     /**
-   * Global borrow accumulator index at position open (for lazy fee calc).
+   * Cumulative payer fee per unit of dominant-side size that is LP
+   * revenue on collection (§8.2).
    */
-    entry_borrow_index: i128;
+    lp_backed_index_long: i128;
+    lp_backed_index_short: i128;
+    lp_payer_remainder: i128;
     /**
-   * Global funding accumulator index at position open (for lazy fee calc).
+   * Sub-stroop carry of the receiver-liability accrual (§8.3).
    */
-    entry_funding_index: i128;
+    pending_remainder: i128;
     /**
-   * Oracle price at the time the position was opened (scaled by 1e7).
+   * Cumulative payer fee per unit of dominant-side size whose collection
+   * restores cash backing an already-accrued receiver claim (§8.2).
    */
-    entry_price: i128;
+    receiver_backed_index_long: i128;
+    receiver_backed_index_short: i128;
     /**
-   * Flat USDC fee escrowed when TP or SL is set. Paid to executor on trigger, refunded on user close / ADL, forfeited to revenue on liquidation.
+   * Cumulative funding credit per unit of light-side size (§8.2).
    */
-    execution_fee_escrow: i128;
+    receiver_index_long: i128;
+    receiver_index_remainder: i128;
+    receiver_index_short: i128;
+    receiver_payer_remainder: i128;
+    short: MarketSide;
+    /**
+   * §8.1 signed EMA of the instantaneous skew: a fraction of one at
+   * `INDEX_PRECISION` scale, positive when history says longs dominate.
+   * Decays toward the current skew with the global half-life.
+   */
+    skew_ema: i128;
+}
+export interface LpConfig {
+    lp_request_delay: u64;
+    max_withdraw_utilization_bps: u32;
+    min_deposit_nav_factor_bps: u32;
+}
+/**
+ * Represents a single trader's open leveraged position.
+ */
+export interface Position {
     /**
-   * True for a long position, false for a short.
+   * Asset units at `PRICE_PRECISION`.
    */
-    is_long: boolean;
+    base_exposure: i128;
+    borrow_debt: i128;
     /**
-   * Block timestamp when the position was last increased (anti-front-running lock).
+   * Cash owned by an optional-order executor.
    */
+    execution_budget: i128;
+    funding_paid_to_lps_debt: i128;
+    funding_paid_to_receivers_debt: i128;
+    funding_received_debt: i128;
+    id: u64;
+    is_long: boolean;
     last_increased_time: u64;
+    market: string;
+    owner: string;
+    /**
+   * Fixed gross capacity assigned when risk opens.
+   */
+    risk_units: i128;
     /**
-   * Notional size of the position in USDC.
+   * USD notional at `PRICE_PRECISION`.
    */
     size: i128;
     /**
-   * Stop-loss price (scaled by 1e7). 0 = not set.
+   * Trigger price for the optional stop-loss order; `0` = none.
    */
     stop_loss: i128;
     /**
-   * Take-profit price (scaled by 1e7). 0 = not set.
+   * Trader-owned collateral recorded in contract state (the doc's
+   * "stored collateral"). Effective collateral — stored collateral after
+   * pending fees and funding credits — is always derived, never stored.
+   */
+    stored_collateral: i128;
+    /**
+   * Trigger price for the optional take-profit order; `0` = none.
    */
     take_profit: i128;
 }
+export interface LpRequest {
+    amount: i128;
+    execute_after: u64;
+    id: u64;
+    kind: LpRequestKind;
+    owner: string;
+    request_time: u64;
+    status: LpRequestStatus;
+}
 /**
- * Global market state for a single tradeable asset symbol.
+ * Which side currently pays funding (§8.1: the side the blended integral
+ * skew points at — under the EMA this can be the *lighter* side for a
+ * while after the book flips). `None` when the blend is exactly zero.
  */
-export interface MarketInfo {
-    /**
-   * Cumulative borrow fee index (grows monotonically with time).
-   */
-    acc_borrow_index: i128;
+export type PayerSide = {
+    tag: "None";
+    values: void;
+} | {
+    tag: "Long";
+    values: void;
+} | {
+    tag: "Short";
+    values: void;
+};
+export type RiskState = {
+    tag: "Normal";
+    values: void;
+} | {
+    tag: "Warning";
+    values: void;
+} | {
+    tag: "Adl";
+    values: void;
+} | {
+    tag: "HardCap";
+    values: void;
+};
+export interface MarketSide {
+    base_exposure: i128;
+    risk_state: RiskState;
+    risk_units: i128;
+    size_open_interest: i128;
+    stored_collateral_total: i128;
+}
+export interface RoundPrice {
+    price: i128;
+    symbol: string;
+}
+export interface OracleRound {
+    id: u64;
+    previous_id: u64;
+    previous_timestamp: u64;
+    prices: Array<RoundPrice>;
+    timestamp: u64;
+}
+export interface GlobalConfig {
+    base_borrow_rate_bps_day: i128;
     /**
-   * Cumulative funding rate index (signed; positive = longs pay shorts).
+   * §8.1 half-life of the funding skew EMA, seconds (global: one memory
+   * horizon for every market).
    */
-    acc_funding_index: i128;
+    funding_half_life_seconds: u64;
+    hard_cap_factor_limit_bps: u32;
+    lp_revenue_share_bps: u32;
+    max_active_markets: u32;
+    max_adl_reward: i128;
+    max_insolvent_touch_reward: i128;
+    max_variable_borrow_bps_day: i128;
+    min_collateral: i128;
+    min_position_lifetime: u64;
+    risk_capacity_limit_bps: u32;
+    risk_keeper_revenue_share_bps: u32;
+}
+export interface MarketConfig {
+    adl_pnl_factor_bps: u32;
+    adl_reward_bps: u32;
     /**
-   * Volume-weighted average entry price of all active long positions.
+   * §11.1 closing-fee tier when the close worsens skew.
    */
-    global_long_avg_price: i128;
+    close_fee_high_bps: u32;
     /**
-   * Volume-weighted average entry price of all active short positions.
+   * §11.1 closing-fee tier when the close improves or preserves skew.
    */
-    global_short_avg_price: i128;
+    close_fee_low_bps: u32;
+    hard_cap_pnl_factor_bps: u32;
     /**
-   * Timestamp of the last keeper index update.
+   * Margin required to open or add risk (§12.3). Divides max leverage:
+   * a position may not be created closer to liquidation than this.
    */
-    last_index_update: u64;
+    initial_margin_bps: u32;
     /**
-   * Total notional size of all open long positions.
+   * §8.1 weight of the instantaneous skew in the funding blend, in bps;
+   * the rest is the half-life EMA. `BPS` reproduces pure instant skew.
    */
-    long_open_interest: i128;
+    instant_weight_bps: u32;
+    liquidation_reward_bps: u32;
     /**
-   * Total notional size of all open short positions.
+   * Margin below which the position is liquidatable (§12.3). Must not
+   * exceed `initial_margin_bps`; the gap is the entry buffer.
    */
-    short_open_interest: i128;
+    maintenance_margin_bps: u32;
+    market_risk_factor_bps: u32;
+    max_funding_rate_bps_day: i128;
+    max_long_base_exposure: i128;
+    max_long_size_open_interest: i128;
+    max_short_base_exposure: i128;
+    max_short_size_open_interest: i128;
+    recovery_pnl_factor_bps: u32;
+    warning_pnl_factor_bps: u32;
 }
 /**
  * Global safety thresholds for price validation.
  */
 export interface OracleConfig {
     /**
-   * How long a cached aggregated price remains valid (in seconds). A
-   * `get_price` call within this window of the last fetch returns the
-   * cached value without re-querying sources. Must be > 0 and
-   * <= `staleness_threshold` (otherwise the cache could outlive a fresh
-   * source price and serve stale data).
+   * How long a cached aggregated price remains valid after the router
+   * fetch (in seconds). A cache hit also requires every source timestamp
+   * used for the cached median to remain within `staleness_threshold`.
+   * Must be > 0 and <= `staleness_threshold`.
    */
     cache_duration: u64;
     /**
    * Maximum allowed spread between oracle sources in basis points
-   * (e.g., 100 = 1%). Bounded at `shared::constants::MAX_DEVIATION_BPS_CEILING`.
+   * (e.g., 100 = 1%). Bounded at `crate::constants::MAX_DEVIATION_BPS_CEILING`.
    */
     max_deviation_bps: i128;
     /**
    * Minimum number of source responses that must agree within
    * `max_deviation_bps` for OracleRouter to return a price. Floored at
-   * `shared::constants::MIN_REQUIRED_SOURCES_FLOOR`, ceilinged at
-   * `shared::constants::MAX_ORACLE_SOURCES`.
+   * `crate::constants::MIN_REQUIRED_SOURCES_FLOOR`, ceilinged at
+   * `crate::constants::MAX_ORACLE_SOURCES`.
    */
     min_required_sources: u32;
     /**
@@ -1294,6 +1383,13 @@ export interface OracleConfig {
    */
     staleness_threshold: u64;
 }
+export type LpRequestKind = {
+    tag: "Deposit";
+    values: void;
+} | {
+    tag: "Withdrawal";
+    values: void;
+};
 /**
  * Data required during a WASM migration. Single definition for all contracts.
  */
@@ -1303,15 +1399,54 @@ export interface MigrationData {
 /**
  * Pending WASM upgrade — set by `propose_upgrade`, consumed by `upgrade`
  * (cleared atomically on a successful install), or cleared by `cancel_upgrade`.
- * Single shape across every protocol contract; all four contracts store it at
+ * Single shape across every protocol contract. Contracts store it at
  * the shared `pending_upgrade` Symbol key in their own instance storage (see
- * `interfaces::upgrade::pending_upgrade_key`). `upgrade` refuses to install
+ * `crate::upgrade::pending_upgrade_key`). `upgrade` refuses to install
  * unless `pending.wasm_hash` matches the supplied hash and `now >= eta`.
  */
 export interface PendingUpgrade {
     eta: u64;
     wasm_hash: Buffer;
 }
+export type LpRequestStatus = {
+    tag: "Pending";
+    values: void;
+} | {
+    tag: "Settled";
+    values: void;
+} | {
+    tag: "Failed";
+    values: void;
+} | {
+    tag: "Expired";
+    values: void;
+};
+export interface SettlementResult {
+    /**
+   * Shares minted for a deposit or assets paid for a withdrawal.
+   */
+    amount: i128;
+    status: SettlementStatus;
+}
+export type SettlementStatus = {
+    tag: "Settled";
+    values: void;
+} | {
+    tag: "Failed";
+    values: void;
+};
+export interface AccountingSnapshot {
+    cash_lp_equity: i128;
+    cash_shortfall: i128;
+    free_lp_capital: i128;
+    lp_blocked_side_count: u32;
+    non_lp_claims: i128;
+    open_position_count: u64;
+    physical_cash: i128;
+    required_risk_backing: i128;
+    total_risk_units: i128;
+    vault_nav: i128;
+}
 export declare const UpgradeableError: {
     /**
      * When migration is attempted but not allowed due to upgrade state.
@@ -1418,58 +1553,7 @@ export type PausableStorageKey = {
     tag: "Paused";
     values: void;
 };
-/**
- * Execution-bounty and open-fee parameters charged to traders.
- * `open_fee_bps` and `liquidation_bounty_bps` are in basis points;
- * `tp_sl_execution_fee` is a flat USDC amount at PRECISION scale.
- */
-export interface FeeConfig {
-    liquidation_bounty_bps: u32;
-    open_fee_bps: u32;
-    tp_sl_execution_fee: i128;
-}
-/**
- * Defines how protocol revenue is split between parties.
- * All values are in basis points (bps). Must sum to 10_000.
- */
-export interface FeeSplits {
-    dev_bps: u32;
-    lp_bps: u32;
-    staker_bps: u32;
-}
-/**
- * Global protocol risk and timing parameters.
- */
-export interface ProtocolLimits {
-    adl_pnl_bps: u32;
-    adl_utilization_bps: u32;
-    cooldown_duration: u64;
-    funding_cut_bps: u32;
-    liquidation_threshold_bps: u32;
-    max_utilization_ratio: i128;
-    min_collateral: i128;
-    min_position_lifetime: u64;
-}
-/**
- * Borrow rate kink curve and funding rate parameters (all in basis points).
- */
-export interface BorrowRateConfig {
-    base_borrow_rate_bps: i128;
-    base_funding_rate_bps: i128;
-    optimal_utilization_bps: i128;
-    slope1_bps: i128;
-    slope2_bps: i128;
-}
 export interface Client {
-    /**
-     * Construct and simulate a mint transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    mint: ({ shares, receiver, from, operator }: {
-        shares: i128;
-        receiver: string;
-        from: string;
-        operator: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
     /**
      * Construct and simulate a name transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      * Returns the name for this token.
@@ -1485,15 +1569,6 @@ export interface Client {
     pause: ({ caller }: {
         caller: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
-    /**
-     * Construct and simulate a redeem transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    redeem: ({ shares, receiver, owner, operator }: {
-        shares: i128;
-        receiver: string;
-        owner: string;
-        operator: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
     /**
      * Construct and simulate a symbol transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      * Returns the symbol for this token.
@@ -1548,20 +1623,11 @@ export interface Client {
     balance: ({ account }: {
         account: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
-    /**
-     * Construct and simulate a deposit transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    deposit: ({ assets, receiver, from, operator }: {
-        assets: i128;
-        receiver: string;
-        from: string;
-        operator: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
     /**
      * Construct and simulate a migrate transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
-    migrate: ({ migration_data, operator }: {
-        migration_data: MigrationData;
+    migrate: ({ data, operator }: {
+        data: MigrationData;
         operator: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
@@ -1581,34 +1647,14 @@ export interface Client {
      * Construct and simulate a decimals transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
     decimals: (options?: MethodOptions) => Promise<AssembledTransaction<u32>>;
-    /**
-     * Construct and simulate a max_mint transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    max_mint: ({ receiver }: {
-        receiver: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
     /**
      * Construct and simulate a transfer transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     * Override to propagate the sender's remaining lockup onto a recipient
-     * who held no shares before the transfer. Without this, an LP could
-     * circumvent the cooldown by transferring LP shares to a fresh address
-     * that then withdraws. Recipients with an existing balance keep their
-     * own expiry — see `propagate_lockup_on_transfer`.
      */
     transfer: ({ from, to, amount }: {
         from: string;
         to: string;
         amount: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
-    /**
-     * Construct and simulate a withdraw transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    withdraw: ({ assets, receiver, owner, operator }: {
-        assets: i128;
-        receiver: string;
-        owner: string;
-        operator: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
     /**
      * Construct and simulate a allowance transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      * Returns the amount of tokens a `spender` is allowed to spend on behalf
@@ -1624,74 +1670,10 @@ export interface Client {
         owner: string;
         spender: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
-    /**
-     * Construct and simulate a claim_fees transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    claim_fees: ({ caller, recipient }: {
-        caller: string;
-        recipient: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
-    /**
-     * Construct and simulate a max_redeem transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    max_redeem: ({ owner }: {
-        owner: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
-    /**
-     * Construct and simulate a pay_profit transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     * Pay `amount` from the vault to `trader` to settle a profitable close.
-     * Loss settlement does NOT route through here — see ADR-0001.
-     */
-    pay_profit: ({ caller, trader, amount }: {
-        caller: string;
-        trader: string;
-        amount: i128;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
-    /**
-     * Construct and simulate a accrue_fees transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     * Books PM-pushed revenue into `unclaimed_fees`, clamped so
-     * `unclaimed_fees + reserved_usdc` never exceeds `total_assets` — fee
-     * claims can only ever be tagged against capital the vault holds. A
-     * clamped accrual emits `FeeAccrualClamped` for monitoring instead of
-     * reverting: this runs inside PM's close/liquidation paths, which must
-     * never fail on fee bookkeeping.
-     *
-     * Emits `TotalAssetsUpdate` alongside `AccrueFees`. PM's `recv_revenue`
-     * pushes fee USDC into the vault via a raw token transfer immediately
-     * before this call, and no other vault entrypoint witnesses that
-     * transfer — without the snapshot, off-chain indexers would lose the
-     * LP slice (`fee - non_lp_slice`) on every accrual.
-     */
-    accrue_fees: ({ caller, amount }: {
-        caller: string;
-        amount: i128;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
-    /**
-     * Construct and simulate a max_deposit transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    max_deposit: ({ receiver }: {
-        receiver: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
     /**
      * Construct and simulate a query_asset transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
     query_asset: (options?: MethodOptions) => Promise<AssembledTransaction<string>>;
-    /**
-     * Construct and simulate a max_withdraw transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    max_withdraw: ({ owner }: {
-        owner: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
-    /**
-     * Construct and simulate a preview_mint transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    preview_mint: ({ shares }: {
-        shares: i128;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
-    /**
-     * Construct and simulate a total_assets transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    total_assets: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
     /**
      * Construct and simulate a total_supply transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      * Returns the total amount of tokens in circulation.
@@ -1702,20 +1684,22 @@ export interface Client {
      */
     total_supply: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
     /**
-     * Construct and simulate a claim_fees_to transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Construct and simulate a get_lp_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
-    claim_fees_to: ({ caller, recipient, amount }: {
-        caller: string;
-        recipient: string;
-        amount: i128;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    get_lp_config: (options?: MethodOptions) => Promise<AssembledTransaction<LpConfig>>;
     /**
-     * Construct and simulate a reserved_usdc transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Construct and simulate a physical_cash transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
-    reserved_usdc: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    physical_cash: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    /**
+     * Construct and simulate a set_lp_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_lp_config: ({ caller, config }: {
+        caller: string;
+        config: LpConfig;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * Construct and simulate a transfer_from transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     * Same lockup-propagation guarantee for the allowance-based path.
      */
     transfer_from: ({ spender, from, to, amount }: {
         spender: string;
@@ -1725,46 +1709,30 @@ export interface Client {
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * Construct and simulate a cancel_upgrade transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     * PAUSER veto of a pending upgrade.
      */
     cancel_upgrade: ({ caller }: {
         caller: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a free_liquidity transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    free_liquidity: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
-    /**
-     * Construct and simulate a preview_redeem transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Construct and simulate a settle_deposit transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
-    preview_redeem: ({ shares }: {
-        shares: i128;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
-    /**
-     * Construct and simulate a unclaimed_fees transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     * Accrued non-LP revenue awaiting `claim_fees` / `claim_fees_to`. Exposed
-     * so tests can reconcile counter movement against token-side transfers
-     * without inferring via subtraction.
-     */
-    unclaimed_fees: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    settle_deposit: ({ caller, owner, assets, round }: {
+        caller: string;
+        owner: string;
+        assets: i128;
+        round: OracleRound;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<SettlementResult>>;
     /**
-     * Construct and simulate a update_net_pnl transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Construct and simulate a transfer_claim transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
-    update_net_pnl: ({ caller, pnl }: {
+    transfer_claim: ({ caller, recipient, amount, claims_after }: {
         caller: string;
-        pnl: i128;
+        recipient: string;
+        amount: i128;
+        claims_after: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
-    /**
-     * Construct and simulate a preview_deposit transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    preview_deposit: ({ assets }: {
-        assets: i128;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
     /**
      * Construct and simulate a propose_upgrade transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     * Propose a WASM upgrade. UPGRADER role only. Records `{wasm_hash, eta}`
-     * where `eta = now + timelock` so `upgrade` can refuse to install a
-     * different hash or fire before `eta`.
      */
     propose_upgrade: ({ caller, wasm_hash }: {
         caller: string;
@@ -1775,83 +1743,61 @@ export interface Client {
      */
     bump_vault_state: (options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a preview_withdraw transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Construct and simulate a settle_withdrawal transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
-    preview_withdraw: ({ assets }: {
-        assets: i128;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
-    /**
-     * Construct and simulate a convert_to_assets transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    convert_to_assets: ({ shares }: {
+    settle_withdrawal: ({ caller, owner, shares, round }: {
+        caller: string;
+        owner: string;
         shares: i128;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
-    /**
-     * Construct and simulate a convert_to_shares transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     */
-    convert_to_shares: ({ assets }: {
-        assets: i128;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
-    /**
-     * Construct and simulate a lockup_expires_at transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     * Returns the unix timestamp at which `user` may next withdraw/redeem.
-     * Returns 0 if `user` has never deposited (no lockup recorded).
-     */
-    lockup_expires_at: ({ user }: {
-        user: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<u64>>;
+        round: OracleRound;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<SettlementResult>>;
     /**
-     * Construct and simulate a release_liquidity transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Construct and simulate a receive_collateral transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
-    release_liquidity: ({ caller, amount }: {
+    receive_collateral: ({ caller, from, amount }: {
         caller: string;
+        from: string;
         amount: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a reserve_liquidity transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Construct and simulate a set_request_router transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
-    reserve_liquidity: ({ caller, amount }: {
+    set_request_router: ({ caller, request_router }: {
         caller: string;
-        amount: i128;
+        request_router: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a net_global_trader_pnl transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     * Net unrealized PnL across all open trader positions, as last synced by
-     * PM via `update_net_pnl`. Realized PnL is intentionally NOT included —
-     * it has already moved physically through `pay_profit` /
-     * `record_absorbed_collateral` and is reflected directly in `total_assets`.
+     * Construct and simulate a total_share_supply transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
-    net_global_trader_pnl: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    total_share_supply: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
     /**
-     * Construct and simulate a total_assets_excl_pnl transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     * Total assets minus only the fee buffer — PnL is excluded so consumers
-     * (PM's utilization gate) are not subject to mark-price feedback into
-     * the utilization denominator. LP-facing flows still use `free_liquidity`.
+     * Construct and simulate a accounting_snapshot transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
-    total_assets_excl_pnl: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    accounting_snapshot: ({ round }: {
+        round: OracleRound;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<AccountingSnapshot>>;
     /**
-     * Construct and simulate a record_absorbed_collateral transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
-     * Notify the vault that PositionManager has just transferred `amount`
-     * USDC of seized/loss-settlement collateral directly into the vault's
-     * wallet. This call does NOT move tokens, but it DOES verify the
-     * on-chain delta — `post - pre` must equal `amount`, otherwise PM and
-     * Vault have diverged and we panic. See ADR-0001.
+     * Construct and simulate a can_create_lp_request transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
      */
-    record_absorbed_collateral: ({ caller, trader, amount, pre_balance }: {
+    can_create_lp_request: (options?: MethodOptions) => Promise<AssembledTransaction<boolean>>;
+    /**
+     * Construct and simulate a transfer_safety_claim transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    transfer_safety_claim: ({ caller, recipient, amount }: {
         caller: string;
-        trader: string;
+        recipient: string;
         amount: i128;
-        pre_balance: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
 }
 export declare class Client extends ContractClient {
     readonly options: ContractClientOptions;
     static deploy<T = Client>(
     /** Constructor/Initialization Args for the contract's `__constructor` method */
-    { asset, config_manager, position_manager }: {
-        asset: string;
+    { asset_address, config_manager, position_manager, lp_config }: {
+        asset_address: string;
         config_manager: string;
         position_manager: string;
+        lp_config: LpConfig;
     }, 
     /** Options for initializing a Client as well as for calling a method, with extras specific to deploying. */
     options: MethodOptions & Omit<ContractClientOptions, "contractId"> & {
@@ -1864,51 +1810,34 @@ export declare class Client extends ContractClient {
     }): Promise<AssembledTransaction<T>>;
     constructor(options: ContractClientOptions);
     readonly fromJSON: {
-        mint: (json: string) => AssembledTransaction<bigint>;
         name: (json: string) => AssembledTransaction<string>;
         pause: (json: string) => AssembledTransaction<null>;
-        redeem: (json: string) => AssembledTransaction<bigint>;
         symbol: (json: string) => AssembledTransaction<string>;
         approve: (json: string) => AssembledTransaction<null>;
         balance: (json: string) => AssembledTransaction<bigint>;
-        deposit: (json: string) => AssembledTransaction<bigint>;
         migrate: (json: string) => AssembledTransaction<null>;
         unpause: (json: string) => AssembledTransaction<null>;
         upgrade: (json: string) => AssembledTransaction<null>;
         decimals: (json: string) => AssembledTransaction<number>;
-        max_mint: (json: string) => AssembledTransaction<bigint>;
         transfer: (json: string) => AssembledTransaction<null>;
-        withdraw: (json: string) => AssembledTransaction<bigint>;
         allowance: (json: string) => AssembledTransaction<bigint>;
-        claim_fees: (json: string) => AssembledTransaction<null>;
-        max_redeem: (json: string) => AssembledTransaction<bigint>;
-        pay_profit: (json: string) => AssembledTransaction<null>;
-        accrue_fees: (json: string) => AssembledTransaction<null>;
-        max_deposit: (json: string) => AssembledTransaction<bigint>;
         query_asset: (json: string) => AssembledTransaction<string>;
-        max_withdraw: (json: string) => AssembledTransaction<bigint>;
-        preview_mint: (json: string) => AssembledTransaction<bigint>;
-        total_assets: (json: string) => AssembledTransaction<bigint>;
         total_supply: (json: string) => AssembledTransaction<bigint>;
-        claim_fees_to: (json: string) => AssembledTransaction<null>;
-        reserved_usdc: (json: string) => AssembledTransaction<bigint>;
+        get_lp_config: (json: string) => AssembledTransaction<LpConfig>;
+        physical_cash: (json: string) => AssembledTransaction<bigint>;
+        set_lp_config: (json: string) => AssembledTransaction<null>;
         transfer_from: (json: string) => AssembledTransaction<null>;
         cancel_upgrade: (json: string) => AssembledTransaction<null>;
-        free_liquidity: (json: string) => AssembledTransaction<bigint>;
-        preview_redeem: (json: string) => AssembledTransaction<bigint>;
-        unclaimed_fees: (json: string) => AssembledTransaction<bigint>;
-        update_net_pnl: (json: string) => AssembledTransaction<null>;
-        preview_deposit: (json: string) => AssembledTransaction<bigint>;
+        settle_deposit: (json: string) => AssembledTransaction<SettlementResult>;
+        transfer_claim: (json: string) => AssembledTransaction<null>;
         propose_upgrade: (json: string) => AssembledTransaction<null>;
         bump_vault_state: (json: string) => AssembledTransaction<null>;
-        preview_withdraw: (json: string) => AssembledTransaction<bigint>;
-        convert_to_assets: (json: string) => AssembledTransaction<bigint>;
-        convert_to_shares: (json: string) => AssembledTransaction<bigint>;
-        lockup_expires_at: (json: string) => AssembledTransaction<bigint>;
-        release_liquidity: (json: string) => AssembledTransaction<null>;
-        reserve_liquidity: (json: string) => AssembledTransaction<null>;
-        net_global_trader_pnl: (json: string) => AssembledTransaction<bigint>;
-        total_assets_excl_pnl: (json: string) => AssembledTransaction<bigint>;
-        record_absorbed_collateral: (json: string) => AssembledTransaction<null>;
+        settle_withdrawal: (json: string) => AssembledTransaction<SettlementResult>;
+        receive_collateral: (json: string) => AssembledTransaction<null>;
+        set_request_router: (json: string) => AssembledTransaction<null>;
+        total_share_supply: (json: string) => AssembledTransaction<bigint>;
+        accounting_snapshot: (json: string) => AssembledTransaction<AccountingSnapshot>;
+        can_create_lp_request: (json: string) => AssembledTransaction<boolean>;
+        transfer_safety_claim: (json: string) => AssembledTransaction<null>;
     };
 }