@pear-protocol/exchanges-sdk 0.6.7 → 0.8.0

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import PearSDK from '@pear-protocol/core-sdk';
 import { ProxyConfig } from '@pear-protocol/utils';
 import { WebSocket } from 'partysocket';
 import { WalletClient, Transport, Chain, Account } from 'viem';
+import { z } from 'zod';
 
 type SupportedCredentials = HttpTypes.ExchangeCredentialsResponse['credentials'];
 type ExchangesSDKConfig = {
@@ -561,9 +562,26 @@ interface AccountSyncerConfig {
     credentials: SupportedCredentials;
     demo: boolean;
 }
+/**
+ * Outcome of one fill sync cycle, so batch/cron callers can tell a completed
+ * cycle apart from one that must be retried:
+ * - `synced`: the cycle posted, or there was nothing to post.
+ * - `deferred`: the server answered 409 SYNC_CREATE_*; the watermark did not
+ *   advance, so a later cycle retries the same window.
+ * - `aborted`: the exchange fetch failed; nothing was posted.
+ */
+type FillSyncOutcome = 'synced' | 'deferred' | 'aborted';
+/**
+ * Outcome of one funding sync cycle. Funding has no server deferral contract,
+ * so the union is narrower than {@link FillSyncOutcome}:
+ * - `synced`: the cycle posted, or there were no new payments.
+ * - `aborted`: the exchange funding fetch failed; nothing was posted.
+ * A failed post still throws — only the exchange fetch is guarded.
+ */
+type FundingSyncOutcome = 'synced' | 'aborted';
 interface AccountSyncer {
-    synchronizeFills(): Promise<void>;
-    synchronizeFunding(): Promise<void>;
+    synchronizeFills(): Promise<FillSyncOutcome>;
+    synchronizeFunding(): Promise<FundingSyncOutcome>;
 }
 interface ListExternalFillsParams {
     since: Date;
@@ -613,8 +631,8 @@ declare abstract class BaseAccountSyncer<ExternalFill> implements AccountSyncer
      * Independent of the fill sync cycle (`synchronizeFills`) — funding rows are
      * immutable and upsert idempotently, so this is driven on its own cadence.
      */
-    synchronizeFunding(): Promise<void>;
-    synchronizeFills(): Promise<void>;
+    synchronizeFunding(): Promise<FundingSyncOutcome>;
+    synchronizeFills(): Promise<FillSyncOutcome>;
 }
 
 interface BinanceRawUserTrade {
@@ -809,65 +827,440 @@ declare class OkxAccountSyncer extends BaseAccountSyncer<RawFill> {
     private contractsToBase;
 }
 
-declare enum BinanceAccountType {
-    MULTI_ASSET = "MULTI_ASSET",
-    SINGLE_ASSET = "SINGLE_ASSET"
-}
-
-declare enum BybitAccountType {
-    ISOLATED_MARGIN = "ISOLATED_MARGIN",
-    REGULAR_MARGIN = "REGULAR_MARGIN",
-    PORTFOLIO_MARGIN = "PORTFOLIO_MARGIN"
-}
+/**
+ * The account balance a consumer receives, as one discriminated union over `accountMode`.
+ *
+ * Narrowing on the tag gives exactly the fields that venue and mode support and no others, and a
+ * newly added mode fails every exhaustive `switch` at compile time. This module sits above the
+ * venue variant files, which in turn sit above `./balance-core` — one direction, no cycle.
+ */
 
-declare enum HyperliquidAccountType {
-    DEFAULT = "default",
-    DISABLED = "disabled",
-    PORTFOLIO_MARGIN = "portfolioMargin",
-    UNIFIED_ACCOUNT = "unifiedAccount"
-}
+declare const AccountBalance: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"hyperliquid:standard">;
+    spotEquity: z.ZodNullable<z.ZodString>;
+    perpsEquity: z.ZodString;
+    vaultEquity: z.ZodString;
+    stakedEquity: z.ZodNullable<z.ZodString>;
+    unrealizedPnl: z.ZodString;
+    maintenanceMargin: z.ZodString;
+    crossMarginRatio: z.ZodString;
+    crossAccountLeverage: z.ZodString;
+    perDexState: z.ZodArray<z.ZodObject<{
+        dex: z.ZodString;
+        collateralToken: z.ZodNullable<z.ZodNumber>;
+        accountValue: z.ZodString;
+        crossNotional: z.ZodString;
+        crossMaintenanceMargin: z.ZodString;
+        withdrawable: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"hyperliquid:unified">;
+    tradingEquity: z.ZodNullable<z.ZodString>;
+    vaultEquity: z.ZodString;
+    stakedEquity: z.ZodNullable<z.ZodString>;
+    portfolioValue: z.ZodNullable<z.ZodString>;
+    unrealizedPnl: z.ZodString;
+    perpsMaintenanceMargin: z.ZodString;
+    unifiedAccountRatio: z.ZodString;
+    unifiedAccountLeverage: z.ZodNullable<z.ZodString>;
+    perDexState: z.ZodArray<z.ZodObject<{
+        dex: z.ZodString;
+        collateralToken: z.ZodNullable<z.ZodNumber>;
+        accountValue: z.ZodString;
+        crossNotional: z.ZodString;
+        crossMaintenanceMargin: z.ZodString;
+        withdrawable: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"hyperliquid:portfolioMargin">;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodString;
+        ltv: z.ZodNullable<z.ZodString>;
+        borrowCapUsed: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    tradingEquity: z.ZodNullable<z.ZodString>;
+    vaultEquity: z.ZodString;
+    stakedEquity: z.ZodNullable<z.ZodString>;
+    portfolioValue: z.ZodNullable<z.ZodString>;
+    unrealizedPnl: z.ZodString;
+    perpsMaintenanceMargin: z.ZodString;
+    portfolioMarginRatio: z.ZodNullable<z.ZodString>;
+    portfolioAccountLeverage: z.ZodNullable<z.ZodString>;
+    borrowCapUsed: z.ZodNullable<z.ZodString>;
+    perDexState: z.ZodArray<z.ZodObject<{
+        dex: z.ZodString;
+        collateralToken: z.ZodNullable<z.ZodNumber>;
+        accountValue: z.ZodString;
+        crossNotional: z.ZodString;
+        crossMaintenanceMargin: z.ZodString;
+        withdrawable: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    tradingEquity: z.ZodNullable<z.ZodString>;
+    perpetualsEquity: z.ZodNullable<z.ZodString>;
+    spotEquity: z.ZodNullable<z.ZodString>;
+    publicPoolsEquity: z.ZodNullable<z.ZodString>;
+    stakingEquity: z.ZodNullable<z.ZodString>;
+    creditedInLit: z.ZodNullable<z.ZodString>;
+    unrealizedPnl: z.ZodNullable<z.ZodString>;
+    crossLeverage: z.ZodNullable<z.ZodString>;
+    maintenanceMargin: z.ZodNullable<z.ZodString>;
+    crossMarginUsage: z.ZodNullable<z.ZodString>;
+    crossMarginRatio: z.ZodNullable<z.ZodString>;
+    accountMode: z.ZodLiteral<"lighter:classic">;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    portfolioMargin: z.ZodNullable<z.ZodString>;
+    tradingEquity: z.ZodNullable<z.ZodString>;
+    perpetualsEquity: z.ZodNullable<z.ZodString>;
+    spotEquity: z.ZodNullable<z.ZodString>;
+    publicPoolsEquity: z.ZodNullable<z.ZodString>;
+    stakingEquity: z.ZodNullable<z.ZodString>;
+    creditedInLit: z.ZodNullable<z.ZodString>;
+    unrealizedPnl: z.ZodNullable<z.ZodString>;
+    crossLeverage: z.ZodNullable<z.ZodString>;
+    maintenanceMargin: z.ZodNullable<z.ZodString>;
+    crossMarginUsage: z.ZodNullable<z.ZodString>;
+    crossMarginRatio: z.ZodNullable<z.ZodString>;
+    accountMode: z.ZodLiteral<"lighter:unified">;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"binance:singleAsset">;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"binance:multiAsset">;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"bybit:isolatedMargin">;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"bybit:regularMargin">;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"bybit:portfolioMargin">;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"okx:spot">;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"okx:futures">;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"okx:multiCurrencyMargin">;
+}, z.core.$strip>, z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"okx:portfolioMargin">;
+}, z.core.$strip>], "accountMode">;
+type AccountBalance = z.infer<typeof AccountBalance>;
 
-declare enum LighterAccountType {
-    /** @deprecated Use `CLASSIC`; retained as a source-compatible alias. */
-    BASIC = "classic",
-    CLASSIC = "classic",
-    UNIFIED = "unified"
-}
+/**
+ * The primitives every account-balance variant is built from: decimal string formats, the
+ * `accountMode` union tag, and the four core fields every venue fills in every mode.
+ *
+ * This module is the root of the balance schema graph — venue variant files import it, and the
+ * union in `./balance` imports those. Keeping the primitives out of `./balance` is what stops
+ * that graph from becoming a cycle.
+ */
 
-declare enum OkxAccountType {
-    SPOT = "OKX_SPOT",
-    SINGLE_CURRENCY_MARGIN = "OKX_SINGLE",
-    MULTI_CURRENCY_MARGIN = "OKX_MULTI",
-    PORTFOLIO_MARGIN = "OKX_PORTFOLIO"
-}
+/** Unsigned decimal, e.g. "1234.56". Never a JS number — precision is load-bearing. */
+declare const DecimalString: z.ZodString;
+/** Signed decimal, e.g. "+1234.56" / "-1234.56". BUY positive, SELL negative. */
+declare const SignedDecimalString: z.ZodString;
+declare const MarginMode: z.ZodEnum<{
+    isolated: "isolated";
+    cross: "cross";
+}>;
+type MarginMode = z.infer<typeof MarginMode>;
+declare const Side: z.ZodEnum<{
+    BUY: "BUY";
+    SELL: "SELL";
+}>;
+type Side = z.infer<typeof Side>;
+/**
+ * The union tag: venue AND mode in one literal, so narrowing needs no separate venue check.
+ * `hyperliquid:standard` covers the API's `default` and `disabled` — verified identical.
+ */
+declare const AccountMode: z.ZodEnum<{
+    "hyperliquid:standard": "hyperliquid:standard";
+    "hyperliquid:unified": "hyperliquid:unified";
+    "hyperliquid:portfolioMargin": "hyperliquid:portfolioMargin";
+    "lighter:classic": "lighter:classic";
+    "lighter:unified": "lighter:unified";
+    "binance:singleAsset": "binance:singleAsset";
+    "binance:multiAsset": "binance:multiAsset";
+    "bybit:isolatedMargin": "bybit:isolatedMargin";
+    "bybit:regularMargin": "bybit:regularMargin";
+    "bybit:portfolioMargin": "bybit:portfolioMargin";
+    "okx:spot": "okx:spot";
+    "okx:futures": "okx:futures";
+    "okx:multiCurrencyMargin": "okx:multiCurrencyMargin";
+    "okx:portfolioMargin": "okx:portfolioMargin";
+}>;
+type AccountMode = z.infer<typeof AccountMode>;
+/** One collateral pool's own figures, in THAT asset's own units. Never converted. */
+declare const CollateralBalance: z.ZodObject<{
+    asset: z.ZodString;
+    equity: z.ZodString;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    withdrawable: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type CollateralBalance = z.infer<typeof CollateralBalance>;
+/**
+ * Filled by every venue in every mode: the USD scalars a consumer reads without narrowing, plus the
+ * per-collateral rows that say what is actually spendable in each currency.
+ *
+ * The rows are per-asset by construction, so the only USD figures in a variant are the scalars —
+ * which is what makes mixing units impossible rather than merely discouraged.
+ */
+declare const AccountBalanceCore: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+/** Human-readable name for each mode, as the venue's own account page labels it. */
+declare const ACCOUNT_MODE_LABELS: Record<AccountMode, string>;
 
-type MarginMode = 'cross' | 'isolated';
-type AccountType = BinanceAccountType | BybitAccountType | HyperliquidAccountType | LighterAccountType | OkxAccountType;
-declare const ACCOUNT_TYPE_LABELS: Record<AccountType, string>;
-interface AssetBalance {
+/**
+ * Mirrors the shipped basket model (`BasketItem` in the frontend): unsigned `weight`
+ * with `side` alongside, weights summing to 100. Sizing ignores `side` — margin
+ * requirement does not depend on direction — and normalises by Σweight.
+ */
+declare const BasketLeg: z.ZodObject<{
+    asset: z.ZodString;
+    marginMode: z.ZodEnum<{
+        isolated: "isolated";
+        cross: "cross";
+    }>;
+    leverage: z.ZodString;
+    side: z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>;
+    weight: z.ZodNumber;
+}, z.core.$strip>;
+type BasketLeg = z.infer<typeof BasketLeg>;
+declare const MaxBasketSizeInput: z.ZodObject<{
+    legs: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        marginMode: z.ZodEnum<{
+            isolated: "isolated";
+            cross: "cross";
+        }>;
+        leverage: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        weight: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type MaxBasketSizeInput = z.infer<typeof MaxBasketSizeInput>;
+declare const MaxBasketSizeResult: z.ZodObject<{
+    maxNotional: z.ZodNullable<z.ZodString>;
+    legs: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        notional: z.ZodString;
+        marginRequired: z.ZodString;
+    }, z.core.$strip>>;
+    bindingConstraint: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"cross-pool">;
+        pool: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"isolated-leg">;
+        asset: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+type MaxBasketSizeResult = z.infer<typeof MaxBasketSizeResult>;
+/**
+ * One basket leg with its leverage already capped by the venue adapter.
+ *
+ * `marginMode` does not enter the maths: an isolated leg gets dedicated margin, but that margin is
+ * still transferred out of the same free balance, so it draws on the same budget as a cross leg.
+ * It is carried so the caller passes its basket through unchanged.
+ */
+type CappedBasketLeg = {
     asset: string;
-    free: string;
-    used: string;
-    total: string;
-    walletBalance: string;
-    usdValue: string;
-}
-interface AccountBalance {
-    accountType: AccountType;
-    accountTier?: string;
-    free: Record<string, string>;
-    used: Record<string, string>;
-    total: Record<string, string>;
-    availableToTrade: string;
-    totalEquity: string;
-    walletBalance: string;
-    unrealizedPnl: string;
-    initialMarginUsed: string;
-    maintenanceMargin: string;
-    marginRatio: string;
-    assets: AssetBalance[];
-    timestamp: number;
-}
+    /**
+     * The collateral pool this leg's margin comes out of, as the venue adapter resolves it — a CEX
+     * from the symbol's settlement currency, Hyperliquid from the dex's collateral token. Legs in
+     * different pools cannot fund each other.
+     */
+    pool: string;
+    /** Unsigned, in the caller's own scale — `computeMaxBasketSize` normalises by Σweight. */
+    weight: number;
+    effectiveLeverage: string;
+    marginMode: MarginMode;
+    /** This leg's own venue ceiling in USD notional; `null` when the venue names no cap. */
+    maxNotional: string | null;
+};
+/** The margin budget behind each collateral pool, plus the legs those pools must fund at once. */
+type MaxBasketSizeCalculation = {
+    /**
+     * Pool id to that pool's USD-equivalent budget. A pool whose collateral is not ~1 USD supplies no
+     * entry until someone adds a price source, and a leg drawing on a missing entry voids the answer.
+     */
+    budgets: Record<string, string>;
+    legs: CappedBasketLeg[];
+};
+/**
+ * The largest gross notional this basket can reach while every leg stays funded at its weight.
+ *
+ * Returns a null size when a pool behind the basket cannot be valued — never a zero, which a
+ * consumer would read as "no collateral" rather than "not known". A basket whose own figures cannot
+ * be sized (see `isSizeableInput`) gets the same null, so this call never throws and never returns a
+ * result that fails `MaxBasketSizeResult`.
+ */
+declare function computeMaxBasketSize(input: MaxBasketSizeCalculation): MaxBasketSizeResult;
+
 interface AccountPosition {
     symbol: string;
     side: 'long' | 'short' | 'both';
@@ -924,12 +1317,16 @@ interface AccountTracker {
     disconnect(): Promise<void>;
     snapshot(): Promise<AccountSnapshot>;
     snapshotAssets(coins: string[]): Promise<AssetSnapshotMap>;
+    /** Sizes a basket over REST alone, so it stays usable without a running socket. */
+    snapshotMaxBasketSize(input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
     readonly isConnected: boolean;
     readonly isInitialized: boolean;
     readonly hasListeners: boolean;
     trackBalance(cb: BalanceCallback): () => void;
     trackPosition(cb: PositionsCallback): () => void;
     trackAsset(asset: string, cb: TrackedAssetCallback): () => void;
+    /** Async: a basket may name assets this tracker has not subscribed to yet. */
+    maxBasketSize(input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
     getBalance(): AccountBalance | null;
     getPositions(): AccountPosition[];
     getTrackedAsset(coin: string): TrackedAssetInfo | null;
@@ -970,6 +1367,9 @@ declare abstract class BaseAccountTracker implements AccountTracker {
     private broadcast;
     abstract start(): Promise<void>;
     abstract snapshot(): Promise<AccountSnapshot>;
+    /** Every venue implements both sizing paths — the live one and the REST one. */
+    abstract maxBasketSize(input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
+    abstract snapshotMaxBasketSize(input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
     protected abstract fetchAssetSnapshots(coins: string[]): Promise<AssetSnapshotMap>;
     abstract get isConnected(): boolean;
     protected abstract ensureAssetTracked(asset: string): void;
@@ -977,6 +1377,51 @@ declare abstract class BaseAccountTracker implements AccountTracker {
     protected abstract cleanupConnections(): void | Promise<void>;
 }
 
+/**
+ * Binance's two account-mode balance variants.
+ *
+ * Core fields only, with `null` wherever a figure cannot be derived. What differs by mode is not the
+ * shape but when the core scalars go null, which follows each mode's collateral-pool model. One
+ * `z.literal` per mode, because `z.discriminatedUnion` needs a single literal tag per member rather
+ * than a `z.enum` shorthand.
+ */
+
+/**
+ * Single-asset mode runs one collateral pool per settlement currency, and Binance's account-level
+ * figures cover USDT only there. Once a second pool is funded no account total exists to report, so
+ * `totalEquity` goes null and `perCollateral` is the whole answer.
+ */
+declare const BinanceSingleAssetBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"binance:singleAsset">;
+}, z.core.$strip>;
+type BinanceSingleAssetBalance = z.infer<typeof BinanceSingleAssetBalance>;
+declare const BinanceMultiAssetBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"binance:multiAsset">;
+}, z.core.$strip>;
+type BinanceMultiAssetBalance = z.infer<typeof BinanceMultiAssetBalance>;
+
 type BinanceAccountTrackerConfig = AccountTrackerConfig & {
     credentials: SupportedCredentials;
     listenKeyRefreshMs?: number;
@@ -993,10 +1438,19 @@ declare class BinanceAccountTracker extends BaseAccountTracker {
     private listenKeyTimer;
     private pollTimer;
     private currentPositions;
-    private accountType;
+    private accountMode;
     private trackedAssetInfos;
     constructor(config: BinanceAccountTrackerConfig);
     snapshot(): Promise<AccountSnapshot>;
+    /**
+     * Binance sizes no basket in v1: the SDK reads no per-asset max leverage from it, and sizing off
+     * `availableMargin` alone would ship a number no venue field backs. The missing input is
+     * `/fapi/v2/positionRisk` → `maxNotionalValue` (the account's own per-symbol ceiling), with
+     * `/fapi/v1/leverageBracket` behind it for the tier a larger size would fall into.
+     */
+    maxBasketSize(_input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
+    /** The REST path answers the same way — there is no size either way, not a slower one. */
+    snapshotMaxBasketSize(_input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
     /**
      * Stateless one-shot per-asset settings read: `positionRisk` with no symbol returns leverage +
      * margin type for every symbol (positioned or not), so any number of assets costs one call.
@@ -1017,6 +1471,64 @@ declare class BinanceAccountTracker extends BaseAccountTracker {
     private refreshAllPositions;
 }
 
+/**
+ * Bybit's three account-mode balance variants.
+ *
+ * Core fields only — Bybit carries no per-mode detail yet, with `null` wherever a figure cannot
+ * be derived. All three are unified-account modes sharing one margin pool, so the core scalars are
+ * the whole answer and `perCollateral` only breaks them down — where Binance single-asset and OKX
+ * Spot/Futures have to null those scalars once a second pool is funded. The mode still tags the
+ * variant so detail can be added later without another breaking change. One `z.literal` per mode,
+ * because `z.discriminatedUnion` needs a single literal tag per member rather than a `z.enum`
+ * shorthand.
+ */
+
+declare const BybitIsolatedMarginBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"bybit:isolatedMargin">;
+}, z.core.$strip>;
+type BybitIsolatedMarginBalance = z.infer<typeof BybitIsolatedMarginBalance>;
+declare const BybitRegularMarginBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"bybit:regularMargin">;
+}, z.core.$strip>;
+type BybitRegularMarginBalance = z.infer<typeof BybitRegularMarginBalance>;
+declare const BybitPortfolioMarginBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"bybit:portfolioMargin">;
+}, z.core.$strip>;
+type BybitPortfolioMarginBalance = z.infer<typeof BybitPortfolioMarginBalance>;
+
 type BybitAccountTrackerConfig = AccountTrackerConfig & {
     credentials: SupportedCredentials;
 };
@@ -1027,10 +1539,25 @@ declare class BybitAccountTracker extends BaseAccountTracker {
     private openListenerId;
     private rawCoins;
     private lastWallet;
-    private accountType;
+    private accountMode;
+    private withdrawable;
+    private lastWithdrawableReadAt;
+    private withdrawableRefreshTimer;
+    private withdrawableReadInFlight;
+    private withdrawableReadPending;
+    private lifecycleVersion;
     private trackedAssetInfos;
     constructor(config: BybitAccountTrackerConfig);
     snapshot(): Promise<AccountSnapshot>;
+    /**
+     * Bybit sizes no basket in v1: the SDK reads no per-asset max leverage from it, and sizing off
+     * `availableMargin` alone would ship a number no venue field backs. The missing input is
+     * `/v5/position/list` → `leverage` (the account's own per-symbol setting), with
+     * `/v5/market/risk-limit` → `maxLeverage` behind it for the tier a larger size would fall into.
+     */
+    maxBasketSize(_input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
+    /** The REST path answers the same way — there is no size either way, not a slower one. */
+    snapshotMaxBasketSize(_input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
     /**
      * Stateless one-shot per-asset settings read. Bybit has no batch leverage endpoint, but
      * `position/list` by settleCoin returns every open position (with leverage) in one call, so
@@ -1044,15 +1571,232 @@ declare class BybitAccountTracker extends BaseAccountTracker {
     protected cleanupConnections(): Promise<void>;
     get isConnected(): boolean;
     private fetchSnapshotData;
+    /**
+     * Read how much can leave the trading account, for the coins the wallet payload lists.
+     *
+     * Best-effort on purpose: this is a second signed call that a read-only key may be refused, and
+     * a refusal must cost the caller a `null` field rather than the whole balance.
+     *
+     * A refusal is reported as `failed` rather than as an empty answer, because only the caller knows
+     * what to do with it: the snapshot path has no earlier figure and reports nothing known, while
+     * the live path keeps the figure its last successful read published.
+     */
+    private readWithdrawable;
     protected ensureAssetTracked(coin: string): void;
     protected releaseAsset(coin: string): void;
     private subscribe;
     private handleInitialData;
     private routeRaw;
     private handleMessage;
+    /**
+     * Fold one wallet push into the whole account, then publish what that whole account says.
+     *
+     * Bybit pushes only what moved: an update names the coins whose figures changed and leaves every
+     * other coin out. So the coin list is taken from the per-coin merge rather than from the push,
+     * and everything read off it sees every coin the account holds — the published rows, and the
+     * coin list the next transferable-amount read asks about. A push naming one of two funded coins
+     * would otherwise drop the other's row and let its per-coin maximum answer for the account.
+     *
+     * The account-level figures inherit on `??`, never on `||`, because ABSENT and BLANK say
+     * opposite things here. A field this push left out was not restated and its previous value still
+     * stands; a field present as `''` is Bybit withdrawing the figure, which it does for
+     * `totalAvailableBalance` among others. Inheriting a blank would republish a number the venue no
+     * longer states, and it would do it BEHIND `decimalOrNull`, whose whole job is to publish a blank
+     * as `null`: overwriting the blank here means that guard never sees it.
+     */
     private handleWalletUpdate;
+    /** Publish the balance built from the newest wallet payload and the cached transferable amounts. */
+    private emitBalance;
+    /**
+     * Queue the next transferable-amount read, no sooner than the venue's own rate limit allows.
+     *
+     * Nothing waits on it: the wallet update is already published from the cached figure. One queued
+     * read covers every wallet tick that lands before it runs, which is what stops a burst of ticks
+     * becoming a burst of signed calls — and because a tick always leaves a read queued or marked
+     * pending, a moved figure is still picked up within one interval rather than dropped.
+     */
+    private refreshWithdrawableSoon;
+    /**
+     * Hold one transferable-amount read open at a time, and queue the ticks that arrive during it.
+     *
+     * Serialising the reads is what keeps the published figure the newest one: two overlapping reads
+     * can come back in either order, and the older answer landing last would publish an amount the
+     * venue has already moved past.
+     */
+    private refreshWithdrawableBalance;
+    /**
+     * Re-read the transferable amount behind the live path, then re-publish only if it moved.
+     *
+     * Fire-and-forget: the wallet update is already published with the previous figure, so a slow
+     * read delays the correction instead of blocking the balance. A read that FAILS changes nothing
+     * at all — the last good figure stays published, because a refusal says Bybit did not answer,
+     * not that the account has nothing to transfer. Both the read and the re-publish take the NEWEST
+     * wallet rather than the one that queued them, so a wallet update that landed meanwhile is
+     * neither missed nor rolled back.
+     */
+    private performWithdrawableRefresh;
 }
 
+/**
+ * Hyperliquid's three account-mode balance variants.
+ *
+ * Hyperliquid has the most divergent risk model of the five venues, so each mode carries its own
+ * figures rather than sharing one flat shape. HIP-3 dexes can share the main dex's collateral
+ * token, so every account-level figure aggregates across dexes and the per-dex list is kept
+ * alongside — the aggregate hides HIP-3 positions entirely.
+ *
+ * Every figure derived from a spot price is nullable, because a spot balance carries only a token
+ * index and no route to USDC reaches every token. The `perCollateral` rows are not:
+ * a row is a quantity of one collateral token in that token's own units, so it keeps working
+ * precisely because it is never converted.
+ */
+
+declare const HyperliquidDexState: z.ZodObject<{
+    dex: z.ZodString;
+    collateralToken: z.ZodNullable<z.ZodNumber>;
+    accountValue: z.ZodString;
+    crossNotional: z.ZodString;
+    crossMaintenanceMargin: z.ZodString;
+    withdrawable: z.ZodString;
+}, z.core.$strip>;
+type HyperliquidDexState = z.infer<typeof HyperliquidDexState>;
+declare const HyperliquidStandardBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"hyperliquid:standard">;
+    spotEquity: z.ZodNullable<z.ZodString>;
+    perpsEquity: z.ZodString;
+    vaultEquity: z.ZodString;
+    stakedEquity: z.ZodNullable<z.ZodString>;
+    unrealizedPnl: z.ZodString;
+    maintenanceMargin: z.ZodString;
+    crossMarginRatio: z.ZodString;
+    crossAccountLeverage: z.ZodString;
+    perDexState: z.ZodArray<z.ZodObject<{
+        dex: z.ZodString;
+        collateralToken: z.ZodNullable<z.ZodNumber>;
+        accountValue: z.ZodString;
+        crossNotional: z.ZodString;
+        crossMaintenanceMargin: z.ZodString;
+        withdrawable: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type HyperliquidStandardBalance = z.infer<typeof HyperliquidStandardBalance>;
+declare const HyperliquidUnifiedBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"hyperliquid:unified">;
+    tradingEquity: z.ZodNullable<z.ZodString>;
+    vaultEquity: z.ZodString;
+    stakedEquity: z.ZodNullable<z.ZodString>;
+    portfolioValue: z.ZodNullable<z.ZodString>;
+    unrealizedPnl: z.ZodString;
+    perpsMaintenanceMargin: z.ZodString;
+    unifiedAccountRatio: z.ZodString;
+    unifiedAccountLeverage: z.ZodNullable<z.ZodString>;
+    perDexState: z.ZodArray<z.ZodObject<{
+        dex: z.ZodString;
+        collateralToken: z.ZodNullable<z.ZodNumber>;
+        accountValue: z.ZodString;
+        crossNotional: z.ZodString;
+        crossMaintenanceMargin: z.ZodString;
+        withdrawable: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type HyperliquidUnifiedBalance = z.infer<typeof HyperliquidUnifiedBalance>;
+/**
+ * One Portfolio Margin spot holding, as the venue's own balances table states it.
+ *
+ * PM widens the shared `CollateralBalance` in two ways it cannot carry, which is why this variant
+ * declares its own row type rather than reusing it:
+ *
+ * - **the figures are SIGNED.** A borrowed coin holds a negative `total`, and seven of the fourteen
+ *   accounts measured hold one — `0x0871deb3…` reports USDC at −957,802.15. An unsigned row cannot
+ *   state that at all, which is the defect that made a borrowed pool indistinguishable from an
+ *   untouched one.
+ * - **two more columns.** `ltv` and `borrowCapUsed` are per-coin risk weights the venue renders
+ *   beside the quantities, and both are PM-only wire fields.
+ *
+ * The row is otherwise the shared shape: same keys, same meanings, so a consumer reading
+ * `perCollateral` without narrowing still reads `asset` / `equity` / `availableMargin` /
+ * `withdrawable` off every venue.
+ */
+declare const HyperliquidPortfolioMarginCollateral: z.ZodObject<{
+    asset: z.ZodString;
+    equity: z.ZodString;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    withdrawable: z.ZodString;
+    ltv: z.ZodNullable<z.ZodString>;
+    borrowCapUsed: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type HyperliquidPortfolioMarginCollateral = z.infer<typeof HyperliquidPortfolioMarginCollateral>;
+declare const HyperliquidPortfolioMarginBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"hyperliquid:portfolioMargin">;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodString;
+        ltv: z.ZodNullable<z.ZodString>;
+        borrowCapUsed: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    tradingEquity: z.ZodNullable<z.ZodString>;
+    vaultEquity: z.ZodString;
+    stakedEquity: z.ZodNullable<z.ZodString>;
+    portfolioValue: z.ZodNullable<z.ZodString>;
+    unrealizedPnl: z.ZodString;
+    perpsMaintenanceMargin: z.ZodString;
+    portfolioMarginRatio: z.ZodNullable<z.ZodString>;
+    portfolioAccountLeverage: z.ZodNullable<z.ZodString>;
+    borrowCapUsed: z.ZodNullable<z.ZodString>;
+    perDexState: z.ZodArray<z.ZodObject<{
+        dex: z.ZodString;
+        collateralToken: z.ZodNullable<z.ZodNumber>;
+        accountValue: z.ZodString;
+        crossNotional: z.ZodString;
+        crossMaintenanceMargin: z.ZodString;
+        withdrawable: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type HyperliquidPortfolioMarginBalance = z.infer<typeof HyperliquidPortfolioMarginBalance>;
+
+/**
+ * Hyperliquid's two read paths: the live WebSocket tracker and the one-shot REST snapshot.
+ *
+ * Both fill the same `HyperliquidBalanceContext` and hand it to the same mapper, which is what
+ * makes "same account state, same balance" true across two different transports. The tracker takes
+ * every CHANGING value off a channel — `allDexsClearinghouseState`, `spotState`, `webData3`,
+ * `allMids`, `activeAssetData` — including vault equity, which rides `webData3`. Its only REST
+ * reads happen at `start()`: the static dex metadata, and the staking position, which the venue
+ * publishes on no channel at all.
+ *
+ * The snapshot has no channels, so it reads the same figures over REST — vault equity from
+ * `userVaultEquities`, which was measured equal to the `webData3` figure on ten live accounts.
+ */
+
 type HyperliquidAccountTrackerConfig = AccountTrackerConfig & {
     account: TradeAccount;
     credentials: SupportedCredentials;
@@ -1066,17 +1810,33 @@ declare class HyperliquidAccountTracker extends BaseAccountTracker {
     private subscribedCoins;
     private lastSummary;
     private spotCoinBalances;
+    /** Portfolio Margin's own risk scalars, which ride the same `spotState` frame the balances do. */
+    private portfolioMarginRatio;
+    private borrowRatioByToken;
     private hasSpotState;
     private hasClearinghouseState;
     private accountType;
-    private collateralTokenMap;
+    private spotMeta;
+    private collateralTokenNames;
+    private prices;
+    private hasWebData3;
+    private vaultEquity;
+    private stakedHype;
     private dexToMeta;
     private trackedAssetData;
     constructor(config: HyperliquidAccountTrackerConfig);
     /**
-     * Reads account mode, collateral balances, per-DEX state, and positions without opening a socket.
+     * Reads account mode, spot prices, collateral balances, per-DEX state, staking, vaults and
+     * per-asset headroom without opening a socket.
      */
     snapshot(): Promise<AccountSnapshot>;
+    /** Sizes a basket over REST alone, so the call stays usable without a running socket. */
+    snapshotMaxBasketSize(input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
+    /**
+     * Sizes a basket against live state, fetching per-asset data for any leg the socket has not
+     * subscribed to — which is exactly why the call is asynchronous on both paths.
+     */
+    maxBasketSize(input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
     /**
      * Stateless one-shot per-asset settings read via the `activeAssetData` info request (the REST
      * twin of the live WS subscription), one request per coin fired in parallel — the info endpoint
@@ -1100,41 +1860,120 @@ declare class HyperliquidAccountTracker extends BaseAccountTracker {
     private routeRaw;
     private handle;
     private loadPerpMetas;
+    /** Loads the dex metadata a sizing call needs, reusing whatever `start()` already cached. */
+    private loadPerpMetasOnce;
+    /** Loads the token names a pool id is spelled with, reusing whatever `start()` already cached. */
+    private loadCollateralTokenNamesOnce;
+    /** Reads `activeAssetData` for each coin in parallel, dropping the coins the venue refuses. */
+    private fetchActiveAssetEvents;
+    /** The asset set `availableMargin` is the floor over: the locked coins plus every tracked one. */
+    private coinsForAvailableMargin;
     private onClearinghouseState;
     private onActiveAssetData;
+    private onAllMids;
     private onWebData3;
     private onSpotState;
+    /**
+     * Builds the live balance once every channel that feeds it has reported, or `undefined` until then.
+     *
+     * All four are required. Every mode now values the spot wallet, so a balance emitted before
+     * `spotState` and `allMids` would report equity missing its whole spot half; and one emitted
+     * before `webData3` would report vault equity as zero on an account that holds millions in a
+     * vault. Partial equity is worse than no equity, so nothing is published early.
+     */
     private buildBalance;
+    /** The floor of `availableToTrade` over the tracked set; `null` when nothing is tracked. */
+    private availableMargin;
     /** Clears both sides of the live balance join and the public account cache without emitting. */
     private resetLiveAccountState;
     private buildTrackedAssetsMap;
 }
 
+/**
+ * Lighter's two account-mode balance variants.
+ *
+ * Classic is Unified minus `portfolioMargin`, so both modes share one field block.
+ */
+
+declare const LighterClassicBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    tradingEquity: z.ZodNullable<z.ZodString>;
+    perpetualsEquity: z.ZodNullable<z.ZodString>;
+    spotEquity: z.ZodNullable<z.ZodString>;
+    publicPoolsEquity: z.ZodNullable<z.ZodString>;
+    stakingEquity: z.ZodNullable<z.ZodString>;
+    creditedInLit: z.ZodNullable<z.ZodString>;
+    unrealizedPnl: z.ZodNullable<z.ZodString>;
+    crossLeverage: z.ZodNullable<z.ZodString>;
+    maintenanceMargin: z.ZodNullable<z.ZodString>;
+    crossMarginUsage: z.ZodNullable<z.ZodString>;
+    crossMarginRatio: z.ZodNullable<z.ZodString>;
+    accountMode: z.ZodLiteral<"lighter:classic">;
+}, z.core.$strip>;
+type LighterClassicBalance = z.infer<typeof LighterClassicBalance>;
+declare const LighterUnifiedBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    portfolioMargin: z.ZodNullable<z.ZodString>;
+    tradingEquity: z.ZodNullable<z.ZodString>;
+    perpetualsEquity: z.ZodNullable<z.ZodString>;
+    spotEquity: z.ZodNullable<z.ZodString>;
+    publicPoolsEquity: z.ZodNullable<z.ZodString>;
+    stakingEquity: z.ZodNullable<z.ZodString>;
+    creditedInLit: z.ZodNullable<z.ZodString>;
+    unrealizedPnl: z.ZodNullable<z.ZodString>;
+    crossLeverage: z.ZodNullable<z.ZodString>;
+    maintenanceMargin: z.ZodNullable<z.ZodString>;
+    crossMarginUsage: z.ZodNullable<z.ZodString>;
+    crossMarginRatio: z.ZodNullable<z.ZodString>;
+    accountMode: z.ZodLiteral<"lighter:unified">;
+}, z.core.$strip>;
+type LighterUnifiedBalance = z.infer<typeof LighterUnifiedBalance>;
+
 type LighterAccountTrackerConfig = AccountTrackerConfig & {
     account: TradeAccount;
     credentials: SupportedCredentials;
-    sdk?: PearSDK;
 };
 declare class LighterAccountTracker extends BaseAccountTracker {
     private readonly accountIdentifier;
-    private readonly sdk;
     private ws;
     private messageListenerId;
     private openListenerId;
-    private pollTimer;
-    private pollInFlight;
+    private positionPollTimer;
+    private positionPollInFlight;
+    private marketRefreshTimer;
+    private marketRefreshInFlight;
     private startInFlight;
     private lifecycleVersion;
     private stateVersion;
     private assetsByAssetId;
-    private rawPositionsByMarketId;
+    private wsPositionsByMarketId;
     private marketsByMarketId;
-    private summary;
-    private accountTier;
-    private lastAccountTierFetchAt;
+    private marketsBySymbol;
+    private spotPriceBySymbol;
+    private stats;
     private hasAssets;
     constructor(config: LighterAccountTrackerConfig);
-    /** Stateless one-shot account read; tier enrichment is optional and requires SDK-backed auth. */
+    /** Stateless one-shot account read — public endpoints only, and no websocket. */
     snapshot(): Promise<AccountSnapshot>;
     /**
      * Stateless one-shot per-asset settings read, keyed by market id (the same identifier the live
@@ -1143,6 +1982,10 @@ declare class LighterAccountTracker extends BaseAccountTracker {
      * supplies the exchange default for markets absent from the account payload.
      */
     protected fetchAssetSnapshots(marketIds: string[]): Promise<AssetSnapshotMap>;
+    /** Sizes a basket against the live account state, falling back to REST before the socket is up. */
+    maxBasketSize(input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
+    /** Sizes a basket over REST alone, so the answer needs no running socket. */
+    snapshotMaxBasketSize(input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
     start(): Promise<void>;
     /** Creates one tracker lifecycle while repeated callers share the same pending start. */
     private performStart;
@@ -1156,15 +1999,148 @@ declare class LighterAccountTracker extends BaseAccountTracker {
     private routeRaw;
     private handle;
     private onAccountAll;
+    /** Keeps both published scopes: cross drives every "Cross" field, total drives the account ones. */
     private onUserStats;
+    /**
+     * The account's balance, built from websocket state alone.
+     *
+     * Every input is websocket-sourced — `user_stats` for the two account scopes, `account_all` for
+     * the assets and positions — except the market context, which is venue-wide metadata this
+     * tracker re-reads on its own timer. This is the ONLY producer of the value `getBalance()`
+     * returns while the tracker is running; `snapshot()` is the separate REST path and never writes
+     * here.
+     *
+     * Null until both channels have delivered a frame, because a balance built from one of them
+     * would be missing half the account.
+     */
     private buildBalance;
+    /** The market data both read paths join account state against, as the latest read left it. */
+    private marketContext;
+    /** The account's current per-market settings as the base tracker already holds them. */
+    private liveAccountSettings;
     private fetchPrimaryAccount;
-    private fetchAccountTier;
-    private pollAccount;
-    private performAccountPoll;
-    private shouldRefreshAccountTier;
+    private pollPositions;
+    /**
+     * Republishes positions and per-market settings from REST.
+     *
+     * Deliberately publishes NO balance. Every field of both Lighter variants comes off the two
+     * websocket channels — `user_stats` carries both account scopes and `account_all` carries the
+     * assets and positions behind them — so a REST balance here would only overwrite a live value
+     * with an equal one, while making `getBalance()` REST-derived most of the time.
+     *
+     * It also leaves `wsPositionsByMarketId` alone. That store feeds the live balance's unrealized
+     * PnL and maintenance margin, so writing REST rows into it would make a balance labelled live
+     * partly REST-derived without any reader being able to tell.
+     */
+    private performPositionPoll;
+    /** Shares one in-flight market read, so a slow response cannot stack requests behind the WAF. */
+    private refreshMarkets;
+    /**
+     * Re-reads the venue's markets and republishes the balance they move.
+     *
+     * `spotEquity` values each holding at the last trade its own spot book printed, so an index read
+     * only at `start()` values a session-long tracker at session-old prices — and every scalar built
+     * on it drifts with it.
+     *
+     * The perp books ride along, which is what closes the gap `toPositionRisks` documents: a market
+     * Lighter listed after `start()` was unknown to the balance for the rest of the session, so a
+     * position on it left the maintenance figure unknown for just as long. The read already carries
+     * them, so learning them costs nothing. Their risk parameters come along as a consequence, which
+     * only makes a slowly-moving margin fraction current rather than session-old.
+     *
+     * Perp books are UPSERTED, never replaced. An account can still hold a position on a market that
+     * has dropped out of the listing, and the parameters this tracker last saw price that position —
+     * where forgetting the market would stop pricing it at all.
+     *
+     * A read that fails, or that comes back carrying no spot books at all, leaves the last good price
+     * index in place. Stale prices still value the account; an empty index would null every spot
+     * figure the account has at once, which is a worse answer than a slightly old one.
+     *
+     * Only the market data moves here. A newly listed market's exchange-default asset settings reach
+     * `trackAsset` consumers on the next websocket epoch, where `handleWsOpen` already republishes
+     * them for every known market — publishing them here would overwrite the account's own settings.
+     */
+    private performMarketRefresh;
 }
 
+/**
+ * OKX's four account-mode balance variants.
+ *
+ * Core fields only, with `null` wherever a figure cannot be derived. OKX publishes no account-level
+ * margin fields in Futures mode (`acctLv=2`) at all, which is exactly why the flat shape had to go
+ * — and why `perCollateral` matters most there, since `details[].availEq` is per currency. What
+ * differs by mode is not the shape but when the core scalars go null, which follows each mode's
+ * collateral-pool model. One `z.literal` per mode, because `z.discriminatedUnion` needs a single
+ * literal tag per member rather than a `z.enum` shorthand.
+ */
+
+/**
+ * Spot and Futures mode run one collateral pool per currency, so `totalEq` is a USD total across
+ * budgets that cannot fund each other. Once a second pool is funded there is no spendable account
+ * total, so `totalEquity` goes null and `perCollateral` is the whole answer. `OkxFuturesBalance`
+ * carries the same rule.
+ */
+declare const OkxSpotBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"okx:spot">;
+}, z.core.$strip>;
+type OkxSpotBalance = z.infer<typeof OkxSpotBalance>;
+declare const OkxFuturesBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"okx:futures">;
+}, z.core.$strip>;
+type OkxFuturesBalance = z.infer<typeof OkxFuturesBalance>;
+declare const OkxMultiCurrencyMarginBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"okx:multiCurrencyMargin">;
+}, z.core.$strip>;
+type OkxMultiCurrencyMarginBalance = z.infer<typeof OkxMultiCurrencyMarginBalance>;
+declare const OkxPortfolioMarginBalance: z.ZodObject<{
+    totalEquity: z.ZodNullable<z.ZodString>;
+    withdrawableBalance: z.ZodNullable<z.ZodString>;
+    availableMargin: z.ZodNullable<z.ZodString>;
+    poolsShared: z.ZodBoolean;
+    perCollateral: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        equity: z.ZodString;
+        availableMargin: z.ZodNullable<z.ZodString>;
+        withdrawable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+    accountMode: z.ZodLiteral<"okx:portfolioMargin">;
+}, z.core.$strip>;
+type OkxPortfolioMarginBalance = z.infer<typeof OkxPortfolioMarginBalance>;
+
 type OkxAccountTrackerConfig = AccountTrackerConfig & {
     credentials: SupportedCredentials;
 };
@@ -1175,10 +2151,26 @@ declare class OkxAccountTracker extends BaseAccountTracker {
     private openListenerId;
     private rawCoins;
     private lastBalance;
-    private accountType;
+    private accountMode;
+    private withdrawable;
+    private lastWithdrawableReadAt;
+    private withdrawableRefreshTimer;
+    private withdrawableReadInFlight;
+    private withdrawableReadPending;
+    private lifecycleVersion;
     private trackedAssetInfos;
     constructor(config: OkxAccountTrackerConfig);
     snapshot(): Promise<AccountSnapshot>;
+    /**
+     * OKX sizes no basket in v1: the SDK reads no per-asset max leverage from it, and sizing off
+     * `availableMargin` alone would ship a number no venue field backs. The missing input is
+     * `GET /api/v5/public/position-tiers` → `maxLever`/`imr` per tier, which the client does not
+     * call — and it is NOT `GET /api/v5/account/position-tiers`, a different endpoint carrying no
+     * margin or leverage data at all.
+     */
+    maxBasketSize(_input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
+    /** The REST path answers the same way — there is no size either way, not a slower one. */
+    snapshotMaxBasketSize(_input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
     /**
      * Stateless one-shot per-asset leverage read via `leverage-info`, which accepts up to 20 instIds
      * per request (chunked in the client), so N assets cost ceil(N/20) calls. Cross margin only,
@@ -1189,19 +2181,75 @@ declare class OkxAccountTracker extends BaseAccountTracker {
     protected cleanupConnections(): Promise<void>;
     get isConnected(): boolean;
     private fetchSnapshotData;
+    /**
+     * Read how much can leave the trading account, per currency, across everything it owns.
+     *
+     * Best-effort on purpose: this is a fourth signed call that a read-only key may be refused, and
+     * a refusal must cost the caller a `null` field rather than the whole balance.
+     *
+     * A refusal is reported as `failed` rather than as an empty row set, because only the caller
+     * knows what to do with it: the snapshot path has no earlier figure and reports nothing known,
+     * while the live path keeps the figure its last successful read published.
+     */
+    private readMaxWithdrawals;
     protected ensureAssetTracked(instId: string): void;
     protected releaseAsset(instId: string): void;
     private subscribe;
     private handleInitialData;
     private routeRaw;
     private handleMessage;
+    /**
+     * Fold one account push into the whole account, then publish what that whole account says.
+     *
+     * OKX pushes only what moved: an update names the currencies whose figures changed and leaves
+     * every other currency out. So the rows are taken from the per-currency merge rather than from
+     * the push, and everything read off them — the pool count above all — sees every currency the
+     * account holds. A push naming one of two funded currencies would otherwise read as a
+     * single-pool account and publish scalars that describe neither pool.
+     *
+     * The account-level figures inherit on `??`, never on `||`, because ABSENT and BLANK say
+     * opposite things here. A field this push left out was not restated and its previous value still
+     * stands; a field present as `''` is OKX withdrawing the figure, which it does per account mode —
+     * `availableMarginOf` records the mode that blanks `availEq`. Inheriting a blank would republish
+     * a number the venue no longer states, and it would do it BEHIND `decimalOrNull`, whose whole job
+     * is to publish a blank as `null`: overwriting the blank here means that guard never sees it.
+     */
     private handleBalanceUpdate;
+    /** Publish the balance built from the newest account payload and the cached transferable amounts. */
+    private emitBalance;
+    /**
+     * Queue the next transferable-amount read, no sooner than the venue's own rate limit allows.
+     *
+     * Nothing waits on it: the account update is already published from the cached figure. One
+     * queued read covers every account tick that lands before it runs, which is what stops a burst
+     * of ticks becoming a burst of signed calls — and because a tick always leaves a read queued or
+     * marked pending, a moved figure is still picked up within one interval rather than dropped.
+     */
+    private refreshWithdrawableSoon;
+    /**
+     * Hold one transferable-amount read open at a time, and queue the ticks that arrive during it.
+     *
+     * Serialising the reads is what keeps the published figure the newest one: two overlapping reads
+     * can come back in either order, and the older answer landing last would publish an amount the
+     * venue has already moved past.
+     */
+    private refreshWithdrawableBalance;
+    /**
+     * Re-read the transferable amount behind the live path, then re-publish only if it moved.
+     *
+     * Fire-and-forget: the account update is already published with the previous figure, so a slow
+     * read delays the correction instead of blocking the balance. A read that FAILS changes nothing
+     * at all — the last good figure stays published, because a refusal says OKX did not answer, not
+     * that the account has nothing to transfer. The re-publish reads the newest account payload
+     * rather than the one this read started from, so an account update that landed meanwhile is not
+     * rolled back.
+     */
+    private performWithdrawableRefresh;
 }
 
 type CreateAccountTrackerConfig = AccountTrackerConfig & {
     account: TradeAccount;
     credentials: SupportedCredentials;
-    sdk?: PearSDK;
 };
 declare function createAccountTracker(exchange: Connector, config: CreateAccountTrackerConfig): AccountTracker;
 
@@ -1218,6 +2266,11 @@ declare class ExchangesSDK {
     status(connection: ExchangeConnection, options?: ConnectOptions): Promise<AccountStatus>;
     createTracker(connection: ExchangeConnection): AccountTracker;
     snapshot(tradeAccountId: string): Promise<AccountSnapshot>;
+    /**
+     * Sizes a basket in one shot. Routed to the tracker's REST path on purpose: this entry point
+     * builds a throwaway tracker per call, so it must open no socket.
+     */
+    maxBasketSize(tradeAccountId: string, input: MaxBasketSizeInput): Promise<MaxBasketSizeResult>;
     snapshotAssets(tradeAccountId: string, coins: string[]): Promise<AssetSnapshotMap>;
     createHelper<E extends ExchangeHelperExchange>(exchange: E): ExchangeHelperMap[E];
     createSyncer(connection: ExchangeConnection): AccountSyncer;
@@ -1225,4 +2278,4 @@ declare class ExchangesSDK {
     private fetchCredentials;
 }
 
-export { ACCOUNT_TYPE_LABELS, ASSET_DECIMALS, type AccountBalance, type AccountHealthStatus, type AccountPosition, type AccountSnapshot, type AccountStatus, type AccountSyncer, type AccountSyncerConfig, type AccountTracker, type AccountTrackerConfig, type AccountType, type AccountWarningReason, type ApiKey, type ApproveIntegratorParams, type ApproveIntegratorResult, type AssetBalance, AssetId, type AssetSnapshotMap, type BalanceCallback, BaseAccountSyncer, BaseAccountTracker, BaseWs, BinanceAccountSyncer, BinanceAccountTracker, type BinanceAccountTrackerConfig, BinanceAccountType, BinanceExchangeWs, BinanceUserDataWs, type BinanceUserDataWsConfig, BinanceWsApi, type BinanceWsApiConfig, BybitAccountSyncer, BybitAccountTracker, type BybitAccountTrackerConfig, BybitAccountType, BybitExchangeWs, BybitWs, type BybitWsConfig, type CctpDepositHistorySettlement, type CctpDepositIntentParams, type CctpDepositIntentResult, type CctpDepositParams, type CctpDepositProgress, type CctpDepositRegistrationSettlement, type CctpDepositResult, type CctpDepositSettlement, type CctpDepositWalletAdapter, type CheckApiWalletParams, type ConnectOptions, type ConnectWalletParams, type ConnectWalletResult, type CreateAccountTrackerConfig, type CreateExchangeWsConfig, type DepositParams, type DepositResult, type ExchangeConnection, type ExchangeHelperExchange, type ExchangeHelperMap, type ExchangeState, ExchangeWs, type ExchangeWsByConnector, ExchangesSDK, type ExchangesSDKConfig, type FastWithdrawParams, type FastWithdrawResult, HyperliquidAccountSyncer, HyperliquidAccountTracker, type HyperliquidAccountTrackerConfig, HyperliquidAccountType, HyperliquidExchangeWs, type HyperliquidHelper, HyperliquidWs, type IntegratorApprovalRequirements, L2_ASSET_DECIMALS, LIGHTER_CCTP_USDC_ADDRESSES, LIGHTER_CCTP_USDC_DECIMALS, LighterAccountSyncer, LighterAccountTracker, type LighterAccountTrackerConfig, LighterAccountType, type LighterDeposit, type LighterDepositNetwork, LighterExchangeWs, type LighterHelper, type LighterLookupResult, type LighterOnboardingStatus, LighterWs, type ListExternalFillsParams, type ListExternalFundingParams, type ListExternalPositionsParams, MAX_API_KEY_INDEX, MIN_LIGHTER_CCTP_DEPOSIT_USDC, MIN_LIGHTER_FAST_WITHDRAW_USDC, MIN_USER_API_KEY_INDEX, type MarginMode, type MessageListener, OkxAccountSyncer, OkxAccountTracker, type OkxAccountTrackerConfig, OkxAccountType, OkxExchangeWs, OkxWs, type OkxWsConfig, type OpenListener, type PositionsCallback, RouteType, type StateUpdate, type SupportedCredentials, type TrackedAssetCallback, type TrackedAssetInfo, type WalletClientWithAccount, type WithdrawParams, type WithdrawResult, type WsMessage, createAccountSyncer, createAccountTracker, createExchangeWs, createHyperliquidHelper, createLighterHelper, findAvailableApiKeyIndex, getAssetDecimals, getLighterCctpUsdcAddress, usdcAbi };
+export { ACCOUNT_MODE_LABELS, ASSET_DECIMALS, AccountBalance, AccountBalanceCore, type AccountHealthStatus, AccountMode, type AccountPosition, type AccountSnapshot, type AccountStatus, type AccountSyncer, type AccountSyncerConfig, type AccountTracker, type AccountTrackerConfig, type AccountWarningReason, type ApiKey, type ApproveIntegratorParams, type ApproveIntegratorResult, AssetId, type AssetSnapshotMap, type BalanceCallback, BaseAccountSyncer, BaseAccountTracker, BaseWs, BasketLeg, BinanceAccountSyncer, BinanceAccountTracker, type BinanceAccountTrackerConfig, BinanceExchangeWs, BinanceMultiAssetBalance, BinanceSingleAssetBalance, BinanceUserDataWs, type BinanceUserDataWsConfig, BinanceWsApi, type BinanceWsApiConfig, BybitAccountSyncer, BybitAccountTracker, type BybitAccountTrackerConfig, BybitExchangeWs, BybitIsolatedMarginBalance, BybitPortfolioMarginBalance, BybitRegularMarginBalance, BybitWs, type BybitWsConfig, type CappedBasketLeg, type CctpDepositHistorySettlement, type CctpDepositIntentParams, type CctpDepositIntentResult, type CctpDepositParams, type CctpDepositProgress, type CctpDepositRegistrationSettlement, type CctpDepositResult, type CctpDepositSettlement, type CctpDepositWalletAdapter, type CheckApiWalletParams, CollateralBalance, type ConnectOptions, type ConnectWalletParams, type ConnectWalletResult, type CreateAccountTrackerConfig, type CreateExchangeWsConfig, DecimalString, type DepositParams, type DepositResult, type ExchangeConnection, type ExchangeHelperExchange, type ExchangeHelperMap, type ExchangeState, ExchangeWs, type ExchangeWsByConnector, ExchangesSDK, type ExchangesSDKConfig, type FastWithdrawParams, type FastWithdrawResult, type FillSyncOutcome, type FundingSyncOutcome, HyperliquidAccountSyncer, HyperliquidAccountTracker, type HyperliquidAccountTrackerConfig, HyperliquidDexState, HyperliquidExchangeWs, type HyperliquidHelper, HyperliquidPortfolioMarginBalance, HyperliquidPortfolioMarginCollateral, HyperliquidStandardBalance, HyperliquidUnifiedBalance, HyperliquidWs, type IntegratorApprovalRequirements, L2_ASSET_DECIMALS, LIGHTER_CCTP_USDC_ADDRESSES, LIGHTER_CCTP_USDC_DECIMALS, LighterAccountSyncer, LighterAccountTracker, type LighterAccountTrackerConfig, LighterClassicBalance, type LighterDeposit, type LighterDepositNetwork, LighterExchangeWs, type LighterHelper, type LighterLookupResult, type LighterOnboardingStatus, LighterUnifiedBalance, LighterWs, type ListExternalFillsParams, type ListExternalFundingParams, type ListExternalPositionsParams, MAX_API_KEY_INDEX, MIN_LIGHTER_CCTP_DEPOSIT_USDC, MIN_LIGHTER_FAST_WITHDRAW_USDC, MIN_USER_API_KEY_INDEX, MarginMode, type MaxBasketSizeCalculation, MaxBasketSizeInput, MaxBasketSizeResult, type MessageListener, OkxAccountSyncer, OkxAccountTracker, type OkxAccountTrackerConfig, OkxExchangeWs, OkxFuturesBalance, OkxMultiCurrencyMarginBalance, OkxPortfolioMarginBalance, OkxSpotBalance, OkxWs, type OkxWsConfig, type OpenListener, type PositionsCallback, RouteType, Side, SignedDecimalString, type StateUpdate, type SupportedCredentials, type TrackedAssetCallback, type TrackedAssetInfo, type WalletClientWithAccount, type WithdrawParams, type WithdrawResult, type WsMessage, computeMaxBasketSize, createAccountSyncer, createAccountTracker, createExchangeWs, createHyperliquidHelper, createLighterHelper, findAvailableApiKeyIndex, getAssetDecimals, getLighterCctpUsdcAddress, usdcAbi };