@win-trader/bindings 0.0.2 → 0.0.4

package/request-router/dist/index.d.ts

@@ -0,0 +1,546 @@
+import { Buffer } from "buffer";
+import { AssembledTransaction, Client as ContractClient, ClientOptions as ContractClientOptions, MethodOptions } from "@stellar/stellar-sdk/contract";
+import type { u32, u64, i128 } from "@stellar/stellar-sdk/contract";
+export * from "@stellar/stellar-sdk";
+export * as contract from "@stellar/stellar-sdk/contract";
+export * as rpc from "@stellar/stellar-sdk/rpc";
+export declare const RequestRouterError: {
+    1: {
+        message: string;
+    };
+    2: {
+        message: string;
+    };
+    3: {
+        message: string;
+    };
+    4: {
+        message: string;
+    };
+    5: {
+        message: string;
+    };
+    6: {
+        message: string;
+    };
+    7: {
+        message: string;
+    };
+    /**
+     * `upgrade` called with no pending proposal.
+     */
+    8: {
+        message: string;
+    };
+    /**
+     * `upgrade` called before the proposal's timelock eta.
+     */
+    9: {
+        message: string;
+    };
+    /**
+     * `upgrade` called with a hash that differs from the proposal.
+     */
+    10: {
+        message: string;
+    };
+};
+/**
+ * Authoritative per-market state: the side aggregates, the funding indices,
+ * the funding EMA, and the market configuration.
+ *
+ * Soroban limits UDT field names to 30 characters, so where a doc glossary
+ * term is longer the field drops the redundant qualifier and its doc
+ * comment carries the full term (e.g. `receiver_backed_index_long` is the
+ * doc's `receiver_backed_payer_index` for the long side).
+ */
+export interface 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).
+   */
+    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).
+   */
+    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.
+   */
+    skew_ema: i128;
+}
+export interface LpConfig {
+    lp_request_delay: u64;
+    max_withdraw_utilization_bps: u32;
+    min_deposit_nav_factor_bps: u32;
+}
+/**
+ * Represents a single trader's open leveraged position.
+ */
+export interface Position {
+    /**
+   * 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;
+    id: u64;
+    is_long: boolean;
+    last_increased_time: u64;
+    market: string;
+    owner: string;
+    /**
+   * Fixed gross capacity assigned when risk opens.
+   */
+    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.
+   */
+    stored_collateral: i128;
+    /**
+   * Trigger price for the optional take-profit order; `0` = none.
+   */
+    take_profit: i128;
+}
+export interface LpRequest {
+    amount: i128;
+    execute_after: u64;
+    id: u64;
+    kind: LpRequestKind;
+    owner: string;
+    request_time: u64;
+    status: LpRequestStatus;
+}
+/**
+ * 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;
+} | {
+    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;
+    /**
+   * §8.1 half-life of the funding skew EMA, seconds (global: one memory
+   * horizon for every market).
+   */
+    funding_half_life_seconds: u64;
+    hard_cap_factor_limit_bps: u32;
+    lp_revenue_share_bps: u32;
+    max_active_markets: u32;
+    max_adl_reward: i128;
+    max_insolvent_touch_reward: i128;
+    max_variable_borrow_bps_day: i128;
+    min_collateral: i128;
+    min_position_lifetime: u64;
+    risk_capacity_limit_bps: u32;
+    risk_keeper_revenue_share_bps: u32;
+}
+export interface MarketConfig {
+    adl_pnl_factor_bps: u32;
+    adl_reward_bps: u32;
+    /**
+   * §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;
+    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;
+    max_long_base_exposure: i128;
+    max_long_size_open_interest: i128;
+    max_short_base_exposure: i128;
+    max_short_size_open_interest: i128;
+    recovery_pnl_factor_bps: u32;
+    warning_pnl_factor_bps: u32;
+}
+/**
+ * Global safety thresholds for price validation.
+ */
+export interface OracleConfig {
+    /**
+   * How long a cached aggregated price remains valid 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 LpRequestKind = {
+    tag: "Deposit";
+    values: void;
+} | {
+    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 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.
+     */
+    1100: {
+        message: string;
+    };
+};
+export declare const MerkleDistributorError: {
+    /**
+     * The merkle root is not set.
+     */
+    1300: {
+        message: string;
+    };
+    /**
+     * The provided index was already claimed.
+     */
+    1301: {
+        message: string;
+    };
+    /**
+     * The proof is invalid.
+     */
+    1302: {
+        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
+ */
+export type Rounding = {
+    tag: "Floor";
+    values: void;
+} | {
+    tag: "Ceil";
+    values: void;
+} | {
+    tag: "Truncate";
+    values: void;
+};
+export declare const SorobanFixedPointError: {
+    /**
+     * Arithmetic overflow occurred
+     */
+    1500: {
+        message: string;
+    };
+    /**
+     * Division by zero
+     */
+    1501: {
+        message: string;
+    };
+};
+export declare const CryptoError: {
+    /**
+     * The merkle proof length is out of bounds.
+     */
+    1400: {
+        message: string;
+    };
+    /**
+     * The index of the leaf is out of bounds.
+     */
+    1401: {
+        message: string;
+    };
+    /**
+     * No data in hasher state.
+     */
+    1402: {
+        message: string;
+    };
+};
+export declare const PausableError: {
+    /**
+     * The operation failed because the contract is paused.
+     */
+    1000: {
+        message: string;
+    };
+    /**
+     * The operation failed because the contract is not paused.
+     */
+    1001: {
+        message: string;
+    };
+};
+/**
+ * Storage key for the pausable state
+ */
+export type PausableStorageKey = {
+    tag: "Paused";
+    values: void;
+};
+export interface Client {
+    /**
+     * Construct and simulate a migrate transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    migrate: ({ data, operator }: {
+        data: MigrationData;
+        operator: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a 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.
+     */
+    upgrade: ({ new_wasm_hash, operator }: {
+        new_wasm_hash: Buffer;
+        operator: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a get_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.
+     */
+    get_request: ({ request_id }: {
+        request_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<LpRequest>>;
+    /**
+     * Construct and simulate a resolve_next 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.
+     */
+    resolve_next: ({ executor }: {
+        executor: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<SettlementResult>>;
+    /**
+     * 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 propose_upgrade transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    propose_upgrade: ({ caller, wasm_hash }: {
+        caller: string;
+        wasm_hash: Buffer;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a request_deposit transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    request_deposit: ({ owner, assets }: {
+        owner: string;
+        assets: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<u64>>;
+    /**
+     * Construct and simulate a request_withdrawal transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    request_withdrawal: ({ owner, shares }: {
+        owner: string;
+        shares: i128;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<u64>>;
+    /**
+     * Construct and simulate a next_request_to_resolve 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.
+     */
+    next_request_to_resolve: (options?: MethodOptions) => Promise<AssembledTransaction<u64>>;
+}
+export declare class Client extends ContractClient {
+    readonly options: ContractClientOptions;
+    static deploy<T = Client>(
+    /** Constructor/Initialization Args for the contract's `__constructor` method */
+    { asset_address, vault_address, oracle_router, config_manager_address }: {
+        asset_address: string;
+        vault_address: string;
+        oracle_router: string;
+        config_manager_address: string;
+    }, 
+    /** Options for initializing a Client as well as for calling a method, with extras specific to deploying. */
+    options: MethodOptions & Omit<ContractClientOptions, "contractId"> & {
+        /** The hash of the Wasm blob, which must already be installed on-chain. */
+        wasmHash: Buffer | string;
+        /** Salt used to generate the contract's ID. Passed through to {@link Operation.createCustomContract}. Default: random. */
+        salt?: Buffer | Uint8Array;
+        /** The format used to decode `wasmHash`, if it's provided as a string. */
+        format?: "hex" | "base64";
+    }): Promise<AssembledTransaction<T>>;
+    constructor(options: ContractClientOptions);
+    readonly fromJSON: {
+        migrate: (json: string) => AssembledTransaction<null>;
+        upgrade: (json: string) => AssembledTransaction<null>;
+        get_request: (json: string) => AssembledTransaction<LpRequest>;
+        resolve_next: (json: string) => AssembledTransaction<SettlementResult>;
+        cancel_upgrade: (json: string) => AssembledTransaction<null>;
+        propose_upgrade: (json: string) => AssembledTransaction<null>;
+        request_deposit: (json: string) => AssembledTransaction<bigint>;
+        request_withdrawal: (json: string) => AssembledTransaction<bigint>;
+        next_request_to_resolve: (json: string) => AssembledTransaction<bigint>;
+    };
+}