@liberfi.io/ui-perpetuals 0.2.18 → 0.2.20

package/dist/index.d.mts

@@ -12,7 +12,7 @@ declare global {
         };
     }
 }
-declare const _default: "0.2.18";
+declare const _default: "0.2.20";
 
 /**
  * Trading pair symbol format
@@ -190,7 +190,15 @@ interface Trade {
 interface Account {
     /** Total account equity */
     totalEquity: number;
-    /** Available balance */
+    /**
+     * Funds the user can spend on a new isolated position or withdraw
+     * from the venue. For Hyperliquid this maps to the `withdrawable`
+     * field on `clearinghouseState`, which already accounts for cross
+     * margin reservations and the maintenance buffer — using it (rather
+     * than `accountValue - totalMarginUsed`) keeps the form's "Available
+     * Margin" figure aligned with what the venue actually permits when
+     * placing a trade or withdrawing.
+     */
     availableBalance: number;
     /** Total unrealized PnL */
     totalUnrealizedPnl: number;
@@ -199,6 +207,73 @@ interface Account {
     /** Account leverage */
     accountLeverage?: number;
 }
+/**
+ * A single coin's balance in the user's spot wallet.
+ *
+ * Mirrors Hyperliquid's `spotClearinghouseState.balances[]` after numeric
+ * parsing so consumers don't have to repeat the `parseFloat` ritual.
+ */
+interface SpotBalance {
+    /** Coin symbol, e.g. "USDC", "USOL". */
+    coin: string;
+    /** Total balance (free + held), in coin units. */
+    total: number;
+    /**
+     * Raw `total` string as returned by the venue. Preserves the venue's
+     * exact precision — JS `number` round-tripping can drop trailing
+     * zeros or significant digits that matter for display
+     * (e.g. `"0.00000005"` → `5e-8` → `"5e-8"`). Prefer this string when
+     * showing the balance to a user.
+     */
+    totalRaw?: string;
+    /** Held portion (locked in open orders), in coin units. */
+    hold: number;
+    /**
+     * Average notional value at acquisition, when the venue tracks it.
+     * Used by some UIs to compute realised PnL on spot positions.
+     */
+    entryNotional?: number;
+}
+/**
+ * Aggregated user state across the perpetuals + spot wallet, in the
+ * canonical SDK shape.
+ *
+ * This is the unit emitted by {@link IPerpetualsClient.subscribeAccountState}
+ * — venues that expose a single push channel for the user (Hyperliquid's
+ * `webData2`, Drift's `userAccount` pub/sub, etc.) parse it into this
+ * shape so React Query caches consumed by `usePositionsQuery`,
+ * `useOrdersQuery`, and `useAccountStateQuery` stay in sync without
+ * additional REST polls.
+ *
+ * The `raw` field carries the venue's untransformed payload for
+ * power-users / debugging; treat it as opaque.
+ */
+interface AccountState {
+    /** Open positions (filtered to non-zero quantity). */
+    positions: Position[];
+    /** Open limit / trigger orders. */
+    openOrders: Order[];
+    /** Spot wallet balances. */
+    spotBalances: SpotBalance[];
+    /**
+     * Total cross-margin account value in USDC (perp + isolated isolated
+     * positions combined). Mirrors `clearinghouseState.marginSummary.accountValue`.
+     */
+    totalEquity: number;
+    /**
+     * Funds available to open a new isolated position or withdraw —
+     * {@link Account.availableBalance}. Sourced from `withdrawable` on
+     * Hyperliquid; falls back to `accountValue - totalMarginUsed` when
+     * the venue omits an explicit field.
+     */
+    availableBalance: number;
+    /** Sum of unrealised PnL across open positions. */
+    totalUnrealizedPnl: number;
+    /** Venue-reported server time of the snapshot, if available (ms epoch). */
+    serverTime?: number;
+    /** Raw payload from the venue (untransformed) for debugging. */
+    raw?: any;
+}
 /**
  * Position information
  */
@@ -207,8 +282,16 @@ interface Position {
     symbol: string;
     /** Position direction (long or short) */
     side: OrderSide;
-    /** Position quantity (positive for long, negative for short) */
+    /** Position quantity (always positive; use `side` for direction). */
     quantity: number;
+    /**
+     * Raw absolute quantity string as returned by the venue (e.g.
+     * Hyperliquid's `position.szi` with the sign stripped). Preserves
+     * the venue's exact precision — the parsed `quantity` field may lose
+     * trailing zeros or significant digits when round-tripped through
+     * JS `number`. Prefer this string for display.
+     */
+    quantityRaw?: string;
     /** Entry price */
     entryPrice: number;
     /** Current mark price */
@@ -227,6 +310,22 @@ interface Position {
     notionalValue: number;
     /** Timestamp (milliseconds) */
     timestamp?: number;
+    /**
+     * Active take-profit trigger price (USD) for this position, derived
+     * from the venue's open trigger orders. Only the trigger that would
+     * actually close this position is reported (i.e. matching the
+     * closing-side: SELL for a Long position, BUY for a Short).
+     *
+     * `undefined` when no matching trigger exists. Picked from the most
+     * recent matching `Take Profit Market` reduceOnly trigger.
+     */
+    takeProfitPrice?: number;
+    /**
+     * Active stop-loss trigger price (USD) for this position. Same
+     * semantics as {@link takeProfitPrice}, but for the most recent
+     * matching `Stop Market` reduceOnly trigger.
+     */
+    stopLossPrice?: number;
 }
 /**
  * Order information
@@ -260,6 +359,30 @@ interface Order {
     leverage?: number;
     /** Reduce only flag (optional) */
     reduceOnly?: boolean;
+    /**
+     * Whether this order is a trigger order (stop-market, take-profit-market,
+     * etc.). Mirrors Hyperliquid's `isTrigger`. When `true`, {@link triggerPx}
+     * and {@link triggerType} are populated.
+     */
+    isTrigger?: boolean;
+    /**
+     * Activation price (USD) for trigger orders. Reads as `triggerPx` from
+     * Hyperliquid's `frontendOpenOrders` response. Undefined for non-trigger
+     * orders.
+     */
+    triggerPx?: number;
+    /**
+     * Discriminator for trigger orders:
+     *   - `"tp"` — Take Profit Market / Take Profit Limit
+     *   - `"sl"` — Stop Market / Stop Limit
+     * Undefined when {@link isTrigger} is `false` / unknown.
+     */
+    triggerType?: "tp" | "sl";
+    /**
+     * Human-readable trigger condition as supplied by the venue, e.g.
+     * "Price above 81470" / "Price below 73761". Mostly useful for tooltips.
+     */
+    triggerCondition?: string;
 }
 /**
  * User trade history
@@ -313,6 +436,58 @@ interface PlaceOrderParams {
     /** User address (required for authentication) */
     userAddress?: string;
 }
+/**
+ * Enriched place-order callback payload.
+ *
+ * Carried by the {@link PlaceOrderFormScriptProps.onPlaceOrder} hook
+ * exit when the host app wants to bypass the SDK's internal
+ * {@link IPerpetualsClient.placeOrder} mutation and submit the order
+ * itself (typical for Hyperliquid direct-relay setups where the host
+ * holds the wallet keys).
+ *
+ * The form script pre-computes everything that requires venue-specific
+ * context (live mark price, `szDecimals`) so the host hook can stay a
+ * pure venue adapter:
+ *
+ *   - `size` is in coin units, derived as `amount × leverage / refPrice`,
+ *     so the hook only needs to apply the venue's rounding rules.
+ *   - `refPrice` is the live mark price snapshot used for the size
+ *     calculation; the hook reuses it as the basis for any slippage
+ *     guard (e.g. Hyperliquid's `FrontendMarket` orders need a worst-
+ *     case price within ~8% of the mark).
+ *   - `szDecimals` mirrors the venue's per-asset display precision so
+ *     the hook can format the size string without re-querying meta.
+ */
+interface PlaceOrderRequest {
+    /** Trading pair symbol, e.g. "BTC-USDC". */
+    symbol: string;
+    /** Order direction: long (buy) or short (sell). */
+    side: OrderSide;
+    /** Order type: market or limit. */
+    orderType: OrderType;
+    /** Order amount in USDC margin (matches the form input). */
+    amount: number;
+    /** Limit order price (only set for limit orders). */
+    price?: number;
+    /** Leverage multiplier (defaults to 1x). */
+    leverage: number;
+    /** Reduce-only flag (for closing positions). */
+    reduceOnly?: boolean;
+    /** Take profit trigger price. */
+    takeProfitPrice?: number;
+    /** Stop loss trigger price. */
+    stopLossPrice?: number;
+    /** Optional client order ID for caller-side tracking. */
+    clientOrderId?: string;
+    /** User wallet address (always populated when the form gates on auth). */
+    userAddress: string;
+    /** Coin-unit position size, pre-computed as `amount × leverage / refPrice`. */
+    size: number;
+    /** Live mark price snapshot used for `size` (and any slippage math). */
+    refPrice: number;
+    /** Venue-published display precision for the asset's size field. */
+    szDecimals: number;
+}
 /**
  * Cancel order parameters
  */
@@ -335,6 +510,67 @@ interface GetPositionsParams {
     /** Optional: filter by specific trading pair */
     symbol?: string;
 }
+/**
+ * Per-asset leverage configuration for a user, independent of whether
+ * an open position exists.
+ *
+ * Hyperliquid stores leverage settings at the `(user, coin)` granularity
+ * server-side. After the user calls `updateLeverage`, the value
+ * persists even when no position is open, so the form can recall the
+ * latest configured leverage on every page load instead of falling back
+ * to a hardcoded default.
+ */
+interface ActiveAssetLeverage {
+    /** Configured leverage multiplier (e.g. 20 for 20x). */
+    value: number;
+    /** Whether the position uses isolated or cross-margin. */
+    type: "isolated" | "cross";
+}
+/**
+ * Parameters for {@link IPerpetualsClient.getActiveAssetLeverage}.
+ */
+interface GetActiveAssetLeverageParams {
+    /** User wallet address. */
+    userAddress: string;
+    /** Trading pair symbol (e.g. "BTC-USDC"). */
+    symbol: string;
+}
+/**
+ * Static, per-asset metadata that the venue publishes about a perp
+ * symbol. Independent of the user (no wallet involved) and rarely
+ * changes — listing additions / leverage caps update infrequently.
+ *
+ * Used by the Place Order form to:
+ *  - format the token quantity badge with the correct number of decimal
+ *    places (BTC → 5, ETH → 4, SOL → 2, DOGE → 0). Hyperliquid hands
+ *    this out as `szDecimals` on `meta.universe[i]`; we surface it under
+ *    the same name so SDK consumers don't need to translate.
+ *  - read the venue's max leverage cap (40x for BTC, 25x for ETH, ...)
+ *    when scaling the leverage modal.
+ *
+ * Implementations that don't expose this data may return `null`; the
+ * caller is expected to fall back to its own heuristics.
+ */
+interface AssetMeta {
+    /**
+     * Number of decimal places the venue uses to express the **size**
+     * (token quantity, not USD notional) of this asset. A value of `5`
+     * means the smallest tradeable unit is `1e-5` of the token.
+     *
+     * Mirrors Hyperliquid's `szDecimals` exactly. Other venues may store
+     * the same information as `stepSize = 10 ^ -szDecimals`.
+     */
+    szDecimals: number;
+    /** Maximum leverage the venue allows for this asset (e.g. 40 for BTC). */
+    maxLeverage?: number;
+}
+/**
+ * Parameters for {@link IPerpetualsClient.getAssetMeta}.
+ */
+interface GetAssetMetaParams {
+    /** Trading pair symbol (e.g. "BTC-USDC"). */
+    symbol: string;
+}
 /**
  * Get open orders parameters
  */
@@ -377,6 +613,12 @@ interface PlaceOrderResult {
     status: OrderStatus;
     /** Order creation timestamp (milliseconds) */
     timestamp: number;
+    /**
+     * Average fill price, only populated when the order filled
+     * synchronously (market orders typically). Undefined for resting
+     * limit orders.
+     */
+    avgPrice?: number;
     /** Raw response data (for debugging, optional) */
     raw?: any;
 }
@@ -405,7 +647,7 @@ interface GetPositionsResult {
     positions: Position[];
     /** Total account equity (optional) */
     totalEquity?: number;
-    /** Available balance (optional) */
+    /** See {@link Account.availableBalance} — the venue's "withdrawable" figure. */
     availableBalance?: number;
     /** Total unrealized PnL (optional) */
     totalUnrealizedPnl?: number;
@@ -538,6 +780,32 @@ interface IPerpetualsClient {
      * @throws {Error} Network error or API error
      */
     getTrades(params?: GetTradesParams): Promise<GetTradesResult>;
+    /**
+     * Read the user's per-asset leverage configuration even when no
+     * position is open. Used by the Place Order form to seed the leverage
+     * slider from the venue's source of truth instead of a local default.
+     *
+     * Implementations that don't expose this data may return `null`; the
+     * caller is expected to fall back to its own default (e.g. 20x).
+     *
+     * @param params User address + trading pair symbol.
+     * @returns The configured leverage, or `null` when unavailable.
+     * @throws {Error} Network error or API error
+     */
+    getActiveAssetLeverage(params: GetActiveAssetLeverageParams): Promise<ActiveAssetLeverage | null>;
+    /**
+     * Read the venue's static metadata for a perp symbol — `szDecimals`
+     * (token-size precision) and `maxLeverage`. Used by the Place Order
+     * form to format the converted token quantity with the right number
+     * of decimal places per asset. Hyperliquid implements this against
+     * the `meta` info endpoint; venues without an equivalent may return
+     * `null`.
+     *
+     * @param params Trading pair symbol.
+     * @returns The asset's metadata, or `null` when unavailable.
+     * @throws {Error} Network error or API error
+     */
+    getAssetMeta(params: GetAssetMetaParams): Promise<AssetMeta | null>;
     /**
      * Connect to WebSocket server
      * @throws {Error} Connection failed
@@ -576,6 +844,26 @@ interface IPerpetualsClient {
      * @returns Subscription ID (for unsubscribing)
      */
     subscribeUserData(type: "orders" | "positions" | "fills", userAddress: string, callback: (data: any) => void): string;
+    /**
+     * Subscribe to the user's full account state via a single push
+     * channel (Hyperliquid `webData2`, Drift `userAccount`, etc.).
+     *
+     * Replaces a fan of REST polls — `clearinghouseState`,
+     * `spotClearinghouseState`, `openOrders` — with one subscription that
+     * the venue pushes incrementally on each fill / margin movement.
+     *
+     * Optional because not every venue exposes a unified user channel;
+     * implementations that don't may omit it. Consumers that depend on
+     * it (e.g. `useAccountStateSubscription`) must guard with
+     * `typeof client.subscribeAccountState === "function"`.
+     *
+     * @param userAddress Wallet address whose state to track.
+     * @param callback Receives the canonical {@link AccountState} on every
+     *   push. The SDK transforms the venue's raw payload before invoking
+     *   the callback so consumers only see SDK types.
+     * @returns Subscription ID for {@link unsubscribe}.
+     */
+    subscribeAccountState?(userAddress: string, callback: (state: AccountState) => void): string;
     /**
      * Unsubscribe
      * @param subscriptionId Subscription ID
@@ -650,6 +938,23 @@ declare class HyperliquidPerpetualsClient implements IPerpetualsClient {
      * on {@link LiberFiPerpetualsClient}.
      */
     private wsRefCount;
+    /**
+     * Process-local memoisation of the venue's asset universe (the
+     * `meta` info endpoint). Hyperliquid's universe rarely changes (new
+     * listings, leverage cap adjustments) so the SDK caches the parsed
+     * map for {@link ASSET_META_TTL_MS} per client instance to spare
+     * downstream consumers a network round-trip on every render.
+     *
+     * The TanStack Query layer adds another tier of caching above this
+     * (per `staleTime`), but caching here too keeps the contract correct
+     * for non-React callers that talk to the client directly.
+     */
+    private assetMetaCache;
+    /**
+     * In-flight `getAssetMeta` request, deduped so concurrent callers
+     * collapse onto a single network request when the cache misses.
+     */
+    private assetMetaPending;
     /**
      * 构造 Hyperliquid 客户端
      *
@@ -771,6 +1076,35 @@ declare class HyperliquidPerpetualsClient implements IPerpetualsClient {
      * @throws {Error} 缺少必需参数
      */
     getPositions(params?: GetPositionsParams): Promise<GetPositionsResult>;
+    /**
+     * Read the user's per-asset leverage configuration via the
+     * `activeAssetData` info endpoint. This works whether or not an open
+     * position exists for the asset, so the UI can render the latest
+     * configured leverage on a fresh page load.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-users-active-asset-data
+     */
+    getActiveAssetLeverage(params: GetActiveAssetLeverageParams): Promise<ActiveAssetLeverage | null>;
+    /**
+     * Fetch the venue's static metadata for `params.symbol` (currently
+     * `szDecimals` and `maxLeverage`). Backed by Hyperliquid's `meta`
+     * info endpoint, with an in-memory cache keyed on this client
+     * instance and TTL'd at {@link ASSET_META_TTL_MS}.
+     *
+     * Returns `null` when the symbol isn't part of the universe so
+     * downstream consumers can branch on absence without try/catching
+     * lookups for unsupported coins.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals#retrieve-perpetuals-metadata
+     */
+    getAssetMeta(params: GetAssetMetaParams): Promise<AssetMeta | null>;
+    /**
+     * Internal: ensure {@link assetMetaCache} is populated and fresh,
+     * then return the resolved coin → {@link AssetMeta} map. Concurrent
+     * cache misses share a single in-flight request via
+     * {@link assetMetaPending}.
+     */
+    private fetchAssetUniverse;
     /**
      * 获取用户挂单信息
      *
@@ -844,6 +1178,29 @@ declare class HyperliquidPerpetualsClient implements IPerpetualsClient {
      * @returns Subscription ID (for unsubscribing)
      */
     subscribeUserData(type: "orders" | "positions" | "fills", userAddress: string, callback: (data: any) => void): string;
+    /**
+     * Subscribe to the user's full account state via Hyperliquid's
+     * `webData2` channel. Each push carries a complete snapshot of:
+     *
+     *  - `clearinghouseState` — perp positions, margin summaries, and the
+     *    `withdrawable` figure used as "Available Margin".
+     *  - `spotState` — spot wallet balances (USDC, USOL, etc.).
+     *  - `openOrders` — the user's resting limit orders.
+     *
+     * Replaces three separate REST polls (`clearinghouseState`,
+     * `spotClearinghouseState`, `openOrders`) with a single push channel.
+     * Hooks like `useAccountStateSubscription` use this to seed React
+     * Query caches in real time so consumers see fills / margin moves
+     * the moment Hyperliquid pushes them.
+     *
+     * @param userAddress Wallet address whose state to track.
+     * @param callback Receives the canonical {@link AccountState} on
+     *   every push (raw payload available on `state.raw`).
+     * @returns Subscription ID for {@link unsubscribe}.
+     *
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions#webdata2
+     */
+    subscribeAccountState(userAddress: string, callback: (state: AccountState) => void): string;
     /**
      * Unsubscribe from a data stream
      *
@@ -1197,6 +1554,27 @@ declare class LiberFiPerpetualsClient implements IPerpetualsClient {
     getPositions(params?: GetPositionsParams): Promise<GetPositionsResult>;
     getOpenOrders(params?: GetOpenOrdersParams): Promise<GetOpenOrdersResult>;
     getTrades(params?: GetTradesParams): Promise<GetTradesResult>;
+    /**
+     * The LiberFi backend does not yet expose an `activeAssetData`
+     * equivalent. Returning `null` lets the form fall back to its own
+     * default leverage without raising — the perpetuals-server can grow
+     * this endpoint later and we'll plug it in here.
+     */
+    getActiveAssetLeverage(_params: GetActiveAssetLeverageParams): Promise<ActiveAssetLeverage | null>;
+    /**
+     * The LiberFi backend doesn't currently surface per-asset
+     * `szDecimals` / `maxLeverage` over a dedicated endpoint. We could
+     * derive `szDecimals` from {@link getSupportedCoins}'s `stepSize`
+     * once perpetuals-server starts populating it (`szDecimals =
+     * -log10(stepSize)`), but until then the form falls back to its
+     * adaptive heuristic when this returns `null`.
+     *
+     * TODO(perpetuals-server): expose `GET /v1/markets/:symbol/meta`
+     * (or extend the existing `/v1/coins` payload with `szDecimals` +
+     * `maxLeverage`) so this can resolve without a side trip to the
+     * upstream venue.
+     */
+    getAssetMeta(_params: GetAssetMetaParams): Promise<AssetMeta | null>;
     placeOrder(params: PlaceOrderParams): Promise<PlaceOrderResult>;
     cancelOrder(params: CancelOrderParams): Promise<CancelOrderResult>;
     connectWebSocket(): Promise<void>;
@@ -1634,6 +2012,72 @@ declare function tradesQueryKey(params: Omit<UseTradesQueryParams, "enabled">):
 declare function fetchTrades(client: IPerpetualsClient, params: GetTradesParams): Promise<GetTradesResult>;
 declare function useTradesQuery(params: UseTradesQueryParams, options?: Omit<UseQueryOptions<GetTradesResult, Error, GetTradesResult, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<GetTradesResult, Error>;
 
+interface UseActiveAssetLeverageQueryParams {
+    /** User wallet address. Query stays disabled until this is set. */
+    userAddress?: string;
+    /** Trading pair symbol (e.g. "BTC-USDC"). */
+    symbol: string;
+    /** Optional override; useful for tests. */
+    enabled?: boolean;
+}
+/**
+ * React Query key for the user's per-asset leverage configuration.
+ *
+ * Accepts an undefined `userAddress` (e.g. before the wallet connects)
+ * because consumers often want a stable key shape to feed
+ * `invalidateQueries` after the address resolves. The fallback empty
+ * string just makes the key deterministic; the query itself stays
+ * disabled until both fields are populated.
+ */
+declare function activeAssetLeverageQueryKey(params: {
+    userAddress?: GetActiveAssetLeverageParams["userAddress"];
+    symbol?: GetActiveAssetLeverageParams["symbol"];
+}): string[];
+declare function fetchActiveAssetLeverage(client: IPerpetualsClient, params: GetActiveAssetLeverageParams): Promise<ActiveAssetLeverage | null>;
+/**
+ * Read the user's configured leverage for `symbol` from the venue,
+ * independent of whether an open position exists. Backed by Hyperliquid's
+ * `activeAssetData` info endpoint when the active provider is
+ * Hyperliquid; the LiberFi adapter currently returns `null` (the form
+ * will fall back to its default).
+ *
+ * The returned data updates every 30s while the form is mounted, and
+ * the consumer is expected to invalidate the query after a successful
+ * `updateLeverage` so the UI reflects the new value immediately.
+ */
+declare function useActiveAssetLeverageQuery(params: UseActiveAssetLeverageQueryParams, options?: Omit<UseQueryOptions<ActiveAssetLeverage | null, Error, ActiveAssetLeverage | null, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<ActiveAssetLeverage | null, Error>;
+
+interface UseAssetMetaQueryParams {
+    /** Trading pair symbol (e.g. "BTC-USDC"). */
+    symbol?: string;
+    /** Optional override; useful for tests. */
+    enabled?: boolean;
+}
+/**
+ * React Query key for the per-asset metadata query.
+ *
+ * Tolerates an undefined `symbol` so consumers can build a stable key
+ * shape before the symbol resolves; the query itself stays disabled
+ * until both `enabled` and `symbol` are truthy.
+ */
+declare function assetMetaQueryKey(params: {
+    symbol?: GetAssetMetaParams["symbol"];
+}): string[];
+declare function fetchAssetMeta(client: IPerpetualsClient, params: GetAssetMetaParams): Promise<AssetMeta | null>;
+/**
+ * Read the venue's static metadata (`szDecimals`, `maxLeverage`) for
+ * `symbol`. Backed by Hyperliquid's `meta` info endpoint when the
+ * active provider is Hyperliquid; the LiberFi adapter currently
+ * returns `null` (the form falls back to an adaptive precision rule).
+ *
+ * The data is process-stable for minutes at a time (Hyperliquid only
+ * updates the universe on listing additions / leverage cap changes),
+ * so we set a generous `staleTime` of 60 seconds. Consumers don't
+ * need to invalidate this on user actions — the data is keyed on
+ * symbol alone.
+ */
+declare function useAssetMetaQuery(params: UseAssetMetaQueryParams, options?: Omit<UseQueryOptions<AssetMeta | null, Error, AssetMeta | null, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<AssetMeta | null, Error>;
+
 type UseCreateOrderMutationParams = PlaceOrderParams;
 declare function createOrder(client: IPerpetualsClient, params: UseCreateOrderMutationParams): Promise<PlaceOrderResult>;
 declare function useCreateOrderMutation(options?: Omit<UseMutationOptions<PlaceOrderResult, Error, UseCreateOrderMutationParams>, "mutationFn">): _tanstack_react_query.UseMutationResult<PlaceOrderResult, Error, PlaceOrderParams, unknown>;
@@ -1698,6 +2142,96 @@ interface UseUserDataSubscriptionResult<T> {
 }
 declare function useUserDataSubscription<T = UserDataType extends "orders" ? Order : UserDataType extends "positions" ? Position : TradeHistory>(params: UseUserDataSubscriptionParams): UseUserDataSubscriptionResult<T>;
 
+interface UseAccountStateSubscriptionParams {
+    /**
+     * Wallet address whose state should be tracked. When undefined or
+     * empty the subscription is disabled, so it's safe to mount this
+     * hook before authentication completes.
+     */
+    userAddress?: string;
+    /** Disable the subscription entirely (e.g. for SSR / paused tabs). */
+    enabled?: boolean;
+}
+interface UseAccountStateSubscriptionResult {
+    /** Latest account state pushed by the venue. */
+    data: AccountState | null;
+    /** WebSocket connection status (true after the first successful connect). */
+    isConnected: boolean;
+    /** Last connection / subscription error, or null on success. */
+    error: Error | null;
+}
+/**
+ * Subscribe to the venue's unified user-state push channel
+ * (Hyperliquid's `webData2`) and fan the snapshots out across the
+ * SDK's React Query caches.
+ *
+ * Why this hook exists:
+ *
+ * The naive way to keep `usePositionsQuery`, `useOrdersQuery`, and a
+ * spot-balance reader live is to crank their `refetchInterval` down to
+ * a few seconds, hammering Hyperliquid's `clearinghouseState` /
+ * `spotClearinghouseState` / `openOrders` endpoints. That trades
+ * bandwidth for latency and still misses fills between polls. Axiom
+ * uses a single `webData2` subscription instead, and so should we.
+ *
+ * On every push this hook writes the parsed snapshot to:
+ *  - {@link accountStateQueryKey} — the canonical cache slot read by
+ *    {@link useAccountStateQuery} (consumed by wallet buttons,
+ *    deposit modals, etc.).
+ *  - {@link positionsQueryKey} — keeps `usePositionsQuery` in sync so
+ *    the place-order form's Available Margin / Current Position
+ *    reflects the venue without a second REST round-trip.
+ *  - {@link ordersQueryKey} — keeps `useOrdersQuery` in sync for the
+ *    open-orders table.
+ *
+ * Mount this hook **once** at the top of the perpetuals shell (a
+ * shared layout, an app-wide provider, …). Children read through
+ * existing hooks; nothing else needs to know that the data arrives
+ * via WebSocket.
+ *
+ * Falls back gracefully when the venue does not support a unified
+ * channel: if `client.subscribeAccountState` is missing the hook is a
+ * no-op, and the existing REST polling continues to drive the caches.
+ */
+declare function useAccountStateSubscription(params: UseAccountStateSubscriptionParams): UseAccountStateSubscriptionResult;
+
+interface UseAccountStateQueryParams {
+    /** User wallet address. The query is disabled when missing. */
+    userAddress?: string;
+    enabled?: boolean;
+}
+/**
+ * Stable React Query key for the user's full account state. Shared
+ * between {@link useAccountStateQuery} (read) and
+ * `useAccountStateSubscription` (write) so a webData2 push and a
+ * consumer reader land on the same cache slot.
+ */
+declare function accountStateQueryKey(params: Pick<UseAccountStateQueryParams, "userAddress">): string[];
+/**
+ * Read the user's full account state (positions, open orders, spot
+ * balances, available margin) from the React Query cache.
+ *
+ * This hook does NOT itself fetch data over HTTP — the cache is fed
+ * exclusively by `useAccountStateSubscription`, which subscribes to
+ * Hyperliquid's `webData2` push channel and writes every snapshot
+ * into the same cache slot. Mount the subscription somewhere high in
+ * the tree (e.g. an app-shell layout) and this hook becomes a cheap
+ * subscriber that re-renders whenever a fresh push lands.
+ *
+ * Returning `null` means no push has been received yet — wait for the
+ * subscription to flush its initial snapshot rather than firing a
+ * REST fallback, since `webData2` always primes the stream on
+ * connect.
+ *
+ * @example
+ * function WalletButton() {
+ *   const { address } = useWallet();
+ *   const { data: account } = useAccountStateQuery({ userAddress: address });
+ *   return <span>{account?.availableBalance.toFixed(2)} USDC</span>;
+ * }
+ */
+declare function useAccountStateQuery(params: UseAccountStateQueryParams, options?: Omit<UseQueryOptions<AccountState | null, Error, AccountState | null, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<AccountState | null, Error>;
+
 /**
  * Hook to access the deposit client from `PerpetualsProvider`.
  *
@@ -2223,13 +2757,42 @@ type PlaceOrderFormWidgetProps = {
      * control.
      */
     onAddFunds?: () => void;
+    /**
+     * Optional callback fired when the user confirms a new leverage value
+     * in the leverage modal. The host app should sign + relay the
+     * `updateLeverage` action to Hyperliquid and surface a toast. While
+     * the returned promise is pending the modal's button shows a spinner;
+     * if it rejects, the modal stays open so the user can retry.
+     */
+    onUpdateLeverage?: (leverage: number) => Promise<void>;
+    /**
+     * Optional callback that takes over order submission. When provided,
+     * the widget bypasses its internal `client.placeOrder` mutation and
+     * forwards the enriched {@link PlaceOrderRequest} (live mark price +
+     * coin-unit size + per-asset `szDecimals`) so the host can sign and
+     * relay the action against the venue directly. While the returned
+     * promise is pending, the submit button shows a spinner; on
+     * rejection, `onError` fires.
+     *
+     * Mirrors the `onUpdateLeverage` pattern. When omitted, the SDK
+     * falls back to `IPerpetualsClient.placeOrder` (used by the LiberFi
+     * adapter, which holds the signing keys server-side).
+     */
+    onPlaceOrder?: (request: PlaceOrderRequest) => Promise<PlaceOrderResult>;
     className?: string;
 };
-declare function PlaceOrderFormWidget({ symbol, userAddress, maxLeverage, onSuccess, onError, onAddFunds, className, }: PlaceOrderFormWidgetProps): react_jsx_runtime.JSX.Element;
+declare function PlaceOrderFormWidget({ symbol, userAddress, maxLeverage, onSuccess, onError, onAddFunds, onUpdateLeverage, onPlaceOrder, className, }: PlaceOrderFormWidgetProps): react_jsx_runtime.JSX.Element;
 
 type PlaceOrderFormData = {
     price?: number;
-    amount: number;
+    /**
+     * USDC margin the user is committing to this trade. Optional so the
+     * form can render an empty input on first mount (placeholder
+     * `0.0 USDC`) instead of pre-filling `0`. The notional position size
+     * a venue cares about is derived as `amount * leverage`; the token
+     * quantity is `(amount * leverage) / currentPrice`.
+     */
+    amount?: number;
     leverage: number;
     takeProfitPrice?: number;
     takeProfitPercent?: number;
@@ -2242,6 +2805,32 @@ type UsePlaceOrderFormScriptParams = {
     maxLeverage?: number;
     onSuccess?: () => void;
     onError?: (error: Error) => void;
+    /**
+     * Optional callback fired when the user confirms a new leverage value
+     * in the leverage modal. The host app is expected to sign + relay the
+     * `updateLeverage` action to Hyperliquid (and surface a toast). The
+     * widget tracks the returned promise to drive the modal's button
+     * loading state — when the promise rejects, the modal stays open so
+     * the user can retry.
+     *
+     * When omitted, the modal falls back to a local-only update: the
+     * leverage slider commits to the form state without contacting the
+     * exchange.
+     */
+    onUpdateLeverage?: (leverage: number) => Promise<void>;
+    /**
+     * Optional callback that takes over order submission. When provided,
+     * the form bypasses the SDK's internal `client.placeOrder` mutation
+     * and forwards the enriched {@link PlaceOrderRequest} (live mark
+     * price + coin-unit size + per-asset `szDecimals`) so the host can
+     * sign + relay the action against the venue directly.
+     *
+     * Mirrors the {@link onUpdateLeverage} pattern; when omitted, the
+     * widget falls back to {@link useCreateOrderMutation} → the
+     * configured `IPerpetualsClient.placeOrder` (used by the LiberFi
+     * adapter, which holds the signing keys server-side).
+     */
+    onPlaceOrder?: (request: PlaceOrderRequest) => Promise<PlaceOrderResult>;
 };
 type UsePlaceOrderFormScriptResult = {
     form: ReturnType<typeof useForm<PlaceOrderFormData>>;
@@ -2257,16 +2846,64 @@ type UsePlaceOrderFormScriptResult = {
     liquidationPrice?: number;
     availableMargin: number;
     accountValue: number;
-    currentPosition?: number;
+    /**
+     * Position the user currently holds in the symbol shown by the form.
+     * Shaped to match the Axiom layout — `Long 0.00045 BTC (1.19 USDC)` —
+     * by exposing the venue-precision size, base symbol, and isolated
+     * margin used. `undefined` when there is no position for the symbol.
+     */
+    currentPosition?: {
+        side: OrderSide;
+        /** Absolute quantity from the venue (preserves precision when available). */
+        quantity: number;
+        /** Raw absolute quantity string from the venue, e.g. `"0.00045"`. */
+        quantityRaw?: string;
+        /** Isolated margin used by this position, in USDC. */
+        margin: number;
+        /** Base asset symbol, e.g. `"BTC"` for `"BTC-USDC"`. */
+        base: string;
+    };
     maxLeverage: number;
     /**
-     * Leverage currently configured on Hyperliquid for the active symbol's
-     * position. `undefined` when the user has no open position for the
-     * symbol (and therefore no per-asset leverage to read).
+     * Leverage currently configured on the venue for `symbol`, sourced
+     * from the `activeAssetData` info endpoint. Defined whether or not
+     * an open position exists; `undefined` only while the query is
+     * loading or when the venue does not expose this data (e.g. the
+     * LiberFi adapter today).
      */
     currentLeverage?: number;
+    /**
+     * `true` once the venue has returned a leverage value for `symbol`.
+     * The UI uses this to render a skeleton in place of the form's
+     * default until the real configuration arrives, avoiding a
+     * `20 → real value` flash on refresh.
+     */
+    isLeverageReady: boolean;
+    /**
+     * `true` when the user has at least one resting order on the venue
+     * for `symbol`. Surfaced to the leverage modal so it can warn
+     * "open order(s) will be affected by leverage change" — Hyperliquid
+     * recomputes margin on resting orders whenever the per-asset
+     * leverage changes, so the user should know before confirming.
+     *
+     * Sourced from the same `webData2` snapshot that drives positions
+     * and balances, so it stays in sync with the rest of the form
+     * without an extra REST round-trip.
+     */
+    hasOpenOrdersForSymbol: boolean;
+    /**
+     * Number of decimal places the venue uses to express the size
+     * (token quantity) for `symbol`. Sourced from the `meta` info
+     * endpoint; `undefined` while the query is in flight or when the
+     * venue does not expose it (e.g. the LiberFi adapter today). The UI
+     * uses this to format the converted token quantity badge with
+     * per-asset precision (BTC → 5, SOL → 2, DOGE → 0).
+     */
+    szDecimals?: number;
+    /** Forwarded callback (see {@link UsePlaceOrderFormScriptParams.onUpdateLeverage}). */
+    onUpdateLeverage?: (leverage: number) => Promise<void>;
 };
-declare function usePlaceOrderFormScript({ symbol, userAddress, maxLeverage: maxLeverageProp, onSuccess, onError, }: UsePlaceOrderFormScriptParams): UsePlaceOrderFormScriptResult;
+declare function usePlaceOrderFormScript({ symbol, userAddress, maxLeverage: maxLeverageProp, onSuccess, onError, onUpdateLeverage, onPlaceOrder, }: UsePlaceOrderFormScriptParams): UsePlaceOrderFormScriptResult;
 
 type PlaceOrderFormUIProps = {
     methods: UseFormReturn<PlaceOrderFormData>;
@@ -2283,8 +2920,45 @@ type PlaceOrderFormUIProps = {
     liquidationPrice?: number;
     availableMargin: number;
     accountValue: number;
-    currentPosition?: number;
+    /**
+     * Position the user currently holds in the symbol shown by the form.
+     * Shaped to match the Axiom layout — `Long 0.00045 BTC (1.19 USDC)`.
+     * `undefined` when there is no open position for `symbol`, in which
+     * case the row falls back to `--`.
+     */
+    currentPosition?: {
+        side: "long" | "short";
+        quantity: number;
+        quantityRaw?: string;
+        margin: number;
+        base: string;
+    };
     maxLeverage: number;
+    /**
+     * Whether the leverage value can be displayed. When `false` the
+     * leverage button shows a skeleton instead of the form's default,
+     * to avoid flashing `20x` before the venue's per-asset configuration
+     * is loaded. Defaults to `true` for backwards compatibility.
+     */
+    isLeverageReady?: boolean;
+    /**
+     * Whether the user has at least one resting order on `symbol`.
+     * Drives the leverage modal's "Open order(s) will be affected"
+     * advisory — Hyperliquid recomputes resting-order margin when the
+     * per-asset leverage changes, so the user should see this before
+     * confirming. Purely informational; does NOT block the update.
+     */
+    hasOpenOrdersForSymbol?: boolean;
+    /**
+     * Number of decimal places the venue uses for the size of `symbol`
+     * (e.g. BTC → 5, ETH → 4, SOL → 2, DOGE → 0). Sourced from
+     * Hyperliquid's `meta` info endpoint via `useAssetMetaQuery`. The
+     * UI uses this to format the converted token quantity badge with
+     * per-asset precision. When omitted the form falls back to an
+     * adaptive heuristic that keeps the badge readable across coins
+     * with very different price magnitudes.
+     */
+    szDecimals?: number;
     /**
      * Optional callback fired when the user clicks the "Add More Funds"
      * button (typically wired by the host app to open a deposit dialog).
@@ -2292,8 +2966,17 @@ type PlaceOrderFormUIProps = {
      * don't support a deposit flow don't render a dead control.
      */
     onAddFunds?: () => void;
+    /**
+     * Optional callback fired when the user confirms a new leverage in
+     * the leverage modal. The widget tracks the returned promise to
+     * drive the modal's button loading state — when it rejects the
+     * modal stays open so the caller can retry. When omitted, the
+     * leverage value is committed to the form locally without contacting
+     * the exchange.
+     */
+    onUpdateLeverage?: (leverage: number) => Promise<void>;
 };
-declare function PlaceOrderFormUI({ methods, side, orderType, onSideChange, onOrderTypeChange, onSubmit, isSubmitting, symbol, currentPrice, estimatedFee, liquidationPrice, availableMargin, accountValue, currentPosition, maxLeverage: _maxLeverage, onAddFunds, }: PlaceOrderFormUIProps): react_jsx_runtime.JSX.Element;
+declare function PlaceOrderFormUI({ methods, side, orderType, onSideChange, onOrderTypeChange, onSubmit, isSubmitting, symbol, currentPrice, estimatedFee, liquidationPrice, availableMargin, accountValue, currentPosition, maxLeverage, isLeverageReady, hasOpenOrdersForSymbol, szDecimals, onAddFunds, onUpdateLeverage, }: PlaceOrderFormUIProps): react_jsx_runtime.JSX.Element;
 
 type PositionsWidgetProps = {
     userAddress?: string;
@@ -2302,17 +2985,47 @@ type PositionsWidgetProps = {
     onCloseError?: (error: Error) => void;
     className?: string;
 };
+/**
+ * Positions table widget. Owns no business logic — wires the
+ * `usePositionsScript` data layer (sort + close-mutation) to the
+ * presentational `PositionsUI`. The host page just provides the
+ * connected wallet address and (optionally) a symbol filter; the
+ * widget handles everything else (sort state, realtime updates,
+ * close-position toasts in the consumer's mutation lifecycle).
+ */
 declare function PositionsWidget({ userAddress, symbol, onCloseSuccess, onCloseError, className, }: PositionsWidgetProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * Stable identifier for a sortable column. Mirrors Axiom's set: 7 of the
+ * 9 columns are sortable; `tpsl` and `close` are interaction-only.
+ *
+ * Kept as a discriminated string union (rather than an enum) so it
+ * survives a tsup build to a stable runtime string — consumers that
+ * persist the active sort key to local-storage / URL params are
+ * insulated from enum-numbering churn.
+ */
+type PositionSortKey = "asset" | "position" | "value" | "entry" | "mark" | "liq" | "marginPnl";
+type SortDirection = "asc" | "desc";
 type PositionsUIProps = {
+    /** Already-sorted positions. The script layer owns sort state. */
     positions: Position[];
+    /** Currently active sort column, or `null` when no sort applied. */
+    sortKey: PositionSortKey | null;
+    sortDir: SortDirection;
+    onSort: (key: PositionSortKey) => void;
     onClosePosition: (position: Position) => void;
     isClosing: boolean;
+    /** Optional className for the outer container. */
+    className?: string;
 };
-declare function PositionsUI({ positions, onClosePosition, isClosing, }: PositionsUIProps): react_jsx_runtime.JSX.Element;
+declare function PositionsUI({ positions, sortKey, sortDir, onSort, onClosePosition, isClosing, className, }: PositionsUIProps): react_jsx_runtime.JSX.Element;
 /** Loading skeleton for positions panel */
 declare function PositionsSkeleton(): react_jsx_runtime.JSX.Element;
-/** Empty state when there are no open positions */
+/**
+ * Standalone empty-state component. The main `PositionsUI` renders its
+ * own empty layout (header + centred message) so this export exists for
+ * consumers that wire their own empty state outside the widget.
+ */
 declare function PositionsEmpty(): react_jsx_runtime.JSX.Element;
 
 type UsePositionsScriptParams = {
@@ -2322,12 +3035,30 @@ type UsePositionsScriptParams = {
     onCloseError?: (error: Error) => void;
 };
 type UsePositionsScriptResult = {
+    /** Positions already sorted by the active `sortKey` / `sortDir`. */
     positions: Position[];
     isLoading: boolean;
     error: Error | null;
+    /** Active sort column (`null` only when the consumer overrides it). */
+    sortKey: PositionSortKey | null;
+    sortDir: SortDirection;
+    /** Toggle the sort column / direction. Mirrors Axiom's 2-state cycle:
+     * first click on a new column → asc, subsequent clicks toggle asc ↔
+     * desc. There is no "no-sort" state. */
+    onSort: (key: PositionSortKey) => void;
     handleClosePosition: (position: Position) => Promise<void>;
     isClosing: boolean;
 };
+/**
+ * Container hook for the positions table. Responsibilities:
+ *   - read positions via `usePositionsQuery` (which the consumer's
+ *     `useAccountStateSubscription` keeps live via webData2 cache
+ *     write-through, so we do **not** subscribe to `userEvents` here —
+ *     doing so would clobber the TP/SL + mark-price enrichment that
+ *     the client adds on the webData2 path).
+ *   - own sort state (default `marginPnl ↓`, mirroring Axiom).
+ *   - expose a `handleClosePosition` shim over `useCreateOrderMutation`.
+ */
 declare function usePositionsScript({ userAddress, symbol, onCloseSuccess, onCloseError, }: UsePositionsScriptParams): UsePositionsScriptResult;
 
 type OpenOrdersWidgetProps = {
@@ -2643,4 +3374,4 @@ interface HyperliquidInitWidgetProps extends Pick<UseHyperliquidSetupOptions, "a
 }
 declare function HyperliquidInitWidget({ adapter, userAddress, steps, autoLoad, onComplete, onError, onDismiss, className, }: HyperliquidInitWidgetProps): react_jsx_runtime.JSX.Element;
 
-export { type Account, type ApproveBuilderFeeParams, type CancelOrderParams, type CancelOrderResult, type Coin, CoinInfoNotFoundUI, CoinInfoSkeletonsUI, CoinInfoUI, type CoinInfoUIProps, CoinInfoWidget, type CoinInfoWidgetProps, DEFAULT_ORDER_BOOK_PRECISION_OPTIONS, type DepositBreakdown, DepositConfirmUI, type DepositConfirmUIProps, type DepositErrorInfo, type DepositEvent, DepositFlowWidget, type DepositFlowWidgetProps, DepositFormUI, type DepositFormUIProps, type DepositPhase, type DepositQuoteRequest, type DepositQuoteResponse, type DepositSource, type DepositState, type DepositStatus, type DepositStatusResponse, type DepositStatusTransition, DepositStatusUI, type DepositStatusUIProps, type DepositSubmitRequest, type DepositSubmitResponse, type ExecuteDepositInput, type GetOpenOrdersParams, type GetOpenOrdersResult, type GetPositionsParams, type GetPositionsResult, type GetTradesParams, type GetTradesResult, HL_USDC_DECIMALS, type HyperliquidAccountState, HyperliquidApiError, type HyperliquidClientConfig, type HyperliquidEnvironment, HyperliquidInitUI, type HyperliquidInitUIProps, HyperliquidInitWidget, type HyperliquidInitWidgetProps, HyperliquidPerpetualsClient, type HyperliquidSetupActionResult, type IHyperliquidSetupAdapter, type IPerpDepositClient, type IPerpetualsClient, type Kline, type KlineInterval, type KlineQueryOptions, LiberFiApiError, type LiberFiHttpMethod, type RequestOptions as LiberFiHttpRequestOptions, LiberFiHttpTransport, type LiberFiHttpTransportConfig, LiberFiPerpDepositClient, type LiberFiPerpDepositClientConfig, LiberFiPerpetualsClient, type LiberFiPerpetualsClientConfig, type MarketData, type MarketDataType, OpenOrdersEmpty, OpenOrdersSkeleton, OpenOrdersUI, type OpenOrdersUIProps, OpenOrdersWidget, type OpenOrdersWidgetProps, type Order, type OrderBook, type OrderBookAggregationOptions, type OrderBookLevel, OrderBookUI, type OrderBookUIProps, OrderBookWidget, type OrderBookWidgetProps, type OrderSide, type OrderStatus, type OrderType, PerpetualsContext, type PerpetualsContextValue, PerpetualsProvider, type PerpetualsProviderProps, type PlaceOrderFormData, PlaceOrderFormUI, type PlaceOrderFormUIProps, PlaceOrderFormWidget, type PlaceOrderFormWidgetProps, type PlaceOrderParams, type PlaceOrderResult, type Position, PositionsEmpty, PositionsSkeleton, PositionsUI, type PositionsUIProps, PositionsWidget, type PositionsWidgetProps, type PriceLevel, SearchCoinsUI, type SearchCoinsUIProps, SearchCoinsWidget, type SearchCoinsWidgetProps, type SetReferrerParams, type SetupAction, type SetupPhase, type SetupState, type SetupStep, type SetupStepId, type SignAndBroadcastSolanaTx, type SignTypedDataFn, type StepRecord, type StepStatus, type Symbol, TERMINAL_DEPOSIT_STATUSES, type TimeRange, type Trade, type TradeHistory, TradeHistoryEmpty, TradeHistorySkeleton, TradeHistoryUI, type TradeHistoryUIProps, TradeHistoryWidget, type TradeHistoryWidgetProps, type TradeSide, TradesUI, type TradesUIProps, TradesWidget, type TradesWidgetProps, type TradingProvider, type UpdateLeverageParams, type UseCancelOrderMutationParams, type UseCandlesSubscriptionParams, type UseCandlesSubscriptionResult, type UseCoinInfoReturnType, type UseCreateOrderMutationParams, type UseHyperliquidSetupOptions, type UseHyperliquidSetupResult, type UseKlinesQueryParams, type UseMarketDataSubscriptionParams, type UseMarketDataSubscriptionResult, type UseMarketQueryParams, type UseMarketsQueryParams, type UseOpenOrdersScriptParams, type UseOpenOrdersScriptResult, type UseOrderBookQueryParams, type UseOrderBookScriptParams, type UseOrderBookScriptResult, type UseOrdersQueryParams, type UsePerpDepositExecuteResult, type UsePerpDepositQuoteOptions, type UsePerpDepositStatusOptions, type UsePlaceOrderFormScriptParams, type UsePlaceOrderFormScriptResult, type UsePositionsQueryParams, type UsePositionsScriptParams, type UsePositionsScriptResult, type UseRecentTradesQueryParams, type UseSearchCoinsScriptParams, type UseSearchCoinsScriptResult, type UseTradeHistoryScriptParams, type UseTradeHistoryScriptResult, type UseTradesQueryParams, type UseTradesScriptParams, type UseTradesScriptResult, type UseUserDataSubscriptionParams, type UseUserDataSubscriptionResult, type UserDataType, aggregationFromStep, cancelOrder, classifyStep, coinsQueryKey, createOrder, currentBreakdown as currentDepositBreakdown, currentStatus as currentDepositStatus, fetchCoins, fetchKlines, fetchMarket, fetchMarkets, fetchOrderBook, fetchOrders, fetchPerpDepositQuote, fetchPerpDepositStatus, fetchPositions, fetchRecentTrades, fetchTrades, hlUsdcRawToUsdc, initialDepositState, initialSetupState, isPolling as isDepositPolling, isTerminal as isDepositTerminal, isTerminalLifecycle as isTerminalDepositLifecycle, klinesQueryKey, lamportsToSol, marketQueryKey, marketsQueryKey, microUsdcToUsdc, nextRunnableStep, orderBookQueryKey, ordersQueryKey, perpDepositQuoteQueryKey, perpDepositStatusQueryKey, positionsQueryKey, recentTradesQueryKey, reduceDepositState, reduceSetupState, secondsUntil, shortAddress, solToLamports, tradesQueryKey, useCancelOrderMutation, useCandlesSubscription, useCoinInfo, useCoinsQuery, useCreateOrderMutation, useHyperliquidSetup, useKlinesQuery, useMarketDataSubscription, useMarketQuery, useMarketsQuery, useOpenOrdersScript, useOrderBookQuery, useOrderBookScript, useOrdersQuery, usePerpDepositClient, usePerpDepositClientMaybe, usePerpDepositExecute, usePerpDepositQuote, usePerpDepositStatus, usePerpetualsClient, usePlaceOrderFormScript, usePositionsQuery, usePositionsScript, useRecentTradesQuery, useSearchCoinsScript, useTradeHistoryScript, useTradesQuery, useTradesScript, useUserDataSubscription, _default as version };
+export { type Account, type AccountState, type ActiveAssetLeverage, type ApproveBuilderFeeParams, type AssetMeta, type CancelOrderParams, type CancelOrderResult, type Coin, CoinInfoNotFoundUI, CoinInfoSkeletonsUI, CoinInfoUI, type CoinInfoUIProps, CoinInfoWidget, type CoinInfoWidgetProps, DEFAULT_ORDER_BOOK_PRECISION_OPTIONS, type DepositBreakdown, DepositConfirmUI, type DepositConfirmUIProps, type DepositErrorInfo, type DepositEvent, DepositFlowWidget, type DepositFlowWidgetProps, DepositFormUI, type DepositFormUIProps, type DepositPhase, type DepositQuoteRequest, type DepositQuoteResponse, type DepositSource, type DepositState, type DepositStatus, type DepositStatusResponse, type DepositStatusTransition, DepositStatusUI, type DepositStatusUIProps, type DepositSubmitRequest, type DepositSubmitResponse, type ExecuteDepositInput, type GetActiveAssetLeverageParams, type GetAssetMetaParams, type GetOpenOrdersParams, type GetOpenOrdersResult, type GetPositionsParams, type GetPositionsResult, type GetTradesParams, type GetTradesResult, HL_USDC_DECIMALS, type HyperliquidAccountState, HyperliquidApiError, type HyperliquidClientConfig, type HyperliquidEnvironment, HyperliquidInitUI, type HyperliquidInitUIProps, HyperliquidInitWidget, type HyperliquidInitWidgetProps, HyperliquidPerpetualsClient, type HyperliquidSetupActionResult, type IHyperliquidSetupAdapter, type IPerpDepositClient, type IPerpetualsClient, type Kline, type KlineInterval, type KlineQueryOptions, LiberFiApiError, type LiberFiHttpMethod, type RequestOptions as LiberFiHttpRequestOptions, LiberFiHttpTransport, type LiberFiHttpTransportConfig, LiberFiPerpDepositClient, type LiberFiPerpDepositClientConfig, LiberFiPerpetualsClient, type LiberFiPerpetualsClientConfig, type MarketData, type MarketDataType, OpenOrdersEmpty, OpenOrdersSkeleton, OpenOrdersUI, type OpenOrdersUIProps, OpenOrdersWidget, type OpenOrdersWidgetProps, type Order, type OrderBook, type OrderBookAggregationOptions, type OrderBookLevel, OrderBookUI, type OrderBookUIProps, OrderBookWidget, type OrderBookWidgetProps, type OrderSide, type OrderStatus, type OrderType, PerpetualsContext, type PerpetualsContextValue, PerpetualsProvider, type PerpetualsProviderProps, type PlaceOrderFormData, PlaceOrderFormUI, type PlaceOrderFormUIProps, PlaceOrderFormWidget, type PlaceOrderFormWidgetProps, type PlaceOrderParams, type PlaceOrderRequest, type PlaceOrderResult, type Position, type PositionSortKey, PositionsEmpty, PositionsSkeleton, PositionsUI, type PositionsUIProps, PositionsWidget, type PositionsWidgetProps, type PriceLevel, SearchCoinsUI, type SearchCoinsUIProps, SearchCoinsWidget, type SearchCoinsWidgetProps, type SetReferrerParams, type SetupAction, type SetupPhase, type SetupState, type SetupStep, type SetupStepId, type SignAndBroadcastSolanaTx, type SignTypedDataFn, type SortDirection, type SpotBalance, type StepRecord, type StepStatus, type Symbol, TERMINAL_DEPOSIT_STATUSES, type TimeRange, type Trade, type TradeHistory, TradeHistoryEmpty, TradeHistorySkeleton, TradeHistoryUI, type TradeHistoryUIProps, TradeHistoryWidget, type TradeHistoryWidgetProps, type TradeSide, TradesUI, type TradesUIProps, TradesWidget, type TradesWidgetProps, type TradingProvider, type UpdateLeverageParams, type UseAccountStateQueryParams, type UseAccountStateSubscriptionParams, type UseAccountStateSubscriptionResult, type UseActiveAssetLeverageQueryParams, type UseAssetMetaQueryParams, type UseCancelOrderMutationParams, type UseCandlesSubscriptionParams, type UseCandlesSubscriptionResult, type UseCoinInfoReturnType, type UseCreateOrderMutationParams, type UseHyperliquidSetupOptions, type UseHyperliquidSetupResult, type UseKlinesQueryParams, type UseMarketDataSubscriptionParams, type UseMarketDataSubscriptionResult, type UseMarketQueryParams, type UseMarketsQueryParams, type UseOpenOrdersScriptParams, type UseOpenOrdersScriptResult, type UseOrderBookQueryParams, type UseOrderBookScriptParams, type UseOrderBookScriptResult, type UseOrdersQueryParams, type UsePerpDepositExecuteResult, type UsePerpDepositQuoteOptions, type UsePerpDepositStatusOptions, type UsePlaceOrderFormScriptParams, type UsePlaceOrderFormScriptResult, type UsePositionsQueryParams, type UsePositionsScriptParams, type UsePositionsScriptResult, type UseRecentTradesQueryParams, type UseSearchCoinsScriptParams, type UseSearchCoinsScriptResult, type UseTradeHistoryScriptParams, type UseTradeHistoryScriptResult, type UseTradesQueryParams, type UseTradesScriptParams, type UseTradesScriptResult, type UseUserDataSubscriptionParams, type UseUserDataSubscriptionResult, type UserDataType, accountStateQueryKey, activeAssetLeverageQueryKey, aggregationFromStep, assetMetaQueryKey, cancelOrder, classifyStep, coinsQueryKey, createOrder, currentBreakdown as currentDepositBreakdown, currentStatus as currentDepositStatus, fetchActiveAssetLeverage, fetchAssetMeta, fetchCoins, fetchKlines, fetchMarket, fetchMarkets, fetchOrderBook, fetchOrders, fetchPerpDepositQuote, fetchPerpDepositStatus, fetchPositions, fetchRecentTrades, fetchTrades, hlUsdcRawToUsdc, initialDepositState, initialSetupState, isPolling as isDepositPolling, isTerminal as isDepositTerminal, isTerminalLifecycle as isTerminalDepositLifecycle, klinesQueryKey, lamportsToSol, marketQueryKey, marketsQueryKey, microUsdcToUsdc, nextRunnableStep, orderBookQueryKey, ordersQueryKey, perpDepositQuoteQueryKey, perpDepositStatusQueryKey, positionsQueryKey, recentTradesQueryKey, reduceDepositState, reduceSetupState, secondsUntil, shortAddress, solToLamports, tradesQueryKey, useAccountStateQuery, useAccountStateSubscription, useActiveAssetLeverageQuery, useAssetMetaQuery, useCancelOrderMutation, useCandlesSubscription, useCoinInfo, useCoinsQuery, useCreateOrderMutation, useHyperliquidSetup, useKlinesQuery, useMarketDataSubscription, useMarketQuery, useMarketsQuery, useOpenOrdersScript, useOrderBookQuery, useOrderBookScript, useOrdersQuery, usePerpDepositClient, usePerpDepositClientMaybe, usePerpDepositExecute, usePerpDepositQuote, usePerpDepositStatus, usePerpetualsClient, usePlaceOrderFormScript, usePositionsQuery, usePositionsScript, useRecentTradesQuery, useSearchCoinsScript, useTradeHistoryScript, useTradesQuery, useTradesScript, useUserDataSubscription, _default as version };