@pear-protocol/exchanges-sdk 0.3.0 → 0.4.0

package/dist/tracker/base.test.js

@@ -0,0 +1,132 @@
+import { describe, it, expect } from 'vitest';
+import { BaseAccountTracker } from './base';
+import { HyperliquidAccountType } from './hyperliquid/types';
+
+class FakeAccountTracker extends BaseAccountTracker {
+  connected = false;
+  startCalls = 0;
+  cleanupCalls = 0;
+  assetSnapshotCalls = [];
+  async start() {
+    this.startCalls++;
+    this.connected = true;
+  }
+  async snapshot() {
+    return { balance: null, positions: [] };
+  }
+  async fetchAssetSnapshots(coins) {
+    this.assetSnapshotCalls.push(coins);
+    return Object.fromEntries(coins.map((coin) => [coin, { coin, leverage: "1", marginType: "cross" }]));
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  updatePositions(positions, mode = "merge") {
+    this.onStateUpdate({ positions, positionsMode: mode });
+  }
+  updateBalance(balance) {
+    this.onStateUpdate({ balance });
+  }
+  updateTrackedAsset(asset, info) {
+    this.onStateUpdate({ trackedAssets: /* @__PURE__ */ new Map([[asset, info]]) });
+  }
+  ensureAssetTracked() {
+  }
+  releaseAsset() {
+  }
+  async cleanupConnections() {
+    this.cleanupCalls++;
+    this.connected = false;
+  }
+}
+function buildConfig() {
+  return { demo: true, credentials: { api_key: "key", api_secret: "secret", api_pass: "pass" } };
+}
+describe("BaseAccountTracker", () => {
+  it("constructs from credentials + demo with no socket side-effect", () => {
+    const tracker = new FakeAccountTracker(buildConfig());
+    expect(tracker.isConnected).toBe(false);
+    expect(tracker.isInitialized).toBe(false);
+    expect(tracker.startCalls).toBe(0);
+  });
+  it("exposes snapshot() on the AccountTracker interface", () => {
+    const tracker = new FakeAccountTracker(buildConfig());
+    expect(typeof tracker.snapshot).toBe("function");
+  });
+  it("snapshotAssets() dedupes requested coins and skips the read entirely for an empty list", async () => {
+    const tracker = new FakeAccountTracker(buildConfig());
+    await expect(tracker.snapshotAssets([])).resolves.toEqual({});
+    expect(tracker.assetSnapshotCalls).toEqual([]);
+    const result = await tracker.snapshotAssets(["BTC", "ETH", "BTC"]);
+    expect(tracker.assetSnapshotCalls).toEqual([["BTC", "ETH"]]);
+    expect(Object.keys(result)).toEqual(["BTC", "ETH"]);
+  });
+  it("start() opens a connection and disconnect() tears down whatever start() created", async () => {
+    const tracker = new FakeAccountTracker(buildConfig());
+    await tracker.start();
+    expect(tracker.isConnected).toBe(true);
+    expect(tracker.cleanupCalls).toBe(0);
+    await tracker.disconnect();
+    expect(tracker.isConnected).toBe(false);
+    expect(tracker.cleanupCalls).toBe(1);
+  });
+  it("distinguishes incremental position deltas from authoritative snapshots", () => {
+    const tracker = new FakeAccountTracker(buildConfig());
+    const btc = {
+      symbol: "BTC",
+      side: "long",
+      size: "1",
+      entryPrice: "100",
+      unrealizedPnl: "0",
+      leverage: "2",
+      marginType: "cross",
+      liquidationPrice: null
+    };
+    const eth = { ...btc, symbol: "ETH" };
+    tracker.updatePositions(/* @__PURE__ */ new Map([["BTC:long", btc]]));
+    tracker.updatePositions(/* @__PURE__ */ new Map([["ETH:long", eth]]));
+    expect(tracker.getPositions()).toEqual([btc, eth]);
+    tracker.updatePositions(/* @__PURE__ */ new Map([["ETH:long", eth]]), "replace");
+    expect(tracker.getPositions()).toEqual([eth]);
+    tracker.updatePositions(/* @__PURE__ */ new Map(), "replace");
+    expect(tracker.getPositions()).toEqual([]);
+  });
+  it("clears and broadcasts a balance that is no longer safe to represent", () => {
+    const tracker = new FakeAccountTracker(buildConfig());
+    const balance = {
+      accountType: HyperliquidAccountType.DEFAULT,
+      free: { USDC: "100" },
+      used: { USDC: "0" },
+      total: { USDC: "100" },
+      availableToTrade: "100",
+      totalEquity: "100",
+      walletBalance: "100",
+      unrealizedPnl: "0",
+      initialMarginUsed: "0",
+      maintenanceMargin: "0",
+      marginRatio: "0.0000",
+      assets: [],
+      timestamp: 1
+    };
+    const updates = [];
+    tracker.trackBalance((update) => updates.push(update));
+    tracker.updateBalance(balance);
+    tracker.updateBalance(null);
+    expect(tracker.getBalance()).toBeNull();
+    expect(updates).toEqual([balance, null]);
+  });
+  it("replays an explicitly cleared balance to listeners registered later", () => {
+    const tracker = new FakeAccountTracker(buildConfig());
+    const updates = [];
+    tracker.updateBalance(null);
+    tracker.trackBalance((update) => updates.push(update));
+    expect(tracker.isInitialized).toBe(true);
+    expect(updates).toEqual([null]);
+  });
+  it("does not mark account state initialized from asset metadata alone", () => {
+    const tracker = new FakeAccountTracker(buildConfig());
+    tracker.updateTrackedAsset("BTC", { coin: "BTC", leverage: "2", marginType: "cross" });
+    expect(tracker.getTrackedAsset("BTC")).toEqual({ coin: "BTC", leverage: "2", marginType: "cross" });
+    expect(tracker.isInitialized).toBe(false);
+  });
+});

package/dist/tracker/binance/tracker.js

@@ -1,4 +1,5 @@
-import { fetchAccountStatus, fetchAllPositionRisk, fetchMultiAssetsMargin, keepAliveListenKey, fetchPositionRisk } from '../../client/binance/rest';
+import { createExchangeWs } from '../../client';
+import { fetchAllPositionRisk, keepAliveListenKey, fetchAccountStatus, fetchMultiAssetsMargin, fetchPositionRisk } from '../../client/binance/rest';
 import { BaseAccountTracker } from '../base';
 import { positionKey } from '../utils';
 import { DEFAULT_LISTEN_KEY_REFRESH_MS, DEFAULT_ACCOUNT_POLL_MS } from './const';
@@ -7,8 +8,8 @@ import { BinanceAccountType } from './types';
 
 class BinanceAccountTracker extends BaseAccountTracker {
   creds;
-  userDataWs;
-  wsApiWs;
+  userDataWs = null;
+  wsApiWs = null;
   listenKeyRefreshMs;
   accountPollMs;
   userDataListenerId = null;
@@ -20,22 +21,38 @@ class BinanceAccountTracker extends BaseAccountTracker {
   trackedAssetInfos = /* @__PURE__ */ new Map();
   constructor(config) {
     super(config);
-    this.credentials = config.credentials;
     this.creds = config.credentials;
-    this.userDataWs = config.userDataWs;
-    this.wsApiWs = config.wsApiWs;
     this.listenKeyRefreshMs = config.listenKeyRefreshMs ?? DEFAULT_LISTEN_KEY_REFRESH_MS;
     this.accountPollMs = config.accountPollMs ?? DEFAULT_ACCOUNT_POLL_MS;
   }
+  async snapshot() {
+    const { snapshot, positionRisk, multiAssetsMargin } = await this.fetchSnapshotData();
+    const accountType = multiAssetsMargin ? BinanceAccountType.MULTI_ASSET : BinanceAccountType.SINGLE_ASSET;
+    const balance = { ...mapBalance(snapshot), accountType };
+    return { balance, positions: Array.from(mapPositions(positionRisk).values()) };
+  }
+  /**
+   * Stateless one-shot per-asset settings read: `positionRisk` with no symbol returns leverage +
+   * margin type for every symbol (positioned or not), so any number of assets costs one call.
+   */
+  async fetchAssetSnapshots(coins) {
+    const risks = await fetchAllPositionRisk(this.creds, this.demo);
+    const bySymbol = new Map(risks.map((risk) => [risk.symbol, risk]));
+    const result = {};
+    for (const coin of coins) {
+      const risk = bySymbol.get(coin);
+      result[coin] = risk ? toTrackedAssetInfo(coin, risk) : null;
+    }
+    return result;
+  }
   async start() {
-    const [snapshot, positionRisk, multiAssetsMargin] = await Promise.all([
-      fetchAccountStatus(this.creds, this.demo),
-      fetchAllPositionRisk(this.creds, this.demo),
-      fetchMultiAssetsMargin(this.creds, this.demo)
-    ]);
+    const { snapshot, positionRisk, multiAssetsMargin } = await this.fetchSnapshotData();
     this.accountType = multiAssetsMargin ? BinanceAccountType.MULTI_ASSET : BinanceAccountType.SINGLE_ASSET;
     this.handleAccountStatus(snapshot);
     this.handlePositionRisk(positionRisk, false);
+    const ws = await createExchangeWs("binance", { demo: this.demo, credentials: this.credentials });
+    this.userDataWs = ws.userData;
+    this.wsApiWs = ws.wsApi;
     this.userDataListenerId = this.userDataWs.addMessageListener((raw) => this.routeUserData(raw));
     this.wsApiListenerId = this.wsApiWs.addMessageListener((raw) => this.routeWsApi(raw));
     this.listenKeyTimer = setInterval(() => {
@@ -52,24 +69,34 @@ class BinanceAccountTracker extends BaseAccountTracker {
     if (this.pollTimer) clearInterval(this.pollTimer);
     this.pollTimer = null;
     if (this.userDataListenerId) {
-      this.userDataWs.removeMessageListener(this.userDataListenerId);
+      this.userDataWs?.removeMessageListener(this.userDataListenerId);
       this.userDataListenerId = null;
     }
     if (this.wsApiListenerId) {
-      this.wsApiWs.removeMessageListener(this.wsApiListenerId);
+      this.wsApiWs?.removeMessageListener(this.wsApiListenerId);
       this.wsApiListenerId = null;
     }
+    this.userDataWs?.destroy();
+    this.userDataWs = null;
+    this.wsApiWs?.destroy();
+    this.wsApiWs = null;
   }
   get isConnected() {
-    return this.userDataWs.connected && this.wsApiWs.connected;
+    return Boolean(this.userDataWs?.connected && this.wsApiWs?.connected);
+  }
+  async fetchSnapshotData() {
+    const [snapshot, positionRisk, multiAssetsMargin] = await Promise.all([
+      fetchAccountStatus(this.creds, this.demo),
+      fetchAllPositionRisk(this.creds, this.demo),
+      fetchMultiAssetsMargin(this.creds, this.demo)
+    ]);
+    return { snapshot, positionRisk, multiAssetsMargin };
   }
   ensureAssetTracked(coin) {
     if (this.trackedAssetInfos.has(coin)) return;
     fetchPositionRisk(this.creds, coin, this.demo).then((risk) => {
       if (!risk) return;
-      const leverage = risk.leverage;
-      const marginType = risk.marginType;
-      const info = { coin, leverage, marginType };
+      const info = toTrackedAssetInfo(coin, risk);
       this.trackedAssetInfos.set(coin, info);
       const trackedAssets = /* @__PURE__ */ new Map();
       trackedAssets.set(coin, info);
@@ -83,7 +110,7 @@ class BinanceAccountTracker extends BaseAccountTracker {
     this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
   }
   pollAccountStatus() {
-    if (!this.wsApiWs.connected) return;
+    if (!this.wsApiWs?.connected) return;
     this.wsApiWs.sendSignedRequest(this.creds, "v2/account.status").catch((err) => {
       this.onError(err instanceof Error ? err : new Error(String(err)));
     });
@@ -177,5 +204,8 @@ class BinanceAccountTracker extends BaseAccountTracker {
     });
   }
 }
+function toTrackedAssetInfo(coin, risk) {
+  return { coin, leverage: risk.leverage, marginType: risk.marginType };
+}
 
 export { BinanceAccountTracker };

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 };