@win-trader/bindings 0.1.0 → 0.3.0

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

@@ -11,201 +11,108 @@ export declare const PositionManagerError: {
     2: {
         message: string;
     };
-    3: {
+    10: {
         message: string;
     };
-    4: {
+    11: {
         message: string;
     };
-    5: {
+    12: {
         message: string;
     };
-    6: {
+    14: {
         message: string;
     };
-    7: {
+    16: {
         message: string;
     };
-    8: {
+    20: {
         message: string;
     };
-    9: {
+    21: {
         message: string;
     };
-    10: {
+    22: {
         message: string;
     };
-    11: {
+    23: {
         message: string;
     };
-    12: {
+    24: {
         message: string;
     };
-    13: {
+    25: {
         message: string;
     };
-    14: {
+    26: {
         message: string;
     };
-    15: {
+    27: {
         message: string;
     };
-    16: {
+    28: {
         message: string;
     };
-    17: {
+    29: {
         message: string;
     };
-    18: {
+    31: {
         message: string;
     };
-    19: {
+    32: {
         message: string;
     };
-    20: {
+    33: {
         message: string;
     };
-    /**
-     * The contract is operationally paused (distinct from a risk state).
-     */
-    21: {
+    40: {
         message: string;
     };
-    /**
-     * An accounting invariant broke — e.g. a negative pending fee, which
-     * means a decreasing index or corrupted debt baseline (§11.2).
-     */
-    22: {
+    41: {
         message: string;
     };
-    /**
-     * `upgrade` called with no pending proposal.
-     */
-    23: {
+    42: {
         message: string;
     };
-    /**
-     * `upgrade` called before the proposal's timelock eta.
-     */
-    24: {
-        message: string;
-    };
-    /**
-     * `upgrade` called with a hash that differs from the proposal.
-     */
-    25: {
+    46: {
         message: string;
     };
-    /**
-     * No entry order exists for the given id.
-     */
-    26: {
-        message: string;
-    };
-    /**
-     * `execute_entry_order` called before the trigger price was crossed.
-     */
-    27: {
+    47: {
         message: string;
     };
-    /**
-     * `register_referral_code` for a code that is already owned.
-     */
-    28: {
+    60: {
         message: string;
     };
-    /**
-     * A referral code failed the length/format bounds.
-     */
-    29: {
+    61: {
         message: string;
     };
-    /**
-     * `set_referrer` for a code no one has registered.
-     */
-    30: {
+    70: {
         message: string;
     };
-    /**
-     * A trader tried to set their own code as their referrer.
-     */
-    31: {
+    80: {
         message: string;
     };
 };
-/**
- * Which collection routed revenue through the split (§13).
- */
-export type FeeSource = {
-    tag: "Closing";
-    values: void;
-} | {
-    tag: "Borrow";
-    values: void;
-};
-/**
- * Why a position left the book.
- */
-export type CloseReason = {
-    tag: "Trader";
-    values: void;
-} | {
-    tag: "Liquidation";
-    values: void;
-} | {
-    tag: "Deleverage";
-    values: void;
-} | {
-    tag: "Order";
-    values: void;
-};
-/**
- * Why an entry order was removed before filling.
- */
-export type CancelReason = {
-    tag: "Owner";
-    values: void;
-} | {
-    tag: "Expired";
-    values: void;
-} | {
-    tag: "PullFailed";
-    values: void;
-};
-/**
- * §5.1 global state: the five non-LP claim totals, the risk counters, and
- * the global borrow accrual. The receiver-funding liability total is fed
- * per-market by `funding::accrue` (§8.3).
- */
 export interface Ledger {
+    action_escrow_total: i128;
     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;
-    /**
-   * §11.1 referral rewards accrued but not yet claimed — the aggregate
-   * backing the per-referrer `ReferralBalance` map (their sum is this
-   * total). Like every claim here it is a label on cash already in the
-   * vault, so NAV and the solvency checks net it out automatically.
-   */
-    referral_claimable_total: i128;
-    risk_keeper_reserve_total: i128;
+    restricted_market_side_count: u32;
+    state_version: u32;
     total_risk_units: i128;
+    unclaimed_payout_total: i128;
 }
 export type StorageKey = {
     tag: "ConfigManager";
     values: void;
 } | {
-    tag: "OracleRouter";
+    tag: "PriceFeed";
     values: void;
 } | {
     tag: "Vault";
@@ -213,9 +120,6 @@ export type StorageKey = {
 } | {
     tag: "GlobalConfig";
     values: void;
-} | {
-    tag: "Initialized";
-    values: void;
 } | {
     tag: "Paused";
     values: void;
@@ -241,119 +145,113 @@ export type StorageKey = {
     tag: "MarketDisabled";
     values: readonly [string];
 } | {
-    tag: "EntryOrder";
+    tag: "PendingAction";
     values: readonly [u64];
 } | {
-    tag: "NextEntryOrderId";
+    tag: "NextActionId";
     values: void;
 } | {
-    tag: "ReferralCode";
+    tag: "UnclaimedPayout";
     values: readonly [string];
 } | {
-    tag: "Referrer";
-    values: readonly [string];
+    tag: "Governor";
+    values: void;
 } | {
-    tag: "ReferralBalance";
-    values: readonly [string];
+    tag: "PriceFeedDecimals";
+    values: void;
+};
+export type FeeSource = {
+    tag: "Opening";
+    values: void;
+} | {
+    tag: "Closing";
+    values: void;
+} | {
+    tag: "Borrow";
+    values: void;
+};
+export type CloseReason = {
+    tag: "VoluntaryClose";
+    values: void;
+} | {
+    tag: "TakeProfit";
+    values: void;
+} | {
+    tag: "StopLoss";
+    values: void;
+} | {
+    tag: "Liquidation";
+    values: void;
+} | {
+    tag: "Adl";
+    values: void;
 };
 /**
- * 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).
+ * SEP-40 asset identifier. Markets are quoted as `Other(market symbol)`.
  */
+export type Asset = {
+    tag: "Stellar";
+    values: readonly [string];
+} | {
+    tag: "Other";
+    values: readonly [string];
+};
+export interface PriceData {
+    price: i128;
+    timestamp: u64;
+}
+export interface StampedPrice {
+    observed_at: u64;
+    price: i128;
+}
 export interface Market {
     config: MarketConfig;
-    /**
-   * `INDEX_PRECISION`-scaled bps/day payer rate as of the last refresh.
-   */
     current_payer_rate: i128;
     current_payer_side: PayerSide;
     last_funding_checkpoint: u64;
     long: MarketSide;
-    /**
-   * Cumulative payer fee per unit of dominant-side size that is LP
-   * revenue on collection (§8.2).
-   */
+    long_payer_remainders: RemainderGroup;
     lp_backed_index_long: i128;
     lp_backed_index_short: i128;
-    lp_payer_remainder: i128;
-    /**
-   * Sub-stroop carry of the receiver-liability accrual (§8.3).
-   */
-    pending_remainder: i128;
-    /**
-   * Cumulative payer fee per unit of dominant-side size whose collection
-   * restores cash backing an already-accrued receiver claim (§8.2).
-   */
+    pending_receiver_funding: i128;
     receiver_backed_index_long: i128;
     receiver_backed_index_short: i128;
-    /**
-   * Cumulative funding credit per unit of light-side size (§8.2).
-   */
     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.
-   */
+    short_payer_remainders: RemainderGroup;
     skew_ema: i128;
 }
+export type Trigger = {
+    tag: "None";
+    values: void;
+} | {
+    tag: "Attached";
+    values: readonly [TriggerInstruction];
+};
 export interface LpConfig {
-    lp_request_delay: u64;
+    lp_request_delay_seconds: u64;
     max_withdraw_utilization_bps: u32;
     min_deposit_nav_factor_bps: u32;
 }
-/**
- * Represents a single trader's open leveraged position.
- */
 export interface Position {
-    /**
-   * Asset units at `PRICE_PRECISION`.
-   */
     base_exposure: i128;
-    borrow_debt: i128;
-    /**
-   * 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;
+    borrow_index_snapshot: i128;
     id: u64;
     is_long: boolean;
-    last_increased_time: u64;
+    lp_payer_index_snapshot: i128;
     market: string;
+    opened_at: u64;
     owner: string;
-    /**
-   * Fixed gross capacity assigned when risk opens.
-   */
+    pending_mutation_action_id: Option<u64>;
+    receiver_index_snapshot: i128;
+    receiver_payer_index_snapshot: i128;
     risk_units: i128;
-    /**
-   * USD notional at `PRICE_PRECISION`.
-   */
     size: i128;
-    /**
-   * Trigger price for the optional stop-loss order; `0` = none.
-   */
-    stop_loss: i128;
-    /**
-   * 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.
-   */
+    stop_loss: Trigger;
     stored_collateral: i128;
-    /**
-   * Trigger price for the optional take-profit order; `0` = none.
-   */
-    take_profit: i128;
+    stored_minimum_borrow_fee: i128;
+    take_profit: Trigger;
 }
 export interface LpRequest {
     amount: i128;
@@ -362,13 +260,12 @@ export interface LpRequest {
     kind: LpRequestKind;
     owner: string;
     request_time: u64;
+    /**
+   * The resolve reward fixed when the request was made.
+   */
+    reward: i128;
     status: LpRequestStatus;
 }
-/**
- * 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 type PayerSide = {
     tag: "None";
     values: void;
@@ -392,122 +289,67 @@ export type RiskState = {
     tag: "HardCap";
     values: void;
 };
-/**
- * A pending limit/stop entry order: the frozen `open_position` arguments
- * plus a trigger condition and an expiry. Placing one only writes this
- * record — no funds move. A keeper's `execute_entry_order` pulls the
- * collateral via the owner's token allowance and opens the position
- * exactly as a market open would.
- */
-export interface EntryOrder {
-    acceptable_price: i128;
-    collateral: i128;
-    execution_budget: i128;
-    /**
-   * Ledger timestamp after which the order is dead and swept on the next
-   * touch (user-configurable max TTL).
-   */
-    expires_at: u64;
-    id: u64;
-    is_long: boolean;
-    market: string;
-    owner: string;
-    size: i128;
-    stop_loss: i128;
-    take_profit: i128;
-    /**
-   * True → fill when price ≥ trigger (stop/breakout entry); false → fill
-   * when price ≤ trigger (limit/dip entry). Inferred at placement from
-   * the trigger vs. the current price.
-   */
-    trigger_above: boolean;
-    /**
-   * The oracle price at which the order becomes fillable.
-   */
-    trigger_price: i128;
-}
+export type ActionKind = {
+    tag: "MarketOpen";
+    values: void;
+} | {
+    tag: "LimitOpen";
+    values: void;
+} | {
+    tag: "Decrease";
+    values: void;
+} | {
+    tag: "Close";
+    values: void;
+};
 export interface MarketSide {
     base_exposure: i128;
+    hard_cap_payout_factor: i128;
+    hard_cap_reference_pnl: i128;
     risk_state: RiskState;
     risk_units: i128;
     size_open_interest: i128;
     stored_collateral_total: i128;
 }
-export interface RoundPrice {
-    price: i128;
-    symbol: string;
+export interface OpenPayload {
+    acceptable_price: i128;
+    expires_at: u64;
+    is_long: boolean;
+    size: i128;
+    stop_loss: i128;
+    submitted_collateral: i128;
+    take_profit: i128;
 }
-export interface OracleRound {
-    id: u64;
-    previous_id: u64;
-    previous_timestamp: u64;
-    prices: Array<RoundPrice>;
-    timestamp: u64;
+export interface ClosePayload {
+    acceptable_price: i128;
+    position_id: u64;
 }
 export interface GlobalConfig {
     base_borrow_rate_bps_day: i128;
-    /**
-   * §9.2 borrow-curve exponent, bps: 20_000 = u² (legacy quadratic),
-   * 10_000 = linear. Bounded to ≤ 100_000 (e ≤ 10) by validation.
-   */
-    borrow_exponent_bps: u32;
-    /**
-   * §8.1 half-life of the funding skew EMA, seconds (global: one memory
-   * horizon for every market).
-   */
+    borrow_lp_revenue_share_bps: u32;
+    config_timelock_seconds: u64;
+    fee_lp_revenue_share_bps: u32;
     funding_half_life_seconds: u64;
-    hard_cap_factor_limit_bps: u32;
-    lp_revenue_share_bps: u32;
+    global_hard_cap_limit_bps: u32;
+    hard_cap_relatch_band_bps: u32;
+    keeper_rewards: KeeperRewards;
     max_active_markets: u32;
-    max_adl_reward: i128;
-    max_insolvent_touch_reward: i128;
+    max_market_order_lifetime: u64;
+    max_order_lifetime_seconds: u64;
+    max_price_age_seconds: u64;
     max_variable_borrow_bps_day: i128;
-    /**
-   * §11.2 minimum borrow charge per capitalization: an index delta at
-   * `INDEX_PRECISION` scale applied to the position's risk units
-   * (2e11 = 2 bps of notional at a 10% market risk factor). Zero
-   * disables the floor.
-   */
-    min_borrow_index_delta: i128;
+    min_borrow_fee_seconds: u64;
     min_collateral: i128;
     min_position_lifetime: u64;
-    /**
-   * §11.1 share of a closing fee routed to the trader's referrer, carved
-   * from the protocol slice (keeper and LP shares are untouched). `0`
-   * disables referral accrual globally — a kill switch. Validated so
-   * `lp + keeper + referral ≤ BPS`, keeping the protocol remainder ≥ 0.
-   */
-    referral_fee_share_bps: u32;
     risk_capacity_limit_bps: u32;
-    risk_keeper_revenue_share_bps: u32;
 }
 export interface MarketConfig {
     adl_pnl_factor_bps: u32;
-    adl_reward_bps: u32;
-    /**
-   * §11.1 closing-fee tier when the close worsens skew.
-   */
-    close_fee_high_bps: u32;
-    /**
-   * §11.1 closing-fee tier when the close improves or preserves skew.
-   */
-    close_fee_low_bps: u32;
+    close_pnl_fee_bps: u32;
+    close_size_fee_bps: u32;
     hard_cap_pnl_factor_bps: u32;
-    /**
-   * Margin required to open or add risk (§12.3). Divides max leverage:
-   * a position may not be created closer to liquidation than this.
-   */
     initial_margin_bps: u32;
-    /**
-   * §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.
-   */
     instant_weight_bps: u32;
-    liquidation_reward_bps: u32;
-    /**
-   * Margin below which the position is liquidatable (§12.3). Must not
-   * exceed `initial_margin_bps`; the gap is the entry buffer.
-   */
     maintenance_margin_bps: u32;
     market_risk_factor_bps: u32;
     max_funding_rate_bps_day: i128;
@@ -515,37 +357,88 @@ export interface MarketConfig {
     max_long_size_open_interest: i128;
     max_short_base_exposure: i128;
     max_short_size_open_interest: i128;
+    open_fee_bps: u32;
+    order_execution_delay_seconds: u64;
     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 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 `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
-   * `crate::constants::MIN_REQUIRED_SOURCES_FLOOR`, ceilinged at
-   * `crate::constants::MAX_ORACLE_SOURCES`.
-   */
-    min_required_sources: u32;
-    /**
-   * Maximum age of an external SEP-40 price feed before it is rejected
-   * as stale (in seconds).
-   */
-    staleness_threshold: u64;
+export type ActionOutcome = {
+    tag: "Executed";
+    values: void;
+} | {
+    tag: "Failed";
+    values: void;
+} | {
+    tag: "Cancelled";
+    values: void;
+} | {
+    tag: "Expired";
+    values: void;
+} | {
+    tag: "Superseded";
+    values: void;
+} | {
+    tag: "NotReady";
+    values: void;
+} | {
+    tag: "Pending";
+    values: void;
+} | {
+    tag: "RequiresLiquidation";
+    values: void;
+};
+export type ActionPayload = {
+    tag: "MarketOpen";
+    values: readonly [OpenPayload];
+} | {
+    tag: "LimitOpen";
+    values: readonly [OpenPayload, TriggerCondition];
+} | {
+    tag: "Decrease";
+    values: readonly [DecreasePayload];
+} | {
+    tag: "Close";
+    values: readonly [ClosePayload];
+};
+export type FailureReason = {
+    tag: "PriceBoundExceeded";
+    values: void;
+} | {
+    tag: "CapacityExceeded";
+    values: void;
+} | {
+    tag: "ExposureCapExceeded";
+    values: void;
+} | {
+    tag: "SideRestricted";
+    values: void;
+} | {
+    tag: "InsufficientCollateral";
+    values: void;
+} | {
+    tag: "UnpayableProfit";
+    values: void;
+} | {
+    tag: "PositionGone";
+    values: void;
+} | {
+    tag: "MarketPaused";
+    values: void;
+} | {
+    tag: "SizeTooSmall";
+    values: void;
+};
+export interface KeeperRewards {
+    adl: i128;
+    close: i128;
+    decrease: i128;
+    expiry: i128;
+    limit_order: i128;
+    liquidation: i128;
+    lp_resolve: i128;
+    open: i128;
+    sl: i128;
+    tp: i128;
 }
 export type LpRequestKind = {
     tag: "Deposit";
@@ -554,24 +447,35 @@ export type LpRequestKind = {
     tag: "Withdrawal";
     values: void;
 };
-/**
- * Data required during a WASM migration. Single definition for all contracts.
- */
 export interface MigrationData {
     version: u32;
 }
-/**
- * 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. Contracts store it at
- * the shared `pending_upgrade` Symbol key in their own instance storage (see
- * `crate::upgrade::pending_upgrade_key`). `upgrade` refuses to install
- * unless `pending.wasm_hash` matches the supplied hash and `now >= eta`.
- */
+export interface PendingAction {
+    action_id: u64;
+    commit_observed_at: u64;
+    created_at: u64;
+    escrowed_collateral: i128;
+    execute_after: u64;
+    kind: ActionKind;
+    market_id: string;
+    owner: string;
+    payload: ActionPayload;
+}
 export interface PendingUpgrade {
     eta: u64;
     wasm_hash: Buffer;
 }
+export interface RemainderGroup {
+    distribution_remainder: i128;
+    lp_payer_remainder: i128;
+    receiver_liability_remainder: i128;
+    receiver_payer_remainder: i128;
+}
+export interface DecreasePayload {
+    acceptable_price: i128;
+    position_id: u64;
+    size_removed: i128;
+}
 export type LpRequestStatus = {
     tag: "Pending";
     values: void;
@@ -581,32 +485,20 @@ export type LpRequestStatus = {
 } | {
     tag: "Failed";
     values: void;
-} | {
-    tag: "Expired";
-    values: void;
 };
-/**
- * The caller-supplied fields of a `place_entry_order` request, bundled so
- * the entry point stays within Soroban's parameter limit. `owner` and
- * `market` are passed alongside; `id` and `trigger_above` are derived at
- * placement.
- */
-export interface EntryOrderParams {
-    acceptable_price: i128;
-    collateral: i128;
-    execution_budget: i128;
-    expires_at: u64;
-    is_long: boolean;
-    size: i128;
-    stop_loss: i128;
-    take_profit: i128;
-    trigger_price: i128;
+export interface PendingFeesView {
+    borrow: i128;
+    funding_paid_to_lps: i128;
+    funding_paid_to_receivers: i128;
+    funding_received: i128;
+}
+export interface PendingPriceFeed {
+    effective_at: u64;
+    price_feed: string;
 }
 export interface SettlementResult {
-    /**
-   * Shares minted for a deposit or assets paid for a withdrawal.
-   */
     amount: i128;
+    reward: i128;
     status: SettlementStatus;
 }
 export type SettlementStatus = {
@@ -615,19 +507,49 @@ export type SettlementStatus = {
 } | {
     tag: "Failed";
     values: void;
+} | {
+    tag: "NotReady";
+    values: void;
 };
+export interface TriggerCondition {
+    trigger_above: boolean;
+    trigger_price: i128;
+}
 export interface AccountingSnapshot {
     cash_lp_equity: i128;
     cash_shortfall: i128;
+    deleveraging_side_count: u32;
     free_lp_capital: i128;
-    lp_blocked_side_count: u32;
+    min_equity_clear_of_adl: i128;
     non_lp_claims: i128;
     open_position_count: u64;
     physical_cash: i128;
     required_risk_backing: i128;
+    restricted_side_count: u32;
     total_risk_units: i128;
     vault_nav: i128;
 }
+export interface TriggerInstruction {
+    acceptable_price: i128;
+    commit_observed_at: u64;
+    committed_at: u64;
+    execute_after: u64;
+    trigger_price: i128;
+}
+export interface PendingGlobalConfig {
+    config: GlobalConfig;
+    effective_at: u64;
+}
+export interface PendingMarketConfig {
+    config: MarketConfig;
+    effective_at: u64;
+}
+export interface EventHeader {
+    actor: string;
+    event_version: u32;
+    ledger_timestamp: u64;
+    market: string;
+}
 export declare const UpgradeableError: {
     /**
      * When migration is attempted but not allowed due to upgrade state.
@@ -656,16 +578,6 @@ export declare const MerkleDistributorError: {
         message: string;
     };
 };
-/**
- * Storage keys for the data associated with `MerkleDistributor`
- */
-export type MerkleDistributorStorageKey = {
-    tag: "Root";
-    values: void;
-} | {
-    tag: "Claimed";
-    values: readonly [u32];
-};
 /**
  * Rounding direction for division operations
  */
@@ -693,37 +605,47 @@ export declare const SorobanFixedPointError: {
         message: string;
     };
 };
-export declare const CryptoError: {
+export declare const PausableError: {
     /**
-     * The merkle proof length is out of bounds.
+     * The operation failed because the contract is paused.
      */
-    1400: {
+    1000: {
         message: string;
     };
     /**
-     * The index of the leaf is out of bounds.
+     * The operation failed because the contract is not paused.
      */
-    1401: {
+    1001: {
         message: string;
     };
+};
+/**
+ * Storage keys for the data associated with `MerkleDistributor`
+ */
+export type MerkleDistributorStorageKey = {
+    tag: "Root";
+    values: void;
+} | {
+    tag: "Claimed";
+    values: readonly [u32];
+};
+export declare const CryptoError: {
     /**
-     * No data in hasher state.
+     * The merkle proof length is out of bounds.
      */
-    1402: {
+    1400: {
         message: string;
     };
-};
-export declare const PausableError: {
     /**
-     * The operation failed because the contract is paused.
+     * The index of the leaf is out of bounds.
      */
-    1000: {
+    1401: {
         message: string;
     };
     /**
-     * The operation failed because the contract is not paused.
+     * No data in hasher state.
      */
-    1001: {
+    1402: {
         message: string;
     };
 };
@@ -762,13 +684,13 @@ export interface Client {
         operator: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * 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.
+     * Construct and simulate a governor 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: ({ position_id, take_profit, stop_loss }: {
-        position_id: u64;
-        take_profit: i128;
-        stop_loss: i128;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    governor: (options?: MethodOptions) => Promise<AssembledTransaction<string>>;
+    /**
+     * Construct and simulate a is_paused 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_paused: (options?: MethodOptions) => Promise<AssembledTransaction<boolean>>;
     /**
      * 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.
      */
@@ -782,18 +704,36 @@ export interface Client {
     get_market: ({ market }: {
         market: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<Market>>;
+    /**
+     * Construct and simulate a price_feed 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.
+     */
+    price_feed: (options?: MethodOptions) => Promise<AssembledTransaction<string>>;
+    /**
+     * Construct and simulate a execute_adl 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_adl: ({ keeper, position_id }: {
+        keeper: string;
+        position_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<ActionOutcome>>;
+    /**
+     * Construct and simulate a claim_payout 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_payout: ({ owner }: {
+        owner: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    /**
+     * Construct and simulate a create_close 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.
+     */
+    create_close: ({ position_id, acceptable_price }: {
+        position_id: u64;
+        acceptable_price: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<u64>>;
     /**
      * 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: ({ position_id }: {
         position_id: u64;
     }, options?: MethodOptions) => Promise<AssembledTransaction<Position>>;
-    /**
-     * Construct and simulate a get_referrer 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_referrer: ({ trader }: {
-        trader: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<Option<string>>>;
     /**
      * 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.
      */
@@ -802,18 +742,12 @@ export interface Client {
         amount: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a set_referrer 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_close 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_referrer: ({ trader, code }: {
-        trader: string;
-        code: string;
-    }, 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: ({ position_id }: {
-        position_id: u64;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    settle_close: ({ keeper, action_id }: {
+        keeper: string;
+        action_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<ActionOutcome>>;
     /**
      * 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.
      */
@@ -821,13 +755,6 @@ export interface Client {
         caller: 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, position_id }: {
-        caller: 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.
      */
@@ -837,23 +764,24 @@ export interface Client {
      */
     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.
+     * Construct and simulate a set_stop_loss 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;
+    set_stop_loss: ({ position_id, trigger_price, acceptable_price }: {
+        position_id: u64;
+        trigger_price: i128;
         acceptable_price: i128;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<u64>>;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * 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 add_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.
+     */
+    add_collateral: ({ position_id, amount }: {
+        position_id: u64;
+        amount: i128;
+    }, 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.
      */
@@ -868,12 +796,6 @@ export interface Client {
         recipient: string;
         amount: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
-    /**
-     * Construct and simulate a claim_referral 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_referral: ({ referrer }: {
-        referrer: string;
-    }, 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.
      */
@@ -889,11 +811,19 @@ export interface Client {
         market_symbol: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a get_entry_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.
+     * Construct and simulate a clear_stop_loss 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_entry_order: ({ order_id }: {
-        order_id: u64;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<EntryOrder>>;
+    clear_stop_loss: ({ position_id }: {
+        position_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a create_decrease 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.
+     */
+    create_decrease: ({ position_id, size_removed, acceptable_price }: {
+        position_id: u64;
+        size_removed: i128;
+        acceptable_price: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<u64>>;
     /**
      * 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.
      */
@@ -902,57 +832,90 @@ export interface Client {
         wasm_hash: Buffer;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a referral_balance 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_take_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.
      */
-    referral_balance: ({ referrer }: {
-        referrer: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
-    /**
-     * 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.
-     */
-    decrease_position: ({ position_id, size_removed, collateral_withdrawn, acceptable_price }: {
+    set_take_profit: ({ position_id, trigger_price, acceptable_price }: {
         position_id: u64;
-        size_removed: i128;
-        collateral_withdrawn: i128;
+        trigger_price: i128;
         acceptable_price: i128;
     }, 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 settle_decrease 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.
+     */
+    settle_decrease: ({ keeper, action_id }: {
+        keeper: string;
+        action_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<ActionOutcome>>;
+    /**
+     * Construct and simulate a unclaimed_payout 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.
+     */
+    unclaimed_payout: ({ owner }: {
+        owner: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    /**
+     * Construct and simulate a cancel_limit_open 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_limit_open: ({ action_id }: {
+        action_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<i128>>;
+    /**
+     * Construct and simulate a clear_take_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.
      */
-    increase_position: ({ position_id, size_added, collateral_added, acceptable_price }: {
+    clear_take_profit: ({ position_id }: {
         position_id: u64;
-        size_added: i128;
-        collateral_added: i128;
-        acceptable_price: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a place_entry_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.
+     * Construct and simulate a create_limit_open 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.
      */
-    place_entry_order: ({ owner, market, params }: {
+    create_limit_open: ({ owner, market, request, trigger_price }: {
         owner: string;
         market: string;
-        params: EntryOrderParams;
+        request: OpenPayload;
+        trigger_price: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<u64>>;
     /**
-     * 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.
+     * Construct and simulate a deregister_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.
      */
-    set_global_config: ({ caller, config }: {
+    deregister_market: ({ caller, actor, market_symbol }: {
         caller: string;
-        config: GlobalConfig;
+        actor: string;
+        market_symbol: string;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * 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.
+     * Construct and simulate a execute_stop_loss 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_market_config: ({ caller, market_symbol, config }: {
-        caller: string;
-        market_symbol: string;
-        config: MarketConfig;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    execute_stop_loss: ({ keeper, position_id }: {
+        keeper: string;
+        position_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<ActionOutcome>>;
+    /**
+     * Construct and simulate a settle_limit_open 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.
+     */
+    settle_limit_open: ({ keeper, action_id }: {
+        keeper: string;
+        action_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<ActionOutcome>>;
+    /**
+     * Construct and simulate a create_market_open 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.
+     */
+    create_market_open: ({ owner, market, request }: {
+        owner: string;
+        market: string;
+        request: OpenPayload;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<u64>>;
     /**
-     * Construct and simulate a cancel_entry_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.
+     * Construct and simulate a get_pending_action 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_entry_order: ({ order_id }: {
-        order_id: u64;
+    get_pending_action: ({ action_id }: {
+        action_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<PendingAction>>;
+    /**
+     * Construct and simulate a install_price_feed 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.
+     */
+    install_price_feed: ({ caller, actor, price_feed }: {
+        caller: string;
+        actor: string;
+        price_feed: string;
     }, 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.
@@ -963,45 +926,44 @@ export interface Client {
     /**
      * 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, position_id }: {
-        caller: string;
+    liquidate_position: ({ keeper, position_id }: {
+        keeper: string;
         position_id: u64;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a settle_market_open 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.
+     */
+    settle_market_open: ({ keeper, action_id }: {
+        keeper: string;
+        action_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<ActionOutcome>>;
     /**
      * 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;
+    accounting_snapshot: ({ physical }: {
         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.
+     * Construct and simulate a clean_expired_entry 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, position_id }: {
-        caller: string;
-        position_id: u64;
+    clean_expired_entry: ({ keeper, action_id }: {
+        keeper: string;
+        action_id: u64;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * Construct and simulate a execute_entry_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.
+     * Construct and simulate a execute_take_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.
      */
-    execute_entry_order: ({ caller, order_id }: {
-        caller: string;
-        order_id: u64;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    execute_take_profit: ({ keeper, position_id }: {
+        keeper: string;
+        position_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<ActionOutcome>>;
     /**
      * 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 }: {
+    prepare_lp_snapshot: ({ caller, physical }: {
         caller: string;
-        round: OracleRound;
         physical: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<AccountingSnapshot>>;
-    /**
-     * Construct and simulate a referral_code_owner 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.
-     */
-    referral_code_owner: ({ code }: {
-        code: string;
-    }, options?: MethodOptions) => Promise<AssembledTransaction<Option<string>>>;
     /**
      * 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.
      */
@@ -1010,57 +972,31 @@ export interface Client {
         physical: i128;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
-     * 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.
+     * Construct and simulate a install_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.
      */
-    can_create_lp_request: ({ caller, physical }: {
+    install_global_config: ({ caller, actor, config }: {
         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 register_referral_code 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.
-     */
-    register_referral_code: ({ owner, code }: {
-        owner: string;
-        code: string;
+        actor: string;
+        config: GlobalConfig;
     }, 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 referral_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.
-     */
-    referral_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.
+     * Construct and simulate a install_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.
      */
-    withdraw_execution_budget: ({ position_id, amount }: {
-        position_id: u64;
-        amount: i128;
+    install_market_config: ({ caller, actor, market_symbol, config }: {
+        caller: string;
+        actor: string;
+        market_symbol: string;
+        config: MarketConfig;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
-    /**
-     * 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.
-     */
-    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 }: {
+    { config_manager, governor, price_feed, config }: {
         config_manager: string;
-        oracle_router: string;
+        governor: string;
+        price_feed: string;
         config: GlobalConfig;
     }, 
     /** Options for initializing a Client as well as for calling a method, with extras specific to deploying. */
@@ -1078,49 +1014,51 @@ export declare class Client extends ContractClient {
         migrate: (json: string) => AssembledTransaction<null>;
         unpause: (json: string) => AssembledTransaction<null>;
         upgrade: (json: string) => AssembledTransaction<null>;
-        set_tp_sl: (json: string) => AssembledTransaction<null>;
+        governor: (json: string) => AssembledTransaction<string>;
+        is_paused: (json: string) => AssembledTransaction<boolean>;
         set_vault: (json: string) => AssembledTransaction<null>;
         get_market: (json: string) => AssembledTransaction<Market>;
+        price_feed: (json: string) => AssembledTransaction<string>;
+        execute_adl: (json: string) => AssembledTransaction<ActionOutcome>;
+        claim_payout: (json: string) => AssembledTransaction<bigint>;
+        create_close: (json: string) => AssembledTransaction<bigint>;
         get_position: (json: string) => AssembledTransaction<Position>;
-        get_referrer: (json: string) => AssembledTransaction<Option<string>>;
         recapitalize: (json: string) => AssembledTransaction<null>;
-        set_referrer: (json: string) => AssembledTransaction<null>;
-        bump_position: (json: string) => AssembledTransaction<null>;
+        settle_close: (json: string) => AssembledTransaction<ActionOutcome>;
         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>;
+        set_stop_loss: (json: string) => AssembledTransaction<null>;
         active_markets: (json: string) => AssembledTransaction<string[]>;
+        add_collateral: (json: string) => AssembledTransaction<null>;
         cancel_upgrade: (json: string) => AssembledTransaction<null>;
         claim_protocol: (json: string) => AssembledTransaction<null>;
-        claim_referral: (json: string) => AssembledTransaction<null>;
         disable_market: (json: string) => AssembledTransaction<null>;
         update_indices: (json: string) => AssembledTransaction<null>;
-        get_entry_order: (json: string) => AssembledTransaction<EntryOrder>;
+        clear_stop_loss: (json: string) => AssembledTransaction<null>;
+        create_decrease: (json: string) => AssembledTransaction<bigint>;
         propose_upgrade: (json: string) => AssembledTransaction<null>;
-        referral_balance: (json: string) => AssembledTransaction<bigint>;
-        decrease_position: (json: string) => AssembledTransaction<null>;
-        increase_position: (json: string) => AssembledTransaction<null>;
-        place_entry_order: (json: string) => AssembledTransaction<bigint>;
-        set_global_config: (json: string) => AssembledTransaction<null>;
-        set_market_config: (json: string) => AssembledTransaction<null>;
-        cancel_entry_order: (json: string) => AssembledTransaction<null>;
+        set_take_profit: (json: string) => AssembledTransaction<null>;
+        settle_decrease: (json: string) => AssembledTransaction<ActionOutcome>;
+        unclaimed_payout: (json: string) => AssembledTransaction<bigint>;
+        cancel_limit_open: (json: string) => AssembledTransaction<bigint>;
+        clear_take_profit: (json: string) => AssembledTransaction<null>;
+        create_limit_open: (json: string) => AssembledTransaction<bigint>;
+        deregister_market: (json: string) => AssembledTransaction<null>;
+        execute_stop_loss: (json: string) => AssembledTransaction<ActionOutcome>;
+        settle_limit_open: (json: string) => AssembledTransaction<ActionOutcome>;
+        create_market_open: (json: string) => AssembledTransaction<bigint>;
+        get_pending_action: (json: string) => AssembledTransaction<PendingAction>;
+        install_price_feed: (json: string) => AssembledTransaction<null>;
         is_market_disabled: (json: string) => AssembledTransaction<boolean>;
         liquidate_position: (json: string) => AssembledTransaction<null>;
+        settle_market_open: (json: string) => AssembledTransaction<ActionOutcome>;
         accounting_snapshot: (json: string) => AssembledTransaction<AccountingSnapshot>;
-        deleverage_position: (json: string) => AssembledTransaction<null>;
-        execute_entry_order: (json: string) => AssembledTransaction<null>;
+        clean_expired_entry: (json: string) => AssembledTransaction<null>;
+        execute_take_profit: (json: string) => AssembledTransaction<ActionOutcome>;
         prepare_lp_snapshot: (json: string) => AssembledTransaction<AccountingSnapshot>;
-        referral_code_owner: (json: string) => AssembledTransaction<Option<string>>;
         refresh_borrow_rate: (json: string) => AssembledTransaction<null>;
-        can_create_lp_request: (json: string) => AssembledTransaction<boolean>;
-        fund_execution_budget: (json: string) => AssembledTransaction<null>;
-        register_referral_code: (json: string) => AssembledTransaction<null>;
-        protocol_claimable_total: (json: string) => AssembledTransaction<bigint>;
-        referral_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>;
+        install_global_config: (json: string) => AssembledTransaction<null>;
+        install_market_config: (json: string) => AssembledTransaction<null>;
     };
 }