@pear-protocol/exchanges-sdk 0.2.0 → 0.4.0

package/dist/syncer/lighter/syncer.test.js

@@ -1,8 +1,10 @@
 import { vi, describe, beforeEach, it, expect } from 'vitest';
-import { fetchTradesSince } from '../../client/lighter/rest';
+import { fetchTradesSince, fetchPositionFundingSince, fetchAccount } from '../../client/lighter/rest';
 import { LighterAccountSyncer } from './syncer';
 
 vi.mock("../../client/lighter/rest", () => ({
+  fetchAccount: vi.fn(),
+  fetchPositionFundingSince: vi.fn(),
   fetchTradesSince: vi.fn()
 }));
 const ACCOUNT_INDEX = 87440;
@@ -78,11 +80,29 @@ const TRADES = [
     taker_position_size_before: "0.00000",
     maker_position_size_before: "0.00000",
     integrator_maker_fee: 50
+  },
+  {
+    // A flip is not a reduce-only fill: Lighter explicitly reports that the
+    // account-side position sign changed after crossing through zero.
+    trade_id: 90000000002,
+    trade_id_str: "90000000002",
+    type: "trade",
+    market_id: 1,
+    size: "0.00200",
+    price: "65000.0",
+    usd_amount: "130.000000",
+    ask_account_id: ACCOUNT_INDEX,
+    bid_account_id: 726722,
+    is_maker_ask: false,
+    timestamp: 1782050001e3,
+    taker_position_size_before: "0.00100",
+    taker_position_sign_changed: true,
+    maker_position_size_before: "0.00000"
   }
 ];
-function createSyncer() {
+function createSyncer(demo = false, createAuthToken = vi.fn().mockResolvedValue({ token: "test-token" })) {
   const sdk = {
-    core: { misc: { lighter: { createAuthToken: vi.fn().mockResolvedValue({ token: "test-token" }) } } }
+    core: { misc: { lighter: { createAuthToken } } }
   };
   const config = {
     sdk,
@@ -90,12 +110,12 @@ function createSyncer() {
     account: { exchangeIdentifier: String(ACCOUNT_INDEX) },
     credentials: { api_key_index: 0, api_private_key: "test-key" },
     ws: {},
-    demo: false
+    demo
   };
   return new LighterAccountSyncer(config);
 }
-async function listFills() {
-  const syncer = createSyncer();
+async function listFills(demo = false) {
+  const syncer = createSyncer(demo);
   const params = {
     since: /* @__PURE__ */ new Date(0),
     instruments: [{ id: "1" }],
@@ -104,6 +124,26 @@ async function listFills() {
   };
   return syncer.listExternalFills(params);
 }
+async function listFunding(demo = false) {
+  const syncer = createSyncer(demo);
+  const params = {
+    since: /* @__PURE__ */ new Date(1e3),
+    instruments: [{ id: "1" }]
+  };
+  return syncer.listExternalFunding(params);
+}
+async function listPositions() {
+  const syncer = createSyncer();
+  const params = {
+    instruments: [
+      {
+        id: "1",
+        precision: { quantity: { contractSize: 0.01 } }
+      }
+    ]
+  };
+  return syncer.listExternalPositions(params);
+}
 const byId = (fills, id) => fills.find((fill) => fill.exchangeFillId === id);
 describe("LighterAccountSyncer fee mapping", () => {
   beforeEach(() => {
@@ -145,4 +185,90 @@ describe("LighterAccountSyncer fee mapping", () => {
       builderFee: "0.005"
     });
   });
+  it("does not classify a position flip as reduce-only", async () => {
+    const fills = await listFills();
+    expect(byId(fills, "90000000002")).toMatchObject({
+      side: "SELL",
+      reduceOnly: false
+    });
+  });
+});
+describe("LighterAccountSyncer funding mapping", () => {
+  it("fetches paginated position funding with the generated auth token", async () => {
+    vi.mocked(fetchPositionFundingSince).mockResolvedValue([
+      {
+        timestamp: 1e3,
+        market_id: 1,
+        funding_id: 7,
+        change: "-2",
+        discount: "0",
+        rate: "0.0001",
+        position_size: "4",
+        position_side: "long"
+      }
+    ]);
+    await expect(listFunding()).resolves.toEqual([
+      {
+        connector: "lighter",
+        instrumentId: "1",
+        fundingRate: "0.0001",
+        notional: "-2",
+        fundingPerUnit: "-0.5",
+        timestamp: 1e3
+      }
+    ]);
+    expect(fetchPositionFundingSince).toHaveBeenCalledWith(ACCOUNT_INDEX, "test-token", /* @__PURE__ */ new Date(1e3), false);
+  });
+});
+describe("LighterAccountSyncer demo authentication boundary", () => {
+  it("rejects authenticated demo history reads before minting a mainnet token", async () => {
+    vi.clearAllMocks();
+    await expect(listFills(true)).rejects.toThrow("backend signing is mainnet-only");
+    await expect(listFunding(true)).rejects.toThrow("backend signing is mainnet-only");
+    expect(fetchTradesSince).not.toHaveBeenCalled();
+    expect(fetchPositionFundingSince).not.toHaveBeenCalled();
+  });
+});
+describe("LighterAccountSyncer position mapping", () => {
+  it("derives mark price from position value in normalized base units", async () => {
+    vi.mocked(fetchAccount).mockResolvedValue({
+      code: 200,
+      accounts: [
+        {
+          account_type: 0,
+          collateral: "1000",
+          total_asset_value: "1000",
+          available_balance: "900",
+          cross_asset_value: "1000",
+          cross_initial_margin_requirement: "100",
+          cross_maintenance_margin_requirement: "50",
+          positions: [
+            {
+              market_id: 1,
+              symbol: "BTC",
+              initial_margin_fraction: "10",
+              sign: -1,
+              position: "100",
+              avg_entry_price: "50000",
+              position_value: "60000",
+              unrealized_pnl: "-10000",
+              liquidation_price: "70000",
+              margin_mode: 0,
+              allocated_margin: "0"
+            }
+          ]
+        }
+      ]
+    });
+    await expect(listPositions()).resolves.toEqual([
+      {
+        symbol: "1",
+        size: "1",
+        side: "SELL",
+        entryPrice: "50000",
+        markPrice: "60000"
+      }
+    ]);
+    expect(fetchAccount).toHaveBeenCalledWith(ACCOUNT_INDEX, false);
+  });
 });

package/dist/syncer/okx/syncer.js

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { fetchFillsHistorySince } from '../../client/okx/rest';
+import { fetchPositions, fetchFillsHistorySince } from '../../client/okx/rest';
 import { BaseAccountSyncer } from '../base';
 
 class OkxAccountSyncer extends BaseAccountSyncer {
@@ -8,6 +8,27 @@ class OkxAccountSyncer extends BaseAccountSyncer {
     super(config);
     this.creds = config.credentials;
   }
+  async listExternalPositions({
+    instruments
+  }) {
+    const rawPositions = await fetchPositions(this.creds, this.demo);
+    const contractSizeByInstrumentId = new Map(
+      instruments.map((instrument) => [instrument.id, instrument.precision.quantity.contractSize])
+    );
+    return rawPositions.reduce((positions, rawPosition) => {
+      if (!rawPosition.pos || rawPosition.pos === "0") return positions;
+      const contractSize = contractSizeByInstrumentId.get(rawPosition.instId) ?? 1;
+      const signedSize = new BigNumber(rawPosition.pos);
+      positions.push({
+        symbol: rawPosition.instId,
+        size: signedSize.abs().times(contractSize).toFixed(),
+        side: signedSize.isGreaterThan(0) ? "BUY" : "SELL",
+        entryPrice: rawPosition.avgPx,
+        markPrice: rawPosition.avgPx
+      });
+      return positions;
+    }, []);
+  }
   async listExternalFills({
     since,
     instruments
@@ -16,28 +37,31 @@ class OkxAccountSyncer extends BaseAccountSyncer {
     const contractSizeByInstrumentId = new Map(
       instruments.map((instrument) => [instrument.id, instrument.precision.quantity.contractSize])
     );
-    return fills.reduce((acc, fill) => {
-      const contractSize = contractSizeByInstrumentId.get(fill.instId) ?? 1;
-      acc.push({
+    return fills.reduce((result, rawFill) => {
+      const contractSize = contractSizeByInstrumentId.get(rawFill.instId) ?? 1;
+      result.push({
         connector: "okx",
-        exchangeFillId: fill.billId || fill.tradeId,
-        cloid: fill.clOrdId || null,
-        symbol: fill.instId,
-        price: fill.fillPx,
-        quantity: this.contractsToBase(fill.fillSz, contractSize),
-        side: fill.side === "buy" ? "BUY" : "SELL",
-        reduceOnly: this.isReduceOnly(fill),
-        timestamp: Number(fill.fillTime || fill.ts),
-        tradeFee: new BigNumber(fill.fee || 0).abs().toFixed(),
+        exchangeFillId: rawFill.billId || rawFill.tradeId,
+        cloid: rawFill.clOrdId || null,
+        symbol: rawFill.instId,
+        price: rawFill.fillPx,
+        quantity: this.contractsToBase(rawFill.fillSz, contractSize),
+        side: rawFill.side === "buy" ? "BUY" : "SELL",
+        reduceOnly: this.isReduceOnly(rawFill),
+        timestamp: Number(rawFill.fillTime || rawFill.ts),
+        tradeFee: new BigNumber(rawFill.fee || 0).abs().toFixed(),
         builderFee: "0",
         liquidation: null
       });
-      return acc;
+      return result;
     }, []);
   }
-  isReduceOnly(fill) {
-    if (fill.posSide === "long") return fill.side === "sell";
-    if (fill.posSide === "short") return fill.side === "buy";
+  async listExternalFunding(_params) {
+    throw new Error("funding sync is not implemented for okx");
+  }
+  isReduceOnly(rawFill) {
+    if (rawFill.posSide === "long") return rawFill.side === "sell";
+    if (rawFill.posSide === "short") return rawFill.side === "buy";
     return false;
   }
   contractsToBase(quantity, contractSize) {

package/dist/tracker/base.js

@@ -1,8 +1,9 @@
 class BaseAccountTracker {
   onError;
   demo;
-  credentials = null;
+  credentials;
   balance = null;
+  balanceInitialized = false;
   positions = /* @__PURE__ */ new Map();
   initialized = false;
   balanceListeners = /* @__PURE__ */ new Set();
@@ -10,11 +11,17 @@ class BaseAccountTracker {
   assetEntries = /* @__PURE__ */ new Map();
   constructor(config) {
     this.demo = config.demo;
+    this.credentials = config.credentials;
     this.onError = (error) => {
       console.warn("[AccountTracker] error:", error.message);
       config.onError?.(error);
     };
   }
+  async snapshotAssets(coins) {
+    const unique = [...new Set(coins)];
+    if (unique.length === 0) return {};
+    return this.fetchAssetSnapshots(unique);
+  }
   async disconnect() {
     this.balanceListeners.clear();
     this.positionListeners.clear();
@@ -33,7 +40,7 @@ class BaseAccountTracker {
   }
   trackBalance(cb) {
     this.balanceListeners.add(cb);
-    if (this.balance) this.notify(cb, this.balance);
+    if (this.balanceInitialized) this.notify(cb, this.balance);
     return () => this.balanceListeners.delete(cb);
   }
   trackPosition(cb) {
@@ -70,17 +77,27 @@ class BaseAccountTracker {
   getTrackedAsset(coin) {
     return this.assetEntries.get(coin)?.info ?? null;
   }
+  /** Drops cached account snapshots without broadcasting a fabricated explicit-null update. */
+  resetAccountState() {
+    this.balance = null;
+    this.balanceInitialized = false;
+    this.positions.clear();
+    this.initialized = false;
+  }
   onStateUpdate(update) {
-    if (update.balance) this.applyBalanceUpdate(update.balance);
-    if (update.positions) this.applyPositionsUpdate(update.positions);
+    const hasAccountState = update.balance !== void 0 || update.positions !== void 0;
+    if (update.balance !== void 0) this.applyBalanceUpdate(update.balance);
+    if (update.positions) this.applyPositionsUpdate(update.positions, update.positionsMode ?? "merge");
     if (update.trackedAssets) this.applyTrackedAssetsUpdate(update.trackedAssets);
-    if (!this.initialized) this.initialized = true;
+    if (hasAccountState && !this.initialized) this.initialized = true;
   }
   applyBalanceUpdate(balance) {
     this.balance = balance;
+    this.balanceInitialized = true;
     this.broadcast(this.balanceListeners, balance);
   }
-  applyPositionsUpdate(positions) {
+  applyPositionsUpdate(positions, mode) {
+    if (mode === "replace") this.positions.clear();
     for (const [key, pos] of positions) {
       if (pos.size === "0") this.positions.delete(key);
       else this.positions.set(key, pos);

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