@pear-protocol/exchanges-sdk 0.2.0 → 0.4.0

package/dist/tracker/binance/tracker.test.js

@@ -0,0 +1,138 @@
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { BinanceAccountTracker } from './tracker';
+
+const {
+  fetchAccountStatusMock,
+  fetchAllPositionRiskMock,
+  fetchMultiAssetsMarginMock,
+  fetchPositionRiskMock,
+  keepAliveListenKeyMock
+} = vi.hoisted(() => ({
+  fetchAccountStatusMock: vi.fn(),
+  fetchAllPositionRiskMock: vi.fn(),
+  fetchMultiAssetsMarginMock: vi.fn(),
+  fetchPositionRiskMock: vi.fn(),
+  keepAliveListenKeyMock: vi.fn()
+}));
+vi.mock("../../client/binance/rest", () => ({
+  fetchAccountStatus: fetchAccountStatusMock,
+  fetchAllPositionRisk: fetchAllPositionRiskMock,
+  fetchMultiAssetsMargin: fetchMultiAssetsMarginMock,
+  fetchPositionRisk: fetchPositionRiskMock,
+  keepAliveListenKey: keepAliveListenKeyMock
+}));
+const creds = {
+  read: { api_key: "rk", api_secret: "rs" },
+  write: { api_key: "wk", api_secret: "ws" }
+};
+function buildTracker() {
+  return new BinanceAccountTracker({ demo: true, credentials: creds });
+}
+describe("BinanceAccountTracker.snapshot", () => {
+  beforeEach(() => {
+    fetchAccountStatusMock.mockReset();
+    fetchAllPositionRiskMock.mockReset();
+    fetchMultiAssetsMarginMock.mockReset();
+  });
+  it("splices accountType onto the omit-shaped mapBalance() result", async () => {
+    fetchAccountStatusMock.mockResolvedValue({
+      totalWalletBalance: "5000",
+      totalMarginBalance: "5000",
+      availableBalance: "4500",
+      totalUnrealizedProfit: "25",
+      totalInitialMargin: "200",
+      totalMaintMargin: "50",
+      assets: [
+        {
+          asset: "USDT",
+          walletBalance: "5000",
+          availableBalance: "4500",
+          unrealizedProfit: "25",
+          marginBalance: "5000",
+          initialMargin: "200",
+          maintMargin: "50",
+          marginAvailable: true
+        }
+      ]
+    });
+    fetchAllPositionRiskMock.mockResolvedValue([
+      {
+        symbol: "BTCUSDT",
+        leverage: "10",
+        marginType: "cross",
+        isAutoAddMargin: "false",
+        isolatedMargin: "0",
+        positionAmt: "0.5",
+        entryPrice: "50000",
+        breakEvenPrice: "50000",
+        unRealizedProfit: "25",
+        liquidationPrice: "40000",
+        markPrice: "51000",
+        maxNotionalValue: "1000000",
+        positionSide: "BOTH",
+        notional: "25500",
+        isolatedWallet: "0",
+        updateTime: 0
+      }
+    ]);
+    fetchMultiAssetsMarginMock.mockResolvedValue(true);
+    const snapshot = await buildTracker().snapshot();
+    expect(snapshot.balance).toMatchObject({
+      accountType: "MULTI_ASSET",
+      totalEquity: "5000",
+      availableToTrade: "4500",
+      maintenanceMargin: "50",
+      marginRatio: "0.0100"
+    });
+    expect(snapshot.positions).toHaveLength(1);
+    expect(snapshot.positions[0]).toMatchObject({
+      symbol: "BTCUSDT",
+      side: "long",
+      leverage: "10",
+      marginType: "cross",
+      liquidationPrice: "40000"
+    });
+  });
+  it("reports SINGLE_ASSET accountType when multi-assets margin is off", async () => {
+    fetchAccountStatusMock.mockResolvedValue({
+      totalWalletBalance: "0",
+      totalMarginBalance: "0",
+      availableBalance: "0",
+      totalUnrealizedProfit: "0",
+      totalInitialMargin: "0",
+      totalMaintMargin: "0",
+      assets: []
+    });
+    fetchAllPositionRiskMock.mockResolvedValue([]);
+    fetchMultiAssetsMarginMock.mockResolvedValue(false);
+    const snapshot = await buildTracker().snapshot();
+    expect(snapshot.balance?.accountType).toBe("SINGLE_ASSET");
+    expect(snapshot.positions).toEqual([]);
+  });
+});
+describe("BinanceAccountTracker.snapshotAssets", () => {
+  beforeEach(() => {
+    fetchAllPositionRiskMock.mockReset();
+  });
+  it("answers any number of symbols from one all-symbols positionRisk call", async () => {
+    fetchAllPositionRiskMock.mockResolvedValue([
+      { symbol: "BTCUSDT", leverage: "10", marginType: "cross" },
+      { symbol: "ETHUSDT", leverage: "5", marginType: "isolated" }
+    ]);
+    const result = await buildTracker().snapshotAssets(["BTCUSDT", "ETHUSDT", "DOGEUSDT"]);
+    expect(fetchAllPositionRiskMock).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({
+      BTCUSDT: { coin: "BTCUSDT", leverage: "10", marginType: "cross" },
+      ETHUSDT: { coin: "ETHUSDT", leverage: "5", marginType: "isolated" },
+      DOGEUSDT: null
+    });
+  });
+  it("collapses hedge-mode LONG/SHORT rows into one entry per symbol", async () => {
+    fetchAllPositionRiskMock.mockResolvedValue([
+      { symbol: "BTCUSDT", leverage: "10", marginType: "cross", positionSide: "LONG" },
+      { symbol: "BTCUSDT", leverage: "10", marginType: "cross", positionSide: "SHORT" }
+    ]);
+    const result = await buildTracker().snapshotAssets(["BTCUSDT"]);
+    expect(result.BTCUSDT).toEqual({ coin: "BTCUSDT", leverage: "10", marginType: "cross" });
+  });
+});

package/dist/tracker/bybit/tracker.js

@@ -1,11 +1,12 @@
-import { fetchWalletBalance, fetchPositions, fetchAccountInfo, fetchPositionLeverage } from '../../client/bybit/rest';
+import { createExchangeWs } from '../../client';
+import { fetchPositions, fetchPositionLeverage, fetchWalletBalance, fetchAccountInfo } from '../../client/bybit/rest';
 import { BaseAccountTracker } from '../base';
 import { mergeRawCoins, buildBalance, mapPositions, mapPositionUpdates } from './mapper';
 import './types';
 
 class BybitAccountTracker extends BaseAccountTracker {
   creds;
-  ws;
+  ws = null;
   messageListenerId = null;
   openListenerId = null;
   rawCoins = /* @__PURE__ */ new Map();
@@ -14,47 +15,94 @@ class BybitAccountTracker extends BaseAccountTracker {
   trackedAssetInfos = /* @__PURE__ */ new Map();
   constructor(config) {
     super(config);
-    this.credentials = config.credentials;
     this.creds = config.credentials;
-    this.ws = config.ws;
   }
-  async start() {
-    const [wallet, positionsUsd, positionsUsdc, accountInfo] = await Promise.all([
-      fetchWalletBalance(this.creds, this.demo),
-      fetchPositions(this.creds, "USDT", this.demo),
-      fetchPositions(this.creds, "USDC", this.demo),
-      fetchAccountInfo(this.creds, this.demo)
-    ]);
-    this.handleInitialData(
-      wallet ?? null,
-      [positionsUsd, positionsUsdc].flat(),
-      accountInfo?.marginMode ?? null
+  async snapshot() {
+    const { wallet, positions, accountInfo } = await this.fetchSnapshotData();
+    const accountType = accountInfo?.marginMode ?? null;
+    let balance = null;
+    if (wallet) {
+      const rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), wallet.coin ?? []);
+      balance = buildBalance(wallet, rawCoins, accountType);
+    }
+    return { balance, positions: Array.from(mapPositions(positions).values()) };
+  }
+  /**
+   * 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=`
+   * returns the leverage setting even at size 0). For ≤2 symbols the per-symbol reads alone are
+   * cheaper than the two settleCoin reads, so the batch step is skipped. A failed fill-in maps
+   * to `null`; the read only throws when no underlying read succeeded.
+   */
+  async fetchAssetSnapshots(coins) {
+    const bySymbol = /* @__PURE__ */ new Map();
+    const useBatch = coins.length > 2;
+    if (useBatch) {
+      const [positionsUsd, positionsUsdc] = await Promise.all([
+        fetchPositions(this.creds, "USDT", this.demo),
+        fetchPositions(this.creds, "USDC", this.demo)
+      ]);
+      for (const pos of [positionsUsd, positionsUsdc].flat()) {
+        if (pos.symbol) bySymbol.set(pos.symbol, pos);
+      }
+    }
+    const missing = coins.filter((coin) => !bySymbol.has(coin));
+    const fillIns = await Promise.allSettled(
+      missing.map((symbol) => fetchPositionLeverage(this.creds, symbol, this.demo))
     );
+    missing.forEach((symbol, i) => {
+      const res = fillIns[i];
+      if (res?.status === "fulfilled" && res.value) bySymbol.set(symbol, res.value);
+    });
+    if (!useBatch && fillIns.every((res) => res.status === "rejected")) {
+      throw new Error("Bybit snapshotAssets: every position read failed");
+    }
+    const result = {};
+    for (const coin of coins) {
+      const pos = bySymbol.get(coin);
+      result[coin] = pos ? toTrackedAssetInfo(coin, pos) : null;
+    }
+    return result;
+  }
+  async start() {
+    const { wallet, positions, accountInfo } = await this.fetchSnapshotData();
+    this.handleInitialData(wallet ?? null, positions, accountInfo?.marginMode ?? null);
+    this.ws = await createExchangeWs("bybit", { demo: this.demo, credentials: this.credentials });
     this.messageListenerId = this.ws.main.addMessageListener((raw) => this.routeRaw(raw));
     this.openListenerId = this.ws.main.addOpenListener(() => {
-      this.ws.authenticate().then(() => this.subscribe()).catch((err) => this.onError(err));
+      this.ws?.authenticate().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 [wallet, positionsUsd, positionsUsdc, accountInfo] = await Promise.all([
+      fetchWalletBalance(this.creds, this.demo),
+      fetchPositions(this.creds, "USDT", this.demo),
+      fetchPositions(this.creds, "USDC", this.demo),
+      fetchAccountInfo(this.creds, this.demo)
+    ]);
+    return { wallet, positions: [positionsUsd, positionsUsdc].flat(), accountInfo };
   }
   ensureAssetTracked(coin) {
     if (this.trackedAssetInfos.has(coin)) return;
     fetchPositionLeverage(this.creds, coin, this.demo).then((pos) => {
-      const leverage = pos?.leverage || "1";
-      const marginType = pos?.tradeMode === "1" ? "cross" : "isolated";
-      const info = { coin, leverage, marginType };
+      const info = toTrackedAssetInfo(coin, pos);
       this.trackedAssetInfos.set(coin, info);
       const trackedAssets = /* @__PURE__ */ new Map();
       trackedAssets.set(coin, info);
@@ -68,7 +116,7 @@ class BybitAccountTracker extends BaseAccountTracker {
     this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
   }
   subscribe() {
-    this.ws.main.send({ op: "subscribe", args: ["wallet", "position"] });
+    this.ws?.main.send({ op: "subscribe", args: ["wallet", "position"] });
   }
   handleInitialData(wallet, positions, accountType) {
     this.accountType = accountType;
@@ -134,5 +182,12 @@ class BybitAccountTracker extends BaseAccountTracker {
     if (balance) this.onStateUpdate({ balance });
   }
 }
+function toTrackedAssetInfo(coin, pos) {
+  return {
+    coin,
+    leverage: pos?.leverage || "1",
+    marginType: pos?.tradeMode === "1" ? "isolated" : "cross"
+  };
+}
 
 export { BybitAccountTracker };

package/dist/tracker/bybit/tracker.test.js

@@ -0,0 +1,145 @@
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { BybitAccountTracker } from './tracker';
+
+const { fetchWalletBalanceMock, fetchPositionsMock, fetchAccountInfoMock, fetchPositionLeverageMock } = vi.hoisted(
+  () => ({
+    fetchWalletBalanceMock: vi.fn(),
+    fetchPositionsMock: vi.fn(),
+    fetchAccountInfoMock: vi.fn(),
+    fetchPositionLeverageMock: vi.fn()
+  })
+);
+vi.mock("../../client/bybit/rest", () => ({
+  fetchWalletBalance: fetchWalletBalanceMock,
+  fetchPositions: fetchPositionsMock,
+  fetchAccountInfo: fetchAccountInfoMock,
+  fetchPositionLeverage: fetchPositionLeverageMock
+}));
+const creds = { api_key: "k", api_secret: "s" };
+function buildTracker() {
+  return new BybitAccountTracker({ demo: true, credentials: creds });
+}
+describe("BybitAccountTracker.snapshot", () => {
+  beforeEach(() => {
+    fetchWalletBalanceMock.mockReset();
+    fetchPositionsMock.mockReset();
+    fetchAccountInfoMock.mockReset();
+  });
+  it("returns mapped balance + positions across USDT and USDC settle coins with no socket opened", async () => {
+    fetchWalletBalanceMock.mockResolvedValue({
+      totalEquity: "2000",
+      totalWalletBalance: "2000",
+      totalMarginBalance: "2000",
+      totalAvailableBalance: "1800",
+      totalPerpUPL: "50",
+      totalInitialMargin: "100",
+      totalMaintenanceMargin: "20",
+      accountMMRate: "0.0100",
+      coin: [
+        {
+          coin: "USDT",
+          equity: "2000",
+          usdValue: "2000",
+          walletBalance: "2000",
+          unrealisedPnl: "50",
+          totalPositionIM: "100",
+          totalPositionMM: "20",
+          totalOrderIM: "0",
+          locked: "0",
+          borrowAmount: "0",
+          marginCollateral: true,
+          collateralSwitch: true
+        }
+      ]
+    });
+    fetchPositionsMock.mockImplementation(async (_creds, settleCoin) => {
+      if (settleCoin === "USDT") {
+        return [
+          {
+            symbol: "BTCUSDT",
+            side: "Buy",
+            size: "1",
+            avgPrice: "50000",
+            unrealisedPnl: "10",
+            leverage: "5",
+            tradeMode: "0",
+            liqPrice: "40000"
+          }
+        ];
+      }
+      return [];
+    });
+    fetchAccountInfoMock.mockResolvedValue({ marginMode: "REGULAR_MARGIN", updatedTime: "0" });
+    const snapshot = await buildTracker().snapshot();
+    expect(snapshot.balance).toMatchObject({
+      accountType: "REGULAR_MARGIN",
+      totalEquity: "2000",
+      availableToTrade: "1800",
+      maintenanceMargin: "20",
+      marginRatio: "0.0100"
+    });
+    expect(snapshot.positions).toHaveLength(1);
+    expect(snapshot.positions[0]).toMatchObject({
+      symbol: "BTCUSDT",
+      side: "long",
+      leverage: "5",
+      marginType: "cross",
+      liquidationPrice: "40000"
+    });
+    expect(fetchPositionsMock).toHaveBeenCalledWith(creds, "USDT", true);
+    expect(fetchPositionsMock).toHaveBeenCalledWith(creds, "USDC", true);
+    expect(fetchPositionLeverageMock).not.toHaveBeenCalled();
+  });
+  it("returns a null balance when the wallet fetch is empty", async () => {
+    fetchWalletBalanceMock.mockResolvedValue(void 0);
+    fetchPositionsMock.mockResolvedValue([]);
+    fetchAccountInfoMock.mockResolvedValue({ marginMode: "REGULAR_MARGIN", updatedTime: "0" });
+    const snapshot = await buildTracker().snapshot();
+    expect(snapshot.balance).toBeNull();
+    expect(snapshot.positions).toEqual([]);
+  });
+});
+describe("BybitAccountTracker.snapshotAssets", () => {
+  beforeEach(() => {
+    fetchPositionsMock.mockReset();
+    fetchPositionLeverageMock.mockReset();
+  });
+  it(">2 symbols: resolves positioned symbols from the two settleCoin reads and fills in the rest per symbol", async () => {
+    fetchPositionsMock.mockImplementation(
+      async (_creds, settleCoin) => settleCoin === "USDT" ? [
+        { symbol: "BTCUSDT", size: "1", leverage: "10", tradeMode: "0" },
+        { symbol: "ETHUSDT", size: "2", leverage: "5", tradeMode: "1" }
+      ] : []
+    );
+    fetchPositionLeverageMock.mockResolvedValue({ symbol: "DOGEUSDT", size: "0", leverage: "3", tradeMode: "0" });
+    const result = await buildTracker().snapshotAssets(["BTCUSDT", "ETHUSDT", "DOGEUSDT"]);
+    expect(fetchPositionsMock).toHaveBeenCalledTimes(2);
+    expect(fetchPositionLeverageMock).toHaveBeenCalledTimes(1);
+    expect(fetchPositionLeverageMock).toHaveBeenCalledWith(creds, "DOGEUSDT", true);
+    expect(result).toEqual({
+      BTCUSDT: { coin: "BTCUSDT", leverage: "10", marginType: "cross" },
+      ETHUSDT: { coin: "ETHUSDT", leverage: "5", marginType: "isolated" },
+      DOGEUSDT: { coin: "DOGEUSDT", leverage: "3", marginType: "cross" }
+    });
+  });
+  it("\u22642 symbols: skips the settleCoin batch and reads per symbol directly", async () => {
+    fetchPositionLeverageMock.mockResolvedValue({ symbol: "BTCUSDT", size: "0", leverage: "10", tradeMode: "0" });
+    const result = await buildTracker().snapshotAssets(["BTCUSDT"]);
+    expect(fetchPositionsMock).not.toHaveBeenCalled();
+    expect(fetchPositionLeverageMock).toHaveBeenCalledTimes(1);
+    expect(result.BTCUSDT).toEqual({ coin: "BTCUSDT", leverage: "10", marginType: "cross" });
+  });
+  it("maps a failed fill-in to null while the others succeed", async () => {
+    fetchPositionLeverageMock.mockImplementation(async (_creds, symbol) => {
+      if (symbol === "NOPEUSDT") throw new Error("10001");
+      return { symbol, size: "0", leverage: "10", tradeMode: "0" };
+    });
+    const result = await buildTracker().snapshotAssets(["BTCUSDT", "NOPEUSDT"]);
+    expect(result.BTCUSDT).toMatchObject({ leverage: "10", marginType: "cross" });
+    expect(result.NOPEUSDT).toBeNull();
+  });
+  it("throws when every per-symbol read fails", async () => {
+    fetchPositionLeverageMock.mockRejectedValue(new Error("down"));
+    await expect(buildTracker().snapshotAssets(["BTCUSDT", "ETHUSDT"])).rejects.toThrow("every position read failed");
+  });
+});