@pear-protocol/exchanges-sdk 0.0.18 → 0.1.1

package/dist/sdk.d.ts

@@ -0,0 +1,43 @@
+import { Connector } from '@pear-protocol/types';
+import { ExchangeHelperExchange, ExchangeHelperMap } from './helper/types.js';
+import { AccountPositionSyncer } from './syncer/base.js';
+import { ExchangesSDKConfig, ExchangeConnection } from './types.js';
+import { AccountTracker } from './tracker/base.js';
+import './helper/lighter/types.js';
+import './helper/lighter/ethereum/types.js';
+import 'viem';
+import './client/lighter/rest.js';
+import '@pear-protocol/core-sdk';
+import './client/index.js';
+import './client/binance/exchange-ws.js';
+import './client/base-ws.js';
+import 'partysocket';
+import './client/exchange-ws.js';
+import './client/binance/ws.js';
+import './client/bybit/exchange-ws.js';
+import './client/bybit/ws.js';
+import './client/hyperliquid/exchange-ws.js';
+import './client/hyperliquid/ws.js';
+import './client/lighter/exchange-ws.js';
+import './client/lighter/ws.js';
+import './client/okx/exchange-ws.js';
+import './client/okx/ws.js';
+import './tracker/types.js';
+import './tracker/binance/types.js';
+import './tracker/bybit/types.js';
+import './tracker/hyperliquid/types.js';
+import './tracker/lighter/types.js';
+import './tracker/okx/types.js';
+
+declare class ExchangesSDK {
+    private sdk;
+    private demo;
+    constructor(config: ExchangesSDKConfig);
+    connect(tradeAccountId: string, exchange: Connector): Promise<ExchangeConnection>;
+    createTracker(connection: ExchangeConnection): AccountTracker;
+    createHelper<E extends ExchangeHelperExchange>(exchange: E): ExchangeHelperMap[E];
+    createPositionSyncer(connection: ExchangeConnection): AccountPositionSyncer;
+    private fetchCredentials;
+}
+
+export { ExchangesSDK };

package/dist/sdk.js

@@ -0,0 +1,52 @@
+import { createExchangeWs } from './client';
+import './helper';
+import { createExchangeHelper } from './helper/factory';
+import { AccountPositionSyncer } from './syncer';
+import { createAccountTracker } from './tracker';
+
+class ExchangesSDK {
+  sdk;
+  demo;
+  constructor(config) {
+    this.sdk = config.sdk;
+    this.demo = config.demo ?? false;
+  }
+  async connect(tradeAccountId, exchange) {
+    const credentials = await this.fetchCredentials(tradeAccountId, exchange);
+    const ws = await createExchangeWs(exchange, { demo: this.demo, credentials });
+    return { exchange, credentials, ws };
+  }
+  createTracker(connection) {
+    return createAccountTracker(connection.exchange, {
+      demo: this.demo,
+      credentials: connection.credentials,
+      ws: connection.ws
+    });
+  }
+  createHelper(exchange) {
+    return createExchangeHelper(exchange, this.sdk);
+  }
+  createPositionSyncer(connection) {
+    return new AccountPositionSyncer({
+      sdk: this.sdk,
+      credentials: connection.credentials,
+      ws: connection.ws,
+      demo: this.demo
+    });
+  }
+  async fetchCredentials(tradeAccountId, exchange) {
+    const response = await this.sdk.core.accounts.credentials(tradeAccountId);
+    const baseCreds = response.credentials;
+    if (exchange === "hyperliquid" || exchange === "lighter") {
+      const { accounts } = await this.sdk.core.accounts.list();
+      const account = accounts.find((a) => a.id === tradeAccountId);
+      if (!account) {
+        throw new Error(`Trade account ${tradeAccountId} not found`);
+      }
+      return { ...baseCreds, accountIdentifier: account.exchangeIdentifier };
+    }
+    return baseCreds;
+  }
+}
+
+export { ExchangesSDK };

package/dist/syncer/base.d.ts

@@ -0,0 +1,33 @@
+import PearSDK from '@pear-protocol/core-sdk';
+import { Connector } from '@pear-protocol/types';
+import { ExchangeWsByConnector } from '../client/index.js';
+import { SupportedCredentials } from '../types.js';
+import '../client/binance/exchange-ws.js';
+import '../client/base-ws.js';
+import 'partysocket';
+import '../client/exchange-ws.js';
+import '../client/binance/ws.js';
+import '../client/bybit/exchange-ws.js';
+import '../client/bybit/ws.js';
+import '../client/hyperliquid/exchange-ws.js';
+import '../client/hyperliquid/ws.js';
+import '../client/lighter/exchange-ws.js';
+import '../client/lighter/ws.js';
+import '../client/okx/exchange-ws.js';
+import '../client/okx/ws.js';
+
+type AccountPositionSyncerConfig = {
+    sdk: PearSDK;
+    credentials: SupportedCredentials;
+    ws: ExchangeWsByConnector[Connector];
+    demo: boolean;
+};
+declare class AccountPositionSyncer {
+    protected sdk: PearSDK;
+    protected credentials: SupportedCredentials;
+    protected ws: ExchangeWsByConnector[Connector];
+    protected demo: boolean;
+    constructor(config: AccountPositionSyncerConfig);
+}
+
+export { AccountPositionSyncer, type AccountPositionSyncerConfig };

package/dist/syncer/base.js

@@ -0,0 +1,14 @@
+class AccountPositionSyncer {
+  sdk;
+  credentials;
+  ws;
+  demo;
+  constructor(config) {
+    this.sdk = config.sdk;
+    this.credentials = config.credentials;
+    this.ws = config.ws;
+    this.demo = config.demo;
+  }
+}
+
+export { AccountPositionSyncer };

package/dist/syncer/index.d.ts

@@ -0,0 +1,18 @@
+export { AccountPositionSyncer, AccountPositionSyncerConfig } from './base.js';
+import '@pear-protocol/core-sdk';
+import '@pear-protocol/types';
+import '../client/index.js';
+import '../types.js';
+import '../client/binance/exchange-ws.js';
+import '../client/base-ws.js';
+import 'partysocket';
+import '../client/exchange-ws.js';
+import '../client/binance/ws.js';
+import '../client/bybit/exchange-ws.js';
+import '../client/bybit/ws.js';
+import '../client/hyperliquid/exchange-ws.js';
+import '../client/hyperliquid/ws.js';
+import '../client/lighter/exchange-ws.js';
+import '../client/lighter/ws.js';
+import '../client/okx/exchange-ws.js';
+import '../client/okx/ws.js';

package/dist/syncer/index.js

@@ -0,0 +1 @@
+export * from './base';

package/dist/tracker/base.d.ts

@@ -0,0 +1,79 @@
+import { SupportedCredentials } from '../types.js';
+import { BalanceCallback, PositionsCallback, TrackedAssetCallback, AccountBalance, AccountPosition, TrackedAssetInfo, StateUpdate } from './types.js';
+import '@pear-protocol/core-sdk';
+import '@pear-protocol/types';
+import '../client/binance/exchange-ws.js';
+import '../client/base-ws.js';
+import 'partysocket';
+import '../client/exchange-ws.js';
+import '../client/binance/ws.js';
+import '../client/bybit/exchange-ws.js';
+import '../client/bybit/ws.js';
+import '../client/hyperliquid/exchange-ws.js';
+import '../client/hyperliquid/ws.js';
+import '../client/lighter/exchange-ws.js';
+import '../client/lighter/ws.js';
+import '../client/okx/exchange-ws.js';
+import '../client/okx/ws.js';
+import './binance/types.js';
+import './bybit/types.js';
+import './hyperliquid/types.js';
+import './lighter/types.js';
+import './okx/types.js';
+
+type ErrorHandler = (error: Error) => void;
+type AccountTrackerConfig = {
+    demo: boolean;
+    onError?: ErrorHandler;
+};
+interface AccountTracker {
+    start(): Promise<void>;
+    disconnect(): Promise<void>;
+    readonly isConnected: boolean;
+    readonly isInitialized: boolean;
+    readonly hasListeners: boolean;
+    trackBalance(cb: BalanceCallback): () => void;
+    trackPosition(cb: PositionsCallback): () => void;
+    trackAsset(asset: string, cb: TrackedAssetCallback): () => void;
+    getBalance(): AccountBalance | null;
+    getPositions(): AccountPosition[];
+    getTrackedAsset(coin: string): TrackedAssetInfo | null;
+}
+declare abstract class BaseAccountTracker implements AccountTracker {
+    protected onError: ErrorHandler;
+    protected demo: boolean;
+    protected credentials: SupportedCredentials | null;
+    private balance;
+    private positions;
+    private initialized;
+    private balanceListeners;
+    private positionListeners;
+    private assetEntries;
+    constructor(config: AccountTrackerConfig);
+    disconnect(): Promise<void>;
+    get isInitialized(): boolean;
+    get hasListeners(): boolean;
+    trackBalance(cb: BalanceCallback): () => void;
+    trackPosition(cb: PositionsCallback): () => void;
+    trackAsset(asset: string, cb: TrackedAssetCallback): () => void;
+    private releaseAssetListener;
+    protected get trackedCoins(): ReadonlySet<string>;
+    getBalance(): AccountBalance | null;
+    getPositions(): AccountPosition[];
+    getTrackedAsset(coin: string): TrackedAssetInfo | null;
+    protected onStateUpdate(update: StateUpdate): void;
+    private applyBalanceUpdate;
+    private applyPositionsUpdate;
+    private applyTrackedAssetsUpdate;
+    private getOrCreateAssetEntry;
+    private positionSnapshot;
+    private notify;
+    private broadcast;
+    abstract start(): Promise<void>;
+    abstract get isConnected(): boolean;
+    protected abstract ensureAssetTracked(asset: string): void;
+    protected abstract releaseAsset(asset: string): void;
+    protected abstract cleanupConnections(): void | Promise<void>;
+}
+
+export { type AccountTracker, type AccountTrackerConfig, BaseAccountTracker };

package/dist/tracker/base.js

@@ -0,0 +1,120 @@
+class BaseAccountTracker {
+  onError;
+  demo;
+  credentials = null;
+  balance = null;
+  positions = /* @__PURE__ */ new Map();
+  initialized = false;
+  balanceListeners = /* @__PURE__ */ new Set();
+  positionListeners = /* @__PURE__ */ new Set();
+  assetEntries = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.demo = config.demo;
+    this.onError = (error) => {
+      console.warn("[AccountTracker] error:", error.message);
+      config.onError?.(error);
+    };
+  }
+  async disconnect() {
+    this.balanceListeners.clear();
+    this.positionListeners.clear();
+    this.assetEntries.clear();
+    await this.cleanupConnections();
+  }
+  get isInitialized() {
+    return this.initialized;
+  }
+  get hasListeners() {
+    if (this.balanceListeners.size > 0 || this.positionListeners.size > 0) return true;
+    for (const entry of this.assetEntries.values()) {
+      if (entry.listeners.size > 0) return true;
+    }
+    return false;
+  }
+  trackBalance(cb) {
+    this.balanceListeners.add(cb);
+    if (this.balance) this.notify(cb, this.balance);
+    return () => this.balanceListeners.delete(cb);
+  }
+  trackPosition(cb) {
+    this.positionListeners.add(cb);
+    if (this.initialized) this.notify(cb, this.positionSnapshot());
+    return () => this.positionListeners.delete(cb);
+  }
+  trackAsset(asset, cb) {
+    const entry = this.getOrCreateAssetEntry(asset);
+    entry.listeners.add(cb);
+    if (this.isConnected) this.ensureAssetTracked(asset);
+    if (entry.info) this.notify(cb, entry.info);
+    return () => this.releaseAssetListener(asset, cb);
+  }
+  releaseAssetListener(asset, cb) {
+    const entry = this.assetEntries.get(asset);
+    if (!entry) return;
+    entry.listeners.delete(cb);
+    if (entry.listeners.size === 0 && this.isConnected) {
+      this.releaseAsset(asset);
+    }
+  }
+  get trackedCoins() {
+    return new Set(
+      [...this.assetEntries.entries()].filter(([, entry]) => entry.listeners.size > 0).map(([coin]) => coin)
+    );
+  }
+  getBalance() {
+    return this.balance;
+  }
+  getPositions() {
+    return this.positionSnapshot();
+  }
+  getTrackedAsset(coin) {
+    return this.assetEntries.get(coin)?.info ?? null;
+  }
+  onStateUpdate(update) {
+    if (update.balance) this.applyBalanceUpdate(update.balance);
+    if (update.positions) this.applyPositionsUpdate(update.positions);
+    if (update.trackedAssets) this.applyTrackedAssetsUpdate(update.trackedAssets);
+    if (!this.initialized) this.initialized = true;
+  }
+  applyBalanceUpdate(balance) {
+    this.balance = balance;
+    this.broadcast(this.balanceListeners, balance);
+  }
+  applyPositionsUpdate(positions) {
+    for (const [key, pos] of positions) {
+      if (pos.size === "0") this.positions.delete(key);
+      else this.positions.set(key, pos);
+    }
+    this.broadcast(this.positionListeners, this.positionSnapshot());
+  }
+  applyTrackedAssetsUpdate(trackedAssets) {
+    for (const [coin, info] of trackedAssets) {
+      const entry = this.getOrCreateAssetEntry(coin);
+      entry.info = info;
+      this.broadcast(entry.listeners, info);
+    }
+  }
+  getOrCreateAssetEntry(coin) {
+    let entry = this.assetEntries.get(coin);
+    if (!entry) {
+      entry = { info: null, listeners: /* @__PURE__ */ new Set() };
+      this.assetEntries.set(coin, entry);
+    }
+    return entry;
+  }
+  positionSnapshot() {
+    return Array.from(this.positions.values());
+  }
+  notify(cb, arg) {
+    try {
+      cb(arg);
+    } catch (err) {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  broadcast(listeners, arg) {
+    for (const cb of listeners) this.notify(cb, arg);
+  }
+}
+
+export { BaseAccountTracker };

package/dist/tracker/binance/const.d.ts

@@ -0,0 +1,4 @@
+declare const DEFAULT_LISTEN_KEY_REFRESH_MS: number;
+declare const DEFAULT_ACCOUNT_POLL_MS = 1000;
+
+export { DEFAULT_ACCOUNT_POLL_MS, DEFAULT_LISTEN_KEY_REFRESH_MS };

package/dist/tracker/binance/const.js

@@ -0,0 +1,4 @@
+const DEFAULT_LISTEN_KEY_REFRESH_MS = 25 * 60 * 1e3;
+const DEFAULT_ACCOUNT_POLL_MS = 1e3;
+
+export { DEFAULT_ACCOUNT_POLL_MS, DEFAULT_LISTEN_KEY_REFRESH_MS };

package/dist/{account/exchanges → tracker}/binance/mapper.d.ts

@@ -1,7 +1,10 @@
-import { j as BinanceRawAccountStatus, a as AccountBalance, k as BinanceRawPositionRisk, c as AccountPosition } from '../../../types-Caz2X4h0.js';
+import { BinanceRawAccountStatus, BinanceRawPositionRisk } from '../../client/binance/types.js';
+import { AccountBalance, AccountPosition } from '../types.js';
 import '@pear-protocol/types';
+import './types.js';
 import '../bybit/types.js';
 import '../hyperliquid/types.js';
+import '../lighter/types.js';
 import '../okx/types.js';
 
 declare function mapBalance(raw: BinanceRawAccountStatus): Omit<AccountBalance, 'accountType'>;

package/dist/{account/exchanges → tracker}/binance/mapper.js

@@ -1,5 +1,6 @@
-import '../../types';
-import { positionKey } from '../../utils';
+import BigNumber from 'bignumber.js';
+import '../types';
+import { positionKey } from '../utils';
 
 function mapBalance(raw) {
   const free = {};
@@ -11,7 +12,7 @@ function mapBalance(raw) {
     const ab = a.availableBalance ?? "0";
     const mb = a.marginBalance ?? "0";
     const im = a.initialMargin ?? "0";
-    if (parseFloat(wb) === 0 && parseFloat(ab) === 0 && parseFloat(mb) === 0) continue;
+    if (new BigNumber(wb).isZero() && new BigNumber(ab).isZero() && new BigNumber(mb).isZero()) continue;
     free[a.asset] = ab;
     used[a.asset] = im;
     total[a.asset] = mb;
@@ -26,9 +27,9 @@ function mapBalance(raw) {
   }
   const totalMarginBalance = raw.totalMarginBalance ?? "0";
   const totalMaintMargin = raw.totalMaintMargin ?? "0";
-  const marginBalance = parseFloat(totalMarginBalance);
-  const maintMargin = parseFloat(totalMaintMargin);
-  const marginRatio = marginBalance > 0 ? (maintMargin / marginBalance).toFixed(4) : "0.0000";
+  const marginBalanceBN = new BigNumber(totalMarginBalance);
+  const maintMarginBN = new BigNumber(totalMaintMargin);
+  const marginRatio = marginBalanceBN.gt(0) ? maintMarginBN.div(marginBalanceBN).toFixed(4) : "0.0000";
   return {
     free,
     used,

package/dist/tracker/binance/tracker.d.ts

@@ -0,0 +1,60 @@
+import { BinanceUserDataWs, BinanceWsApi } from '../../client/binance/ws.js';
+import { SupportedCredentials } from '../../types.js';
+import { BaseAccountTracker, AccountTrackerConfig } from '../base.js';
+import '@pear-protocol/types';
+import '../../client/base-ws.js';
+import 'partysocket';
+import '@pear-protocol/core-sdk';
+import '../../client/binance/exchange-ws.js';
+import '../../client/exchange-ws.js';
+import '../../client/bybit/exchange-ws.js';
+import '../../client/bybit/ws.js';
+import '../../client/hyperliquid/exchange-ws.js';
+import '../../client/hyperliquid/ws.js';
+import '../../client/lighter/exchange-ws.js';
+import '../../client/lighter/ws.js';
+import '../../client/okx/exchange-ws.js';
+import '../../client/okx/ws.js';
+import '../types.js';
+import './types.js';
+import '../bybit/types.js';
+import '../hyperliquid/types.js';
+import '../lighter/types.js';
+import '../okx/types.js';
+
+type BinanceAccountTrackerConfig = AccountTrackerConfig & {
+    credentials: SupportedCredentials;
+    userDataWs: BinanceUserDataWs;
+    wsApiWs: BinanceWsApi;
+    listenKeyRefreshMs?: number;
+    accountPollMs?: number;
+};
+declare class BinanceAccountTracker extends BaseAccountTracker {
+    private readonly creds;
+    private readonly userDataWs;
+    private readonly wsApiWs;
+    private readonly listenKeyRefreshMs;
+    private readonly accountPollMs;
+    private userDataListenerId;
+    private wsApiListenerId;
+    private listenKeyTimer;
+    private pollTimer;
+    private currentPositions;
+    private accountType;
+    private trackedAssetInfos;
+    constructor(config: BinanceAccountTrackerConfig);
+    start(): Promise<void>;
+    protected cleanupConnections(): Promise<void>;
+    get isConnected(): boolean;
+    protected ensureAssetTracked(coin: string): void;
+    protected releaseAsset(coin: string): void;
+    private pollAccountStatus;
+    private routeUserData;
+    private routeWsApi;
+    private handleAccountStatus;
+    private handlePositionRisk;
+    private handleUserDataEvent;
+    private refreshAllPositions;
+}
+
+export { BinanceAccountTracker, type BinanceAccountTrackerConfig };

package/dist/tracker/binance/tracker.js

@@ -0,0 +1,181 @@
+import { fetchAccountStatus, fetchAllPositionRisk, fetchMultiAssetsMargin, keepAliveListenKey, 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';
+import { mapBalance, mapPositions, mergePositions } from './mapper';
+import { BinanceAccountType } from './types';
+
+class BinanceAccountTracker extends BaseAccountTracker {
+  creds;
+  userDataWs;
+  wsApiWs;
+  listenKeyRefreshMs;
+  accountPollMs;
+  userDataListenerId = null;
+  wsApiListenerId = null;
+  listenKeyTimer = null;
+  pollTimer = null;
+  currentPositions = /* @__PURE__ */ new Map();
+  accountType = BinanceAccountType.SINGLE_ASSET;
+  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 start() {
+    const [snapshot, positionRisk, multiAssetsMargin] = await Promise.all([
+      fetchAccountStatus(this.creds, this.demo),
+      fetchAllPositionRisk(this.creds, this.demo),
+      fetchMultiAssetsMargin(this.creds, this.demo)
+    ]);
+    this.accountType = multiAssetsMargin ? BinanceAccountType.MULTI_ASSET : BinanceAccountType.SINGLE_ASSET;
+    this.handleAccountStatus(snapshot);
+    this.handlePositionRisk(positionRisk, false);
+    this.userDataListenerId = this.userDataWs.addMessageListener((raw) => this.routeUserData(raw));
+    this.wsApiListenerId = this.wsApiWs.addMessageListener((raw) => this.routeWsApi(raw));
+    this.listenKeyTimer = setInterval(() => {
+      keepAliveListenKey(this.creds.read.api_key, this.demo).catch(
+        (err) => this.onError(err instanceof Error ? err : new Error(String(err)))
+      );
+    }, this.listenKeyRefreshMs);
+    this.pollAccountStatus();
+    this.pollTimer = setInterval(() => this.pollAccountStatus(), this.accountPollMs);
+  }
+  async cleanupConnections() {
+    if (this.listenKeyTimer) clearInterval(this.listenKeyTimer);
+    this.listenKeyTimer = null;
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    this.pollTimer = null;
+    if (this.userDataListenerId) {
+      this.userDataWs.removeMessageListener(this.userDataListenerId);
+      this.userDataListenerId = null;
+    }
+    if (this.wsApiListenerId) {
+      this.wsApiWs.removeMessageListener(this.wsApiListenerId);
+      this.wsApiListenerId = null;
+    }
+  }
+  get isConnected() {
+    return this.userDataWs.connected && this.wsApiWs.connected;
+  }
+  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 };
+      this.trackedAssetInfos.set(coin, info);
+      const trackedAssets = /* @__PURE__ */ new Map();
+      trackedAssets.set(coin, info);
+      this.onStateUpdate({ trackedAssets });
+    }).catch((err) => {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+  releaseAsset(coin) {
+    this.trackedAssetInfos.delete(coin);
+    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
+  }
+  pollAccountStatus() {
+    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)));
+    });
+  }
+  routeUserData(raw) {
+    try {
+      const event = JSON.parse(raw);
+      this.handleUserDataEvent(event);
+    } catch (err) {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  routeWsApi(raw) {
+    try {
+      const msg = JSON.parse(raw);
+      if (msg.id !== void 0 && msg.result !== void 0) {
+        this.handleAccountStatus(msg.result);
+      }
+    } catch (err) {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  handleAccountStatus(result) {
+    const balance = { ...mapBalance(result), accountType: this.accountType };
+    this.onStateUpdate({ balance });
+  }
+  handlePositionRisk(risk, merge) {
+    let positions = mapPositions(risk);
+    if (merge && this.currentPositions.size > 0) {
+      positions = mergePositions(positions, this.currentPositions);
+    }
+    this.currentPositions = positions;
+    this.onStateUpdate({ positions });
+  }
+  handleUserDataEvent(event) {
+    if (event.e === "ACCOUNT_CONFIG_UPDATE" && event.ac) {
+      const symbol = event.ac.s ?? "";
+      const leverage = event.ac.l ?? "0";
+      if (symbol && leverage !== "0") {
+        const existing = this.trackedAssetInfos.get(symbol);
+        if (existing) {
+          const updated = { ...existing, leverage };
+          this.trackedAssetInfos.set(symbol, updated);
+          const trackedAssets = /* @__PURE__ */ new Map();
+          trackedAssets.set(symbol, updated);
+          this.onStateUpdate({ trackedAssets });
+        }
+      }
+      this.refreshAllPositions();
+    }
+    if (event.e === "ACCOUNT_UPDATE") {
+      this.refreshAllPositions();
+    }
+  }
+  refreshAllPositions() {
+    const symbols = /* @__PURE__ */ new Set();
+    for (const pos of this.currentPositions.values()) symbols.add(pos.symbol);
+    for (const coin of this.trackedCoins) symbols.add(coin);
+    if (symbols.size === 0) return;
+    const promises = Array.from(symbols).map(
+      (symbol) => fetchPositionRisk(this.creds, symbol, this.demo).catch(() => void 0)
+    );
+    Promise.all(promises).then((results) => {
+      const freshPositions = /* @__PURE__ */ new Map();
+      for (const risk of results) {
+        if (!risk) continue;
+        const amt = risk.positionAmt ?? "0";
+        if (amt === "0" || amt === "") continue;
+        const symbol = risk.symbol ?? "";
+        const side = amt.startsWith("-") ? "short" : "long";
+        freshPositions.set(positionKey(symbol, side), {
+          symbol,
+          side,
+          size: amt,
+          entryPrice: risk.entryPrice ?? "0",
+          unrealizedPnl: risk.unRealizedProfit ?? "0",
+          leverage: risk.leverage ?? "0",
+          marginType: risk.marginType,
+          liquidationPrice: risk.liquidationPrice || null
+        });
+      }
+      for (const [key, pos] of this.currentPositions) {
+        if (!symbols.has(pos.symbol) && !freshPositions.has(key)) {
+          freshPositions.set(key, pos);
+        }
+      }
+      this.currentPositions = freshPositions;
+      this.onStateUpdate({ positions: freshPositions });
+    }).catch((err) => {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+}
+
+export { BinanceAccountTracker };

package/dist/tracker/binance/types.d.ts

@@ -0,0 +1,6 @@
+declare enum BinanceAccountType {
+    MULTI_ASSET = "MULTI_ASSET",
+    SINGLE_ASSET = "SINGLE_ASSET"
+}
+
+export { BinanceAccountType };