@pear-protocol/exchanges-sdk 0.0.18 → 0.1.1

package/dist/tracker/okx/tracker.js

@@ -0,0 +1,134 @@
+import { fetchAccountConfig, fetchBalance, fetchPositions, fetchLeverageInfo } from '../../client/okx/rest';
+import { BaseAccountTracker } from '../base';
+import { acctLvToAccountType, mergeRawCoins, buildBalance, mapPositions, mapPositionUpdates } from './mapper';
+
+class OkxAccountTracker extends BaseAccountTracker {
+  creds;
+  ws;
+  messageListenerId = null;
+  openListenerId = null;
+  rawCoins = /* @__PURE__ */ new Map();
+  lastBalance = null;
+  accountType = null;
+  trackedAssetInfos = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super(config);
+    this.credentials = config.credentials;
+    this.creds = config.credentials;
+    this.ws = config.ws;
+  }
+  async start() {
+    const [config, balance, positions] = await Promise.all([
+      fetchAccountConfig(this.creds, this.demo),
+      fetchBalance(this.creds, this.demo),
+      fetchPositions(this.creds, this.demo)
+    ]);
+    this.accountType = acctLvToAccountType(config.acctLv);
+    this.handleInitialData(balance, positions);
+    this.messageListenerId = this.ws.main.addMessageListener((raw) => this.routeRaw(raw));
+    this.openListenerId = this.ws.main.addOpenListener(() => {
+      this.ws.login().then(() => this.subscribe()).catch((err) => this.onError(err));
+    });
+    this.subscribe();
+  }
+  async cleanupConnections() {
+    if (this.messageListenerId) {
+      this.ws.main.removeMessageListener(this.messageListenerId);
+      this.messageListenerId = null;
+    }
+    if (this.openListenerId) {
+      this.ws.main.removeOpenListener(this.openListenerId);
+      this.openListenerId = null;
+    }
+  }
+  get isConnected() {
+    return this.ws.isConnected;
+  }
+  ensureAssetTracked(instId) {
+    if (this.trackedAssetInfos.has(instId)) return;
+    fetchLeverageInfo(this.creds, instId, this.demo).then((info) => {
+      const leverage = info?.lever || "0";
+      const marginType = info?.mgnMode;
+      const trackedAssetInfo = { coin: instId, leverage, marginType };
+      this.trackedAssetInfos.set(instId, trackedAssetInfo);
+      const trackedAssets = /* @__PURE__ */ new Map([[instId, trackedAssetInfo]]);
+      this.onStateUpdate({ trackedAssets });
+    }).catch((err) => this.onError(err instanceof Error ? err : new Error(String(err))));
+  }
+  releaseAsset(instId) {
+    this.trackedAssetInfos.delete(instId);
+    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
+  }
+  subscribe() {
+    this.ws.main.send({
+      op: "subscribe",
+      args: [{ channel: "account" }, { channel: "positions", instType: "SWAP" }]
+    });
+  }
+  handleInitialData(balance, positions) {
+    this.lastBalance = balance;
+    this.rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), balance.details ?? []);
+    const built = buildBalance(balance, this.rawCoins, this.accountType);
+    if (built) this.onStateUpdate({ balance: built });
+    this.onStateUpdate({ positions: mapPositions(positions) });
+  }
+  routeRaw(raw) {
+    if (raw === "pong") return;
+    try {
+      const msg = JSON.parse(raw);
+      if (msg.event) return;
+      if (msg.arg && msg.data) {
+        this.handleMessage(msg);
+      }
+    } catch (err) {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  handleMessage(msg) {
+    if (msg.arg.channel === "account") {
+      const raw = msg.data[0];
+      if (raw) this.handleBalanceUpdate(raw);
+      return;
+    }
+    if (msg.arg.channel === "positions") {
+      const posMsg = msg;
+      const action = posMsg.action ?? "update";
+      const rawPositions = posMsg.data;
+      const positions = action === "snapshot" ? mapPositions(rawPositions) : mapPositionUpdates(rawPositions);
+      if (positions.size === 0 && action !== "snapshot") return;
+      const trackedAssets = /* @__PURE__ */ new Map();
+      for (const p of rawPositions) {
+        const existing = this.trackedAssetInfos.get(p.instId);
+        if (existing) {
+          const leverage = p.lever || existing.leverage;
+          const marginType = p.mgnMode;
+          const updated = { ...existing, leverage, marginType };
+          this.trackedAssetInfos.set(p.instId, updated);
+          trackedAssets.set(p.instId, updated);
+        }
+      }
+      this.onStateUpdate({
+        positions,
+        ...trackedAssets.size > 0 ? { trackedAssets } : {}
+      });
+    }
+  }
+  handleBalanceUpdate(raw) {
+    this.rawCoins = mergeRawCoins(this.rawCoins, raw.details ?? []);
+    const merged = this.lastBalance ? {
+      totalEq: raw.totalEq || this.lastBalance.totalEq,
+      adjEq: raw.adjEq || this.lastBalance.adjEq,
+      availEq: raw.availEq || this.lastBalance.availEq,
+      mmr: raw.mmr || this.lastBalance.mmr,
+      imr: raw.imr || this.lastBalance.imr,
+      upl: raw.upl || this.lastBalance.upl,
+      mgnRatio: raw.mgnRatio || this.lastBalance.mgnRatio,
+      details: raw.details ?? this.lastBalance.details
+    } : raw;
+    this.lastBalance = merged;
+    const built = buildBalance(merged, this.rawCoins, this.accountType);
+    if (built) this.onStateUpdate({ balance: built });
+  }
+}
+
+export { OkxAccountTracker };

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

@@ -0,0 +1,8 @@
+declare enum OkxAccountType {
+    SPOT = "OKX_SPOT",
+    SINGLE_CURRENCY_MARGIN = "OKX_SINGLE",
+    MULTI_CURRENCY_MARGIN = "OKX_MULTI",
+    PORTFOLIO_MARGIN = "OKX_PORTFOLIO"
+}
+
+export { OkxAccountType };

package/dist/tracker/types.d.ts

@@ -0,0 +1,63 @@
+import { BinanceAccountType } from './binance/types.js';
+import { BybitAccountType } from './bybit/types.js';
+import { HyperliquidAccountType } from './hyperliquid/types.js';
+import { LighterAccountType } from './lighter/types.js';
+import { OkxAccountType } from './okx/types.js';
+
+type MarginMode = 'cross' | 'isolated';
+type AccountType = BinanceAccountType | BybitAccountType | HyperliquidAccountType | LighterAccountType | OkxAccountType;
+declare const ACCOUNT_TYPE_LABELS: Record<AccountType, string>;
+interface AssetBalance {
+    asset: string;
+    free: string;
+    used: string;
+    total: string;
+    walletBalance: string;
+    usdValue: string;
+}
+interface AccountBalance {
+    accountType: AccountType;
+    free: Record<string, string>;
+    used: Record<string, string>;
+    total: Record<string, string>;
+    availableToTrade: string;
+    totalEquity: string;
+    walletBalance: string;
+    unrealizedPnl: string;
+    initialMarginUsed: string;
+    maintenanceMargin: string;
+    marginRatio: string;
+    assets: AssetBalance[];
+    timestamp: number;
+}
+interface AccountPosition {
+    symbol: string;
+    side: 'long' | 'short' | 'both';
+    size: string;
+    entryPrice: string;
+    unrealizedPnl: string;
+    leverage: string;
+    marginType: MarginMode;
+    liquidationPrice: string | null;
+}
+interface TrackedAssetInfo {
+    coin: string;
+    leverage: string;
+    marginType: MarginMode;
+}
+interface ExchangeState {
+    balance: AccountBalance | null;
+    positions: Map<string, AccountPosition>;
+    lastUpdated: number;
+    initialized: boolean;
+}
+type BalanceCallback = (balance: AccountBalance) => void;
+type PositionsCallback = (positions: AccountPosition[]) => void;
+type TrackedAssetCallback = (info: TrackedAssetInfo) => void;
+interface StateUpdate {
+    balance?: AccountBalance;
+    positions?: Map<string, AccountPosition>;
+    trackedAssets?: Map<string, TrackedAssetInfo>;
+}
+
+export { ACCOUNT_TYPE_LABELS, type AccountBalance, type AccountPosition, type AccountType, type AssetBalance, type BalanceCallback, type ExchangeState, type MarginMode, type PositionsCallback, type StateUpdate, type TrackedAssetCallback, type TrackedAssetInfo };

package/dist/{account → tracker}/types.js

@@ -1,7 +1,8 @@
-import { BinanceAccountType } from './exchanges/binance/types';
-import { BybitAccountType } from './exchanges/bybit/types';
-import { HyperliquidAccountType } from './exchanges/hyperliquid/types';
-import { OkxAccountType } from './exchanges/okx/types';
+import { BinanceAccountType } from './binance/types';
+import { BybitAccountType } from './bybit/types';
+import { HyperliquidAccountType } from './hyperliquid/types';
+import { LighterAccountType } from './lighter/types';
+import { OkxAccountType } from './okx/types';
 
 const ACCOUNT_TYPE_LABELS = {
   [BinanceAccountType.SINGLE_ASSET]: "Single-Asset Mode",
@@ -14,6 +15,7 @@ const ACCOUNT_TYPE_LABELS = {
   [HyperliquidAccountType.DEX_ABSTRACTION]: "Standard (Shared HIP-3 Balance)",
   [HyperliquidAccountType.PORTFOLIO_MARGIN]: "Portfolio Margin",
   [HyperliquidAccountType.UNIFIED_ACCOUNT]: "Unified Account",
+  [LighterAccountType.BASIC]: "Standard",
   [OkxAccountType.SPOT]: "Spot Mode",
   [OkxAccountType.SINGLE_CURRENCY_MARGIN]: "Single-Currency Margin",
   [OkxAccountType.MULTI_CURRENCY_MARGIN]: "Multi-Currency Margin",

package/dist/tracker/utils.d.ts

@@ -0,0 +1,11 @@
+import { ExchangeState } from './types.js';
+import './binance/types.js';
+import './bybit/types.js';
+import './hyperliquid/types.js';
+import './lighter/types.js';
+import './okx/types.js';
+
+declare function createEmptyState(): ExchangeState;
+declare function positionKey(symbol: string, side: string): string;
+
+export { createEmptyState, positionKey };

package/dist/{account → tracker}/utils.js

@@ -2,8 +2,6 @@ function createEmptyState() {
   return {
     balance: null,
     positions: /* @__PURE__ */ new Map(),
-    leverageSettings: /* @__PURE__ */ new Map(),
-    trackedAssets: /* @__PURE__ */ new Map(),
     lastUpdated: 0,
     initialized: false
   };

package/dist/types.d.ts

@@ -0,0 +1,50 @@
+import PearSDK from '@pear-protocol/core-sdk';
+import { BinanceCredentialsDTO, BybitCredentialsDTO, HyperliquidCredentialsDTO, LighterCredentialsDTO, OkxCredentialsDTO } from '@pear-protocol/types';
+import { BinanceExchangeWs } from './client/binance/exchange-ws.js';
+import { BybitExchangeWs } from './client/bybit/exchange-ws.js';
+import { HyperliquidExchangeWs } from './client/hyperliquid/exchange-ws.js';
+import { LighterExchangeWs } from './client/lighter/exchange-ws.js';
+import { OkxExchangeWs } from './client/okx/exchange-ws.js';
+import './client/base-ws.js';
+import 'partysocket';
+import './client/exchange-ws.js';
+import './client/binance/ws.js';
+import './client/bybit/ws.js';
+import './client/hyperliquid/ws.js';
+import './client/lighter/ws.js';
+import './client/okx/ws.js';
+
+type HyperliquidAccountCredentials = HyperliquidCredentialsDTO & {
+    accountIdentifier: string;
+};
+type LighterAccountCredentials = LighterCredentialsDTO & {
+    accountIdentifier: string;
+};
+type SupportedCredentials = BinanceCredentialsDTO | BybitCredentialsDTO | HyperliquidAccountCredentials | LighterAccountCredentials | OkxCredentialsDTO;
+type ExchangesSDKConfig = {
+    sdk: PearSDK;
+    demo?: boolean;
+};
+type ExchangeConnection = {
+    exchange: 'binance';
+    credentials: BinanceCredentialsDTO;
+    ws: BinanceExchangeWs;
+} | {
+    exchange: 'bybit';
+    credentials: BybitCredentialsDTO;
+    ws: BybitExchangeWs;
+} | {
+    exchange: 'okx';
+    credentials: OkxCredentialsDTO;
+    ws: OkxExchangeWs;
+} | {
+    exchange: 'hyperliquid';
+    credentials: HyperliquidAccountCredentials;
+    ws: HyperliquidExchangeWs;
+} | {
+    exchange: 'lighter';
+    credentials: LighterAccountCredentials;
+    ws: LighterExchangeWs;
+};
+
+export type { ExchangeConnection, ExchangesSDKConfig, HyperliquidAccountCredentials, LighterAccountCredentials, SupportedCredentials };

package/dist/types.js

@@ -0,0 +1 @@
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/exchanges-sdk",
-  "version": "0.0.18",
+  "version": "0.1.1",
   "description": "Pear Protocol Exchanges SDK",
   "private": false,
   "type": "module",
@@ -25,11 +25,15 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@pear-protocol/core-sdk": "0.0.17",
-    "@pear-protocol/types": "0.0.15",
-    "@pear-protocol/utils": "0.0.15",
+    "@pear-protocol/core-sdk": "0.0.18",
+    "@pear-protocol/types": "0.0.16",
+    "@pear-protocol/utils": "0.0.16",
+    "bignumber.js": "9.3.1",
     "partysocket": "^1.0.3"
   },
+  "peerDependencies": {
+    "viem": "^2.38.0"
+  },
   "devDependencies": {
     "@backend/typescript-config": "workspace:*",
     "tsup": "8.5.1",

package/dist/account/account-manager.d.ts

@@ -1,31 +0,0 @@
-import PearSDK from '@pear-protocol/core-sdk';
-import { Connector } from '@pear-protocol/types';
-import { Credentials } from '../credentials.js';
-import { B as BalanceCallback, i as Tracker, a as AccountBalance, P as PositionsCallback, c as AccountPosition, T as TrackedAssetCallback, h as TrackedAssetInfo } from '../types-Caz2X4h0.js';
-import './exchanges/bybit/types.js';
-import './exchanges/hyperliquid/types.js';
-import './exchanges/okx/types.js';
-
-declare class AccountManager {
-    private credentials;
-    private sdk;
-    private demo;
-    private activeAccount;
-    private balanceListeners;
-    private positionListeners;
-    private assetListeners;
-    constructor(credentials: Credentials, sdk: PearSDK, demo?: boolean);
-    connect(tradeAccountId: string, exchange: Connector): Promise<void>;
-    trackBalance(cb: BalanceCallback): Tracker<AccountBalance | null>;
-    trackPositions(cb: PositionsCallback): Tracker<AccountPosition[]>;
-    trackAsset(coin: string, cb: TrackedAssetCallback): Tracker<TrackedAssetInfo | null>;
-    getLeverage(symbol: string): string | null;
-    disconnect(): Promise<void>;
-    destroy(): Promise<void>;
-    get isConnected(): boolean;
-    get isInitialized(): boolean;
-    private resolveCredentials;
-    private startWs;
-}
-
-export { AccountManager };

package/dist/account/account-manager.js

@@ -1,119 +0,0 @@
-import { ExchangeAccount } from './exchange-account';
-
-class AccountManager {
-  credentials;
-  sdk;
-  demo;
-  activeAccount = null;
-  balanceListeners = /* @__PURE__ */ new Map();
-  positionListeners = /* @__PURE__ */ new Map();
-  assetListeners = /* @__PURE__ */ new Map();
-  constructor(credentials, sdk, demo = false) {
-    this.credentials = credentials;
-    this.sdk = sdk;
-    this.demo = demo;
-  }
-  async connect(tradeAccountId, exchange) {
-    await this.disconnect();
-    const creds = await this.resolveCredentials(tradeAccountId, exchange);
-    await this.startWs(exchange, creds);
-  }
-  trackBalance(cb) {
-    const id = Math.random().toString(36).slice(2);
-    this.balanceListeners.set(id, cb);
-    if (this.activeAccount) {
-      this.activeAccount.trackBalance(cb, id);
-    }
-    return {
-      get: () => this.activeAccount?.getBalance() ?? null,
-      untrack: () => {
-        this.balanceListeners.delete(id);
-        this.activeAccount?.untrackBalance(id);
-      }
-    };
-  }
-  trackPositions(cb) {
-    const id = Math.random().toString(36).slice(2);
-    this.positionListeners.set(id, cb);
-    if (this.activeAccount) {
-      this.activeAccount.trackPositions(cb, id);
-    }
-    return {
-      get: () => this.activeAccount?.getPositions() ?? [],
-      untrack: () => {
-        this.positionListeners.delete(id);
-        this.activeAccount?.untrackPositions(id);
-      }
-    };
-  }
-  trackAsset(coin, cb) {
-    const id = Math.random().toString(36).slice(2);
-    this.assetListeners.set(id, { coin, cb });
-    if (this.activeAccount) {
-      this.activeAccount.trackAsset(coin, cb, id);
-    }
-    return {
-      get: () => this.activeAccount?.getTrackedAsset(coin) ?? null,
-      untrack: () => {
-        this.assetListeners.delete(id);
-        this.activeAccount?.untrackAsset(id);
-      }
-    };
-  }
-  getLeverage(symbol) {
-    return this.activeAccount?.getLeverage(symbol) ?? null;
-  }
-  async disconnect() {
-    if (this.activeAccount) {
-      await this.activeAccount.disconnect();
-      this.activeAccount = null;
-    }
-    this.balanceListeners.clear();
-    this.positionListeners.clear();
-    this.assetListeners.clear();
-  }
-  async destroy() {
-    await this.disconnect();
-    this.credentials.clear();
-  }
-  get isConnected() {
-    return this.activeAccount?.isConnected ?? false;
-  }
-  get isInitialized() {
-    return this.activeAccount?.isInitialized ?? false;
-  }
-  async resolveCredentials(tradeAccountId, exchange) {
-    const creds = await this.credentials.getOrFetch(tradeAccountId);
-    if (exchange === "hyperliquid") {
-      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`);
-      }
-      if (!account.exchangeIdentifier) {
-        throw new Error(`Trade account ${tradeAccountId} has no Hyperliquid address`);
-      }
-      return {
-        ...creds,
-        address: account.exchangeIdentifier
-      };
-    }
-    return creds;
-  }
-  async startWs(exchange, creds) {
-    const account = new ExchangeAccount({ exchange, demo: this.demo });
-    await account.connect(creds);
-    this.activeAccount = account;
-    for (const [id, cb] of this.balanceListeners.entries()) {
-      account.trackBalance(cb, id);
-    }
-    for (const [id, cb] of this.positionListeners.entries()) {
-      account.trackPositions(cb, id);
-    }
-    for (const [id, { coin, cb }] of this.assetListeners.entries()) {
-      account.trackAsset(coin, cb, id);
-    }
-  }
-}
-
-export { AccountManager };

package/dist/account/exchange-account.d.ts

@@ -1,35 +0,0 @@
-import { b as AccountConfig, g as SupportedCredentials, B as BalanceCallback, a as AccountBalance, P as PositionsCallback, c as AccountPosition, T as TrackedAssetCallback, h as TrackedAssetInfo } from '../types-Caz2X4h0.js';
-import '@pear-protocol/types';
-import './exchanges/bybit/types.js';
-import './exchanges/hyperliquid/types.js';
-import './exchanges/okx/types.js';
-
-declare class ExchangeAccount {
-    private exchange;
-    private demo;
-    private orchestrator;
-    private state;
-    private balanceListeners;
-    private positionListeners;
-    private assetListeners;
-    private onAuthError?;
-    constructor(config: AccountConfig);
-    connect(credentials: SupportedCredentials): Promise<void>;
-    disconnect(): Promise<void>;
-    get isConnected(): boolean;
-    get isInitialized(): boolean;
-    get hasListeners(): boolean;
-    trackBalance(cb: BalanceCallback, id?: string): string;
-    untrackBalance(id: string): void;
-    getBalance(): AccountBalance | null;
-    trackPositions(cb: PositionsCallback, id?: string): string;
-    untrackPositions(id: string): void;
-    getPositions(): AccountPosition[];
-    trackAsset(coin: string, cb: TrackedAssetCallback, id: string): string;
-    untrackAsset(id: string): void;
-    getTrackedAsset(coin: string): TrackedAssetInfo | null;
-    getLeverage(symbol: string): string | null;
-    private applyStateUpdate;
-}
-
-export { ExchangeAccount };

package/dist/account/exchange-account.js

@@ -1,158 +0,0 @@
-import { createOrchestrator } from './exchanges';
-import { createEmptyState } from './utils';
-
-class ExchangeAccount {
-  exchange;
-  demo;
-  orchestrator = null;
-  state;
-  balanceListeners = /* @__PURE__ */ new Map();
-  positionListeners = /* @__PURE__ */ new Map();
-  assetListeners = /* @__PURE__ */ new Map();
-  onAuthError;
-  constructor(config) {
-    this.exchange = config.exchange;
-    this.demo = config.demo ?? false;
-    this.onAuthError = config.onAuthError;
-    this.state = createEmptyState();
-  }
-  async connect(credentials) {
-    await this.disconnect();
-    this.state = createEmptyState();
-    this.orchestrator = createOrchestrator(
-      this.exchange,
-      {
-        onError: (error) => {
-          console.warn(`[ExchangeAccount] ${this.exchange} error:`, error.message);
-          if (error.message.includes("auth") || error.message.includes("login")) {
-            this.onAuthError?.();
-          }
-        },
-        onStateUpdate: (update) => this.applyStateUpdate(update),
-        demo: this.demo
-      },
-      credentials
-    );
-    await this.orchestrator.start();
-  }
-  async disconnect() {
-    this.balanceListeners.clear();
-    this.positionListeners.clear();
-    this.assetListeners.clear();
-    if (this.orchestrator) {
-      await this.orchestrator.stop();
-      this.orchestrator = null;
-    }
-  }
-  get isConnected() {
-    return this.orchestrator?.isConnected ?? false;
-  }
-  get isInitialized() {
-    return this.state.initialized;
-  }
-  get hasListeners() {
-    return this.balanceListeners.size > 0 || this.positionListeners.size > 0 || this.assetListeners.size > 0;
-  }
-  trackBalance(cb, id) {
-    id ??= Math.random().toString(36).slice(2);
-    this.balanceListeners.set(id, cb);
-    if (this.state.balance) {
-      cb(this.state.balance);
-    }
-    return id;
-  }
-  untrackBalance(id) {
-    this.balanceListeners.delete(id);
-  }
-  getBalance() {
-    return this.state.balance;
-  }
-  trackPositions(cb, id) {
-    id ??= Math.random().toString(36).slice(2);
-    this.positionListeners.set(id, cb);
-    if (this.state.initialized) {
-      cb(Array.from(this.state.positions.values()));
-    }
-    return id;
-  }
-  untrackPositions(id) {
-    this.positionListeners.delete(id);
-  }
-  getPositions() {
-    return Array.from(this.state.positions.values());
-  }
-  trackAsset(coin, cb, id) {
-    this.assetListeners.set(id, { coin, cb });
-    this.orchestrator?.trackAsset(coin);
-    const existing = this.state.trackedAssets.get(coin);
-    if (existing) {
-      cb(existing);
-    }
-    return id;
-  }
-  untrackAsset(id) {
-    const entry = this.assetListeners.get(id);
-    if (!entry) return;
-    this.assetListeners.delete(id);
-    const hasOtherListeners = Array.from(this.assetListeners.values()).some((l) => l.coin === entry.coin);
-    if (!hasOtherListeners) {
-      this.orchestrator?.untrackAsset(entry.coin);
-    }
-  }
-  getTrackedAsset(coin) {
-    return this.state.trackedAssets.get(coin) ?? null;
-  }
-  getLeverage(symbol) {
-    const setting = this.state.leverageSettings.get(symbol);
-    if (setting !== void 0) return setting;
-    for (const pos of this.state.positions.values()) {
-      if (pos.symbol === symbol) return pos.leverage;
-    }
-    return null;
-  }
-  applyStateUpdate(update) {
-    if (update.balance) {
-      this.state.balance = update.balance;
-      for (const cb of this.balanceListeners.values()) {
-        try {
-          cb(update.balance);
-        } catch {
-        }
-      }
-    }
-    if (update.positions) {
-      for (const [key, pos] of update.positions) {
-        if (pos.size === "0") {
-          this.state.positions.delete(key);
-        } else {
-          this.state.positions.set(key, pos);
-        }
-      }
-      const positions = Array.from(this.state.positions.values());
-      for (const cb of this.positionListeners.values()) {
-        cb(positions);
-      }
-    }
-    if (update.leverageSettings) {
-      for (const [symbol, lev] of update.leverageSettings) {
-        this.state.leverageSettings.set(symbol, lev);
-      }
-    }
-    if (update.trackedAssets) {
-      for (const [coin, info] of update.trackedAssets) {
-        this.state.trackedAssets.set(coin, info);
-        for (const listener of this.assetListeners.values()) {
-          if (listener.coin === coin) {
-            listener.cb(info);
-          }
-        }
-      }
-    }
-    this.state.lastUpdated = Date.now();
-    if (!this.state.initialized) {
-      this.state.initialized = true;
-    }
-  }
-}
-
-export { ExchangeAccount };