@win-trader/bindings 0.0.3 → 0.1.0

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

@@ -1,6 +1,6 @@
 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";
+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";
@@ -96,12 +96,48 @@ export declare const PositionManagerError: {
     25: {
         message: string;
     };
+    /**
+     * No entry order exists for the given id.
+     */
+    26: {
+        message: string;
+    };
+    /**
+     * `execute_entry_order` called before the trigger price was crossed.
+     */
+    27: {
+        message: string;
+    };
+    /**
+     * `register_referral_code` for a code that is already owned.
+     */
+    28: {
+        message: string;
+    };
+    /**
+     * A referral code failed the length/format bounds.
+     */
+    29: {
+        message: string;
+    };
+    /**
+     * `set_referrer` for a code no one has registered.
+     */
+    30: {
+        message: string;
+    };
+    /**
+     * A trader tried to set their own code as their referrer.
+     */
+    31: {
+        message: string;
+    };
 };
 /**
  * Which collection routed revenue through the split (§13).
  */
 export type FeeSource = {
-    tag: "Opening";
+    tag: "Closing";
     values: void;
 } | {
     tag: "Borrow";
@@ -123,9 +159,23 @@ export type CloseReason = {
     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 accrual state (borrow index + receiver-funding flow).
+ * the global borrow accrual. The receiver-funding liability total is fed
+ * per-market by `funding::accrue` (§8.3).
  */
 export interface Ledger {
     borrow_index: i128;
@@ -141,15 +191,17 @@ export interface Ledger {
     pending_receiver_funding_total: i128;
     position_collateral_total: i128;
     protocol_claimable_total: i128;
-    receiver_accrual_remainder: i128;
     /**
-   * Sum of every market's receiver flow, cash/second at `INDEX_PRECISION`.
+   * §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.
    */
-    receiver_flow_per_second: i128;
+    referral_claimable_total: i128;
     risk_keeper_reserve_total: i128;
     total_risk_units: i128;
 }
-export type Key = {
+export type StorageKey = {
     tag: "ConfigManager";
     values: void;
 } | {
@@ -188,10 +240,25 @@ export type Key = {
 } | {
     tag: "MarketDisabled";
     values: readonly [string];
+} | {
+    tag: "EntryOrder";
+    values: readonly [u64];
+} | {
+    tag: "NextEntryOrderId";
+    values: void;
+} | {
+    tag: "ReferralCode";
+    values: readonly [string];
+} | {
+    tag: "Referrer";
+    values: readonly [string];
+} | {
+    tag: "ReferralBalance";
+    values: readonly [string];
 };
 /**
  * Authoritative per-market state: the side aggregates, the funding indices,
- * the current funding flows, and the market configuration.
+ * 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
@@ -201,7 +268,7 @@ export type Key = {
 export interface Market {
     config: MarketConfig;
     /**
-   * `INDEX_PRECISION`-scaled bps/day payer rate for the current interval.
+   * `INDEX_PRECISION`-scaled bps/day payer rate as of the last refresh.
    */
     current_payer_rate: i128;
     current_payer_side: PayerSide;
@@ -213,12 +280,11 @@ export interface Market {
    */
     lp_backed_index_long: i128;
     lp_backed_index_short: i128;
+    lp_payer_remainder: i128;
     /**
-   * LP-allocated remainder of the payer flow, cash/second at
-   * `INDEX_PRECISION` (§8.1).
+   * Sub-stroop carry of the receiver-liability accrual (§8.3).
    */
-    lp_flow_per_second: i128;
-    lp_payer_remainder: i128;
+    pending_remainder: i128;
     /**
    * Cumulative payer fee per unit of dominant-side size whose collection
    * restores cash backing an already-accrued receiver claim (§8.2).
@@ -226,12 +292,6 @@ export interface Market {
     receiver_backed_index_long: i128;
     receiver_backed_index_short: i128;
     /**
-   * Receiver-allocated share of the payer flow, cash/second at
-   * `INDEX_PRECISION` (§8.1).
-   */
-    receiver_flow_per_second: i128;
-    receiver_flow_remainder: i128;
-    /**
    * Cumulative funding credit per unit of light-side size (§8.2).
    */
     receiver_index_long: i128;
@@ -239,6 +299,12 @@ export interface Market {
     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;
@@ -299,8 +365,9 @@ export interface LpRequest {
     status: LpRequestStatus;
 }
 /**
- * Which side currently pays funding (§8.1: the side with more base
- * exposure). `None` when the market is balanced or empty.
+ * 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";
@@ -325,6 +392,40 @@ 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 interface MarketSide {
     base_exposure: i128;
     risk_state: RiskState;
@@ -345,22 +446,68 @@ export interface OracleRound {
 }
 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).
+   */
+    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;
+    /**
+   * §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_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;
     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;
@@ -368,8 +515,6 @@ export interface MarketConfig {
     max_long_size_open_interest: i128;
     max_short_base_exposure: i128;
     max_short_size_open_interest: i128;
-    open_fee_high_bps: u32;
-    open_fee_low_bps: u32;
     recovery_pnl_factor_bps: u32;
     warning_pnl_factor_bps: u32;
 }
@@ -440,6 +585,23 @@ export type LpRequestStatus = {
     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 SettlementResult {
     /**
    * Shares minted for a deposit or assets paid for a withdrawal.
@@ -626,6 +788,12 @@ export interface Client {
     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.
      */
@@ -633,6 +801,13 @@ export interface Client {
         contributor: string;
         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.
+     */
+    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.
      */
@@ -693,6 +868,12 @@ 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.
      */
@@ -707,6 +888,12 @@ export interface Client {
         caller: string;
         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.
+     */
+    get_entry_order: ({ order_id }: {
+        order_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<EntryOrder>>;
     /**
      * 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.
      */
@@ -714,6 +901,12 @@ export interface Client {
         caller: string;
         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.
+     */
+    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.
      */
@@ -732,6 +925,14 @@ export interface Client {
         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.
+     */
+    place_entry_order: ({ owner, market, params }: {
+        owner: string;
+        market: string;
+        params: EntryOrderParams;
+    }, 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.
      */
@@ -747,6 +948,12 @@ export interface Client {
         market_symbol: string;
         config: MarketConfig;
     }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+    /**
+     * 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.
+     */
+    cancel_entry_order: ({ order_id }: {
+        order_id: u64;
+    }, 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.
      */
@@ -774,6 +981,13 @@ export interface Client {
         caller: string;
         position_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.
+     */
+    execute_entry_order: ({ caller, order_id }: {
+        caller: string;
+        order_id: u64;
+    }, options?: MethodOptions) => Promise<AssembledTransaction<null>>;
     /**
      * 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.
      */
@@ -782,6 +996,12 @@ export interface Client {
         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.
      */
@@ -803,10 +1023,21 @@ export interface Client {
         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;
+    }, 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.
      */
@@ -851,7 +1082,9 @@ export declare class Client extends ContractClient {
         set_vault: (json: string) => AssembledTransaction<null>;
         get_market: (json: string) => AssembledTransaction<Market>;
         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>;
         enable_market: (json: string) => AssembledTransaction<null>;
         execute_order: (json: string) => AssembledTransaction<null>;
@@ -861,22 +1094,31 @@ export declare class Client extends ContractClient {
         active_markets: (json: string) => AssembledTransaction<string[]>;
         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>;
         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>;
         is_market_disabled: (json: string) => AssembledTransaction<boolean>;
         liquidate_position: (json: string) => AssembledTransaction<null>;
         accounting_snapshot: (json: string) => AssembledTransaction<AccountingSnapshot>;
         deleverage_position: (json: string) => AssembledTransaction<null>;
+        execute_entry_order: (json: string) => AssembledTransaction<null>;
         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>;