@win-trader/bindings 0.0.1 → 0.0.3

package/position-manager/dist/index.d.ts

@@ -14,15 +14,9 @@ export declare const PositionManagerError: {
     3: {
         message: string;
     };
-    /**
-     * New trade would push vault utilization past MaxUtilizationRatio (85%).
-     */
     4: {
         message: string;
     };
-    /**
-     * decrease_position called before MinPositionLifetime has elapsed.
-     */
     5: {
         message: string;
     };
@@ -35,271 +29,371 @@ export declare const PositionManagerError: {
     8: {
         message: string;
     };
-    /**
-     * liquidate_position called but the position is still healthy.
-     */
     9: {
         message: string;
     };
-    /**
-     * deleverage_position called but ADL trigger conditions are not met.
-     */
     10: {
         message: string;
     };
-    /**
-     * Position leverage exceeds the per-market max leverage.
-     */
     11: {
         message: string;
     };
-    /**
-     * No max leverage configured for this market symbol.
-     */
     12: {
         message: string;
     };
-    /**
-     * execute_order called but neither TP nor SL trigger condition is met.
-     */
     13: {
         message: string;
     };
-    /**
-     * Invalid take-profit or stop-loss price for the position direction.
-     */
     14: {
         message: string;
     };
-    /**
-     * increase_position called with `is_long` opposite to the existing position's direction.
-     */
     15: {
         message: string;
     };
-    /**
-     * Collateral below the protocol's min_collateral limit.
-     */
     16: {
         message: string;
     };
-    /**
-     * ADL target position is not profitable (PnL <= 0).
-     */
     17: {
         message: string;
     };
-    /**
-     * Max leverage exceeds the absolute safety cap (200x).
-     */
     18: {
         message: string;
     };
-    /**
-     * Mark price at execution time exceeded the trader's `acceptable_price`.
-     */
     19: {
         message: string;
     };
-    /**
-     * `set_max_leverage` called with a value below `MIN_LEVERAGE`. Use
-     * `disable_market` to take a market offline instead.
-     */
     20: {
         message: string;
     };
     /**
-     * Trading is disabled for this market — `enable_market` re-opens it.
+     * The contract is operationally paused (distinct from a risk state).
      */
     21: {
         message: string;
     };
     /**
-     * `decrease_position` called with `size_delta > pos.size`. Use
-     * `pos.size` (or simply close fully) instead of over-closing.
+     * An accounting invariant broke — e.g. a negative pending fee, which
+     * means a decreasing index or corrupted debt baseline (§11.2).
      */
     22: {
         message: string;
     };
     /**
-     * `upgrade` rejected — no `propose_upgrade` was made before commit.
+     * `upgrade` called with no pending proposal.
      */
     23: {
         message: string;
     };
     /**
-     * `upgrade` rejected — timelock has not elapsed yet.
+     * `upgrade` called before the proposal's timelock eta.
      */
     24: {
         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.
      */
     25: {
         message: string;
     };
 };
-export type StorageKey = {
-    tag: "Initialized";
+/**
+ * Which collection routed revenue through the split (§13).
+ */
+export type FeeSource = {
+    tag: "Opening";
     values: void;
 } | {
-    tag: "VaultAddress";
+    tag: "Borrow";
+    values: void;
+};
+/**
+ * Why a position left the book.
+ */
+export type CloseReason = {
+    tag: "Trader";
     values: void;
 } | {
-    tag: "ConfigManager";
+    tag: "Liquidation";
     values: void;
 } | {
-    tag: "OracleRouter";
+    tag: "Deleverage";
     values: void;
 } | {
-    tag: "IsPaused";
+    tag: "Order";
+    values: void;
+};
+/**
+ * §5.1 global state: the five non-LP claim totals, the risk counters, and
+ * the global accrual state (borrow index + receiver-funding flow).
+ */
+export interface Ledger {
+    borrow_index: i128;
+    borrow_index_remainder: i128;
+    /**
+   * `INDEX_PRECISION`-scaled bps/day rate for the current interval.
+   */
+    current_borrow_rate: i128;
+    execution_budget_total: i128;
+    last_global_checkpoint: u64;
+    lp_blocked_side_count: u32;
+    open_position_count: u64;
+    pending_receiver_funding_total: i128;
+    position_collateral_total: i128;
+    protocol_claimable_total: i128;
+    receiver_accrual_remainder: i128;
+    /**
+   * Sum of every market's receiver flow, cash/second at `INDEX_PRECISION`.
+   */
+    receiver_flow_per_second: i128;
+    risk_keeper_reserve_total: i128;
+    total_risk_units: i128;
+}
+export type Key = {
+    tag: "ConfigManager";
     values: void;
 } | {
-    tag: "Version";
+    tag: "OracleRouter";
     values: void;
 } | {
-    tag: "RealizedPnl";
+    tag: "Vault";
     values: void;
 } | {
-    tag: "TotalUnrealizedPnl";
+    tag: "GlobalConfig";
     values: void;
 } | {
-    tag: "MarketUnrealizedPnl";
-    values: readonly [string];
+    tag: "Initialized";
+    values: void;
 } | {
-    tag: "FundingPool";
-    values: readonly [string];
+    tag: "Paused";
+    values: void;
 } | {
-    tag: "LastUnpauseTime";
+    tag: "NextPositionId";
     values: void;
 } | {
-    tag: "LastPauseTime";
+    tag: "ActiveMarkets";
     values: void;
 } | {
-    tag: "MaxLeverage";
-    values: readonly [string];
+    tag: "Ledger";
+    values: void;
 } | {
-    tag: "MarketDisabled";
-    values: readonly [string];
+    tag: "Version";
+    values: void;
 } | {
     tag: "Position";
-    values: readonly [PositionKey];
+    values: readonly [u64];
 } | {
     tag: "Market";
     values: readonly [string];
 } | {
-    tag: "MarketRegistry";
-    values: void;
+    tag: "MarketDisabled";
+    values: readonly [string];
 };
 /**
- * Composite key for looking up a position by trader address and asset symbol.
- */
-export interface PositionKey {
-    symbol: string;
-    trader: string;
-}
-/**
- * Represents a single trader's open leveraged position.
+ * Authoritative per-market state: the side aggregates, the funding indices,
+ * the current funding flows, 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 for the current interval.
    */
-    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;
     /**
-   * Global funding accumulator index at position open (for lazy fee calc).
+   * LP-allocated remainder of the payer flow, cash/second at
+   * `INDEX_PRECISION` (§8.1).
    */
-    entry_funding_index: i128;
+    lp_flow_per_second: i128;
+    lp_payer_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.
+   * Receiver-allocated share of the payer flow, cash/second at
+   * `INDEX_PRECISION` (§8.1).
    */
-    execution_fee_escrow: i128;
+    receiver_flow_per_second: i128;
+    receiver_flow_remainder: i128;
     /**
-   * True for a long position, false for a short.
+   * Cumulative funding credit per unit of light-side size (§8.2).
    */
-    is_long: boolean;
-    /**
-   * Block timestamp when the position was last increased (anti-front-running lock).
-   */
-    last_increased_time: u64;
-    /**
-   * Notional size of the position in USDC.
-   */
-    size: i128;
-    /**
-   * Stop-loss price (scaled by 1e7). 0 = not set.
-   */
-    stop_loss: i128;
-    /**
-   * Take-profit price (scaled by 1e7). 0 = not set.
-   */
-    take_profit: i128;
+    receiver_index_long: i128;
+    receiver_index_remainder: i128;
+    receiver_index_short: i128;
+    receiver_payer_remainder: i128;
+    short: MarketSide;
+}
+export interface LpConfig {
+    lp_request_delay: u64;
+    max_withdraw_utilization_bps: u32;
+    min_deposit_nav_factor_bps: u32;
 }
 /**
- * Global market state for a single tradeable asset symbol.
+ * Represents a single trader's open leveraged position.
  */
-export interface MarketInfo {
+export interface Position {
     /**
-   * Cumulative borrow fee index (grows monotonically with time).
+   * Asset units at `PRICE_PRECISION`.
    */
-    acc_borrow_index: i128;
+    base_exposure: i128;
+    borrow_debt: i128;
     /**
-   * Cumulative funding rate index (signed; positive = longs pay shorts).
+   * Cash owned by an optional-order executor.
    */
-    acc_funding_index: i128;
+    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;
     /**
-   * Volume-weighted average entry price of all active long positions.
+   * Fixed gross capacity assigned when risk opens.
    */
-    global_long_avg_price: i128;
+    risk_units: i128;
     /**
-   * Volume-weighted average entry price of all active short positions.
+   * USD notional at `PRICE_PRECISION`.
    */
-    global_short_avg_price: i128;
+    size: i128;
     /**
-   * Timestamp of the last keeper index update.
+   * Trigger price for the optional stop-loss order; `0` = none.
    */
-    last_index_update: u64;
+    stop_loss: i128;
     /**
-   * Total notional size of all open long positions.
+   * 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.
    */
-    long_open_interest: i128;
+    stored_collateral: i128;
     /**
-   * Total notional size of all open short positions.
+   * Trigger price for the optional take-profit order; `0` = none.
    */
-    short_open_interest: i128;
+    take_profit: i128;
+}
+export interface LpRequest {
+    amount: i128;
+    execute_after: u64;
+    id: u64;
+    kind: LpRequestKind;
+    owner: string;
+    request_time: u64;
+    status: LpRequestStatus;
+}
+/**
+ * Which side currently pays funding (§8.1: the side with more base
+ * exposure). `None` when the market is balanced or empty.
+ */
+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;
+    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;
+    hard_cap_pnl_factor_bps: u32;
+    liquidation_reward_bps: u32;
+    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;
+    open_fee_high_bps: u32;
+    open_fee_low_bps: u32;
+    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;
     /**
@@ -308,6 +402,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.
  */
@@ -317,15 +418,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.
@@ -432,48 +572,6 @@ 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 pause 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.
@@ -504,81 +602,110 @@ export interface Client {
     /**
      * Construct and simulate a set_tp_sl 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_tp_sl: ({ trader, symbol, take_profit, stop_loss }: {
-        trader: string;
-        symbol: string;
+    set_tp_sl: ({ position_id, take_profit, stop_loss }: {
+        position_id: u64;
         take_profit: i128;
         stop_loss: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * Construct and simulate a set_vault 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.
-     * Wire the linked Vault. ADMIN-only and one-shot: reverts with
-     * `AlreadyInitialized` once the Vault is set, so the trusted Vault link
-     * is immutable after deploy. Called once by the deployer immediately
-     * after the Vault is deployed.
      */
-    set_vault: ({ caller, vault_address }: {
+    set_vault: ({ caller, vault }: {
         caller: string;
-        vault_address: string;
+        vault: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * Construct and simulate a get_market 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.
      */
-    get_market: ({ symbol }: {
-        symbol: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<MarketInfo>>;
+    get_market: ({ market }: {
+        market: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<Market>>;
     /**
      * Construct and simulate a get_position 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.
      */
-    get_position: ({ trader, symbol }: {
-        trader: string;
-        symbol: string;
+    get_position: ({ position_id }: {
+        position_id: u64;
     }, options?: MethodOptions) => Promise<AssembledTransaction<Position>>;
     /**
-     * Construct and simulate a realized_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 recapitalize 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.
      */
-    realized_pnl: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    recapitalize: ({ contributor, amount }: {
+        contributor: string;
+        amount: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * Construct and simulate a bump_position 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.
      */
-    bump_position: ({ user_address, symbol }: {
-        user_address: string;
-        symbol: string;
+    bump_position: ({ position_id }: {
+        position_id: u64;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * Construct and simulate a enable_market 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.
      */
-    enable_market: ({ caller, symbol }: {
+    enable_market: ({ caller, market }: {
         caller: string;
-        symbol: string;
+        market: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * Construct and simulate a execute_order 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.
      */
-    execute_order: ({ caller, trader, symbol }: {
+    execute_order: ({ caller, position_id }: {
         caller: string;
-        trader: string;
-        symbol: string;
+        position_id: u64;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a global_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.
+     */
+    global_config: (options?: MethodOptions) => Promise<AssembledTransaction<GlobalConfig>>;
+    /**
+     * Construct and simulate a non_lp_claims 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.
+     */
+    non_lp_claims: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    /**
+     * Construct and simulate a open_position 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.
+     */
+    open_position: ({ owner, market_symbol, is_long, size, collateral, execution_budget, take_profit, stop_loss, acceptable_price }: {
+        owner: string;
+        market_symbol: string;
+        is_long: boolean;
+        size: i128;
+        collateral: i128;
+        execution_budget: i128;
+        take_profit: i128;
+        stop_loss: i128;
+        acceptable_price: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<u64>>;
+    /**
+     * Construct and simulate a active_markets 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.
+     */
+    active_markets: (options?: MethodOptions) => Promise<AssembledTransaction<Array<string>>>;
     /**
      * 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.
      */
     cancel_upgrade: ({ caller }: {
         caller: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a claim_protocol 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_protocol: ({ caller, recipient, amount }: {
+        caller: string;
+        recipient: string;
+        amount: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * Construct and simulate a disable_market 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.
      */
-    disable_market: ({ caller, symbol }: {
+    disable_market: ({ caller, market }: {
         caller: string;
-        symbol: string;
+        market: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * Construct and simulate a update_indices 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_indices: ({ caller, symbol }: {
+    update_indices: ({ caller, market_symbol }: {
         caller: string;
-        symbol: string;
+        market_symbol: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * 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.
@@ -588,85 +715,122 @@ export interface Client {
         wasm_hash: Buffer;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a get_max_leverage 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 decrease_position 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.
      */
-    get_max_leverage: ({ symbol }: {
-        symbol: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    decrease_position: ({ position_id, size_removed, collateral_withdrawn, acceptable_price }: {
+        position_id: u64;
+        size_removed: i128;
+        collateral_withdrawn: i128;
+        acceptable_price: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a set_max_leverage 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 increase_position 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_max_leverage: ({ caller, symbol, max_leverage }: {
-        caller: string;
-        symbol: string;
-        max_leverage: i128;
+    increase_position: ({ position_id, size_added, collateral_added, acceptable_price }: {
+        position_id: u64;
+        size_added: i128;
+        collateral_added: i128;
+        acceptable_price: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a decrease_position 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_global_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.
      */
-    decrease_position: ({ trader, symbol, size_delta, acceptable_price }: {
-        trader: string;
-        symbol: string;
-        size_delta: i128;
-        acceptable_price: i128;
+    set_global_config: ({ caller, config }: {
+        caller: string;
+        config: GlobalConfig;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a increase_position 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_market_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.
      */
-    increase_position: ({ trader, symbol, size, collateral, is_long, take_profit, stop_loss, acceptable_price }: {
-        trader: string;
-        symbol: string;
-        size: i128;
-        collateral: i128;
-        is_long: boolean;
-        take_profit: i128;
-        stop_loss: i128;
-        acceptable_price: i128;
+    set_market_config: ({ caller, market_symbol, config }: {
+        caller: string;
+        market_symbol: string;
+        config: MarketConfig;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * Construct and simulate a is_market_disabled 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.
      */
-    is_market_disabled: ({ symbol }: {
-        symbol: string;
+    is_market_disabled: ({ market }: {
+        market: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<boolean>>;
     /**
      * Construct and simulate a liquidate_position 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.
      */
-    liquidate_position: ({ caller, trader, symbol }: {
+    liquidate_position: ({ caller, position_id }: {
         caller: string;
-        trader: string;
-        symbol: string;
+        position_id: u64;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * 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.
+     */
+    accounting_snapshot: ({ round, physical }: {
+        round: OracleRound;
+        physical: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<AccountingSnapshot>>;
     /**
      * Construct and simulate a deleverage_position 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.
      */
-    deleverage_position: ({ caller, trader, symbol }: {
+    deleverage_position: ({ caller, position_id }: {
         caller: string;
-        trader: string;
-        symbol: string;
+        position_id: u64;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a sync_unrealized_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 prepare_lp_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.
+     */
+    prepare_lp_snapshot: ({ caller, round, physical }: {
+        caller: string;
+        round: OracleRound;
+        physical: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<AccountingSnapshot>>;
+    /**
+     * Construct and simulate a refresh_borrow_rate 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.
      */
-    sync_unrealized_pnl: (options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    refresh_borrow_rate: ({ caller, physical }: {
+        caller: string;
+        physical: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a total_unrealized_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 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.
      */
-    total_unrealized_pnl: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    can_create_lp_request: ({ caller, physical }: {
+        caller: string;
+        physical: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<boolean>>;
+    /**
+     * Construct and simulate a fund_execution_budget 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.
+     */
+    fund_execution_budget: ({ position_id, amount }: {
+        position_id: u64;
+        amount: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a protocol_claimable_total 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.
+     */
+    protocol_claimable_total: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    /**
+     * Construct and simulate a risk_keeper_reserve_total 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.
+     */
+    risk_keeper_reserve_total: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    /**
+     * Construct and simulate a withdraw_execution_budget 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_execution_budget: ({ position_id, amount }: {
+        position_id: u64;
+        amount: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a market_unrealized_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 pending_receiver_funding_total 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.
      */
-    market_unrealized_pnl: ({ symbol }: {
-        symbol: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    pending_receiver_funding_total: (options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
 }
 export declare class Client extends ContractClient {
     readonly options: ContractClientOptions;
     static deploy<T = Client>(
     /** Constructor/Initialization Args for the contract's `__constructor` method */
-    { config_manager, oracle_router }: {
+    { config_manager, oracle_router, config }: {
         config_manager: string;
         oracle_router: string;
+        config: GlobalConfig;
     }, 
     /** Options for initializing a Client as well as for calling a method, with extras specific to deploying. */
     options: MethodOptions & Omit<ContractClientOptions, "contractId"> & {
@@ -685,25 +849,36 @@ export declare class Client extends ContractClient {
         upgrade: (json: string) => AssembledTransaction<null>;
         set_tp_sl: (json: string) => AssembledTransaction<null>;
         set_vault: (json: string) => AssembledTransaction<null>;
-        get_market: (json: string) => AssembledTransaction<MarketInfo>;
+        get_market: (json: string) => AssembledTransaction<Market>;
         get_position: (json: string) => AssembledTransaction<Position>;
-        realized_pnl: (json: string) => AssembledTransaction<bigint>;
+        recapitalize: (json: string) => AssembledTransaction<null>;
         bump_position: (json: string) => AssembledTransaction<null>;
         enable_market: (json: string) => AssembledTransaction<null>;
         execute_order: (json: string) => AssembledTransaction<null>;
+        global_config: (json: string) => AssembledTransaction<GlobalConfig>;
+        non_lp_claims: (json: string) => AssembledTransaction<bigint>;
+        open_position: (json: string) => AssembledTransaction<bigint>;
+        active_markets: (json: string) => AssembledTransaction<string[]>;
         cancel_upgrade: (json: string) => AssembledTransaction<null>;
+        claim_protocol: (json: string) => AssembledTransaction<null>;
         disable_market: (json: string) => AssembledTransaction<null>;
         update_indices: (json: string) => AssembledTransaction<null>;
         propose_upgrade: (json: string) => AssembledTransaction<null>;
-        get_max_leverage: (json: string) => AssembledTransaction<bigint>;
-        set_max_leverage: (json: string) => AssembledTransaction<null>;
         decrease_position: (json: string) => AssembledTransaction<null>;
         increase_position: (json: string) => AssembledTransaction<null>;
+        set_global_config: (json: string) => AssembledTransaction<null>;
+        set_market_config: (json: string) => AssembledTransaction<null>;
         is_market_disabled: (json: string) => AssembledTransaction<boolean>;
         liquidate_position: (json: string) => AssembledTransaction<null>;
+        accounting_snapshot: (json: string) => AssembledTransaction<AccountingSnapshot>;
         deleverage_position: (json: string) => AssembledTransaction<null>;
-        sync_unrealized_pnl: (json: string) => AssembledTransaction<null>;
-        total_unrealized_pnl: (json: string) => AssembledTransaction<bigint>;
-        market_unrealized_pnl: (json: string) => AssembledTransaction<bigint>;
+        prepare_lp_snapshot: (json: string) => AssembledTransaction<AccountingSnapshot>;
+        refresh_borrow_rate: (json: string) => AssembledTransaction<null>;
+        can_create_lp_request: (json: string) => AssembledTransaction<boolean>;
+        fund_execution_budget: (json: string) => AssembledTransaction<null>;
+        protocol_claimable_total: (json: string) => AssembledTransaction<bigint>;
+        risk_keeper_reserve_total: (json: string) => AssembledTransaction<bigint>;
+        withdraw_execution_budget: (json: string) => AssembledTransaction<null>;
+        pending_receiver_funding_total: (json: string) => AssembledTransaction<bigint>;
     };
 }