@pear-protocol/exchanges-sdk 0.2.0 → 0.4.0

package/dist/tracker/lighter/tracker.js

@@ -1,67 +1,161 @@
 import BigNumber from 'bignumber.js';
-import { fetchOrderBookDetails, fetchAccount } from '../../client/lighter/rest';
+import { createExchangeWs } from '../../client';
+import { fetchOrderBookDetails, fetchAccount, fetchAccountLimits } from '../../client/lighter/rest';
 import { BaseAccountTracker } from '../base';
-import { leverageFromImf, mapPositions, mapBalance } from './mapper';
+import { mapPositions, buildAccountBalance, mapMarketDefaultAssetInfo, mapBalance, toLighterAccountTier } from './mapper';
+import { LighterAccountType } from './types';
 
+const ACCOUNT_TIER_REFRESH_INTERVAL_MS = 6e4;
+function toPosRecord(positions) {
+  const posRecord = {};
+  for (const p of positions) {
+    posRecord[String(p.market_id)] = p;
+  }
+  return posRecord;
+}
 class LighterAccountTracker extends BaseAccountTracker {
   accountIdentifier;
-  ws;
+  sdk;
+  ws = null;
   messageListenerId = null;
   openListenerId = null;
   pollTimer = null;
+  pollInFlight = null;
+  startInFlight = null;
+  lifecycleVersion = 0;
+  stateVersion = 0;
   assetsByAssetId = /* @__PURE__ */ new Map();
+  rawPositionsByMarketId = /* @__PURE__ */ new Map();
+  marketsByMarketId = /* @__PURE__ */ new Map();
   summary = null;
+  accountTier;
+  lastAccountTierFetchAt = 0;
   hasAssets = false;
   constructor(config) {
     super(config);
-    this.credentials = config.credentials;
     this.accountIdentifier = config.account.exchangeIdentifier;
-    this.ws = config.ws;
+    this.sdk = config.sdk;
+  }
+  /** Stateless one-shot account read; tier enrichment is optional and requires SDK-backed auth. */
+  async snapshot() {
+    const [account, markets, accountTier] = await Promise.all([
+      this.fetchPrimaryAccount(),
+      fetchOrderBookDetails(this.demo),
+      this.fetchAccountTier()
+    ]);
+    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),
+      positions: Array.from(positions.values())
+    };
+  }
+  /**
+   * Stateless one-shot per-asset settings read, keyed by market id (the same identifier the live
+   * trackAsset path uses). One public `GET /api/v1/account` covers every market the account holds
+   * a position row for (custom margin included, even when its size is zero); `orderBookDetails`
+   * supplies the exchange default for markets absent from the account payload.
+   */
+  async fetchAssetSnapshots(marketIds) {
+    const [account, markets] = await Promise.all([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 result = {};
+    for (const marketId of marketIds) {
+      result[marketId] = trackedAssets.get(marketId) ?? defaults.get(marketId) ?? null;
+    }
+    return result;
+  }
+  start() {
+    if (this.startInFlight) {
+      return this.startInFlight;
+    }
+    if (this.ws || this.pollTimer) {
+      return Promise.resolve();
+    }
+    const start = this.performStart().finally(() => {
+      if (this.startInFlight === start) {
+        this.startInFlight = null;
+      }
+    });
+    this.startInFlight = start;
+    return start;
   }
-  async start() {
-    const markets = await fetchOrderBookDetails();
+  /** 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()]);
+    if (lifecycleVersion !== this.lifecycleVersion) return;
+    this.accountTier = accountTier;
+    this.lastAccountTierFetchAt = Date.now();
     const trackedAssets = /* @__PURE__ */ new Map();
     for (const m of markets) {
-      trackedAssets.set(String(m.market_id), {
-        coin: m.symbol,
-        leverage: leverageFromImf(new BigNumber(m.default_initial_margin_fraction).div(100).toFixed()),
-        marginType: "cross"
-      });
+      this.marketsByMarketId.set(m.market_id, m);
+      trackedAssets.set(String(m.market_id), mapMarketDefaultAssetInfo(m));
     }
     this.onStateUpdate({ trackedAssets });
+    const ws = (await createExchangeWs("lighter", { demo: this.demo, credentials: this.credentials })).main;
+    if (lifecycleVersion !== this.lifecycleVersion) {
+      ws.destroy();
+      return;
+    }
+    this.ws = ws;
     this.messageListenerId = this.ws.addMessageListener((raw) => this.routeRaw(raw));
-    this.openListenerId = this.ws.addOpenListener(() => this.sendStaticSubs());
-    this.sendStaticSubs();
-    this.pollAccount();
-    this.pollTimer = setInterval(() => this.pollAccount(), 2e3);
+    this.openListenerId = this.ws.addOpenListener(() => this.handleWsOpen());
+    this.handleWsOpen();
+    void this.pollAccount();
+    this.pollTimer = setInterval(() => void this.pollAccount(), 2e3);
   }
   async cleanupConnections() {
+    this.lifecycleVersion += 1;
+    this.startInFlight = null;
     if (this.pollTimer) {
       clearInterval(this.pollTimer);
       this.pollTimer = null;
     }
     if (this.messageListenerId) {
-      this.ws.removeMessageListener(this.messageListenerId);
+      this.ws?.removeMessageListener(this.messageListenerId);
       this.messageListenerId = null;
     }
     if (this.openListenerId) {
-      this.ws.removeOpenListener(this.openListenerId);
+      this.ws?.removeOpenListener(this.openListenerId);
       this.openListenerId = null;
     }
+    this.ws?.destroy();
+    this.ws = null;
   }
   get isConnected() {
-    return this.ws.connected;
+    return this.ws?.connected ?? false;
   }
   ensureAssetTracked(_coin) {
   }
   releaseAsset(_coin) {
   }
+  /** Starts a clean account-data epoch before subscribing on each websocket connection. */
+  handleWsOpen() {
+    this.stateVersion += 1;
+    this.assetsByAssetId.clear();
+    this.rawPositionsByMarketId.clear();
+    this.summary = null;
+    this.hasAssets = false;
+    this.resetAccountState();
+    const trackedAssets = /* @__PURE__ */ new Map();
+    for (const market of this.marketsByMarketId.values()) {
+      trackedAssets.set(String(market.market_id), mapMarketDefaultAssetInfo(market));
+    }
+    this.onStateUpdate({ trackedAssets });
+    this.sendStaticSubs();
+  }
   sendStaticSubs() {
-    this.ws.send({
+    this.ws?.send({
       type: "subscribe",
       channel: `account_all/${this.accountIdentifier}`
     });
-    this.ws.send({
+    this.ws?.send({
       type: "subscribe",
       channel: `user_stats/${this.accountIdentifier}`
     });
@@ -87,16 +181,37 @@ class LighterAccountTracker extends BaseAccountTracker {
     }
   }
   onAccountAll(data) {
+    this.stateVersion += 1;
     const update = {};
+    const isSnapshot = data.type === "subscribed/account_all";
     if (data.assets) {
+      if (isSnapshot) {
+        this.assetsByAssetId.clear();
+      }
       for (const [id, asset] of Object.entries(data.assets)) {
         this.assetsByAssetId.set(id, asset);
       }
       this.hasAssets = true;
     }
-    if (data.positions && Object.keys(data.positions).length > 0) {
-      const { positions, trackedAssets } = mapPositions(data.positions);
+    if (data.positions) {
+      const positionsForMapping = { ...data.positions };
+      if (isSnapshot) {
+        this.rawPositionsByMarketId.clear();
+      }
+      for (const [marketId, position] of Object.entries(data.positions)) {
+        if (new BigNumber(position.position).isZero()) {
+          const previousPosition = this.rawPositionsByMarketId.get(marketId);
+          if (previousPosition) {
+            positionsForMapping[marketId] = { ...position, sign: previousPosition.sign };
+          }
+          this.rawPositionsByMarketId.delete(marketId);
+        } else {
+          this.rawPositionsByMarketId.set(marketId, position);
+        }
+      }
+      const { positions, trackedAssets } = mapPositions(positionsForMapping, !isSnapshot);
       update.positions = positions;
+      update.positionsMode = isSnapshot ? "replace" : "merge";
       update.trackedAssets = trackedAssets;
     }
     const balance = this.buildBalance();
@@ -104,46 +219,105 @@ class LighterAccountTracker extends BaseAccountTracker {
     if (Object.keys(update).length > 0) this.onStateUpdate(update);
   }
   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"
+      marginUsagePct: s.margin_usage || "0",
+      accountType: s.account_trading_mode === 1 ? LighterAccountType.UNIFIED : LighterAccountType.CLASSIC,
+      accountTier: this.accountTier
     };
     const balance = this.buildBalance();
     if (balance) this.onStateUpdate({ balance });
   }
   buildBalance() {
     if (!this.summary || !this.hasAssets) return null;
-    return mapBalance(this.summary, this.assetsByAssetId);
+    return mapBalance(
+      { ...this.summary, accountTier: this.accountTier },
+      this.assetsByAssetId,
+      this.rawPositionsByMarketId.values(),
+      this.marketsByMarketId
+    );
+  }
+  async fetchPrimaryAccount() {
+    const data = await fetchAccount(Number(this.accountIdentifier), this.demo);
+    return data.accounts[0];
   }
-  async pollAccount() {
+  async fetchAccountTier() {
+    if (!this.sdk || this.demo) return void 0;
     try {
+      const credentials = this.credentials;
       const accountIndex = Number(this.accountIdentifier);
-      const data = await fetchAccount(accountIndex);
-      const account = data.accounts[0];
-      if (!account?.positions?.length) return;
-      const posRecord = {};
-      for (const p of account.positions) {
-        posRecord[String(p.market_id)] = {
-          market_id: p.market_id,
-          symbol: p.symbol,
-          initial_margin_fraction: p.initial_margin_fraction,
-          sign: p.sign,
-          position: p.position,
-          avg_entry_price: p.avg_entry_price,
-          unrealized_pnl: p.unrealized_pnl,
-          liquidation_price: p.liquidation_price,
-          margin_mode: p.margin_mode
-        };
-      }
-      const { positions, trackedAssets } = mapPositions(posRecord);
-      this.onStateUpdate({ positions, trackedAssets });
+      const { token } = await this.sdk.core.misc.lighter.createAuthToken({
+        accountIndex,
+        apiKeyIndex: credentials.api_key_index,
+        apiPrivateKey: credentials.api_private_key
+      });
+      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;
+    const lifecycleVersion = this.lifecycleVersion;
+    const stateVersion = this.stateVersion;
+    const poll = this.performAccountPoll(lifecycleVersion, stateVersion).finally(() => {
+      if (this.pollInFlight === poll) {
+        this.pollInFlight = null;
+      }
+    });
+    this.pollInFlight = poll;
+    return poll;
+  }
+  async performAccountPoll(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)
+      ]);
+      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);
+        }
+      }
+      this.onStateUpdate({
+        balance: buildAccountBalance(account, this.marketsByMarketId, this.accountTier),
+        positions,
+        positionsMode: "replace",
+        trackedAssets
+      });
+    } catch (err) {
+      if (lifecycleVersion === this.lifecycleVersion) {
+        this.onError(err instanceof Error ? err : new Error(String(err)));
+      }
     }
   }
+  shouldRefreshAccountTier() {
+    return this.sdk !== void 0 && Date.now() - this.lastAccountTierFetchAt >= ACCOUNT_TIER_REFRESH_INTERVAL_MS;
+  }
 }
 
 export { LighterAccountTracker };