@win-trader/bindings 0.0.4 → 0.3.0

package/market-governor/dist/index.d.ts

@@ -0,0 +1,660 @@
+import { Buffer } from "buffer";
+import { AssembledTransaction, Client as ContractClient, ClientOptions as ContractClientOptions, MethodOptions } from "@stellar/stellar-sdk/contract";
+import type { u32, u64, i128, Option } 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 MarketGovernorError: {
+    500: {
+        message: string;
+    };
+    510: {
+        message: string;
+    };
+    520: {
+        message: string;
+    };
+    521: {
+        message: string;
+    };
+    530: {
+        message: string;
+    };
+    531: {
+        message: string;
+    };
+    540: {
+        message: string;
+    };
+    541: {
+        message: string;
+    };
+    542: {
+        message: string;
+    };
+};
+export type Key = {
+    tag: "ConfigManager";
+    values: void;
+} | {
+    tag: "PositionManager";
+    values: void;
+} | {
+    tag: "PendingGlobalConfig";
+    values: void;
+} | {
+    tag: "PendingMarketConfig";
+    values: readonly [string];
+} | {
+    tag: "PendingPriceFeed";
+    values: void;
+} | {
+    tag: "Version";
+    values: void;
+};
+/**
+ * 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;
+    current_payer_rate: i128;
+    current_payer_side: PayerSide;
+    last_funding_checkpoint: u64;
+    long: MarketSide;
+    long_payer_remainders: RemainderGroup;
+    lp_backed_index_long: i128;
+    lp_backed_index_short: i128;
+    pending_receiver_funding: i128;
+    receiver_backed_index_long: i128;
+    receiver_backed_index_short: i128;
+    receiver_index_long: i128;
+    receiver_index_short: i128;
+    short: MarketSide;
+    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_seconds: u64;
+    max_withdraw_utilization_bps: u32;
+    min_deposit_nav_factor_bps: u32;
+}
+export interface Position {
+    base_exposure: i128;
+    borrow_index_snapshot: i128;
+    id: u64;
+    is_long: boolean;
+    lp_payer_index_snapshot: i128;
+    market: string;
+    opened_at: u64;
+    owner: string;
+    pending_mutation_action_id: Option<u64>;
+    receiver_index_snapshot: i128;
+    receiver_payer_index_snapshot: i128;
+    risk_units: i128;
+    size: i128;
+    stop_loss: Trigger;
+    stored_collateral: i128;
+    stored_minimum_borrow_fee: i128;
+    take_profit: Trigger;
+}
+export interface LpRequest {
+    amount: i128;
+    execute_after: u64;
+    id: u64;
+    kind: LpRequestKind;
+    owner: string;
+    request_time: u64;
+    /**
+   * The resolve reward fixed when the request was made.
+   */
+    reward: i128;
+    status: LpRequestStatus;
+}
+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 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 OpenPayload {
+    acceptable_price: i128;
+    expires_at: u64;
+    is_long: boolean;
+    size: i128;
+    stop_loss: i128;
+    submitted_collateral: i128;
+    take_profit: i128;
+}
+export interface ClosePayload {
+    acceptable_price: i128;
+    position_id: u64;
+}
+export interface GlobalConfig {
+    base_borrow_rate_bps_day: i128;
+    borrow_lp_revenue_share_bps: u32;
+    config_timelock_seconds: u64;
+    fee_lp_revenue_share_bps: u32;
+    funding_half_life_seconds: u64;
+    global_hard_cap_limit_bps: u32;
+    hard_cap_relatch_band_bps: u32;
+    keeper_rewards: KeeperRewards;
+    max_active_markets: u32;
+    max_market_order_lifetime: u64;
+    max_order_lifetime_seconds: u64;
+    max_price_age_seconds: u64;
+    max_variable_borrow_bps_day: i128;
+    min_borrow_fee_seconds: u64;
+    min_collateral: i128;
+    min_position_lifetime: u64;
+    risk_capacity_limit_bps: u32;
+}
+export interface MarketConfig {
+    adl_pnl_factor_bps: u32;
+    close_pnl_fee_bps: u32;
+    close_size_fee_bps: u32;
+    hard_cap_pnl_factor_bps: u32;
+    initial_margin_bps: u32;
+    instant_weight_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_bps: u32;
+    order_execution_delay_seconds: u64;
+    recovery_pnl_factor_bps: u32;
+    warning_pnl_factor_bps: u32;
+}
+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";
+    values: void;
+} | {
+    tag: "Withdrawal";
+    values: void;
+};
+export interface MigrationData {
+    version: u32;
+}
+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;
+} | {
+    tag: "Settled";
+    values: void;
+} | {
+    tag: "Failed";
+    values: void;
+};
+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 {
+    amount: i128;
+    reward: i128;
+    status: SettlementStatus;
+}
+export type SettlementStatus = {
+    tag: "Settled";
+    values: void;
+} | {
+    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;
+    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.
+     */
+    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;
+    };
+};
+/**
+ * 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 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 keys for the data associated with `MerkleDistributor`
+ */
+export type MerkleDistributorStorageKey = {
+    tag: "Root";
+    values: void;
+} | {
+    tag: "Claimed";
+    values: readonly [u32];
+};
+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;
+    };
+};
+/**
+ * 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 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 apply_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.
+     */
+    apply_price_feed: ({ caller }: {
+        caller: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a position_manager 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.
+     */
+    position_manager: (options?: MethodOptions) => Promise<AssembledTransaction<string>>;
+    /**
+     * Construct and simulate a cancel_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.
+     */
+    cancel_price_feed: ({ caller }: {
+        caller: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * 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.
+     */
+    deregister_market: ({ caller, market_symbol }: {
+        caller: string;
+        market_symbol: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a propose_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.
+     */
+    propose_price_feed: ({ caller, price_feed }: {
+        caller: string;
+        price_feed: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a apply_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.
+     */
+    apply_global_config: ({ caller }: {
+        caller: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a apply_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.
+     */
+    apply_market_config: ({ caller, market_symbol }: {
+        caller: string;
+        market_symbol: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a cancel_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.
+     */
+    cancel_global_config: ({ caller }: {
+        caller: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a cancel_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.
+     */
+    cancel_market_config: ({ caller, market_symbol }: {
+        caller: string;
+        market_symbol: string;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a propose_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.
+     */
+    propose_global_config: ({ caller, config }: {
+        caller: string;
+        config: GlobalConfig;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a propose_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.
+     */
+    propose_market_config: ({ caller, market_symbol, config }: {
+        caller: string;
+        market_symbol: string;
+        config: MarketConfig;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+}
+export declare class Client extends ContractClient {
+    readonly options: ContractClientOptions;
+    static deploy<T = Client>(
+    /** Constructor/Initialization Args for the contract's `__constructor` method */
+    { config_manager, position_manager }: {
+        config_manager: string;
+        position_manager: 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>;
+        cancel_upgrade: (json: string) => AssembledTransaction<null>;
+        propose_upgrade: (json: string) => AssembledTransaction<null>;
+        apply_price_feed: (json: string) => AssembledTransaction<null>;
+        position_manager: (json: string) => AssembledTransaction<string>;
+        cancel_price_feed: (json: string) => AssembledTransaction<null>;
+        deregister_market: (json: string) => AssembledTransaction<null>;
+        propose_price_feed: (json: string) => AssembledTransaction<null>;
+        apply_global_config: (json: string) => AssembledTransaction<null>;
+        apply_market_config: (json: string) => AssembledTransaction<null>;
+        cancel_global_config: (json: string) => AssembledTransaction<null>;
+        cancel_market_config: (json: string) => AssembledTransaction<null>;
+        propose_global_config: (json: string) => AssembledTransaction<null>;
+        propose_market_config: (json: string) => AssembledTransaction<null>;
+    };
+}