@pear-protocol/exchanges-sdk 0.6.7 → 0.7.0

package/dist/tracker/lighter/tracker.js

@@ -1,14 +1,23 @@
 import BigNumber from 'bignumber.js';
 import { createExchangeWs } from '../../client';
-import { fetchOrderBookDetails, fetchAccount, fetchAccountLimits } from '../../client/lighter/rest';
-import { retrieveLighterAuthToken } from '../../helper/lighter/auth-token.helper';
+import { fetchOrderBookDetails, fetchAccount } from '../../client/lighter/rest';
 import { BaseAccountTracker } from '../base';
-import { mapPositions, buildAccountBalance, mapMarketDefaultAssetInfo, mapBalance, toLighterAccountTier } from './mapper';
-import { LighterAccountType } from './types';
+import { computeMaxBasketSize } from '../basket-size';
+import { toLighterBasketCalculation } from './basket-size';
+import { buildSpotPriceIndex, mapPositions, mapRestBalance, mapMarketDefaultAssetInfo, toLighterAccountType, mapLiveBalance } from './mapper';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const ACCOUNT_TIER_REFRESH_INTERVAL_MS = 6e4;
+const POSITION_POLL_INTERVAL_MS = 2e3;
+const MARKET_REFRESH_INTERVAL_MS = 6e4;
+const DECIMAL_PATTERN = /^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
+function isZeroSize(size) {
+  if (!DECIMAL_PATTERN.test(size)) {
+    return true;
+  }
+  return new BigNumber(size).isZero();
+}
+__name(isZeroSize, "isZeroSize");
 function toPosRecord(positions) {
   const posRecord = {};
   for (const p of positions) {
@@ -22,45 +31,44 @@ class LighterAccountTracker extends BaseAccountTracker {
     __name(this, "LighterAccountTracker");
   }
   accountIdentifier;
-  sdk;
   ws = null;
   messageListenerId = null;
   openListenerId = null;
-  pollTimer = null;
-  pollInFlight = null;
+  positionPollTimer = null;
+  positionPollInFlight = null;
+  marketRefreshTimer = null;
+  marketRefreshInFlight = null;
   startInFlight = null;
   lifecycleVersion = 0;
   stateVersion = 0;
   assetsByAssetId = /* @__PURE__ */ new Map();
-  rawPositionsByMarketId = /* @__PURE__ */ new Map();
+  // Written only by `account_all`. The live balance reads its unrealized PnL and maintenance
+  // margin from here, so keeping REST out of it is what makes that balance wholly websocket-derived.
+  wsPositionsByMarketId = /* @__PURE__ */ new Map();
   marketsByMarketId = /* @__PURE__ */ new Map();
-  summary = null;
-  accountTier;
-  lastAccountTierFetchAt = 0;
+  marketsBySymbol = /* @__PURE__ */ new Map();
+  // Seeded empty, which still prices the quote asset — spot dollars are dollars before any
+  // market data arrives, and a balance the index cannot price would otherwise read as unknown.
+  spotPriceBySymbol = buildSpotPriceIndex([]);
+  stats = null;
   hasAssets = false;
   constructor(config) {
     super(config);
     this.accountIdentifier = config.account.exchangeIdentifier;
-    this.sdk = config.sdk;
   }
-  /** 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. */
   async snapshot() {
-    const [account, markets, accountTier] = await Promise.all([
+    const [account, markets] = await Promise.all([
       this.fetchPrimaryAccount(),
-      fetchOrderBookDetails(this.demo),
-      this.fetchAccountTier()
+      fetchOrderBookDetails(this.demo)
     ]);
     if (!account) return {
       balance: null,
       positions: []
     };
     const { positions } = mapPositions(toPosRecord(account.positions ?? []));
-    const marketsByMarketId = new Map(markets.map((market) => [
-      market.market_id,
-      market
-    ]));
     return {
-      balance: buildAccountBalance(account, marketsByMarketId, accountTier),
+      balance: mapRestBalance(account, toMarketContext(markets.perp, markets.spot), Date.now()),
       positions: Array.from(positions.values())
     };
   }
@@ -75,22 +83,48 @@ class LighterAccountTracker extends BaseAccountTracker {
       this.fetchPrimaryAccount(),
       fetchOrderBookDetails(this.demo)
     ]);
-    const { trackedAssets } = mapPositions(toPosRecord(account?.positions ?? []), true);
-    const defaults = /* @__PURE__ */ new Map();
-    for (const m of markets) {
-      defaults.set(String(m.market_id), mapMarketDefaultAssetInfo(m));
-    }
+    const settings = toAccountSettings(markets.perp, account?.positions ?? []);
     const result = {};
     for (const marketId of marketIds) {
-      result[marketId] = trackedAssets.get(marketId) ?? defaults.get(marketId) ?? null;
+      result[marketId] = settings.get(marketId) ?? null;
     }
     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(),
+      fetchOrderBookDetails(this.demo)
+    ]);
+    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;
     }
-    if (this.ws || this.pollTimer) {
+    if (this.ws || this.positionPollTimer) {
       return Promise.resolve();
     }
     const start = this.performStart().finally(() => {
@@ -104,16 +138,13 @@ class LighterAccountTracker extends BaseAccountTracker {
   /** Creates one tracker lifecycle while repeated callers share the same pending start. */
   async performStart() {
     const lifecycleVersion = ++this.lifecycleVersion;
-    const [markets, accountTier] = await Promise.all([
-      fetchOrderBookDetails(this.demo),
-      this.fetchAccountTier()
-    ]);
+    const markets = await fetchOrderBookDetails(this.demo);
     if (lifecycleVersion !== this.lifecycleVersion) return;
-    this.accountTier = accountTier;
-    this.lastAccountTierFetchAt = Date.now();
+    this.spotPriceBySymbol = buildSpotPriceIndex(markets.spot);
     const trackedAssets = /* @__PURE__ */ new Map();
-    for (const m of markets) {
+    for (const m of markets.perp) {
       this.marketsByMarketId.set(m.market_id, m);
+      this.marketsBySymbol.set(m.symbol, m);
       trackedAssets.set(String(m.market_id), mapMarketDefaultAssetInfo(m));
     }
     this.onStateUpdate({
@@ -131,15 +162,20 @@ class LighterAccountTracker extends BaseAccountTracker {
     this.messageListenerId = this.ws.addMessageListener((raw) => this.routeRaw(raw));
     this.openListenerId = this.ws.addOpenListener(() => this.handleWsOpen());
     this.handleWsOpen();
-    void this.pollAccount();
-    this.pollTimer = setInterval(() => void this.pollAccount(), 2e3);
+    void this.pollPositions();
+    this.positionPollTimer = setInterval(() => void this.pollPositions(), POSITION_POLL_INTERVAL_MS);
+    this.marketRefreshTimer = setInterval(() => void this.refreshMarkets(), MARKET_REFRESH_INTERVAL_MS);
   }
   async cleanupConnections() {
     this.lifecycleVersion += 1;
     this.startInFlight = null;
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = null;
+    if (this.positionPollTimer) {
+      clearInterval(this.positionPollTimer);
+      this.positionPollTimer = null;
+    }
+    if (this.marketRefreshTimer) {
+      clearInterval(this.marketRefreshTimer);
+      this.marketRefreshTimer = null;
     }
     if (this.messageListenerId) {
       this.ws?.removeMessageListener(this.messageListenerId);
@@ -163,8 +199,8 @@ class LighterAccountTracker extends BaseAccountTracker {
   handleWsOpen() {
     this.stateVersion += 1;
     this.assetsByAssetId.clear();
-    this.rawPositionsByMarketId.clear();
-    this.summary = null;
+    this.wsPositionsByMarketId.clear();
+    this.stats = null;
     this.hasAssets = false;
     this.resetAccountState();
     const trackedAssets = /* @__PURE__ */ new Map();
@@ -230,20 +266,20 @@ class LighterAccountTracker extends BaseAccountTracker {
         ...data.positions
       };
       if (isSnapshot) {
-        this.rawPositionsByMarketId.clear();
+        this.wsPositionsByMarketId.clear();
       }
       for (const [marketId, position] of Object.entries(data.positions)) {
-        if (new BigNumber(position.position).isZero()) {
-          const previousPosition = this.rawPositionsByMarketId.get(marketId);
+        if (isZeroSize(position.position)) {
+          const previousPosition = this.wsPositionsByMarketId.get(marketId);
           if (previousPosition) {
             positionsForMapping[marketId] = {
               ...position,
               sign: previousPosition.sign
             };
           }
-          this.rawPositionsByMarketId.delete(marketId);
+          this.wsPositionsByMarketId.delete(marketId);
         } else {
-          this.rawPositionsByMarketId.set(marketId, position);
+          this.wsPositionsByMarketId.set(marketId, position);
         }
       }
       const { positions, trackedAssets } = mapPositions(positionsForMapping, !isSnapshot);
@@ -255,97 +291,89 @@ class LighterAccountTracker extends BaseAccountTracker {
     if (balance) update.balance = balance;
     if (Object.keys(update).length > 0) this.onStateUpdate(update);
   }
+  /** Keeps both published scopes: cross drives every "Cross" field, total drives the account ones. */
   onUserStats(data) {
     this.stateVersion += 1;
-    const s = data.stats;
-    this.summary = {
-      collateral: s.collateral || "0",
-      portfolioValue: s.portfolio_value || "0",
-      crossPortfolioValue: s.cross_stats?.portfolio_value,
-      availableToTrade: s.available_balance || "0",
-      marginUsagePct: s.margin_usage || "0",
-      accountType: s.account_trading_mode === 1 ? LighterAccountType.UNIFIED : LighterAccountType.CLASSIC,
-      accountTier: this.accountTier
+    const stats = data.stats;
+    this.stats = {
+      accountType: toLighterAccountType(stats.account_trading_mode),
+      total: stats.total_stats,
+      cross: stats.cross_stats
     };
     const balance = this.buildBalance();
     if (balance) this.onStateUpdate({
       balance
     });
   }
+  /**
+  * 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.
+  */
   buildBalance() {
-    if (!this.summary || !this.hasAssets) return null;
-    return mapBalance({
-      ...this.summary,
-      accountTier: this.accountTier
-    }, this.assetsByAssetId, this.rawPositionsByMarketId.values(), this.marketsByMarketId);
+    if (!this.stats || !this.hasAssets) return null;
+    return mapLiveBalance(this.stats, this.assetsByAssetId.values(), this.wsPositionsByMarketId.values(), this.marketContext(), Date.now());
+  }
+  /** The market data both read paths join account state against, as the latest read left it. */
+  marketContext() {
+    return {
+      perpByMarketId: this.marketsByMarketId,
+      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;
   }
   async fetchPrimaryAccount() {
     const data = await fetchAccount(Number(this.accountIdentifier), this.demo);
     return data.accounts[0];
   }
-  async fetchAccountTier() {
-    if (!this.sdk || this.demo) {
-      return void 0;
-    }
-    try {
-      const credentials = this.credentials;
-      const accountIndex = Number(this.accountIdentifier);
-      const token = await retrieveLighterAuthToken(this.sdk, {
-        accountIndex,
-        apiKeyIndex: credentials.api_key_index,
-        apiPrivateKey: credentials.api_private_key
-      }, this.demo);
-      const limits = await fetchAccountLimits(accountIndex, token, this.demo);
-      return toLighterAccountTier(limits.user_tier);
-    } catch (err) {
-      this.onError(err instanceof Error ? err : new Error(String(err)));
-      return void 0;
-    }
-  }
-  pollAccount() {
-    if (this.pollInFlight) return this.pollInFlight;
+  pollPositions() {
+    if (this.positionPollInFlight) return this.positionPollInFlight;
     const lifecycleVersion = this.lifecycleVersion;
     const stateVersion = this.stateVersion;
-    const poll = this.performAccountPoll(lifecycleVersion, stateVersion).finally(() => {
-      if (this.pollInFlight === poll) {
-        this.pollInFlight = null;
+    const poll = this.performPositionPoll(lifecycleVersion, stateVersion).finally(() => {
+      if (this.positionPollInFlight === poll) {
+        this.positionPollInFlight = null;
       }
     });
-    this.pollInFlight = poll;
+    this.positionPollInFlight = poll;
     return poll;
   }
-  async performAccountPoll(lifecycleVersion, stateVersion) {
+  /**
+  * 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.
+  */
+  async performPositionPoll(lifecycleVersion, stateVersion) {
     try {
-      const refreshAccountTier = this.shouldRefreshAccountTier();
-      if (refreshAccountTier) {
-        this.lastAccountTierFetchAt = Date.now();
-      }
-      const [account, refreshedAccountTier] = await Promise.all([
-        this.fetchPrimaryAccount(),
-        refreshAccountTier ? this.fetchAccountTier() : Promise.resolve(void 0)
-      ]);
+      const account = await this.fetchPrimaryAccount();
       if (lifecycleVersion !== this.lifecycleVersion) return;
-      if (refreshAccountTier && refreshedAccountTier !== void 0 && refreshedAccountTier !== this.accountTier) {
-        this.accountTier = refreshedAccountTier;
-        const balance = this.buildBalance();
-        if (balance) {
-          this.onStateUpdate({
-            balance
-          });
-        }
-      }
       if (!account || stateVersion !== this.stateVersion) return;
-      const positionRecord = toPosRecord(account.positions ?? []);
-      const { positions, trackedAssets } = mapPositions(positionRecord, true);
-      this.stateVersion += 1;
-      this.rawPositionsByMarketId.clear();
-      for (const [marketId, position] of Object.entries(positionRecord)) {
-        if (!new BigNumber(position.position).isZero()) {
-          this.rawPositionsByMarketId.set(marketId, position);
-        }
-      }
+      const { positions, trackedAssets } = mapPositions(toPosRecord(account.positions ?? []), true);
       this.onStateUpdate({
-        balance: buildAccountBalance(account, this.marketsByMarketId, this.accountTier),
         positions,
         positionsMode: "replace",
         trackedAssets
@@ -356,9 +384,92 @@ class LighterAccountTracker extends BaseAccountTracker {
       }
     }
   }
-  shouldRefreshAccountTier() {
-    return this.sdk !== void 0 && Date.now() - this.lastAccountTierFetchAt >= ACCOUNT_TIER_REFRESH_INTERVAL_MS;
+  /** Shares one in-flight market read, so a slow response cannot stack requests behind the WAF. */
+  refreshMarkets() {
+    if (this.marketRefreshInFlight) return this.marketRefreshInFlight;
+    const refresh = this.performMarketRefresh(this.lifecycleVersion).finally(() => {
+      if (this.marketRefreshInFlight === refresh) {
+        this.marketRefreshInFlight = null;
+      }
+    });
+    this.marketRefreshInFlight = refresh;
+    return refresh;
+  }
+  /**
+  * 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.
+  */
+  async performMarketRefresh(lifecycleVersion) {
+    try {
+      const markets = await fetchOrderBookDetails(this.demo);
+      if (lifecycleVersion !== this.lifecycleVersion) return;
+      for (const market of markets.perp) {
+        this.marketsByMarketId.set(market.market_id, market);
+        this.marketsBySymbol.set(market.symbol, market);
+      }
+      if (markets.spot.length > 0) {
+        this.spotPriceBySymbol = buildSpotPriceIndex(markets.spot);
+      }
+      const balance = this.buildBalance();
+      if (balance) this.onStateUpdate({
+        balance
+      });
+    } catch (err) {
+      if (lifecycleVersion === this.lifecycleVersion) {
+        this.onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+  }
+}
+function toMarketContext(perpMarkets, spotMarkets) {
+  return {
+    perpByMarketId: new Map(perpMarkets.map((market) => [
+      market.market_id,
+      market
+    ])),
+    spotPriceBySymbol: buildSpotPriceIndex(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) {
+    settings.set(String(market.market_id), mapMarketDefaultAssetInfo(market));
+  }
+  const { trackedAssets } = mapPositions(toPosRecord(positions), true);
+  for (const [marketId, info] of trackedAssets) {
+    settings.set(marketId, info);
   }
+  return settings;
 }
+__name(toAccountSettings, "toAccountSettings");
 
 export { LighterAccountTracker };

package/dist/tracker/lighter/types.js

@@ -4,11 +4,5 @@ var LighterAccountType = /* @__PURE__ */ (function(LighterAccountType2) {
   LighterAccountType2["UNIFIED"] = "unified";
   return LighterAccountType2;
 })({});
-var LighterAccountTier = /* @__PURE__ */ (function(LighterAccountTier2) {
-  LighterAccountTier2["STANDARD"] = "standard";
-  LighterAccountTier2["PREMIUM"] = "premium";
-  LighterAccountTier2["PLUS"] = "plus";
-  return LighterAccountTier2;
-})({});
 
-export { LighterAccountTier, LighterAccountType };
+export { LighterAccountType };

package/dist/tracker/okx/balance.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { AccountBalanceCore } from '../balance-core';
+
+const OkxSpotBalance = AccountBalanceCore.extend({
+  accountMode: z.literal("okx:spot")
+});
+const OkxFuturesBalance = AccountBalanceCore.extend({
+  accountMode: z.literal("okx:futures")
+});
+const OkxMultiCurrencyMarginBalance = AccountBalanceCore.extend({
+  accountMode: z.literal("okx:multiCurrencyMargin")
+});
+const OkxPortfolioMarginBalance = AccountBalanceCore.extend({
+  accountMode: z.literal("okx:portfolioMargin")
+});
+
+export { OkxFuturesBalance, OkxMultiCurrencyMarginBalance, OkxPortfolioMarginBalance, OkxSpotBalance };