@pear-protocol/exchanges-sdk 0.0.9 → 0.0.11

package/dist/account/exchanges/base.js

@@ -1,21 +1,19 @@
-import { reconnectDelay, clearTimer } from '../../utils/ws';
-
 class BaseOrchestrator {
   onStateUpdate;
   onError;
   demo;
   credentials = null;
-  manualClose = false;
-  reconnectAttempts = 0;
-  reconnectTimer = null;
+  stopped = false;
   trackedCoins = /* @__PURE__ */ new Set();
-  startGeneration = 0;
-  starting = false;
   constructor(config) {
     this.onStateUpdate = config.onStateUpdate;
     this.onError = config.onError;
     this.demo = config.demo;
   }
+  /** Awaitable first-time connection. Errors propagate to caller. */
+  async start() {
+    await this.initAsync();
+  }
   trackAsset(coin) {
     if (this.trackedCoins.has(coin)) return;
     this.trackedCoins.add(coin);
@@ -38,26 +36,6 @@ class BaseOrchestrator {
   canUntrackAsset(_coin) {
     return true;
   }
-  scheduleReconnect() {
-    if (this.manualClose || !this.credentials) return;
-    this.reconnectAttempts += 1;
-    const delay = reconnectDelay(this.reconnectAttempts);
-    this.reconnectTimer = setTimeout(() => {
-      if (this.credentials && !this.starting) {
-        this.guardedStart(this.credentials);
-      }
-    }, delay);
-  }
-  clearReconnectTimer() {
-    this.reconnectTimer = clearTimer(this.reconnectTimer);
-  }
-  guardedStart(credentials) {
-    if (this.starting) return;
-    this.starting = true;
-    this.start(credentials).catch((err) => this.onError(err instanceof Error ? err : new Error(String(err)))).finally(() => {
-      this.starting = false;
-    });
-  }
 }
 
 export { BaseOrchestrator };

package/dist/account/exchanges/binance/asset-tracker.d.ts

@@ -0,0 +1,25 @@
+import { BinanceCredentialsDTO } from '@pear-protocol/types';
+import { S as StateUpdate, h as TrackedAssetInfo } from '../../../types-D2dbAtin.js';
+import '../bybit/types.js';
+import '../hyperliquid/types.js';
+
+type OnStateUpdate = (update: StateUpdate) => void;
+type OnError = (error: Error) => void;
+declare class BinanceAssetTracker {
+    private onStateUpdate;
+    private onError;
+    private getCreds;
+    private getDemo;
+    private trackedAssetInfos;
+    constructor(deps: {
+        onStateUpdate: OnStateUpdate;
+        onError: OnError;
+        getCreds: () => BinanceCredentialsDTO;
+        getDemo: () => boolean;
+    });
+    getInfos(): Map<string, TrackedAssetInfo>;
+    onAssetTracked(coin: string): void;
+    onAssetUntracked(coin: string): void;
+}
+
+export { BinanceAssetTracker };

package/dist/account/exchanges/binance/asset-tracker.js

@@ -0,0 +1,38 @@
+import { fetchPositionRisk } from './rest';
+
+class BinanceAssetTracker {
+  onStateUpdate;
+  onError;
+  getCreds;
+  getDemo;
+  trackedAssetInfos = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.onStateUpdate = deps.onStateUpdate;
+    this.onError = deps.onError;
+    this.getCreds = deps.getCreds;
+    this.getDemo = deps.getDemo;
+  }
+  getInfos() {
+    return this.trackedAssetInfos;
+  }
+  onAssetTracked(coin) {
+    fetchPositionRisk(this.getCreds(), coin, this.getDemo()).then((risk) => {
+      if (!risk) return;
+      const leverage = risk.leverage;
+      const marginType = risk.marginType === "isolated" ? "isolated" : "cross";
+      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)));
+    });
+  }
+  onAssetUntracked(coin) {
+    this.trackedAssetInfos.delete(coin);
+    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
+  }
+}
+
+export { BinanceAssetTracker };

package/dist/account/exchanges/binance/mapper.d.ts

@@ -1,8 +1,9 @@
-import { AccountBalance, AccountPosition } from '../../types.js';
-import { BinanceRawAccountStatus, BinanceRawPositionRisk } from './types.js';
+import { j as BinanceRawAccountStatus, a as AccountBalance, k as BinanceRawPositionRisk, c as AccountPosition } from '../../../types-D2dbAtin.js';
 import '@pear-protocol/types';
+import '../bybit/types.js';
+import '../hyperliquid/types.js';
 
-declare function mapBalance(raw: BinanceRawAccountStatus): AccountBalance;
+declare function mapBalance(raw: BinanceRawAccountStatus): Omit<AccountBalance, 'accountType'>;
 declare function mapPositions(raw: BinanceRawPositionRisk[]): Map<string, AccountPosition>;
 declare function mergePositions(incoming: Map<string, AccountPosition>, existing: Map<string, AccountPosition>): Map<string, AccountPosition>;
 

package/dist/account/exchanges/binance/mapper.js

@@ -30,7 +30,6 @@ function mapBalance(raw) {
   const maintMargin = parseFloat(totalMaintMargin);
   const marginRatio = marginBalance > 0 ? (maintMargin / marginBalance).toFixed(4) : "0.0000";
   return {
-    accountType: raw.multiAssetsMargin ? "multi-asset" : "single-asset",
     free,
     used,
     total,

package/dist/account/exchanges/binance/orchestrator.d.ts

@@ -1,6 +1,8 @@
-import { SupportedCredentials } from '../../types.js';
+import { g as SupportedCredentials } from '../../../types-D2dbAtin.js';
 import { BaseOrchestrator, OrchestratorConfig } from '../base.js';
 import '@pear-protocol/types';
+import '../bybit/types.js';
+import '../hyperliquid/types.js';
 
 type BinanceOrchestratorConfig = OrchestratorConfig & {
     listenKeyRefreshMs?: number;
@@ -11,23 +13,18 @@ declare class BinanceOrchestrator extends BaseOrchestrator {
     private listenKeyTimer;
     private pollTimer;
     private creds;
-    private trackedAssetInfos;
-    private currentPositions;
     private readonly listenKeyRefreshMs;
     private readonly accountPollMs;
-    constructor(config: BinanceOrchestratorConfig);
-    start(credentials: SupportedCredentials): Promise<void>;
-    stop(): void;
+    private stateHandler;
+    private assetTracker;
+    constructor(config: BinanceOrchestratorConfig, credentials: SupportedCredentials);
+    protected initAsync(): Promise<void>;
+    protected cleanupConnections(): void;
+    stop(): Promise<void>;
     get isConnected(): boolean;
     onAssetTracked(coin: string): void;
     onAssetUntracked(coin: string): void;
-    setLeverage(symbol: string, leverage: string): Promise<void>;
-    private stopAll;
     private pollAccountStatus;
-    private handleUserDataEvent;
-    private handleAccountStatus;
-    private handlePositionRisk;
-    private refreshAllPositions;
 }
 
 export { BinanceOrchestrator };

package/dist/account/exchanges/binance/orchestrator.js

@@ -1,212 +1,90 @@
-import { positionKey } from '../../utils';
 import { BaseOrchestrator } from '../base';
 import { DEFAULT_LISTEN_KEY_REFRESH_MS, DEFAULT_ACCOUNT_POLL_MS } from './const';
-import { mapBalance, mapPositions, mergePositions } from './mapper';
-import { fetchAccountStatus, fetchAllPositionRisk, createListenKey, keepAliveListenKey, fetchPositionRisk, setLeverage } from './rest';
+import { fetchAccountStatus, fetchAllPositionRisk, fetchMultiAssetsMargin, createListenKey, keepAliveListenKey } from './rest';
+import './types';
 import { BinanceWs } from './ws';
+import { BinanceStateHandler } from './state-handler';
+import { BinanceAssetTracker } from './asset-tracker';
 
 class BinanceOrchestrator extends BaseOrchestrator {
   ws = null;
   listenKeyTimer = null;
   pollTimer = null;
-  creds = null;
-  trackedAssetInfos = /* @__PURE__ */ new Map();
-  currentPositions = /* @__PURE__ */ new Map();
+  creds;
   listenKeyRefreshMs;
   accountPollMs;
-  constructor(config) {
+  stateHandler;
+  assetTracker;
+  constructor(config, credentials) {
     super(config);
+    this.credentials = credentials;
+    this.creds = credentials;
     this.listenKeyRefreshMs = config.listenKeyRefreshMs ?? DEFAULT_LISTEN_KEY_REFRESH_MS;
     this.accountPollMs = config.accountPollMs ?? DEFAULT_ACCOUNT_POLL_MS;
+    this.assetTracker = new BinanceAssetTracker({
+      onStateUpdate: (update) => this.onStateUpdate(update),
+      onError: (err) => this.onError(err),
+      getCreds: () => this.creds,
+      getDemo: () => this.demo
+    });
+    this.stateHandler = new BinanceStateHandler({
+      onStateUpdate: (update) => this.onStateUpdate(update),
+      onError: (err) => this.onError(err),
+      getCreds: () => this.creds,
+      getDemo: () => this.demo,
+      getTrackedCoins: () => this.trackedCoins,
+      getTrackedAssetInfos: () => this.assetTracker.getInfos()
+    });
   }
-  async start(credentials) {
-    const gen = ++this.startGeneration;
-    this.manualClose = false;
-    this.credentials = credentials;
-    this.creds = credentials;
-    this.stopAll();
-    try {
-      const [snapshot, positionRisk] = await Promise.all([
-        fetchAccountStatus(this.creds, this.demo),
-        fetchAllPositionRisk(this.creds, this.demo)
-      ]);
-      if (gen !== this.startGeneration) return;
-      this.handleAccountStatus(snapshot);
-      this.handlePositionRisk(positionRisk, false);
-      const listenKey = await createListenKey(this.creds.read.api_key, this.demo);
-      this.ws = new BinanceWs(
-        {
-          onUserDataEvent: (event) => this.handleUserDataEvent(event),
-          onWsApiResponse: (_id, result) => this.handleAccountStatus(result),
-          onClose: () => {
-            if (!this.manualClose) {
-              this.stopAll();
-              this.scheduleReconnect();
-            }
-          }
-        },
-        this.demo
+  async initAsync() {
+    const [snapshot, positionRisk, multiAssetsMargin] = await Promise.all([
+      fetchAccountStatus(this.creds, this.demo),
+      fetchAllPositionRisk(this.creds, this.demo),
+      fetchMultiAssetsMargin(this.creds, this.demo)
+    ]);
+    this.stateHandler.setMultiAssetsMargin(multiAssetsMargin);
+    this.stateHandler.handleAccountStatus(snapshot);
+    this.stateHandler.handlePositionRisk(positionRisk, false);
+    const listenKey = await createListenKey(this.creds.read.api_key, this.demo);
+    this.ws = new BinanceWs(
+      {
+        onUserDataEvent: (event) => this.stateHandler.handleUserDataEvent(event),
+        onWsApiResponse: (_id, result) => this.stateHandler.handleAccountStatus(result)
+      },
+      this.demo
+    );
+    await this.ws.connectUserDataStream(listenKey);
+    this.listenKeyTimer = setInterval(() => {
+      keepAliveListenKey(this.creds.read.api_key, this.demo).catch(
+        (err) => this.onError(err instanceof Error ? err : new Error(String(err)))
       );
-      await this.ws.connectUserDataStream(listenKey);
-      this.listenKeyTimer = setInterval(() => {
-        if (this.creds) {
-          keepAliveListenKey(this.creds.read.api_key, this.demo).catch(
-            (err) => this.onError(err instanceof Error ? err : new Error(String(err)))
-          );
-        }
-      }, this.listenKeyRefreshMs);
-      await this.ws.connectWsApi(this.creds);
-      this.reconnectAttempts = 0;
-      this.pollAccountStatus();
-      this.pollTimer = setInterval(() => this.pollAccountStatus(), this.accountPollMs);
-    } catch (err) {
-      if (gen !== this.startGeneration) return;
-      this.stopAll();
-      this.onError(err instanceof Error ? err : new Error(String(err)));
-      this.scheduleReconnect();
-    }
+    }, this.listenKeyRefreshMs);
+    await this.ws.connectWsApi(this.creds);
+    this.pollAccountStatus();
+    this.pollTimer = setInterval(() => this.pollAccountStatus(), this.accountPollMs);
   }
-  stop() {
-    this.manualClose = true;
-    this.stopAll();
-    this.credentials = null;
-    this.creds = null;
-    this.trackedAssetInfos.clear();
-    this.currentPositions.clear();
+  cleanupConnections() {
+    if (this.listenKeyTimer) clearInterval(this.listenKeyTimer);
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    this.ws?.close();
+  }
+  async stop() {
+    this.stopped = true;
+    this.cleanupConnections();
   }
   get isConnected() {
     return this.ws?.isConnected ?? false;
   }
   onAssetTracked(coin) {
-    if (!this.creds) return;
-    fetchPositionRisk(this.creds, coin, this.demo).then((risk) => {
-      if (!risk) return;
-      const leverage = risk?.leverage;
-      const marginType = risk?.marginType === "isolated" ? "isolated" : "cross";
-      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)));
-    });
+    this.assetTracker.onAssetTracked(coin);
   }
   onAssetUntracked(coin) {
-    this.trackedAssetInfos.delete(coin);
-    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
-  }
-  async setLeverage(symbol, leverage) {
-    if (!this.creds) throw new Error("Not connected");
-    await setLeverage(this.creds, symbol, leverage, this.demo);
-  }
-  stopAll() {
-    if (this.listenKeyTimer) {
-      clearInterval(this.listenKeyTimer);
-      this.listenKeyTimer = null;
-    }
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = null;
-    }
-    this.clearReconnectTimer();
-    this.ws?.close();
-    this.ws = null;
+    this.assetTracker.onAssetUntracked(coin);
   }
   pollAccountStatus() {
-    if (!this.ws?.isConnected || !this.creds) return;
+    if (!this.ws?.isConnected) return;
     const id = this.ws.nextRequestId();
-    this.ws.sendSignedRequest(id, "v3/account.status");
-  }
-  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 leverageSettings = /* @__PURE__ */ new Map();
-        leverageSettings.set(symbol, leverage);
-        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({ leverageSettings, trackedAssets });
-        } else {
-          this.onStateUpdate({ leverageSettings });
-        }
-      }
-      this.refreshAllPositions();
-    }
-    if (event.e === "ACCOUNT_UPDATE") {
-      this.refreshAllPositions();
-    }
-  }
-  handleAccountStatus(result) {
-    const balance = mapBalance(result);
-    this.onStateUpdate({ balance });
-  }
-  handlePositionRisk(risk, merge) {
-    let positions = mapPositions(risk);
-    if (merge && this.currentPositions.size > 0) {
-      positions = mergePositions(positions, this.currentPositions);
-    }
-    this.currentPositions = positions;
-    const leverageSettings = /* @__PURE__ */ new Map();
-    for (const p of risk) {
-      if (p.symbol && p.leverage) {
-        leverageSettings.set(p.symbol, p.leverage);
-      }
-    }
-    this.onStateUpdate({ positions, leverageSettings });
-  }
-  refreshAllPositions() {
-    if (!this.creds) return;
-    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 creds = this.creds;
-    const promises = Array.from(symbols).map(
-      (symbol) => fetchPositionRisk(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 === "isolated" ? "isolated" : "cross",
-          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)));
-    });
+    this.ws.sendSignedRequest(id, "v2/account.status");
   }
 }
 

package/dist/account/exchanges/binance/rest.d.ts

@@ -1,13 +1,14 @@
 import { BinanceCredentialsDTO } from '@pear-protocol/types';
-import { BinanceRawAccountStatus, BinanceRawPositionRisk, BinanceAssetIndex, BinanceRawLeverageResponse } from './types.js';
-import '../../types.js';
+import { j as BinanceRawAccountStatus, k as BinanceRawPositionRisk, l as BinanceAssetIndex } from '../../../types-D2dbAtin.js';
+import '../bybit/types.js';
+import '../hyperliquid/types.js';
 
 declare function createListenKey(apiKey: string, demo?: boolean): Promise<string>;
 declare function keepAliveListenKey(apiKey: string, demo?: boolean): Promise<void>;
 declare function fetchAccountStatus(creds: BinanceCredentialsDTO, demo: boolean): Promise<BinanceRawAccountStatus>;
 declare function fetchPositionRisk(creds: BinanceCredentialsDTO, symbol: string, demo: boolean): Promise<BinanceRawPositionRisk | undefined>;
 declare function fetchAllPositionRisk(creds: BinanceCredentialsDTO, demo: boolean): Promise<BinanceRawPositionRisk[]>;
-declare function setLeverage(creds: BinanceCredentialsDTO, symbol: string, leverage: string, demo: boolean): Promise<BinanceRawLeverageResponse>;
+declare function fetchMultiAssetsMargin(creds: BinanceCredentialsDTO, demo: boolean): Promise<boolean>;
 declare function fetchAssetIndex(demo: boolean): Promise<BinanceAssetIndex[]>;
 
-export { createListenKey, fetchAccountStatus, fetchAllPositionRisk, fetchAssetIndex, fetchPositionRisk, keepAliveListenKey, setLeverage };
+export { createListenKey, fetchAccountStatus, fetchAllPositionRisk, fetchAssetIndex, fetchMultiAssetsMargin, fetchPositionRisk, keepAliveListenKey };

package/dist/account/exchanges/binance/rest.js

@@ -17,23 +17,6 @@ async function signedGet(creds, path, params, demo) {
   }
   return await response.json();
 }
-async function signedPost(creds, path, params, demo) {
-  const baseUrl = demo ? BASE_URL_TESTNET : BASE_URL;
-  const timestamp = Date.now().toString();
-  const allParams = { ...params, timestamp, recvWindow: "5000" };
-  const queryString = new URLSearchParams(allParams).toString();
-  const signature = await hmacSha256Hex(creds.read.api_secret, queryString);
-  const response = await fetch(`${baseUrl}${path}?${queryString}&signature=${signature}`, {
-    method: "POST",
-    headers: { "X-MBX-APIKEY": creds.read.api_key }
-  });
-  if (!response.ok) {
-    const body = await response.json().catch(() => null);
-    const msg = body?.msg ?? response.statusText;
-    throw new Error(`Binance API error ${response.status}: ${msg}`);
-  }
-  return await response.json();
-}
 async function createListenKey(apiKey, demo = false) {
   const baseUrl = demo ? BASE_URL_TESTNET : BASE_URL;
   const response = await fetch(`${baseUrl}/fapi/v1/listenKey`, {
@@ -66,8 +49,9 @@ async function fetchPositionRisk(creds, symbol, demo) {
 async function fetchAllPositionRisk(creds, demo) {
   return signedGet(creds, "/fapi/v2/positionRisk", {}, demo);
 }
-async function setLeverage(creds, symbol, leverage, demo) {
-  return signedPost(creds, "/fapi/v1/leverage", { symbol, leverage }, demo);
+async function fetchMultiAssetsMargin(creds, demo) {
+  const res = await signedGet(creds, "/fapi/v1/multiAssetsMargin", {}, demo);
+  return res.multiAssetsMargin;
 }
 async function fetchAssetIndex(demo) {
   const baseUrl = demo ? BASE_URL_TESTNET : BASE_URL;
@@ -78,4 +62,4 @@ async function fetchAssetIndex(demo) {
   return await response.json();
 }
 
-export { createListenKey, fetchAccountStatus, fetchAllPositionRisk, fetchAssetIndex, fetchPositionRisk, keepAliveListenKey, setLeverage };
+export { createListenKey, fetchAccountStatus, fetchAllPositionRisk, fetchAssetIndex, fetchMultiAssetsMargin, fetchPositionRisk, keepAliveListenKey };

package/dist/account/exchanges/binance/state-handler.d.ts

@@ -0,0 +1,32 @@
+import { BinanceCredentialsDTO } from '@pear-protocol/types';
+import { S as StateUpdate, h as TrackedAssetInfo, j as BinanceRawAccountStatus, k as BinanceRawPositionRisk, m as BinanceRawUserDataEvent } from '../../../types-D2dbAtin.js';
+import '../bybit/types.js';
+import '../hyperliquid/types.js';
+
+type OnStateUpdate = (update: StateUpdate) => void;
+type OnError = (error: Error) => void;
+declare class BinanceStateHandler {
+    private onStateUpdate;
+    private onError;
+    private getCreds;
+    private getDemo;
+    private getTrackedCoins;
+    private getTrackedAssetInfos;
+    private currentPositions;
+    private accountType;
+    constructor(deps: {
+        onStateUpdate: OnStateUpdate;
+        onError: OnError;
+        getCreds: () => BinanceCredentialsDTO;
+        getDemo: () => boolean;
+        getTrackedCoins: () => ReadonlySet<string>;
+        getTrackedAssetInfos: () => Map<string, TrackedAssetInfo>;
+    });
+    setMultiAssetsMargin(value: boolean): void;
+    handleAccountStatus(result: BinanceRawAccountStatus): void;
+    handlePositionRisk(risk: BinanceRawPositionRisk[], merge: boolean): void;
+    handleUserDataEvent(event: BinanceRawUserDataEvent): void;
+    private refreshAllPositions;
+}
+
+export { BinanceStateHandler };

package/dist/account/exchanges/binance/state-handler.js

@@ -0,0 +1,113 @@
+import { positionKey } from '../../utils';
+import { mapBalance, mapPositions, mergePositions } from './mapper';
+import { fetchPositionRisk } from './rest';
+import { BinanceAccountType } from './types';
+
+class BinanceStateHandler {
+  onStateUpdate;
+  onError;
+  getCreds;
+  getDemo;
+  getTrackedCoins;
+  getTrackedAssetInfos;
+  currentPositions = /* @__PURE__ */ new Map();
+  accountType = BinanceAccountType.SINGLE_ASSET;
+  constructor(deps) {
+    this.onStateUpdate = deps.onStateUpdate;
+    this.onError = deps.onError;
+    this.getCreds = deps.getCreds;
+    this.getDemo = deps.getDemo;
+    this.getTrackedCoins = deps.getTrackedCoins;
+    this.getTrackedAssetInfos = deps.getTrackedAssetInfos;
+  }
+  setMultiAssetsMargin(value) {
+    this.accountType = value ? BinanceAccountType.MULTI_ASSET : BinanceAccountType.SINGLE_ASSET;
+  }
+  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;
+    const leverageSettings = /* @__PURE__ */ new Map();
+    for (const p of risk) {
+      if (p.symbol && p.leverage) {
+        leverageSettings.set(p.symbol, p.leverage);
+      }
+    }
+    this.onStateUpdate({ positions, leverageSettings });
+  }
+  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 leverageSettings = /* @__PURE__ */ new Map();
+        leverageSettings.set(symbol, leverage);
+        const trackedAssetInfos = this.getTrackedAssetInfos();
+        const existing = trackedAssetInfos.get(symbol);
+        if (existing) {
+          const updated = { ...existing, leverage };
+          trackedAssetInfos.set(symbol, updated);
+          const trackedAssets = /* @__PURE__ */ new Map();
+          trackedAssets.set(symbol, updated);
+          this.onStateUpdate({ leverageSettings, trackedAssets });
+        } else {
+          this.onStateUpdate({ leverageSettings });
+        }
+      }
+      this.refreshAllPositions();
+    }
+    if (event.e === "ACCOUNT_UPDATE") {
+      this.refreshAllPositions();
+    }
+  }
+  refreshAllPositions() {
+    const creds = this.getCreds();
+    const demo = this.getDemo();
+    const symbols = /* @__PURE__ */ new Set();
+    for (const pos of this.currentPositions.values()) {
+      symbols.add(pos.symbol);
+    }
+    for (const coin of this.getTrackedCoins()) {
+      symbols.add(coin);
+    }
+    if (symbols.size === 0) return;
+    const promises = Array.from(symbols).map((symbol) => fetchPositionRisk(creds, symbol, 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 === "isolated" ? "isolated" : "cross",
+          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 { BinanceStateHandler };