@pear-protocol/exchanges-sdk 0.10.0 → 0.12.0

package/dist/client/lighter/rest.js

@@ -300,6 +300,80 @@ async function fetchPositionFundingSince(accountIndex, authToken, since, demo =
   return Array.from(results.values());
 }
 __name(fetchPositionFundingSince, "fetchPositionFundingSince");
+async function submitReferralCode(params, demo = false) {
+  const body = new URLSearchParams({
+    l1_address: params.l1Address,
+    referral_code: params.referralCode
+  });
+  if (params.discord) {
+    body.set("discord", params.discord);
+  }
+  if (params.telegram) {
+    body.set("telegram", params.telegram);
+  }
+  if (params.x) {
+    body.set("x", params.x);
+  }
+  if (params.signature) {
+    body.set("signature", params.signature);
+  }
+  const response = await authenticatedLighterFetch(`${getLighterBaseUrl(demo)}/api/v1/referral/use`, params.authToken, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body
+  });
+  await readLighterResponse(response, "/referral/use");
+}
+__name(submitReferralCode, "submitReferralCode");
+async function fetchUserReferrals(params, demo = false) {
+  const query = new URLSearchParams({
+    l1_address: params.l1Address
+  });
+  if (params.cursor) {
+    query.set("cursor", params.cursor);
+  }
+  if (params.statsStartTimestamp !== void 0) {
+    query.set("stats_start_timestamp", params.statsStartTimestamp.toString());
+  }
+  if (params.statsEndTimestamp !== void 0) {
+    query.set("stats_end_timestamp", params.statsEndTimestamp.toString());
+  }
+  if (params.limit !== void 0) {
+    query.set("limit", params.limit.toString());
+  }
+  if (params.eligibleOnly) {
+    query.set("is_eligible", "true");
+  }
+  const response = await authenticatedLighterFetch(`${getLighterBaseUrl(demo)}/api/v1/referral/userReferrals?${query.toString()}`, params.authToken);
+  const data = await readLighterResponse(response, "/referral/userReferrals");
+  const referrals = [];
+  for (const referral of data.referrals ?? []) {
+    if (typeof referral !== "object" || referral === null) {
+      continue;
+    }
+    if (typeof referral.l1_address !== "string") {
+      continue;
+    }
+    referrals.push({
+      l1Address: referral.l1_address,
+      referralCode: typeof referral.referral_code === "string" ? referral.referral_code : "",
+      usedAt: readReferralCount(referral.used_at),
+      tier: typeof referral.tier === "string" ? referral.tier : "",
+      tradeStats: readReferralTradeStats(referral.trade_stats)
+    });
+  }
+  return {
+    usedCode: typeof data.used_code === "string" && data.used_code.length > 0 ? data.used_code : null,
+    referrals,
+    totals: readReferralTotals(data.totals),
+    // Reuse the funding-history reading: it treats an unparseable cursor as live, so the worst an
+    // encoding mismatch costs here is one extra empty page rather than a dropped one.
+    nextCursor: readHistoryCursor(data.cursor)
+  };
+}
+__name(fetchUserReferrals, "fetchUserReferrals");
 async function authenticatedLighterFetch(url, authToken, init) {
   const headers = new Headers(init?.headers);
   headers.set("authorization", authToken);
@@ -374,5 +448,49 @@ async function readLighterResponse(response, endpoint, acceptedCodes = [
   return data;
 }
 __name(readLighterResponse, "readLighterResponse");
+function readReferralTradeStats(stats) {
+  const raw = typeof stats === "object" && stats !== null ? stats : {};
+  return {
+    count: readReferralCount(raw.count),
+    volume: readReferralAmount(raw.volume),
+    webCount: readReferralCount(raw.web_count),
+    webVolume: readReferralAmount(raw.web_volume),
+    mobileAppCount: readReferralCount(raw.mobile_app_count),
+    mobileAppVolume: readReferralAmount(raw.mobile_app_volume),
+    mobileBrowserCount: readReferralCount(raw.mobile_browser_count),
+    mobileBrowserVolume: readReferralAmount(raw.mobile_browser_volume),
+    freeMakerVolume: readReferralAmount(raw.free_maker_volume),
+    freeTakerVolume: readReferralAmount(raw.free_taker_volume),
+    nonFreeMakerVolume: readReferralAmount(raw.non_free_maker_volume),
+    nonFreeTakerVolume: readReferralAmount(raw.non_free_taker_volume),
+    makerFeesPaid: readReferralAmount(raw.maker_fees_paid),
+    takerFeesPaid: readReferralAmount(raw.taker_fees_paid)
+  };
+}
+__name(readReferralTradeStats, "readReferralTradeStats");
+function readReferralTotals(totals) {
+  const raw = typeof totals === "object" && totals !== null ? totals : {};
+  return {
+    count: readReferralCount(raw.count),
+    volume: readReferralAmount(raw.volume),
+    freeMakerVolume: readReferralAmount(raw.free_maker_volume),
+    freeTakerVolume: readReferralAmount(raw.free_taker_volume),
+    nonFreeMakerVolume: readReferralAmount(raw.non_free_maker_volume),
+    nonFreeTakerVolume: readReferralAmount(raw.non_free_taker_volume),
+    makerFeesPaid: readReferralAmount(raw.maker_fees_paid),
+    takerFeesPaid: readReferralAmount(raw.taker_fees_paid),
+    totalReferrals: readReferralCount(raw.total_referrals),
+    totalPremiumReferrals: readReferralCount(raw.total_premium_referrals)
+  };
+}
+__name(readReferralTotals, "readReferralTotals");
+function readReferralCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+__name(readReferralCount, "readReferralCount");
+function readReferralAmount(value) {
+  return typeof value === "string" && value.length > 0 ? value : "0";
+}
+__name(readReferralAmount, "readReferralAmount");
 
-export { createCctpDepositIntentAddress, fetchAccount, fetchAccountLimits, fetchAccountMetadata, fetchAccountsByL1Address, fetchApiKeys, fetchAssetDetails, fetchDepositHistory, fetchDepositNetworks, fetchOrderBookDetails, fetchPositionFundingSince, fetchPublicAccount, fetchPublicOrderBookDetails, fetchTradesSince, fetchWithdrawHistory };
+export { createCctpDepositIntentAddress, fetchAccount, fetchAccountLimits, fetchAccountMetadata, fetchAccountsByL1Address, fetchApiKeys, fetchAssetDetails, fetchDepositHistory, fetchDepositNetworks, fetchOrderBookDetails, fetchPositionFundingSince, fetchPublicAccount, fetchPublicOrderBookDetails, fetchTradesSince, fetchUserReferrals, fetchWithdrawHistory, submitReferralCode };

package/dist/helper/lighter/helper.js

@@ -7,6 +7,7 @@ import { createDepositAddressForRoute, depositThroughRoute } from './deposit.hel
 import { writeWithdraw } from './ethereum';
 import { readWithdrawHistory, readDepositHistory } from './history.helper';
 import { LIGHTER_ACCOUNT_NOT_REGISTERED_CODE, readOnboardingStatus } from './onboarding.helper';
+import { readUserReferrals, applyReferralCode } from './referral.helper';
 import { MIN_LIGHTER_FAST_WITHDRAW_USDC } from './types';
 
 var __defProp = Object.defineProperty;
@@ -198,6 +199,18 @@ function createLighterHelper(sdk, demo = false) {
     /** Reads one page of the account's withdrawal history, newest first. */
     async getWithdrawHistory(params) {
       return readWithdrawHistory(sdk, params, demo);
+    },
+    /** Reads the Fun.xyz bridge deposits Lighter has seen for a wallet. */
+    async listUdaDeposits(walletAddress) {
+      return sdk.core.misc.lighter.listUdaDeposits(walletAddress);
+    },
+    /** Applies a referrer's code to the owner. Lighter accepts this at most once per owner. */
+    async applyReferralCode(params) {
+      return applyReferralCode(sdk, params, demo);
+    },
+    /** Reads one page of the owner's referral record, including the code that referred them. */
+    async getUserReferrals(params) {
+      return readUserReferrals(sdk, params, demo);
     }
   };
   return helper;

package/dist/helper/lighter/referral.helper.js

@@ -0,0 +1,33 @@
+import { submitReferralCode, fetchUserReferrals } from '../../client/lighter/rest';
+import { retrieveLighterAuthToken } from './auth-token.helper';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function applyReferralCode(sdk, params, demo) {
+  const authToken = await retrieveLighterAuthToken(sdk, params.credentials, demo);
+  await submitReferralCode({
+    l1Address: params.l1Address,
+    referralCode: params.referralCode,
+    authToken,
+    discord: params.discord,
+    telegram: params.telegram,
+    x: params.x,
+    signature: params.signature
+  }, demo);
+}
+__name(applyReferralCode, "applyReferralCode");
+async function readUserReferrals(sdk, params, demo) {
+  const authToken = await retrieveLighterAuthToken(sdk, params.credentials, demo);
+  return fetchUserReferrals({
+    l1Address: params.l1Address,
+    authToken,
+    cursor: params.cursor,
+    statsStartTimestamp: params.statsStartTimestamp,
+    statsEndTimestamp: params.statsEndTimestamp,
+    limit: params.limit,
+    eligibleOnly: params.eligibleOnly
+  }, demo);
+}
+__name(readUserReferrals, "readUserReferrals");
+
+export { applyReferralCode, readUserReferrals };

package/dist/index.d.ts

@@ -319,6 +319,62 @@ type LighterWithdrawPage = {
     /** Null once Lighter holds no older page. */
     nextCursor: string | null;
 };
+/** What one referred trader has traded, over whatever window the request asked Lighter for. */
+type LighterReferralTradeStats = {
+    count: number;
+    volume: string;
+    webCount: number;
+    webVolume: string;
+    mobileAppCount: number;
+    mobileAppVolume: string;
+    mobileBrowserCount: number;
+    mobileBrowserVolume: string;
+    freeMakerVolume: string;
+    freeTakerVolume: string;
+    nonFreeMakerVolume: string;
+    nonFreeTakerVolume: string;
+    makerFeesPaid: string;
+    takerFeesPaid: string;
+};
+/** One trader who signed up under the owner's code. */
+type LighterReferral = {
+    l1Address: string;
+    /** The code that trader used, which is the owner's own code. */
+    referralCode: string;
+    /** When the code was used. Lighter states no unit; its funding histories send milliseconds. */
+    usedAt: number;
+    /** Lighter's tier wording for that trader; a kickback accrues only above `standard`. */
+    tier: string;
+    tradeStats: LighterReferralTradeStats;
+};
+/** The owner's running referral totals, which count every referral rather than only this page. */
+type LighterReferralTotals = {
+    count: number;
+    volume: string;
+    freeMakerVolume: string;
+    freeTakerVolume: string;
+    nonFreeMakerVolume: string;
+    nonFreeTakerVolume: string;
+    makerFeesPaid: string;
+    takerFeesPaid: string;
+    totalReferrals: number;
+    /** How many referrals hold a paid tier, which is the only kind that earns a kickback. */
+    totalPremiumReferrals: number;
+};
+/**
+ * One page of an owner's referral record.
+ *
+ * `usedCode` is the only place Lighter reports who referred the owner, and it reports the code
+ * rather than the referrer. Lighter publishes no endpoint that resolves a code back to its owner.
+ */
+type LighterUserReferrals = {
+    /** The code the owner signed up under, or null when nobody referred them. */
+    usedCode: string | null;
+    referrals: LighterReferral[];
+    totals: LighterReferralTotals;
+    /** Null once Lighter holds no further page. */
+    nextCursor: string | null;
+};
 
 /** Shares one live Lighter auth token per account without crossing rotated credentials. */
 
@@ -752,6 +808,38 @@ type LighterOnboardingStatus = {
     mainAccountIndex: number;
     subAccountIndexes: number[];
 };
+type LighterApplyReferralCodeParams = {
+    /** Signs the write; the account it names must belong to the address below. */
+    credentials: LighterAuthCredentials;
+    /** The owner address the referral binds to; Lighter keys its referral record by address. */
+    l1Address: string;
+    /** The referrer's code, spelled the way Lighter prints it. */
+    referralCode: string;
+    /** Lighter accepts a Discord handle beside the code but documents no format for it. */
+    discord?: string;
+    /** Lighter accepts a Telegram handle beside the code but documents no format for it. */
+    telegram?: string;
+    /** Lighter accepts an X handle beside the code but documents no format for it. */
+    x?: string;
+    /** Lighter accepts a signature beside the code but documents neither its payload nor its scheme. */
+    signature?: string;
+};
+type LighterUserReferralsParams = {
+    /** Signs the read; the account it names must belong to the address below. */
+    credentials: LighterAuthCredentials;
+    /** The owner address whose referral record comes back. */
+    l1Address: string;
+    /** The `nextCursor` of the page just read; omit to read the first page. */
+    cursor?: string;
+    /** Opens the `tradeStats` window. Lighter states no unit for it, so pass what its own client passes. */
+    statsStartTimestamp?: number;
+    /** Closes the `tradeStats` window. Lighter states no unit for it, so pass what its own client passes. */
+    statsEndTimestamp?: number;
+    /** Rows per page, between 1 and 300; omit to take Lighter's own page size. */
+    limit?: number;
+    /** Narrows the page to the referrals Lighter counts toward a kickback tier. */
+    eligibleOnly?: boolean;
+};
 interface LighterHelper {
     checkOnboarding(l1Address: string): Promise<LighterOnboardingStatus>;
     lookupAccount(l1Address: string): Promise<LighterLookupResult>;
@@ -774,6 +862,12 @@ interface LighterHelper {
     getDepositHistory(params: LighterDepositHistoryParams): Promise<LighterDepositPage>;
     /** Reads one page of the account's withdrawal history, newest first. */
     getWithdrawHistory(params: LighterWithdrawHistoryParams): Promise<LighterWithdrawPage>;
+    /** Reads the Fun.xyz bridge deposits Lighter has seen for a wallet. */
+    listUdaDeposits(walletAddress: string): Promise<HttpTypes.ListLighterUdaDepositsResult>;
+    /** Applies a referrer's code to the owner. Lighter accepts this at most once per owner. */
+    applyReferralCode(params: LighterApplyReferralCodeParams): Promise<void>;
+    /** Reads one page of the owner's referral record, including the code that referred them. */
+    getUserReferrals(params: LighterUserReferralsParams): Promise<LighterUserReferrals>;
 }
 type LighterLookupResult = {
     mainAccountIndex: number;
@@ -1432,98 +1526,6 @@ declare const AccountBalanceCore: z.ZodObject<{
 /** Human-readable name for each mode, as the venue's own account page labels it. */
 declare const ACCOUNT_MODE_LABELS: Record<AccountMode, string>;
 
-/**
- * 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;
-    /**
-     * 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';
@@ -1580,16 +1582,12 @@ 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;
@@ -1630,9 +1628,6 @@ 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;
@@ -1705,15 +1700,6 @@ declare class BinanceAccountTracker extends BaseAccountTracker {
     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.
@@ -1812,15 +1798,6 @@ declare class BybitAccountTracker extends BaseAccountTracker {
     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
@@ -2093,13 +2070,6 @@ declare class HyperliquidAccountTracker extends BaseAccountTracker {
      * 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
@@ -2123,10 +2093,6 @@ 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. */
@@ -2275,10 +2241,6 @@ 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;
@@ -2323,8 +2285,6 @@ declare class LighterAccountTracker extends BaseAccountTracker {
     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;
     /** Reads the account with credentials when present, or explicitly uses the read-only verifier path. */
     private fetchPrimaryAccount;
     /** Reads market context under the same account identity as the snapshot that consumes it. */
@@ -2484,16 +2444,6 @@ declare class OkxAccountTracker extends BaseAccountTracker {
     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,
@@ -2591,11 +2541,6 @@ 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;
@@ -2603,4 +2548,4 @@ declare class ExchangesSDK {
     private fetchCredentials;
 }
 
-export { ACCOUNT_MODE_LABELS, ASSET_DECIMALS, AccountBalance, AccountBalanceCore, type AccountHealthStatus, AccountMode, type AccountPosition, type AccountSnapshot, type AccountStatus, type AccountSyncer, type AccountSyncerConfig, type AccountTierCallback, 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 CctpDepositAddressParams, type CctpDepositAddressResult, type CctpDepositHistorySettlement, type CctpDepositParams, type CctpDepositRegistrationSettlement, type CctpDepositResult, type CctpDepositSettlement, type ChangeAccountTierParams, type ChangeAccountTierResult, type CheckApiWalletParams, CollateralBalance, type ConnectOptions, type ConnectWalletParams, type ConnectWalletResult, type CreateAccountTrackerConfig, type CreateExchangeWsConfig, DecimalString, type EthereumDepositParams, type EthereumDepositResult, type ExchangeConnection, type ExchangeHelperExchange, type ExchangeHelperMap, type ExchangeState, ExchangeWs, type ExchangeWsByConnector, ExchangesSDK, type ExchangesSDKConfig, FUNXYZ_DEPOSIT_MINIMUMS_USD, FUNXYZ_ETHEREUM_MAINNET_CHAIN_ID, FUNXYZ_EVM_CHAIN_NAMES, type FastWithdrawParams, type FastWithdrawResult, type FillSyncOutcome, type FundingSyncOutcome, type FunxyzAccountState, type FunxyzAsset, type FunxyzDepositAddressParams, type FunxyzDepositAddressResult, type FunxyzDepositCredit, type FunxyzDepositParams, type FunxyzDepositResult, type FunxyzDepositSettlement, type FunxyzDepositSource, type FunxyzMarket, HyperliquidAccountSyncer, HyperliquidAccountTracker, type HyperliquidAccountTrackerConfig, HyperliquidDexState, HyperliquidExchangeWs, type HyperliquidHelper, HyperliquidPortfolioMarginBalance, HyperliquidPortfolioMarginCollateral, HyperliquidStandardBalance, HyperliquidUnifiedBalance, HyperliquidWs, type IntegratorApprovalRequirements, L2_ASSET_DECIMALS, LIGHTER_NATIVE_USDC_ADDRESSES, LIGHTER_USDC_DECIMALS, LighterAccountSyncer, type LighterAccountTier, LighterAccountTracker, type LighterAccountTrackerConfig, type LighterAuthCredentials, LighterClassicBalance, type LighterDeposit, type LighterDepositAddressParams, type LighterDepositAddressResult, type LighterDepositCredit, type LighterDepositHistoryParams, type LighterDepositNetwork, type LighterDepositPage, type LighterDepositParams, type LighterDepositProgress, type LighterDepositResult, type LighterDepositStatus, type LighterDepositWalletAdapter, LighterExchangeWs, type LighterHelper, type LighterLookupResult, type LighterOnboardingStatus, LighterUnifiedBalance, type LighterWithdraw, type LighterWithdrawHistoryParams, type LighterWithdrawPage, type LighterWithdrawStatus, type LighterWithdrawType, 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, getLighterNativeUsdcAddress, listFunxyzTransferableChains, readFunxyzChainSource, readFunxyzMinimumUsd, retrieveLighterAuthToken, usdcAbi };
+export { ACCOUNT_MODE_LABELS, ASSET_DECIMALS, AccountBalance, AccountBalanceCore, type AccountHealthStatus, AccountMode, type AccountPosition, type AccountSnapshot, type AccountStatus, type AccountSyncer, type AccountSyncerConfig, type AccountTierCallback, type AccountTracker, type AccountTrackerConfig, type AccountWarningReason, type ApiKey, type ApproveIntegratorParams, type ApproveIntegratorResult, AssetId, type AssetSnapshotMap, type BalanceCallback, BaseAccountSyncer, BaseAccountTracker, BaseWs, 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 CctpDepositAddressParams, type CctpDepositAddressResult, type CctpDepositHistorySettlement, type CctpDepositParams, type CctpDepositRegistrationSettlement, type CctpDepositResult, type CctpDepositSettlement, type ChangeAccountTierParams, type ChangeAccountTierResult, type CheckApiWalletParams, CollateralBalance, type ConnectOptions, type ConnectWalletParams, type ConnectWalletResult, type CreateAccountTrackerConfig, type CreateExchangeWsConfig, DecimalString, type EthereumDepositParams, type EthereumDepositResult, type ExchangeConnection, type ExchangeHelperExchange, type ExchangeHelperMap, type ExchangeState, ExchangeWs, type ExchangeWsByConnector, ExchangesSDK, type ExchangesSDKConfig, FUNXYZ_DEPOSIT_MINIMUMS_USD, FUNXYZ_ETHEREUM_MAINNET_CHAIN_ID, FUNXYZ_EVM_CHAIN_NAMES, type FastWithdrawParams, type FastWithdrawResult, type FillSyncOutcome, type FundingSyncOutcome, type FunxyzAccountState, type FunxyzAsset, type FunxyzDepositAddressParams, type FunxyzDepositAddressResult, type FunxyzDepositCredit, type FunxyzDepositParams, type FunxyzDepositResult, type FunxyzDepositSettlement, type FunxyzDepositSource, type FunxyzMarket, HyperliquidAccountSyncer, HyperliquidAccountTracker, type HyperliquidAccountTrackerConfig, HyperliquidDexState, HyperliquidExchangeWs, type HyperliquidHelper, HyperliquidPortfolioMarginBalance, HyperliquidPortfolioMarginCollateral, HyperliquidStandardBalance, HyperliquidUnifiedBalance, HyperliquidWs, type IntegratorApprovalRequirements, L2_ASSET_DECIMALS, LIGHTER_NATIVE_USDC_ADDRESSES, LIGHTER_USDC_DECIMALS, LighterAccountSyncer, type LighterAccountTier, LighterAccountTracker, type LighterAccountTrackerConfig, type LighterApplyReferralCodeParams, type LighterAuthCredentials, LighterClassicBalance, type LighterDeposit, type LighterDepositAddressParams, type LighterDepositAddressResult, type LighterDepositCredit, type LighterDepositHistoryParams, type LighterDepositNetwork, type LighterDepositPage, type LighterDepositParams, type LighterDepositProgress, type LighterDepositResult, type LighterDepositStatus, type LighterDepositWalletAdapter, LighterExchangeWs, type LighterHelper, type LighterLookupResult, type LighterOnboardingStatus, type LighterReferral, type LighterReferralTotals, type LighterReferralTradeStats, LighterUnifiedBalance, type LighterUserReferrals, type LighterUserReferralsParams, type LighterWithdraw, type LighterWithdrawHistoryParams, type LighterWithdrawPage, type LighterWithdrawStatus, type LighterWithdrawType, 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 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, createAccountSyncer, createAccountTracker, createExchangeWs, createHyperliquidHelper, createLighterHelper, findAvailableApiKeyIndex, getAssetDecimals, getLighterNativeUsdcAddress, listFunxyzTransferableChains, readFunxyzChainSource, readFunxyzMinimumUsd, retrieveLighterAuthToken, usdcAbi };

package/dist/sdk.js

@@ -42,14 +42,6 @@ class ExchangesSDK {
     const connection = await this.fetchCredentials(tradeAccountId);
     return this.buildTracker(connection).snapshot();
   }
-  /**
-  * 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.
-  */
-  async maxBasketSize(tradeAccountId, input) {
-    const connection = await this.fetchCredentials(tradeAccountId);
-    return this.buildTracker(connection).snapshotMaxBasketSize(input);
-  }
   async snapshotAssets(tradeAccountId, coins) {
     const connection = await this.fetchCredentials(tradeAccountId);
     return this.buildTracker(connection).snapshotAssets(coins);

package/dist/tracker/binance/tracker.js

@@ -38,19 +38,6 @@ class BinanceAccountTracker extends BaseAccountTracker {
     };
   }
   /**
-  * 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.
-  */
-  async maxBasketSize(_input) {
-    return unsizedBasket();
-  }
-  /** The REST path answers the same way — there is no size either way, not a slower one. */
-  async snapshotMaxBasketSize(_input) {
-    return unsizedBasket();
-  }
-  /**
   * 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.
   */
@@ -254,13 +241,5 @@ function toTrackedAssetInfo(coin, risk) {
   };
 }
 __name(toTrackedAssetInfo, "toTrackedAssetInfo");
-function unsizedBasket() {
-  return {
-    maxNotional: null,
-    legs: [],
-    bindingConstraint: null
-  };
-}
-__name(unsizedBasket, "unsizedBasket");
 
 export { BinanceAccountTracker };

package/dist/tracker/bybit/tracker.js

@@ -37,19 +37,6 @@ class BybitAccountTracker extends BaseAccountTracker {
     };
   }
   /**
-  * 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.
-  */
-  async maxBasketSize(_input) {
-    return unsizedBasket();
-  }
-  /** The REST path answers the same way — there is no size either way, not a slower one. */
-  async snapshotMaxBasketSize(_input) {
-    return unsizedBasket();
-  }
-  /**
   * 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
   * only requested symbols without an open position need a per-symbol fill-in read (`?symbol=`
@@ -426,14 +413,6 @@ function sameWithdrawable(left, right) {
   return true;
 }
 __name(sameWithdrawable, "sameWithdrawable");
-function unsizedBasket() {
-  return {
-    maxNotional: null,
-    legs: [],
-    bindingConstraint: null
-  };
-}
-__name(unsizedBasket, "unsizedBasket");
 function toTrackedAssetInfo(coin, pos) {
   return {
     coin,

package/dist/tracker/hyperliquid/collateral.js

@@ -1,5 +1,5 @@
-import { minimumAvailableToTrade } from './basket-size';
 import { splitDexCoin } from './coin-name';
+import { toDecimal } from './decimal';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -44,5 +44,18 @@ function collateralTokenByDex(perDexState) {
   return tokenByDex;
 }
 __name(collateralTokenByDex, "collateralTokenByDex");
+function minimumAvailableToTrade(assetData) {
+  let floor = null;
+  for (const data of assetData) {
+    for (const available of data.availableToTrade ?? []) {
+      const value = toDecimal(available);
+      if (floor === null || value.isLessThan(floor)) {
+        floor = value;
+      }
+    }
+  }
+  return floor === null ? null : floor.toFixed();
+}
+__name(minimumAvailableToTrade, "minimumAvailableToTrade");
 
-export { buildAvailableMarginByToken, buildCollateralTokenNames };
+export { buildAvailableMarginByToken, buildCollateralTokenNames, minimumAvailableToTrade };

package/dist/tracker/hyperliquid/tracker.js

@@ -1,10 +1,8 @@
 import { createExchangeWs } from '../../client';
 import { fetchPerpDexs, fetchInfo, fetchAllMids, fetchUserAbstraction, fetchSpotClearinghouseState, fetchDelegatorSummary, fetchUserVaultEquities, fetchClearinghouseState, fetchActiveAssetData } from '../../client/hyperliquid/rest';
 import { BaseAccountTracker } from '../base';
-import { computeMaxBasketSize } from '../basket-size';
 import { resolveHyperliquidAccountType } from './account-mode';
-import { minimumAvailableToTrade, findLegMarket, buildPoolBudgets, buildCappedLegs } from './basket-size';
-import { buildAvailableMarginByToken, buildCollateralTokenNames } from './collateral';
+import { buildAvailableMarginByToken, buildCollateralTokenNames, minimumAvailableToTrade } from './collateral';
 import { LOCKED_TRACKED_COINS } from './const';
 import { toDecimal, ZERO } from './decimal';
 import { emptyClearinghouseSummary, aggregateClearinghouseStates, mapBalance, mapPositions } from './mapper';
@@ -96,35 +94,6 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       positions
     };
   }
-  /** Sizes a basket over REST alone, so the call stays usable without a running socket. */
-  async snapshotMaxBasketSize(input) {
-    const [dexToMeta, tokenNames] = await Promise.all([
-      this.loadPerpMetasOnce(),
-      this.loadCollateralTokenNamesOnce()
-    ]);
-    const assetData = await this.fetchActiveAssetEvents(input.legs.map((leg) => leg.asset));
-    return sizeBasket(input, dexToMeta, tokenNames, assetData);
-  }
-  /**
-  * 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.
-  */
-  async maxBasketSize(input) {
-    const [dexToMeta, tokenNames] = await Promise.all([
-      this.loadPerpMetasOnce(),
-      this.loadCollateralTokenNamesOnce()
-    ]);
-    const missingCoins = input.legs.map((leg) => leg.asset).filter((asset) => !this.trackedAssetData.has(asset));
-    const fetched = await this.fetchActiveAssetEvents(missingCoins);
-    const assetData = new Map(fetched);
-    for (const leg of input.legs) {
-      const cached = this.trackedAssetData.get(leg.asset);
-      if (cached) {
-        assetData.set(leg.asset, cached);
-      }
-    }
-    return sizeBasket(input, dexToMeta, tokenNames, assetData);
-  }
   /**
   * 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
@@ -363,31 +332,6 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       this.dexToMeta.set(dex, dexMeta);
     });
   }
-  /** Loads the dex metadata a sizing call needs, reusing whatever `start()` already cached. */
-  async loadPerpMetasOnce() {
-    if (this.dexToMeta.size > 0) {
-      return this.dexToMeta;
-    }
-    const [allMetas, perpDexs] = await Promise.all([
-      fetchInfo({
-        type: "allPerpMetas"
-      }, this.demo),
-      fetchPerpDexs(this.demo)
-    ]);
-    this.loadPerpMetas(allMetas, perpDexs);
-    return this.dexToMeta;
-  }
-  /** Loads the token names a pool id is spelled with, reusing whatever `start()` already cached. */
-  async loadCollateralTokenNamesOnce() {
-    if (this.collateralTokenNames.size > 0) {
-      return this.collateralTokenNames;
-    }
-    const spotMeta = await fetchInfo({
-      type: "spotMeta"
-    }, this.demo);
-    this.collateralTokenNames = buildCollateralTokenNames(spotMeta);
-    return this.collateralTokenNames;
-  }
   /** Reads `activeAssetData` for each coin in parallel, dropping the coins the venue refuses. */
   async fetchActiveAssetEvents(coins) {
     const unique = [
@@ -558,18 +502,6 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     return result;
   }
 }
-function sizeBasket(input, dexToMeta, tokenNames, assetData) {
-  const markets = new Map(input.legs.map((leg) => [
-    leg.asset,
-    findLegMarket(dexToMeta, tokenNames, leg.asset, assetData.get(leg.asset)?.leverage.value ?? null)
-  ]));
-  const budgets = buildPoolBudgets(input.legs, markets, assetData);
-  return computeMaxBasketSize({
-    budgets,
-    legs: buildCappedLegs(input.legs, markets)
-  });
-}
-__name(sizeBasket, "sizeBasket");
 function buildTrackedAssetInfo(data) {
   return {
     coin: data.coin,

package/dist/tracker/index.js

@@ -11,7 +11,6 @@ export { OkxAccountTracker } from './okx/tracker';
 export { AccountBalance } from './balance';
 export { ACCOUNT_MODE_LABELS, AccountBalanceCore, AccountMode, CollateralBalance, DecimalString, MarginMode, Side, SignedDecimalString } from './balance-core';
 export { BaseAccountTracker } from './base';
-export { BasketLeg, MaxBasketSizeInput, MaxBasketSizeResult, computeMaxBasketSize } from './basket-size';
 export { BinanceMultiAssetBalance, BinanceSingleAssetBalance } from './binance/balance';
 export { BybitIsolatedMarginBalance, BybitPortfolioMarginBalance, BybitRegularMarginBalance } from './bybit/balance';
 export { HyperliquidDexState, HyperliquidPortfolioMarginBalance, HyperliquidPortfolioMarginCollateral, HyperliquidStandardBalance, HyperliquidUnifiedBalance } from './hyperliquid/balance';

package/dist/tracker/lighter/tracker.js

@@ -3,8 +3,6 @@ import { createExchangeWs } from '../../client';
 import { fetchAccount, fetchPublicAccount, fetchOrderBookDetails, fetchPublicOrderBookDetails, fetchAccountLimits } from '../../client/lighter/rest';
 import { retrieveLighterAuthToken } from '../../helper/lighter/auth-token.helper';
 import { BaseAccountTracker } from '../base';
-import { computeMaxBasketSize } from '../basket-size';
-import { toLighterBasketCalculation } from './basket-size';
 import { buildSpotPriceIndex, mapPositions, mapRestBalance, mapMarketDefaultAssetInfo, toLighterAccountType, mapLiveBalance, toLighterAccountTier } from './mapper';
 
 var __defProp = Object.defineProperty;
@@ -141,36 +139,6 @@ class LighterAccountTracker extends BaseAccountTracker {
     }
     return result;
   }
-  /** Sizes a basket against the live account state, falling back to REST before the socket is up. */
-  async maxBasketSize(input) {
-    if (!this.stats || this.marketsBySymbol.size === 0) {
-      return this.snapshotMaxBasketSize(input);
-    }
-    return computeMaxBasketSize(toLighterBasketCalculation(input.legs, {
-      availableBalance: this.stats.total.available_balance,
-      perpBySymbol: this.marketsBySymbol,
-      settingsByMarketId: this.liveAccountSettings()
-    }));
-  }
-  /** Sizes a basket over REST alone, so the answer needs no running socket. */
-  async snapshotMaxBasketSize(input) {
-    const [account, markets] = await Promise.all([
-      this.fetchPrimaryAccount(),
-      this.fetchMarkets()
-    ]);
-    if (!account) {
-      return computeMaxBasketSize({
-        budgets: {},
-        legs: []
-      });
-    }
-    const context = {
-      availableBalance: account.available_balance,
-      perpBySymbol: toMarketsBySymbol(markets.perp),
-      settingsByMarketId: toAccountSettings(markets.perp, account.positions ?? [])
-    };
-    return computeMaxBasketSize(toLighterBasketCalculation(input.legs, context));
-  }
   start() {
     if (this.startInFlight) {
       return this.startInFlight;
@@ -414,17 +382,6 @@ class LighterAccountTracker extends BaseAccountTracker {
       spotPriceBySymbol: this.spotPriceBySymbol
     };
   }
-  /** The account's current per-market settings as the base tracker already holds them. */
-  liveAccountSettings() {
-    const settings = /* @__PURE__ */ new Map();
-    for (const marketId of this.marketsByMarketId.keys()) {
-      const info = this.getTrackedAsset(String(marketId));
-      if (info) {
-        settings.set(String(marketId), info);
-      }
-    }
-    return settings;
-  }
   /** Reads the account with credentials when present, or explicitly uses the read-only verifier path. */
   async fetchPrimaryAccount() {
     const authToken = await this.retrieveAuthToken();
@@ -604,13 +561,6 @@ function toMarketContext(perpMarkets, spotMarkets) {
   };
 }
 __name(toMarketContext, "toMarketContext");
-function toMarketsBySymbol(perpMarkets) {
-  return new Map(perpMarkets.map((market) => [
-    market.symbol,
-    market
-  ]));
-}
-__name(toMarketsBySymbol, "toMarketsBySymbol");
 function toAccountSettings(perpMarkets, positions) {
   const settings = /* @__PURE__ */ new Map();
   for (const market of perpMarkets) {

package/dist/tracker/okx/tracker.js

@@ -36,20 +36,6 @@ class OkxAccountTracker extends BaseAccountTracker {
     };
   }
   /**
-  * 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.
-  */
-  async maxBasketSize(_input) {
-    return unsizedBasket();
-  }
-  /** The REST path answers the same way — there is no size either way, not a slower one. */
-  async snapshotMaxBasketSize(_input) {
-    return unsizedBasket();
-  }
-  /**
   * 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,
   * matching the account-level assumption used everywhere else in this connector.
@@ -406,13 +392,5 @@ function sameWithdrawable(left, right) {
   return true;
 }
 __name(sameWithdrawable, "sameWithdrawable");
-function unsizedBasket() {
-  return {
-    maxNotional: null,
-    legs: [],
-    bindingConstraint: null
-  };
-}
-__name(unsizedBasket, "unsizedBasket");
 
 export { OkxAccountTracker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/exchanges-sdk",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Pear Protocol Exchanges SDK",
   "private": false,
   "type": "module",
@@ -27,9 +27,9 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@pear-protocol/core-sdk": "^1.19.0",
-    "@pear-protocol/types": "^1.30.0",
-    "@pear-protocol/utils": "^0.5.3",
+    "@pear-protocol/core-sdk": "^1.19.1",
+    "@pear-protocol/types": "^1.30.1",
+    "@pear-protocol/utils": "^0.6.0",
     "bignumber.js": "^11.1.1",
     "partysocket": "^1.0.3",
     "viem": "^2.48.8",

package/dist/tracker/basket-size.js

@@ -1,194 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { z } from 'zod';
-import { Side, DecimalString, MarginMode } from './balance-core';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const BasketLeg = z.object({
-  asset: z.string(),
-  marginMode: MarginMode,
-  leverage: DecimalString,
-  side: Side,
-  /** Unsigned percentage. The set sums to 100. */
-  weight: z.number().positive()
-});
-const MaxBasketSizeInput = z.object({
-  legs: z.array(BasketLeg).min(1)
-});
-const MaxBasketSizeResult = z.object({
-  /**
-  * The whole basket's max GROSS notional in USD — Σ leg notional, not per-side and not per-asset.
-  * The basket is atomic, so this is one ceiling for the entire structure.
-  * Null when the venue cannot supply a per-asset max leverage (all three CEXs in v1), and null
-  * when any leg draws on a pool the caller could not value.
-  */
-  maxNotional: DecimalString.nullable(),
-  /** Derived from maxNotional — each leg's notional at that basket size. NOT a per-leg maximum. */
-  legs: z.array(z.object({
-    asset: z.string(),
-    notional: DecimalString,
-    marginRequired: DecimalString
-  })),
-  /** Which pool or leg ran out first. */
-  bindingConstraint: z.discriminatedUnion("kind", [
-    z.object({
-      kind: z.literal("cross-pool"),
-      pool: z.string()
-    }),
-    z.object({
-      kind: z.literal("isolated-leg"),
-      asset: z.string()
-    })
-  ]).nullable()
-});
-function computeMaxBasketSize(input) {
-  if (!isSizeableInput(input)) {
-    return unsizedResult();
-  }
-  const budgets = new Map(Object.entries(input.budgets));
-  const weightSum = sumWeights(input.legs);
-  if (weightSum.isZero()) {
-    return unsizedResult();
-  }
-  const shares = input.legs.map((leg) => toLegShare(leg, weightSum));
-  const demandByPool = marginPerUnitNotionalByPool(shares);
-  const tightestPool = tightestPoolCeiling(demandByPool, budgets);
-  if (tightestPool === null) {
-    return unsizedResult();
-  }
-  const tightestCap = tightestLegCap(shares);
-  if (tightestCap === null || tightestPool.size.isLessThanOrEqualTo(tightestCap.size)) {
-    return buildResult(tightestPool.size, shares, {
-      kind: "cross-pool",
-      pool: tightestPool.pool
-    });
-  }
-  return buildResult(tightestCap.size, shares, {
-    kind: "isolated-leg",
-    asset: tightestCap.asset
-  });
-}
-__name(computeMaxBasketSize, "computeMaxBasketSize");
-function isSizeableInput(input) {
-  for (const budget of Object.values(input.budgets)) {
-    if (!isUnsignedDecimal(budget)) {
-      return false;
-    }
-  }
-  for (const leg of input.legs) {
-    if (!isPositiveFinite(leg.weight)) {
-      return false;
-    }
-    if (!isUsableLeverage(leg.effectiveLeverage)) {
-      return false;
-    }
-    if (leg.maxNotional !== null && !isUnsignedDecimal(leg.maxNotional)) {
-      return false;
-    }
-  }
-  return true;
-}
-__name(isSizeableInput, "isSizeableInput");
-function isUnsignedDecimal(value) {
-  return DecimalString.safeParse(value).success;
-}
-__name(isUnsignedDecimal, "isUnsignedDecimal");
-function isPositiveFinite(weight) {
-  return Number.isFinite(weight) && weight > 0;
-}
-__name(isPositiveFinite, "isPositiveFinite");
-function isUsableLeverage(effectiveLeverage) {
-  if (!isUnsignedDecimal(effectiveLeverage)) {
-    return false;
-  }
-  return !new BigNumber(effectiveLeverage).isZero();
-}
-__name(isUsableLeverage, "isUsableLeverage");
-function sumWeights(legs) {
-  let total = new BigNumber(0);
-  for (const leg of legs) {
-    total = total.plus(String(leg.weight));
-  }
-  return total;
-}
-__name(sumWeights, "sumWeights");
-function unsizedResult() {
-  return {
-    maxNotional: null,
-    legs: [],
-    bindingConstraint: null
-  };
-}
-__name(unsizedResult, "unsizedResult");
-function toLegShare(leg, weightSum) {
-  return {
-    asset: leg.asset,
-    pool: leg.pool,
-    share: new BigNumber(String(leg.weight)).div(weightSum),
-    imr: new BigNumber(1).div(leg.effectiveLeverage),
-    maxNotional: leg.maxNotional === null ? null : new BigNumber(leg.maxNotional)
-  };
-}
-__name(toLegShare, "toLegShare");
-function marginPerUnitNotionalByPool(shares) {
-  const demandByPool = /* @__PURE__ */ new Map();
-  for (const leg of shares) {
-    const running = demandByPool.get(leg.pool) ?? new BigNumber(0);
-    demandByPool.set(leg.pool, running.plus(leg.share.times(leg.imr)));
-  }
-  return demandByPool;
-}
-__name(marginPerUnitNotionalByPool, "marginPerUnitNotionalByPool");
-function tightestPoolCeiling(demandByPool, budgets) {
-  let tightest = null;
-  for (const [pool, marginPerUnitNotional] of demandByPool) {
-    const budget = budgets.get(pool);
-    if (budget === void 0) {
-      return null;
-    }
-    const size = new BigNumber(budget).div(marginPerUnitNotional);
-    if (tightest === null || size.isLessThan(tightest.size)) {
-      tightest = {
-        pool,
-        size
-      };
-    }
-  }
-  return tightest;
-}
-__name(tightestPoolCeiling, "tightestPoolCeiling");
-function tightestLegCap(shares) {
-  let tightest = null;
-  for (const leg of shares) {
-    if (leg.maxNotional === null) {
-      continue;
-    }
-    const size = leg.maxNotional.div(leg.share);
-    if (tightest === null || size.isLessThan(tightest.size)) {
-      tightest = {
-        asset: leg.asset,
-        size
-      };
-    }
-  }
-  return tightest;
-}
-__name(tightestLegCap, "tightestLegCap");
-function buildResult(size, shares, bindingConstraint) {
-  const legs = shares.map((leg) => {
-    const notional = size.times(leg.share);
-    return {
-      asset: leg.asset,
-      notional: notional.toFixed(),
-      marginRequired: notional.times(leg.imr).toFixed()
-    };
-  });
-  return {
-    maxNotional: size.toFixed(),
-    legs,
-    bindingConstraint
-  };
-}
-__name(buildResult, "buildResult");
-
-export { BasketLeg, MaxBasketSizeInput, MaxBasketSizeResult, computeMaxBasketSize };

package/dist/tracker/hyperliquid/basket-size.js

@@ -1,93 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { splitDexCoin } from './coin-name';
-import { toDecimal } from './decimal';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const UNRESOLVED_POOL = "";
-function buildCappedLegs(legs, markets) {
-  return legs.map((leg) => {
-    const market = markets.get(leg.asset) ?? null;
-    const leverage = effectiveLeverage(leg.leverage, market);
-    return {
-      asset: leg.asset,
-      pool: market?.pool ?? UNRESOLVED_POOL,
-      weight: leg.weight,
-      effectiveLeverage: leverage,
-      marginMode: leg.marginMode,
-      maxNotional: tierBoundaryNotional(market?.marginTiers ?? null, leverage)
-    };
-  });
-}
-__name(buildCappedLegs, "buildCappedLegs");
-function buildPoolBudgets(legs, markets, assetData) {
-  const dataByPool = /* @__PURE__ */ new Map();
-  for (const leg of legs) {
-    const pool = markets.get(leg.asset)?.pool ?? null;
-    const data = assetData.get(leg.asset);
-    if (pool === null || data === void 0) {
-      continue;
-    }
-    const bucket = dataByPool.get(pool) ?? [];
-    bucket.push(data);
-    dataByPool.set(pool, bucket);
-  }
-  const budgets = {};
-  for (const [pool, data] of dataByPool) {
-    const floor = minimumAvailableToTrade(data);
-    if (floor !== null) {
-      budgets[pool] = floor;
-    }
-  }
-  return budgets;
-}
-__name(buildPoolBudgets, "buildPoolBudgets");
-function effectiveLeverage(requestedLeverage, market) {
-  let leverage = toDecimal(requestedLeverage);
-  if (market?.venueMaxLeverage !== null && market?.venueMaxLeverage !== void 0) {
-    leverage = BigNumber.min(leverage, market.venueMaxLeverage);
-  }
-  if (market?.accountLeverage !== null && market?.accountLeverage !== void 0) {
-    leverage = BigNumber.min(leverage, market.accountLeverage);
-  }
-  return BigNumber.max(leverage, 1).toFixed();
-}
-__name(effectiveLeverage, "effectiveLeverage");
-function tierBoundaryNotional(marginTiers, effectiveLeverage2) {
-  if (!marginTiers) {
-    return null;
-  }
-  const leverage = toDecimal(effectiveLeverage2);
-  const boundary = marginTiers.find((tier) => leverage.isGreaterThan(tier.maxLeverage));
-  return boundary ? boundary.lowerBound : null;
-}
-__name(tierBoundaryNotional, "tierBoundaryNotional");
-function minimumAvailableToTrade(assetData) {
-  let floor = null;
-  for (const data of assetData) {
-    for (const available of data.availableToTrade ?? []) {
-      const value = toDecimal(available);
-      if (floor === null || value.isLessThan(floor)) {
-        floor = value;
-      }
-    }
-  }
-  return floor === null ? null : floor.toFixed();
-}
-__name(minimumAvailableToTrade, "minimumAvailableToTrade");
-function findLegMarket(dexToMeta, tokenNames, coin, accountLeverage) {
-  const { dex, bareCoin } = splitDexCoin(coin);
-  const meta = dexToMeta.get(dex);
-  const asset = meta?.universe.find((candidate) => candidate.name === coin || candidate.name === bareCoin);
-  const marginTiers = meta?.marginTables.find(([id]) => id === asset?.marginTableId)?.[1].marginTiers;
-  const collateralToken = meta?.collateralToken;
-  return {
-    pool: collateralToken === void 0 ? null : tokenNames.get(collateralToken) ?? null,
-    venueMaxLeverage: asset?.maxLeverage ?? null,
-    accountLeverage,
-    marginTiers: marginTiers?.length ? marginTiers : null
-  };
-}
-__name(findLegMarket, "findLegMarket");
-
-export { buildCappedLegs, buildPoolBudgets, effectiveLeverage, findLegMarket, minimumAvailableToTrade, tierBoundaryNotional };

package/dist/tracker/lighter/basket-size.js

@@ -1,74 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { QUOTE_ASSET } from './const';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const MARGIN_FRACTION_SCALE = 1e4;
-const CROSS_POOL = QUOTE_ASSET;
-const DECIMAL_PATTERN = /^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
-function toLighterBasketCalculation(legs, context) {
-  const capped = [];
-  for (const leg of legs) {
-    const market = context.perpBySymbol.get(leg.asset);
-    if (!market) {
-      return {
-        budgets: {},
-        legs: []
-      };
-    }
-    capped.push(toCappedLeg(leg, market, context.settingsByMarketId.get(String(market.market_id))));
-  }
-  return {
-    // Every leg draws on the same pool, so one entry carries the whole basket's budget.
-    budgets: {
-      [CROSS_POOL]: context.availableBalance
-    },
-    legs: capped
-  };
-}
-__name(toLighterBasketCalculation, "toLighterBasketCalculation");
-function toCappedLeg(leg, market, currentSetting) {
-  return {
-    asset: leg.asset,
-    pool: CROSS_POOL,
-    weight: leg.weight,
-    effectiveLeverage: effectiveLeverage(leg.leverage, market, currentSetting),
-    marginMode: leg.marginMode,
-    maxNotional: null
-  };
-}
-__name(toCappedLeg, "toCappedLeg");
-function effectiveLeverage(requested, market, currentSetting) {
-  const accountLeverage = currentSetting === void 0 ? defaultAccountLeverage(market) : toDecimal(currentSetting.leverage);
-  const granted = BigNumber.min(toDecimal(requested), venueMaxLeverage(market), accountLeverage);
-  return granted.isFinite() && granted.isGreaterThan(0) ? granted.toFixed() : "1";
-}
-__name(effectiveLeverage, "effectiveLeverage");
-function venueMaxLeverage(market) {
-  return leverageFromMarginFraction(market.min_initial_margin_fraction);
-}
-__name(venueMaxLeverage, "venueMaxLeverage");
-function defaultAccountLeverage(market) {
-  return leverageFromMarginFraction(market.default_initial_margin_fraction).integerValue(BigNumber.ROUND_FLOOR);
-}
-__name(defaultAccountLeverage, "defaultAccountLeverage");
-function leverageFromMarginFraction(marginFraction) {
-  const fraction = toDecimal(marginFraction);
-  if (!fraction.isGreaterThan(0)) {
-    return new BigNumber(1);
-  }
-  return new BigNumber(MARGIN_FRACTION_SCALE).div(fraction);
-}
-__name(leverageFromMarginFraction, "leverageFromMarginFraction");
-function toDecimal(value) {
-  if (typeof value === "number") {
-    return Number.isFinite(value) ? new BigNumber(value) : new BigNumber(0);
-  }
-  if (typeof value !== "string" || !DECIMAL_PATTERN.test(value)) {
-    return new BigNumber(0);
-  }
-  return new BigNumber(value);
-}
-__name(toDecimal, "toDecimal");
-
-export { toLighterBasketCalculation, venueMaxLeverage };