@pear-protocol/exchanges-sdk 0.3.0 → 0.4.0

package/dist/tracker/lighter/tracker.test.js

@@ -0,0 +1,515 @@
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { LighterAccountTracker } from './tracker';
+
+const { createExchangeWsMock, fetchAccountMock, fetchAccountLimitsMock, fetchOrderBookDetailsMock } = vi.hoisted(
+  () => ({
+    createExchangeWsMock: vi.fn(),
+    fetchAccountMock: vi.fn(),
+    fetchAccountLimitsMock: vi.fn(),
+    fetchOrderBookDetailsMock: vi.fn()
+  })
+);
+vi.mock("../../client", () => ({ createExchangeWs: createExchangeWsMock }));
+vi.mock("../../client/lighter/rest", () => ({
+  fetchAccount: fetchAccountMock,
+  fetchAccountLimits: fetchAccountLimitsMock,
+  fetchOrderBookDetails: fetchOrderBookDetailsMock
+}));
+const account = { exchangeIdentifier: "42" };
+function buildTracker(sdk, demo = true) {
+  return new LighterAccountTracker({
+    demo,
+    account,
+    credentials: { api_private_key: "pk", api_key_index: 0 },
+    sdk
+  });
+}
+describe("LighterAccountTracker.snapshot", () => {
+  beforeEach(() => {
+    fetchAccountMock.mockReset();
+    fetchAccountLimitsMock.mockReset();
+    fetchOrderBookDetailsMock.mockReset();
+  });
+  it("reads the public GET /api/v1/account with no signer and maps balance + positions", async () => {
+    fetchOrderBookDetailsMock.mockResolvedValue([
+      {
+        symbol: "BTC-PERP",
+        market_id: 1,
+        status: "active",
+        default_initial_margin_fraction: 1e3,
+        maintenance_margin_fraction: 500
+      }
+    ]);
+    fetchAccountMock.mockResolvedValue({
+      code: 200,
+      accounts: [
+        {
+          account_type: 0,
+          account_trading_mode: 0,
+          collateral: "1000",
+          total_asset_value: "1100",
+          available_balance: "900",
+          cross_asset_value: "1100",
+          cross_initial_margin_requirement: "100",
+          cross_maintenance_margin_requirement: "55",
+          assets: [{ symbol: "USDC", balance: "900", locked_balance: "100" }],
+          positions: [
+            {
+              market_id: 1,
+              symbol: "BTC-PERP",
+              initial_margin_fraction: "10",
+              sign: 1,
+              position: "1",
+              avg_entry_price: "50000",
+              position_value: "1000",
+              unrealized_pnl: "50",
+              liquidation_price: "40000",
+              margin_mode: 0,
+              allocated_margin: "0"
+            }
+          ]
+        }
+      ]
+    });
+    const tracker = buildTracker();
+    const snapshot = await tracker.snapshot();
+    expect(fetchAccountMock).toHaveBeenCalledWith(42, true);
+    expect(snapshot.balance).toMatchObject({
+      accountType: "classic",
+      accountTier: void 0,
+      totalEquity: "1100",
+      availableToTrade: "900",
+      walletBalance: "1000.000000",
+      unrealizedPnl: "50.000000",
+      initialMarginUsed: "100.000000",
+      maintenanceMargin: "55.000000",
+      marginRatio: "0.0500"
+    });
+    expect(snapshot.positions).toHaveLength(1);
+    expect(snapshot.positions[0]).toMatchObject({
+      symbol: "BTC-PERP",
+      side: "long",
+      leverage: "10",
+      // 100 / initial_margin_fraction(10%)
+      marginType: "cross",
+      liquidationPrice: "40000"
+    });
+  });
+  it("enriches snapshots from authenticated accountLimits.user_tier when an SDK is available", async () => {
+    const createAuthToken = vi.fn().mockResolvedValue({ token: "auth-token" });
+    const sdk = { core: { misc: { lighter: { createAuthToken } } } };
+    fetchOrderBookDetailsMock.mockResolvedValue([]);
+    fetchAccountMock.mockResolvedValue({
+      code: 200,
+      accounts: [
+        {
+          account_type: 1,
+          account_trading_mode: 0,
+          collateral: "0",
+          total_asset_value: "0",
+          available_balance: "0",
+          cross_asset_value: "0",
+          cross_initial_margin_requirement: "0",
+          cross_maintenance_margin_requirement: "0",
+          positions: []
+        }
+      ]
+    });
+    fetchAccountLimitsMock.mockResolvedValue({ code: 200, user_tier: "premium" });
+    const snapshot = await buildTracker(sdk, false).snapshot();
+    expect(createAuthToken).toHaveBeenCalledWith({
+      accountIndex: 42,
+      apiKeyIndex: 0,
+      apiPrivateKey: "pk"
+    });
+    expect(fetchAccountLimitsMock).toHaveBeenCalledWith(42, "auth-token", false);
+    expect(snapshot.balance?.accountTier).toBe("premium");
+  });
+  it("skips unsupported demo tier auth while preserving public snapshot data", async () => {
+    const createAuthToken = vi.fn();
+    const sdk = { core: { misc: { lighter: { createAuthToken } } } };
+    fetchOrderBookDetailsMock.mockResolvedValue([]);
+    fetchAccountMock.mockResolvedValue(emptyAccountResponse());
+    const snapshot = await buildTracker(sdk).snapshot();
+    expect(createAuthToken).not.toHaveBeenCalled();
+    expect(fetchAccountLimitsMock).not.toHaveBeenCalled();
+    expect(snapshot.balance).toMatchObject({ accountTier: void 0, totalEquity: "1000" });
+  });
+  it("needs no signer / auth token for the snapshot read", async () => {
+    fetchAccountMock.mockResolvedValue({ code: 200, accounts: [] });
+    fetchOrderBookDetailsMock.mockResolvedValue([]);
+    const snapshot = await buildTracker().snapshot();
+    expect(fetchAccountMock).toHaveBeenCalledWith(42, true);
+    expect(fetchAccountMock).toHaveBeenCalledTimes(1);
+    expect(fetchAccountMock.mock.calls[0]).toHaveLength(2);
+    expect(fetchAccountLimitsMock).not.toHaveBeenCalled();
+    expect(snapshot).toEqual({ balance: null, positions: [] });
+  });
+});
+describe("LighterAccountTracker.snapshotAssets", () => {
+  beforeEach(() => {
+    fetchAccountMock.mockReset();
+    fetchOrderBookDetailsMock.mockReset();
+  });
+  it("answers positioned markets from the account read and the rest from market defaults, keyed by market id", async () => {
+    fetchAccountMock.mockResolvedValue({
+      code: 200,
+      accounts: [
+        {
+          positions: [
+            {
+              market_id: 1,
+              symbol: "BTC-PERP",
+              initial_margin_fraction: "5",
+              sign: 1,
+              position: "1",
+              avg_entry_price: "50000",
+              unrealized_pnl: "0",
+              liquidation_price: "40000",
+              margin_mode: 0
+            },
+            {
+              market_id: 2,
+              symbol: "ETH-PERP",
+              initial_margin_fraction: "25",
+              sign: 1,
+              position: "0",
+              avg_entry_price: "0",
+              unrealized_pnl: "0",
+              liquidation_price: "0",
+              margin_mode: 1
+            }
+          ]
+        }
+      ]
+    });
+    fetchOrderBookDetailsMock.mockResolvedValue([
+      { symbol: "BTC-PERP", market_id: 1, status: "active", default_initial_margin_fraction: 1e3 },
+      { symbol: "ETH-PERP", market_id: 2, status: "active", default_initial_margin_fraction: 2e3 }
+    ]);
+    const result = await buildTracker().snapshotAssets(["1", "2", "999"]);
+    expect(fetchAccountMock).toHaveBeenCalledTimes(1);
+    expect(fetchOrderBookDetailsMock).toHaveBeenCalledTimes(1);
+    expect(result["1"]).toEqual({ coin: "BTC-PERP", leverage: "20", marginType: "cross" });
+    expect(result["2"]).toEqual({ coin: "ETH-PERP", leverage: "4", marginType: "isolated" });
+    expect(result["999"]).toBeNull();
+  });
+});
+describe("LighterAccountTracker start lifecycle", () => {
+  beforeEach(() => {
+    createExchangeWsMock.mockReset();
+    fetchAccountMock.mockReset().mockResolvedValue(emptyAccountResponse());
+    fetchAccountLimitsMock.mockReset();
+    fetchOrderBookDetailsMock.mockReset();
+  });
+  it("shares an overlapping start and leaves one socket and poll timer running", async () => {
+    const markets = deferred();
+    const socket = mockLighterWs();
+    fetchOrderBookDetailsMock.mockReturnValue(markets.promise);
+    createExchangeWsMock.mockResolvedValue({ main: socket });
+    const tracker = buildTracker();
+    const firstStart = tracker.start();
+    const overlappingStart = tracker.start();
+    expect(overlappingStart).toBe(firstStart);
+    expect(fetchOrderBookDetailsMock).toHaveBeenCalledTimes(1);
+    markets.resolve([]);
+    await Promise.all([firstStart, overlappingStart]);
+    await tracker.start();
+    expect(createExchangeWsMock).toHaveBeenCalledTimes(1);
+    expect(socket.addMessageListener).toHaveBeenCalledTimes(1);
+    expect(socket.addOpenListener).toHaveBeenCalledTimes(1);
+    await tracker.disconnect();
+    expect(socket.destroy).toHaveBeenCalledTimes(1);
+  });
+  it("starts a fresh socket after disconnect without retaining the previous lifecycle", async () => {
+    const firstSocket = mockLighterWs();
+    const secondSocket = mockLighterWs();
+    fetchOrderBookDetailsMock.mockResolvedValue([]);
+    createExchangeWsMock.mockResolvedValueOnce({ main: firstSocket }).mockResolvedValueOnce({ main: secondSocket });
+    const tracker = buildTracker();
+    await tracker.start();
+    await tracker.disconnect();
+    await tracker.start();
+    expect(createExchangeWsMock).toHaveBeenCalledTimes(2);
+    expect(firstSocket.destroy).toHaveBeenCalledTimes(1);
+    expect(secondSocket.destroy).not.toHaveBeenCalled();
+    await tracker.disconnect();
+    expect(secondSocket.destroy).toHaveBeenCalledTimes(1);
+  });
+});
+describe("LighterAccountTracker live position snapshots", () => {
+  beforeEach(() => {
+    fetchAccountMock.mockReset();
+    fetchAccountLimitsMock.mockReset();
+    fetchOrderBookDetailsMock.mockReset();
+  });
+  it("removes a prior short when a zero tombstone resets its sign to positive", () => {
+    const tracker = buildTracker();
+    const updates = [];
+    tracker.trackPosition((positions) => updates.push(positions));
+    const internals = tracker;
+    internals.onAccountAll({
+      type: "subscribed/account_all",
+      assets: null,
+      positions: { 1: rawPosition({ sign: -1, position: "2" }) }
+    });
+    internals.onAccountAll({
+      type: "update/account_all",
+      assets: null,
+      positions: { 1: rawPosition({ sign: 1, position: "0" }) }
+    });
+    expect(updates).toEqual([[expect.objectContaining({ side: "short", size: "-2" })], []]);
+    expect(tracker.getPositions()).toEqual([]);
+  });
+  it("clears both websocket balance halves on reconnect before accepting the new account snapshot", () => {
+    const tracker = buildTracker();
+    const internals = tracker;
+    internals.marketsByMarketId.set(1, marketDetail());
+    internals.onUserStats(userStats("1000"));
+    internals.onAccountAll({
+      type: "subscribed/account_all",
+      assets: { 0: { symbol: "USDC", balance: "1000", locked_balance: "0" } },
+      positions: {
+        1: rawPosition({
+          initial_margin_fraction: "25",
+          margin_mode: 1,
+          position: "2"
+        })
+      }
+    });
+    expect(tracker.getBalance()?.totalEquity).toBe("1000");
+    expect(tracker.getPositions()).toHaveLength(1);
+    expect(tracker.getTrackedAsset("1")).toEqual({ coin: "BTC", leverage: "4", marginType: "isolated" });
+    internals.handleWsOpen();
+    expect(tracker.getBalance()).toBeNull();
+    expect(tracker.getPositions()).toEqual([]);
+    expect(tracker.isInitialized).toBe(false);
+    expect(tracker.getTrackedAsset("1")).toEqual({ coin: "BTC", leverage: "10", marginType: "cross" });
+    internals.onAccountAll({
+      type: "subscribed/account_all",
+      assets: { 0: { symbol: "USDC", balance: "200", locked_balance: "0" } },
+      positions: {}
+    });
+    expect(tracker.getBalance()).toBeNull();
+    internals.onUserStats(userStats("200"));
+    expect(tracker.getBalance()).toMatchObject({
+      totalEquity: "200",
+      walletBalance: "200"
+    });
+  });
+  it("replaces cached positions when a REST poll returns an empty full snapshot", async () => {
+    const tracker = buildTracker();
+    const internals = tracker;
+    internals.onAccountAll({
+      type: "subscribed/account_all",
+      assets: null,
+      positions: { 1: rawPosition({ position: "2" }) }
+    });
+    fetchAccountMock.mockResolvedValue({
+      code: 200,
+      accounts: [
+        {
+          account_type: 0,
+          account_trading_mode: 0,
+          collateral: "1000",
+          total_asset_value: "1000",
+          available_balance: "1000",
+          cross_asset_value: "1000",
+          cross_initial_margin_requirement: "0",
+          cross_maintenance_margin_requirement: "0",
+          assets: [],
+          positions: []
+        }
+      ]
+    });
+    await internals.pollAccount();
+    expect(tracker.getPositions()).toEqual([]);
+  });
+  it("preserves zero-position REST settings in poll asset state without creating a position", async () => {
+    const tracker = buildTracker();
+    const internals = tracker;
+    fetchAccountMock.mockResolvedValue({
+      code: 200,
+      accounts: [
+        {
+          ...emptyAccountResponse().accounts[0],
+          positions: [
+            rawPosition({ market_id: 2, symbol: "ETH", position: "0", initial_margin_fraction: "25", margin_mode: 1 })
+          ]
+        }
+      ]
+    });
+    await internals.pollAccount();
+    expect(tracker.getPositions()).toEqual([]);
+    expect(tracker.getTrackedAsset("2")).toEqual({ coin: "ETH", leverage: "4", marginType: "isolated" });
+  });
+  it("periodically refreshes account tier inside the serialized poll and publishes the changed tier", async () => {
+    const createAuthToken = vi.fn().mockResolvedValue({ token: "auth-token" });
+    const sdk = { core: { misc: { lighter: { createAuthToken } } } };
+    const tracker = buildTracker(sdk, false);
+    const balanceUpdates = [];
+    tracker.trackBalance((balance) => balanceUpdates.push(balance));
+    fetchAccountMock.mockResolvedValue(emptyAccountResponse());
+    fetchAccountLimitsMock.mockResolvedValue({ code: 200, user_tier: "plus" });
+    const internals = tracker;
+    internals.accountTier = "premium";
+    internals.lastAccountTierFetchAt = 0;
+    internals.onUserStats({
+      type: "subscribed/user_stats",
+      stats: {
+        collateral: "1000",
+        portfolio_value: "1000",
+        available_balance: "1000",
+        margin_usage: "0",
+        account_trading_mode: 0
+      }
+    });
+    await internals.pollAccount();
+    await internals.pollAccount();
+    internals.onAccountAll({
+      type: "update/account_all",
+      assets: { 0: { symbol: "USDC", balance: "1000", locked_balance: "0" } },
+      positions: {}
+    });
+    expect(createAuthToken).toHaveBeenCalledTimes(1);
+    expect(fetchAccountLimitsMock).toHaveBeenCalledTimes(1);
+    expect(tracker.getBalance()?.accountTier).toBe("plus");
+    expect(balanceUpdates).toContainEqual(expect.objectContaining({ accountTier: "plus" }));
+  });
+  it("keeps tier refresh on its 60-second schedule when websocket traffic makes the REST snapshot stale", async () => {
+    const accountResponse = deferred();
+    const createAuthToken = vi.fn().mockResolvedValue({ token: "auth-token" });
+    const sdk = { core: { misc: { lighter: { createAuthToken } } } };
+    const tracker = buildTracker(sdk, false);
+    fetchAccountMock.mockReturnValueOnce(accountResponse.promise).mockResolvedValue(emptyAccountResponse());
+    fetchAccountLimitsMock.mockResolvedValue({ code: 200, user_tier: "plus" });
+    const internals = tracker;
+    internals.accountTier = "premium";
+    internals.lastAccountTierFetchAt = 0;
+    internals.onAccountAll({
+      type: "subscribed/account_all",
+      assets: { 0: { symbol: "USDC", balance: "1000", locked_balance: "0" } },
+      positions: {}
+    });
+    internals.onUserStats(userStats("1000"));
+    const stalePoll = internals.pollAccount();
+    internals.onUserStats(userStats("1001"));
+    accountResponse.resolve(emptyAccountResponse());
+    await stalePoll;
+    expect(tracker.getBalance()).toMatchObject({
+      accountTier: "plus",
+      totalEquity: "1001"
+    });
+    await internals.pollAccount();
+    expect(createAuthToken).toHaveBeenCalledTimes(1);
+    expect(fetchAccountLimitsMock).toHaveBeenCalledTimes(1);
+    expect(tracker.getBalance()?.accountTier).toBe("plus");
+  });
+  it("shares one in-flight REST poll and ignores its snapshot after a newer websocket update", async () => {
+    const accountResponse = deferred();
+    fetchAccountMock.mockReturnValue(accountResponse.promise);
+    const tracker = buildTracker();
+    const internals = tracker;
+    const firstPoll = internals.pollAccount();
+    const overlappingPoll = internals.pollAccount();
+    expect(fetchAccountMock).toHaveBeenCalledTimes(1);
+    internals.onAccountAll({
+      type: "update/account_all",
+      assets: null,
+      positions: { 1: rawPosition({ position: "3" }) }
+    });
+    accountResponse.resolve(emptyAccountResponse());
+    await Promise.all([firstPoll, overlappingPoll]);
+    expect(tracker.getPositions()).toEqual([expect.objectContaining({ symbol: "BTC", size: "3" })]);
+  });
+  it("ignores a REST poll that resolves after disconnect", async () => {
+    const accountResponse = deferred();
+    fetchAccountMock.mockReturnValue(accountResponse.promise);
+    const tracker = buildTracker();
+    const internals = tracker;
+    internals.onAccountAll({
+      type: "subscribed/account_all",
+      assets: null,
+      positions: { 1: rawPosition({ position: "2" }) }
+    });
+    const poll = internals.pollAccount();
+    await tracker.disconnect();
+    accountResponse.resolve(emptyAccountResponse());
+    await poll;
+    expect(tracker.getPositions()).toEqual([expect.objectContaining({ symbol: "BTC", size: "2" })]);
+  });
+});
+function emptyAccountResponse() {
+  return {
+    code: 200,
+    accounts: [
+      {
+        account_type: 0,
+        account_trading_mode: 0,
+        collateral: "1000",
+        total_asset_value: "1000",
+        available_balance: "1000",
+        cross_asset_value: "1000",
+        cross_initial_margin_requirement: "0",
+        cross_maintenance_margin_requirement: "0",
+        assets: [],
+        positions: []
+      }
+    ]
+  };
+}
+function deferred() {
+  let resolve;
+  const promise = new Promise((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+}
+function mockLighterWs() {
+  return {
+    connected: true,
+    addMessageListener: vi.fn().mockReturnValue("message-listener"),
+    addOpenListener: vi.fn().mockReturnValue("open-listener"),
+    removeMessageListener: vi.fn(),
+    removeOpenListener: vi.fn(),
+    send: vi.fn(),
+    destroy: vi.fn()
+  };
+}
+function rawPosition(overrides) {
+  return {
+    market_id: 1,
+    symbol: "BTC",
+    initial_margin_fraction: "10",
+    sign: 1,
+    position: "1",
+    avg_entry_price: "1000",
+    position_value: "1000",
+    unrealized_pnl: "0",
+    liquidation_price: "500",
+    margin_mode: 0,
+    allocated_margin: "0",
+    ...overrides
+  };
+}
+function marketDetail() {
+  return {
+    market_id: 1,
+    symbol: "BTC",
+    status: "active",
+    default_initial_margin_fraction: 1e3,
+    maintenance_margin_fraction: 1e3
+  };
+}
+function userStats(portfolioValue) {
+  return {
+    type: "subscribed/user_stats",
+    stats: {
+      collateral: portfolioValue,
+      portfolio_value: portfolioValue,
+      available_balance: portfolioValue,
+      margin_usage: "0",
+      account_trading_mode: 0
+    }
+  };
+}

package/dist/tracker/lighter/types.js

@@ -1,6 +1,14 @@
 var LighterAccountType = /* @__PURE__ */ ((LighterAccountType2) => {
-  LighterAccountType2["BASIC"] = "basic";
+  LighterAccountType2["BASIC"] = "classic";
+  LighterAccountType2["CLASSIC"] = "classic";
+  LighterAccountType2["UNIFIED"] = "unified";
   return LighterAccountType2;
 })(LighterAccountType || {});
+var LighterAccountTier = /* @__PURE__ */ ((LighterAccountTier2) => {
+  LighterAccountTier2["STANDARD"] = "standard";
+  LighterAccountTier2["PREMIUM"] = "premium";
+  LighterAccountTier2["PLUS"] = "plus";
+  return LighterAccountTier2;
+})(LighterAccountTier || {});
 
-export { LighterAccountType };
+export { LighterAccountTier, LighterAccountType };

package/dist/tracker/okx/tracker.js

@@ -1,10 +1,11 @@
-import { fetchAccountConfig, fetchBalance, fetchPositions, fetchLeverageInfo } from '../../client/okx/rest';
+import { createExchangeWs } from '../../client';
+import { fetchLeverageInfos, fetchAccountConfig, fetchBalance, fetchPositions } from '../../client/okx/rest';
 import { BaseAccountTracker } from '../base';
-import { acctLvToAccountType, mergeRawCoins, buildBalance, mapPositions, mapPositionUpdates } from './mapper';
+import { acctLvToAccountType, mergeRawCoins, mapPositions, buildBalance, mapPositionUpdates } from './mapper';
 
 class OkxAccountTracker extends BaseAccountTracker {
   creds;
-  ws;
+  ws = null;
   messageListenerId = null;
   openListenerId = null;
   rawCoins = /* @__PURE__ */ new Map();
@@ -13,40 +14,73 @@ class OkxAccountTracker extends BaseAccountTracker {
   trackedAssetInfos = /* @__PURE__ */ new Map();
   constructor(config) {
     super(config);
-    this.credentials = config.credentials;
     this.creds = config.credentials;
-    this.ws = config.ws;
+  }
+  async snapshot() {
+    const { config, balance, positions } = await this.fetchSnapshotData();
+    const accountType = acctLvToAccountType(config.acctLv);
+    const rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), balance.details ?? []);
+    return {
+      balance: buildBalance(balance, rawCoins, accountType),
+      positions: Array.from(mapPositions(positions).values())
+    };
+  }
+  /**
+   * 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.
+   */
+  async fetchAssetSnapshots(instIds) {
+    const infos = await fetchLeverageInfos(this.creds, instIds, this.demo);
+    const byInstId = /* @__PURE__ */ new Map();
+    for (const info of infos) {
+      if (!byInstId.has(info.instId)) byInstId.set(info.instId, info);
+    }
+    const result = {};
+    for (const instId of instIds) {
+      const info = byInstId.get(instId);
+      result[instId] = info ? { coin: instId, leverage: info.lever || "0", marginType: info.mgnMode } : null;
+    }
+    return result;
   }
   async start() {
-    const [config, balance, positions] = await Promise.all([
-      fetchAccountConfig(this.creds, this.demo),
-      fetchBalance(this.creds, this.demo),
-      fetchPositions(this.creds, this.demo)
-    ]);
+    const { config, balance, positions } = await this.fetchSnapshotData();
     this.accountType = acctLvToAccountType(config.acctLv);
     this.handleInitialData(balance, positions);
+    this.ws = await createExchangeWs("okx", { demo: this.demo, credentials: this.credentials });
     this.messageListenerId = this.ws.main.addMessageListener((raw) => this.routeRaw(raw));
     this.openListenerId = this.ws.main.addOpenListener(() => {
-      this.ws.login().then(() => this.subscribe()).catch((err) => this.onError(err));
+      this.ws?.login().then(() => this.subscribe()).catch((err) => this.onError(err));
     });
     this.subscribe();
   }
   async cleanupConnections() {
     if (this.messageListenerId) {
-      this.ws.main.removeMessageListener(this.messageListenerId);
+      this.ws?.main.removeMessageListener(this.messageListenerId);
       this.messageListenerId = null;
     }
     if (this.openListenerId) {
-      this.ws.main.removeOpenListener(this.openListenerId);
+      this.ws?.main.removeOpenListener(this.openListenerId);
       this.openListenerId = null;
     }
+    this.ws?.destroy();
+    this.ws = null;
   }
   get isConnected() {
-    return this.ws.isConnected;
+    return this.ws?.isConnected ?? false;
+  }
+  async fetchSnapshotData() {
+    const [config, balance, positions] = await Promise.all([
+      fetchAccountConfig(this.creds, this.demo),
+      fetchBalance(this.creds, this.demo),
+      fetchPositions(this.creds, this.demo)
+    ]);
+    return { config, balance, positions };
   }
   ensureAssetTracked(instId) {
     if (this.trackedAssetInfos.has(instId)) return;
-    fetchLeverageInfo(this.creds, instId, this.demo).then((info) => {
+    fetchLeverageInfos(this.creds, [instId], this.demo).catch(() => []).then((infos) => {
+      const info = infos[0];
       const leverage = info?.lever || "0";
       const marginType = info?.mgnMode;
       const trackedAssetInfo = { coin: instId, leverage, marginType };
@@ -60,7 +94,7 @@ class OkxAccountTracker extends BaseAccountTracker {
     this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
   }
   subscribe() {
-    this.ws.main.send({
+    this.ws?.main.send({
       op: "subscribe",
       args: [{ channel: "account" }, { channel: "positions", instType: "SWAP" }]
     });