@pear-protocol/exchanges-sdk 0.2.0 → 0.4.0

package/dist/tracker/hyperliquid/tracker.test.js

@@ -0,0 +1,587 @@
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { HyperliquidAccountTracker } from './tracker';
+import { HyperliquidAccountType } from './types';
+
+const {
+  createExchangeWsMock,
+  fetchInfoMock,
+  fetchPerpDexsMock,
+  fetchClearinghouseStateMock,
+  fetchUserAbstractionMock,
+  fetchSpotClearinghouseStateMock,
+  fetchActiveAssetDataMock
+} = vi.hoisted(() => ({
+  createExchangeWsMock: vi.fn(),
+  fetchInfoMock: vi.fn(),
+  fetchPerpDexsMock: vi.fn(),
+  fetchClearinghouseStateMock: vi.fn(),
+  fetchUserAbstractionMock: vi.fn(),
+  fetchSpotClearinghouseStateMock: vi.fn(),
+  fetchActiveAssetDataMock: vi.fn()
+}));
+vi.mock("../../client", () => ({
+  createExchangeWs: createExchangeWsMock
+}));
+vi.mock("../../client/hyperliquid/rest", () => ({
+  fetchInfo: fetchInfoMock,
+  fetchPerpDexs: fetchPerpDexsMock,
+  fetchClearinghouseState: fetchClearinghouseStateMock,
+  fetchUserAbstraction: fetchUserAbstractionMock,
+  fetchSpotClearinghouseState: fetchSpotClearinghouseStateMock,
+  fetchActiveAssetData: fetchActiveAssetDataMock
+}));
+const address = "0xabcdef0000000000000000000000000000000000";
+const account = { exchangeIdentifier: address.toUpperCase() };
+function buildTracker() {
+  return new HyperliquidAccountTracker({
+    demo: true,
+    account,
+    credentials: { signer_key: "sk" }
+  });
+}
+function exchangeWsMock() {
+  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 dexState(coin, accountValue, unrealizedPnl) {
+  return {
+    marginSummary: {
+      accountValue,
+      totalNtlPos: "0",
+      totalRawUsd: accountValue,
+      totalMarginUsed: "10"
+    },
+    crossMarginSummary: {
+      accountValue,
+      totalNtlPos: "0",
+      totalRawUsd: accountValue,
+      totalMarginUsed: "10"
+    },
+    crossMaintenanceMarginUsed: "5",
+    withdrawable: accountValue,
+    assetPositions: [
+      {
+        type: "oneWay",
+        position: {
+          coin,
+          szi: "1",
+          leverage: { type: "cross", value: 10 },
+          entryPx: "50000",
+          positionValue: accountValue,
+          unrealizedPnl,
+          returnOnEquity: "0.1",
+          liquidationPx: "40000",
+          marginUsed: "10",
+          maxLeverage: 50,
+          cumFunding: { allTime: "0", sinceOpen: "0", sinceChange: "0" }
+        }
+      }
+    ],
+    time: 0
+  };
+}
+function allPerpMetas() {
+  return [
+    { collateralToken: 0, universe: [], marginTables: [] },
+    { collateralToken: 360, universe: [], marginTables: [] }
+  ];
+}
+function webData(abstraction) {
+  return {
+    userState: {
+      user: address,
+      abstraction,
+      agentAddress: null,
+      agentValidUntil: null,
+      cumLedger: "0",
+      serverTime: 1,
+      isVault: false
+    },
+    perpDexStates: []
+  };
+}
+describe("HyperliquidAccountTracker.snapshot", () => {
+  beforeEach(() => {
+    fetchInfoMock.mockReset().mockImplementation(async (body) => {
+      if (body.type === "allPerpMetas") return allPerpMetas();
+      if (body.type === "spotMeta") {
+        return {
+          tokens: [
+            { index: 0, name: "USDC" },
+            { index: 360, name: "USDH" }
+          ]
+        };
+      }
+      throw new Error(`Unexpected info request: ${body.type}`);
+    });
+    fetchPerpDexsMock.mockReset();
+    fetchClearinghouseStateMock.mockReset();
+    fetchUserAbstractionMock.mockReset();
+    fetchSpotClearinghouseStateMock.mockReset().mockResolvedValue({ balances: [] });
+  });
+  it("uses spot collateral for Unified balances while retaining positions from every DEX", async () => {
+    fetchPerpDexsMock.mockResolvedValue([null, { name: "builder-dex" }]);
+    fetchClearinghouseStateMock.mockImplementation(
+      async (_user, dex) => dex === "" ? dexState("BTC", "100", "10") : dexState("ETH", "50", "-5")
+    );
+    fetchUserAbstractionMock.mockResolvedValue("unifiedAccount");
+    fetchSpotClearinghouseStateMock.mockResolvedValue({
+      balances: [
+        { coin: "USDC", token: 0, total: "100", hold: "10", entryNtl: "0" },
+        { coin: "USDH", token: 360, total: "50", hold: "5", entryNtl: "0" }
+      ],
+      tokenToAvailableAfterMaintenance: [
+        [0, "85"],
+        [360, "42"]
+      ]
+    });
+    const snapshot = await buildTracker().snapshot();
+    expect(fetchClearinghouseStateMock).toHaveBeenCalledTimes(2);
+    expect(fetchClearinghouseStateMock).toHaveBeenCalledWith(address, "", true);
+    expect(fetchClearinghouseStateMock).toHaveBeenCalledWith(address, "builder-dex", true);
+    expect(fetchSpotClearinghouseStateMock).toHaveBeenCalledWith(address, true);
+    expect(snapshot.balance).toMatchObject({
+      accountType: "unifiedAccount",
+      walletBalance: "145",
+      totalEquity: "150",
+      availableToTrade: "127",
+      free: { USDC: "90", USDH: "45" }
+    });
+    expect(snapshot.positions.map((position) => position.symbol).sort()).toEqual(["BTC", "ETH"]);
+  });
+  it("fails closed for an unrecognized future abstraction value", async () => {
+    fetchPerpDexsMock.mockResolvedValue([null]);
+    fetchClearinghouseStateMock.mockResolvedValue(dexState("BTC", "100", "10"));
+    fetchUserAbstractionMock.mockResolvedValue("somethingNew");
+    const snapshot = await buildTracker().snapshot();
+    expect(snapshot.balance).toBeNull();
+  });
+  it("de-duplicates repeated DEX descriptors without double-counting Standard equity", async () => {
+    fetchPerpDexsMock.mockResolvedValue([null, null]);
+    fetchClearinghouseStateMock.mockResolvedValue(dexState("BTC", "100", "10"));
+    fetchUserAbstractionMock.mockResolvedValue("disabled");
+    const snapshot = await buildTracker().snapshot();
+    expect(fetchClearinghouseStateMock).toHaveBeenCalledTimes(1);
+    expect(snapshot.balance?.totalEquity).toBe("100");
+  });
+  it("uses selected-network spot metadata for Standard collateral assets", async () => {
+    fetchInfoMock.mockImplementation(async (body) => {
+      if (body.type === "allPerpMetas") {
+        return [{ collateralToken: 1452, universe: [], marginTables: [] }];
+      }
+      if (body.type === "spotMeta") {
+        return { tokens: [{ index: 1452, name: "USDH" }] };
+      }
+      throw new Error(`Unexpected info request: ${body.type}`);
+    });
+    fetchPerpDexsMock.mockResolvedValue([null]);
+    fetchClearinghouseStateMock.mockResolvedValue(dexState("BTC", "100", "10"));
+    fetchUserAbstractionMock.mockResolvedValue("disabled");
+    const snapshot = await buildTracker().snapshot();
+    expect(fetchInfoMock).toHaveBeenCalledWith({ type: "spotMeta" }, true);
+    expect(snapshot.balance).toMatchObject({
+      free: { USDH: "100" },
+      total: { USDH: "100" },
+      assets: [{ asset: "USDH" }]
+    });
+  });
+  it("does not expose a fabricated balance for deprecated DEX abstraction", async () => {
+    fetchPerpDexsMock.mockResolvedValue([null, { name: "builder-dex" }]);
+    fetchClearinghouseStateMock.mockImplementation(
+      async (_user, dex) => dex === "" ? dexState("BTC", "100", "10") : dexState("builder-dex:ETH", "100", "10")
+    );
+    fetchUserAbstractionMock.mockResolvedValue("dexAbstraction");
+    const snapshot = await buildTracker().snapshot();
+    expect(snapshot.balance).toBeNull();
+    expect(snapshot.positions).toHaveLength(2);
+  });
+  it("fails the complete snapshot when any DEX read fails", async () => {
+    fetchPerpDexsMock.mockResolvedValue([null, { name: "flaky-dex" }]);
+    fetchClearinghouseStateMock.mockImplementation(async (_user, dex) => {
+      if (dex === "flaky-dex") {
+        throw new Error("503");
+      }
+      return dexState("BTC", "100", "10");
+    });
+    fetchUserAbstractionMock.mockResolvedValue("disabled");
+    await expect(buildTracker().snapshot()).rejects.toThrow("503");
+  });
+  it("throws when every clearinghouse state read fails", async () => {
+    fetchPerpDexsMock.mockResolvedValue([null]);
+    fetchClearinghouseStateMock.mockRejectedValue(new Error("503"));
+    fetchUserAbstractionMock.mockResolvedValue("unifiedAccount");
+    await expect(buildTracker().snapshot()).rejects.toThrow("503");
+  });
+});
+describe("HyperliquidAccountTracker.snapshotAssets", () => {
+  beforeEach(() => {
+    fetchActiveAssetDataMock.mockReset();
+  });
+  it("reads leverage and margin type from testnet for each coin", async () => {
+    fetchActiveAssetDataMock.mockImplementation(
+      async (_user, coin) => coin === "BTC" ? { coin: "BTC", leverage: { type: "cross", value: 20 } } : { coin: "ETH", leverage: { type: "isolated", value: 5 } }
+    );
+    const result = await buildTracker().snapshotAssets(["BTC", "ETH"]);
+    expect(fetchActiveAssetDataMock).toHaveBeenCalledTimes(2);
+    expect(fetchActiveAssetDataMock).toHaveBeenCalledWith(address, "BTC", true);
+    expect(result).toEqual({
+      BTC: { coin: "BTC", leverage: "20", marginType: "cross" },
+      ETH: { coin: "ETH", leverage: "5", marginType: "isolated" }
+    });
+  });
+  it("maps one failed coin read to null while retaining successful settings", async () => {
+    fetchActiveAssetDataMock.mockImplementation(async (_user, coin) => {
+      if (coin === "DOGE") {
+        throw new Error("422");
+      }
+      return { coin, leverage: { type: "cross", value: 10 } };
+    });
+    const result = await buildTracker().snapshotAssets(["BTC", "DOGE"]);
+    expect(result.BTC).toMatchObject({ leverage: "10", marginType: "cross" });
+    expect(result.DOGE).toBeNull();
+  });
+  it("throws when every active-asset read fails", async () => {
+    fetchActiveAssetDataMock.mockRejectedValue(new Error("503"));
+    await expect(buildTracker().snapshotAssets(["BTC", "ETH"])).rejects.toThrow("every activeAssetData read failed");
+  });
+});
+describe("HyperliquidAccountTracker startup lifecycle", () => {
+  beforeEach(() => {
+    fetchInfoMock.mockReset().mockImplementation(async (body) => {
+      if (body.type === "allPerpMetas") return [allPerpMetas()[0]];
+      if (body.type === "spotMeta") return { tokens: [{ index: 0, name: "USDC" }] };
+      throw new Error(`Unexpected info request: ${body.type}`);
+    });
+    fetchPerpDexsMock.mockReset().mockResolvedValue([null]);
+    fetchUserAbstractionMock.mockReset().mockResolvedValue("disabled");
+    createExchangeWsMock.mockReset();
+  });
+  it("abandons startup when disconnect occurs during metadata loading", async () => {
+    const metadata = deferred();
+    fetchInfoMock.mockImplementation(async (body) => {
+      if (body.type === "allPerpMetas") return metadata.promise;
+      if (body.type === "spotMeta") return { tokens: [{ index: 0, name: "USDC" }] };
+      throw new Error(`Unexpected info request: ${body.type}`);
+    });
+    const tracker = buildTracker();
+    const start = tracker.start();
+    await tracker.disconnect();
+    metadata.resolve(allPerpMetas());
+    await start;
+    expect(createExchangeWsMock).not.toHaveBeenCalled();
+    expect(tracker.isConnected).toBe(false);
+  });
+  it("destroys a socket that resolves after disconnect without installing listeners", async () => {
+    const socketCreation = deferred();
+    const ws = exchangeWsMock();
+    createExchangeWsMock.mockReturnValue(socketCreation.promise);
+    const tracker = buildTracker();
+    const start = tracker.start();
+    await vi.waitFor(() => expect(createExchangeWsMock).toHaveBeenCalledTimes(1));
+    await tracker.disconnect();
+    socketCreation.resolve({ main: ws });
+    await start;
+    expect(ws.destroy).toHaveBeenCalledTimes(1);
+    expect(ws.addMessageListener).not.toHaveBeenCalled();
+    expect(ws.addOpenListener).not.toHaveBeenCalled();
+    expect(tracker.isConnected).toBe(false);
+  });
+  it("tears down the active socket before a repeated start installs its replacement", async () => {
+    const firstWs = exchangeWsMock();
+    const secondWs = exchangeWsMock();
+    createExchangeWsMock.mockResolvedValueOnce({ main: firstWs }).mockResolvedValueOnce({ main: secondWs });
+    const tracker = buildTracker();
+    await tracker.start();
+    await tracker.start();
+    expect(firstWs.removeMessageListener).toHaveBeenCalledWith("message-listener");
+    expect(firstWs.removeOpenListener).toHaveBeenCalledWith("open-listener");
+    expect(firstWs.destroy).toHaveBeenCalledTimes(1);
+    expect(secondWs.destroy).not.toHaveBeenCalled();
+    expect(tracker.isConnected).toBe(true);
+  });
+  it("destroys a superseded pending socket without disturbing the newer start generation", async () => {
+    const firstSocketCreation = deferred();
+    const firstWs = exchangeWsMock();
+    const secondWs = exchangeWsMock();
+    createExchangeWsMock.mockImplementationOnce(() => firstSocketCreation.promise).mockResolvedValueOnce({ main: secondWs });
+    const tracker = buildTracker();
+    const firstStart = tracker.start();
+    await vi.waitFor(() => expect(createExchangeWsMock).toHaveBeenCalledTimes(1));
+    const secondStart = tracker.start();
+    await secondStart;
+    firstSocketCreation.resolve({ main: firstWs });
+    await firstStart;
+    expect(firstWs.destroy).toHaveBeenCalledTimes(1);
+    expect(firstWs.addMessageListener).not.toHaveBeenCalled();
+    expect(secondWs.destroy).not.toHaveBeenCalled();
+    expect(tracker.isConnected).toBe(true);
+  });
+});
+describe("HyperliquidAccountTracker live account-mode handling", () => {
+  it("loads selected-network collateral metadata before mapping live Standard balances", async () => {
+    fetchInfoMock.mockReset().mockImplementation(async (body) => {
+      if (body.type === "allPerpMetas") {
+        return [{ collateralToken: 1452, universe: [], marginTables: [] }];
+      }
+      if (body.type === "spotMeta") {
+        return { tokens: [{ index: 1452, name: "USDH" }] };
+      }
+      throw new Error(`Unexpected info request: ${body.type}`);
+    });
+    fetchPerpDexsMock.mockReset().mockResolvedValue([null]);
+    fetchUserAbstractionMock.mockReset().mockResolvedValue("disabled");
+    const ws = {
+      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()
+    };
+    createExchangeWsMock.mockReset().mockResolvedValue({ main: ws });
+    const tracker = buildTracker();
+    await tracker.start();
+    const internals = tracker;
+    internals.onClearinghouseState({
+      user: address,
+      clearinghouseStates: [["", dexState("BTC", "100", "10")]]
+    });
+    expect(fetchInfoMock).toHaveBeenCalledWith({ type: "spotMeta" }, true);
+    expect(tracker.getBalance()).toMatchObject({
+      free: { USDH: "100" },
+      total: { USDH: "100" },
+      assets: [{ asset: "USDH" }]
+    });
+    await tracker.disconnect();
+  });
+  it("waits for spot state before emitting a Unified live balance", () => {
+    const tracker = buildTracker();
+    const updates = [];
+    tracker.trackBalance((balance) => updates.push(balance));
+    const internals = tracker;
+    internals.accountType = HyperliquidAccountType.UNIFIED_ACCOUNT;
+    internals.hasSpotState = false;
+    internals.hasClearinghouseState = false;
+    internals.onClearinghouseState({
+      user: address,
+      clearinghouseStates: [["", dexState("BTC", "100", "10")]]
+    });
+    expect(tracker.getBalance()).toBeNull();
+    expect(updates).toEqual([]);
+    internals.onSpotState({
+      user: address,
+      spotState: {
+        balances: [{ coin: "USDC", token: 0, total: "100", hold: "5", entryNtl: "0" }],
+        tokenToAvailableAfterMaintenance: [[0, "90"]]
+      }
+    });
+    expect(tracker.getBalance()).toMatchObject({
+      accountType: "unifiedAccount",
+      walletBalance: "90",
+      availableToTrade: "90"
+    });
+    expect(updates).toHaveLength(1);
+  });
+  it("waits for clearinghouse state when Unified spot state arrives first", () => {
+    const tracker = buildTracker();
+    const updates = [];
+    tracker.trackBalance((balance) => updates.push(balance));
+    const internals = tracker;
+    internals.accountType = HyperliquidAccountType.UNIFIED_ACCOUNT;
+    internals.hasSpotState = false;
+    internals.hasClearinghouseState = false;
+    internals.onSpotState({
+      user: address,
+      spotState: {
+        balances: [{ coin: "USDC", token: 0, total: "100", hold: "5", entryNtl: "0" }],
+        tokenToAvailableAfterMaintenance: [[0, "90"]]
+      }
+    });
+    expect(tracker.getBalance()).toBeNull();
+    expect(updates).toEqual([]);
+    internals.onClearinghouseState({
+      user: address,
+      clearinghouseStates: [["", dexState("BTC", "100", "10")]]
+    });
+    expect(tracker.getBalance()).toMatchObject({
+      accountType: "unifiedAccount",
+      walletBalance: "90",
+      availableToTrade: "90"
+    });
+    expect(updates).toHaveLength(1);
+  });
+  it("discards both cached snapshots when switching into Unified mode", () => {
+    const tracker = buildTracker();
+    const updates = [];
+    tracker.trackBalance((balance) => updates.push(balance));
+    const internals = tracker;
+    internals.accountType = HyperliquidAccountType.DEFAULT;
+    internals.hasSpotState = false;
+    internals.hasClearinghouseState = false;
+    internals.onClearinghouseState({
+      user: address,
+      clearinghouseStates: [["", dexState("BTC", "100", "10")]]
+    });
+    expect(updates).toHaveLength(1);
+    internals.onWebData3(webData("unifiedAccount"));
+    expect(tracker.getBalance()).toBeNull();
+    expect(updates).toHaveLength(1);
+    internals.onSpotState({
+      user: address,
+      spotState: {
+        balances: [{ coin: "USDC", token: 0, total: "120", hold: "5", entryNtl: "0" }],
+        tokenToAvailableAfterMaintenance: [[0, "100"]]
+      }
+    });
+    expect(updates).toHaveLength(1);
+    internals.onClearinghouseState({
+      user: address,
+      clearinghouseStates: [["", dexState("BTC", "80", "-20")]]
+    });
+    expect(updates).toHaveLength(2);
+    expect(updates[1]).toMatchObject({
+      accountType: "unifiedAccount",
+      availableToTrade: "100",
+      totalEquity: "120"
+    });
+  });
+  it("discards both cached snapshots before resubscribing a reconnected socket", () => {
+    const tracker = buildTracker();
+    const updates = [];
+    tracker.trackBalance((balance) => updates.push(balance));
+    const send = vi.fn();
+    const internals = tracker;
+    internals.accountType = HyperliquidAccountType.UNIFIED_ACCOUNT;
+    internals.hasSpotState = false;
+    internals.hasClearinghouseState = false;
+    internals.ws = { send };
+    internals.onClearinghouseState({
+      user: address,
+      clearinghouseStates: [["", dexState("BTC", "100", "10")]]
+    });
+    internals.onSpotState({
+      user: address,
+      spotState: {
+        balances: [{ coin: "USDC", token: 0, total: "100", hold: "5", entryNtl: "0" }],
+        tokenToAvailableAfterMaintenance: [[0, "90"]]
+      }
+    });
+    expect(updates).toHaveLength(1);
+    internals.resubscribeAll();
+    expect(tracker.getBalance()).toBeNull();
+    expect(updates).toHaveLength(1);
+    internals.onClearinghouseState({
+      user: address,
+      clearinghouseStates: [["", dexState("BTC", "90", "-10")]]
+    });
+    expect(updates).toHaveLength(1);
+    internals.onSpotState({
+      user: address,
+      spotState: {
+        balances: [{ coin: "USDC", token: 0, total: "90", hold: "0", entryNtl: "0" }],
+        tokenToAvailableAfterMaintenance: [[0, "80"]]
+      }
+    });
+    expect(updates).toHaveLength(2);
+    expect(updates[1]).toMatchObject({ totalEquity: "90", availableToTrade: "80" });
+  });
+  it("fails closed and clears listeners for an unknown live mode", () => {
+    const tracker = buildTracker();
+    const updates = [];
+    tracker.trackBalance((balance) => updates.push(balance));
+    const internals = tracker;
+    internals.accountType = HyperliquidAccountType.DEFAULT;
+    internals.hasClearinghouseState = false;
+    internals.onClearinghouseState({
+      user: address,
+      clearinghouseStates: [["", dexState("BTC", "100", "10")]]
+    });
+    expect(updates).toHaveLength(1);
+    const unknownModeEvent = webData("default");
+    unknownModeEvent.userState.abstraction = "somethingNew";
+    internals.onWebData3(unknownModeEvent);
+    expect(tracker.getBalance()).toBeNull();
+    expect(updates).toHaveLength(2);
+    expect(updates[1]).toBeNull();
+  });
+  it("broadcasts explicit null when a live mode becomes known unsupported", () => {
+    const tracker = buildTracker();
+    const updates = [];
+    tracker.trackBalance((balance) => updates.push(balance));
+    const send = vi.fn();
+    const internals = tracker;
+    internals.accountType = HyperliquidAccountType.DEFAULT;
+    internals.hasClearinghouseState = false;
+    internals.ws = { send };
+    internals.onClearinghouseState({
+      user: address,
+      clearinghouseStates: [["", dexState("BTC", "100", "10")]]
+    });
+    internals.onWebData3(webData("portfolioMargin"));
+    expect(tracker.getBalance()).toBeNull();
+    expect(updates).toHaveLength(2);
+    expect(updates[1]).toBeNull();
+  });
+  it("retains locked BTC active-asset data even without a user listener", () => {
+    const tracker = buildTracker();
+    const internals = tracker;
+    const event = {
+      user: address,
+      coin: "BTC",
+      leverage: { type: "cross", value: 20 },
+      maxTradeSzs: ["1", "1"],
+      availableToTrade: ["1", "1"],
+      markPx: "100000"
+    };
+    internals.subscribedCoins.add("BTC");
+    internals.onActiveAssetData(event);
+    expect(tracker.getTrackedAsset("BTC")).toEqual({
+      coin: "BTC",
+      leverage: "20",
+      marginType: "cross"
+    });
+  });
+  it("switches to the portfolio-specific spot subscription when the mode changes", () => {
+    const tracker = buildTracker();
+    const send = vi.fn();
+    const internals = tracker;
+    const event = {
+      userState: {
+        user: address,
+        abstraction: "portfolioMargin",
+        agentAddress: null,
+        agentValidUntil: null,
+        cumLedger: "0",
+        serverTime: 1,
+        isVault: false
+      },
+      perpDexStates: []
+    };
+    internals.accountType = HyperliquidAccountType.DEFAULT;
+    internals.ws = { send };
+    internals.onWebData3(event);
+    expect(send).toHaveBeenNthCalledWith(1, {
+      method: "unsubscribe",
+      subscription: { type: "spotState", user: address }
+    });
+    expect(send).toHaveBeenNthCalledWith(2, {
+      method: "subscribe",
+      subscription: { type: "spotState", user: address, isPortfolioMargin: true }
+    });
+  });
+});
+function deferred() {
+  let resolve;
+  const promise = new Promise((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+}

package/dist/tracker/index.js

@@ -17,67 +17,45 @@ export { OkxAccountType } from './okx/types';
 export * from './types';
 
 function createAccountTracker(exchange, config) {
-  let tracker;
   switch (exchange) {
-    case "binance": {
-      const ws = config.ws;
-      tracker = new BinanceAccountTracker({
+    case "binance":
+      return new BinanceAccountTracker({
         demo: config.demo,
         onError: config.onError,
-        credentials: config.credentials,
-        userDataWs: ws.userData,
-        wsApiWs: ws.wsApi
+        credentials: config.credentials
       });
-      break;
-    }
-    case "bybit": {
-      const ws = config.ws;
-      tracker = new BybitAccountTracker({
+    case "bybit":
+      return new BybitAccountTracker({
         demo: config.demo,
         onError: config.onError,
-        credentials: config.credentials,
-        ws
+        credentials: config.credentials
       });
-      break;
-    }
-    case "okx": {
-      const ws = config.ws;
-      tracker = new OkxAccountTracker({
+    case "okx":
+      return new OkxAccountTracker({
         demo: config.demo,
         onError: config.onError,
-        credentials: config.credentials,
-        ws
+        credentials: config.credentials
       });
-      break;
-    }
-    case "hyperliquid": {
-      const ws = config.ws;
-      tracker = new HyperliquidAccountTracker({
+    case "hyperliquid":
+      return new HyperliquidAccountTracker({
         demo: config.demo,
         onError: config.onError,
         account: config.account,
-        credentials: config.credentials,
-        ws: ws.main
+        credentials: config.credentials
       });
-      break;
-    }
-    case "lighter": {
-      const ws = config.ws;
-      tracker = new LighterAccountTracker({
+    case "lighter":
+      return new LighterAccountTracker({
         demo: config.demo,
         onError: config.onError,
         account: config.account,
         credentials: config.credentials,
-        ws: ws.main
+        sdk: config.sdk
       });
-      break;
-    }
     default: {
       const _exhaustive = exchange;
       throw new Error(`Unsupported exchange: ${String(_exhaustive)}`);
     }
   }
-  return tracker;
 }
 
 export { createAccountTracker };