@pear-protocol/exchanges-sdk 0.0.1

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

@@ -0,0 +1,10 @@
+declare const BASE_URL = "https://fapi.binance.com";
+declare const BASE_URL_TESTNET = "https://testnet.binancefuture.com";
+declare const USER_DATA_STREAM_URL = "wss://fstream.binance.com/ws";
+declare const USER_DATA_STREAM_URL_TESTNET = "wss://stream.binancefuture.com/ws";
+declare const WS_API_URL = "wss://ws-fapi.binance.com/ws-fapi/v1";
+declare const WS_API_URL_TESTNET = "wss://testnet.binancefuture.com/ws-fapi/v1";
+declare const DEFAULT_LISTEN_KEY_REFRESH_MS: number;
+declare const DEFAULT_ACCOUNT_POLL_MS = 1000;
+
+export { BASE_URL, BASE_URL_TESTNET, DEFAULT_ACCOUNT_POLL_MS, DEFAULT_LISTEN_KEY_REFRESH_MS, USER_DATA_STREAM_URL, USER_DATA_STREAM_URL_TESTNET, WS_API_URL, WS_API_URL_TESTNET };

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

@@ -0,0 +1,10 @@
+const BASE_URL = "https://fapi.binance.com";
+const BASE_URL_TESTNET = "https://testnet.binancefuture.com";
+const USER_DATA_STREAM_URL = "wss://fstream.binance.com/ws";
+const USER_DATA_STREAM_URL_TESTNET = "wss://stream.binancefuture.com/ws";
+const WS_API_URL = "wss://ws-fapi.binance.com/ws-fapi/v1";
+const WS_API_URL_TESTNET = "wss://testnet.binancefuture.com/ws-fapi/v1";
+const DEFAULT_LISTEN_KEY_REFRESH_MS = 25 * 60 * 1e3;
+const DEFAULT_ACCOUNT_POLL_MS = 1e3;
+
+export { BASE_URL, BASE_URL_TESTNET, DEFAULT_ACCOUNT_POLL_MS, DEFAULT_LISTEN_KEY_REFRESH_MS, USER_DATA_STREAM_URL, USER_DATA_STREAM_URL_TESTNET, WS_API_URL, WS_API_URL_TESTNET };

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

@@ -0,0 +1,9 @@
+import { AccountBalance, AccountPosition } from '../../types.js';
+import { BinanceRawAccountStatus, BinanceRawPositionRisk } from './types.js';
+import '@pear-protocol/types';
+
+declare function mapBalance(raw: BinanceRawAccountStatus, collateralRatios: Map<string, string>): AccountBalance;
+declare function mapPositions(raw: BinanceRawPositionRisk[]): Map<string, AccountPosition>;
+declare function mergePositions(incoming: Map<string, AccountPosition>, existing: Map<string, AccountPosition>): Map<string, AccountPosition>;
+
+export { mapBalance, mapPositions, mergePositions };

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

@@ -0,0 +1,96 @@
+import '../../types';
+import { positionKey } from '../../utils';
+
+function mapBalance(raw, collateralRatios) {
+  const free = {};
+  const used = {};
+  const total = {};
+  const assets = [];
+  for (const a of raw.assets ?? []) {
+    const wb = a.walletBalance ?? "0";
+    const ab = a.availableBalance ?? "0";
+    const mb = a.marginBalance ?? "0";
+    const im = a.initialMargin ?? "0";
+    const mm = a.maintMargin ?? "0";
+    const up = a.unrealizedProfit ?? "0";
+    if (parseFloat(wb) === 0 && parseFloat(ab) === 0 && parseFloat(mb) === 0) continue;
+    free[a.asset] = ab;
+    used[a.asset] = im;
+    total[a.asset] = mb;
+    assets.push({
+      asset: a.asset,
+      free: ab,
+      used: im,
+      total: mb,
+      walletBalance: wb,
+      unrealizedPnl: up,
+      usdValue: mb,
+      initialMargin: im,
+      maintenanceMargin: mm,
+      isCollateral: a.marginAvailable ?? false,
+      collateralRatio: collateralRatios.get(a.asset) ?? "1.0000",
+      borrowedAmount: "0"
+    });
+  }
+  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";
+  return {
+    exchange: "binance",
+    accountType: raw.multiAssetsMargin ? "multi-asset" : "single-asset",
+    marginMode: "cross",
+    free,
+    used,
+    total,
+    availableToTrade: raw.availableBalance ?? "0",
+    totalEquity: totalMarginBalance,
+    walletBalance: raw.totalWalletBalance ?? "0",
+    unrealizedPnl: raw.totalUnrealizedProfit ?? "0",
+    initialMarginUsed: raw.totalInitialMargin ?? "0",
+    maintenanceMargin: totalMaintMargin,
+    marginRatio,
+    assets,
+    timestamp: Date.now()
+  };
+}
+function mapPositions(raw) {
+  const positions = /* @__PURE__ */ new Map();
+  for (const p of raw) {
+    const amt = p.positionAmt ?? "0";
+    if (amt === "0" || amt === "") continue;
+    const symbol = p.symbol ?? "";
+    const side = amt.startsWith("-") ? "short" : "long";
+    positions.set(positionKey(symbol, side), {
+      symbol,
+      side,
+      size: amt,
+      entryPrice: p.entryPrice ?? "0",
+      unrealizedPnl: p.unRealizedProfit ?? "0",
+      leverage: p.leverage ?? "0",
+      marginType: p.marginType,
+      liquidationPrice: p.liquidationPrice || null
+    });
+  }
+  return positions;
+}
+function mergePositions(incoming, existing) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const [key, pos] of incoming) {
+    const prev = existing.get(key);
+    if (prev) {
+      merged.set(key, {
+        ...pos,
+        leverage: pos.leverage && pos.leverage !== "0" ? pos.leverage : prev.leverage,
+        liquidationPrice: pos.liquidationPrice ?? prev.liquidationPrice,
+        entryPrice: pos.entryPrice && pos.entryPrice !== "0" ? pos.entryPrice : prev.entryPrice
+      });
+    } else {
+      merged.set(key, pos);
+    }
+  }
+  return merged;
+}
+
+export { mapBalance, mapPositions, mergePositions };

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

@@ -0,0 +1,35 @@
+import { SupportedCredentials } from '../../types.js';
+import { BaseOrchestrator, OrchestratorConfig } from '../base.js';
+import '@pear-protocol/types';
+
+type BinanceOrchestratorConfig = OrchestratorConfig & {
+    listenKeyRefreshMs?: number;
+    accountPollMs?: number;
+};
+declare class BinanceOrchestrator extends BaseOrchestrator {
+    private ws;
+    private listenKeyTimer;
+    private pollTimer;
+    private creds;
+    private trackedAssetInfos;
+    private currentPositions;
+    private collateralRatios;
+    private multiAssetsMargin;
+    private readonly listenKeyRefreshMs;
+    private readonly accountPollMs;
+    constructor(config: BinanceOrchestratorConfig);
+    start(credentials: SupportedCredentials): Promise<void>;
+    stop(): 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

@@ -0,0 +1,232 @@
+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, fetchAssetIndex, createListenKey, keepAliveListenKey, fetchPositionRisk, setLeverage } from './rest';
+import { BinanceWs } from './ws';
+
+class BinanceOrchestrator extends BaseOrchestrator {
+  ws = null;
+  listenKeyTimer = null;
+  pollTimer = null;
+  creds = null;
+  trackedAssetInfos = /* @__PURE__ */ new Map();
+  currentPositions = /* @__PURE__ */ new Map();
+  collateralRatios = /* @__PURE__ */ new Map();
+  multiAssetsMargin = false;
+  listenKeyRefreshMs;
+  accountPollMs;
+  constructor(config) {
+    super(config);
+    this.listenKeyRefreshMs = config.listenKeyRefreshMs ?? DEFAULT_LISTEN_KEY_REFRESH_MS;
+    this.accountPollMs = config.accountPollMs ?? DEFAULT_ACCOUNT_POLL_MS;
+  }
+  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.multiAssetsMargin = snapshot.multiAssetsMargin ?? false;
+      if (this.multiAssetsMargin) {
+        const indexData = await fetchAssetIndex(this.demo);
+        if (gen !== this.startGeneration) return;
+        this.collateralRatios.clear();
+        for (const item of indexData) {
+          const asset = item.symbol.replace(/USD$/, "");
+          if (item.bidRate && parseFloat(item.bidRate) > 0) {
+            this.collateralRatios.set(asset, item.bidRate);
+          }
+        }
+      }
+      this.handleAccountStatus(snapshot);
+      this.handlePositionRisk(positionRisk, false);
+      const listenKey = await createListenKey(this.creds.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
+      );
+      await this.ws.connectUserDataStream(listenKey);
+      this.listenKeyTimer = setInterval(() => {
+        if (this.creds) {
+          keepAliveListenKey(this.creds.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();
+    }
+  }
+  stop() {
+    this.manualClose = true;
+    this.stopAll();
+    this.credentials = null;
+    this.creds = null;
+    this.trackedAssetInfos.clear();
+    this.currentPositions.clear();
+    this.collateralRatios.clear();
+    this.multiAssetsMargin = false;
+  }
+  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,
+        availableToTrade: null,
+        maxTradeSzs: null,
+        collateralToken: null
+      };
+      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) });
+  }
+  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;
+  }
+  pollAccountStatus() {
+    if (!this.ws?.isConnected || !this.creds) 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.collateralRatios);
+    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)));
+    });
+  }
+}
+
+export { BinanceOrchestrator };

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

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

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

@@ -0,0 +1,81 @@
+import { hmacSha256Hex } from '../../../utils/hmac';
+import { BASE_URL_TESTNET, BASE_URL } from './const';
+
+async function signedGet(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.api_secret, queryString);
+  const response = await fetch(`${baseUrl}${path}?${queryString}&signature=${signature}`, {
+    headers: { "X-MBX-APIKEY": creds.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 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.api_secret, queryString);
+  const response = await fetch(`${baseUrl}${path}?${queryString}&signature=${signature}`, {
+    method: "POST",
+    headers: { "X-MBX-APIKEY": creds.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`, {
+    method: "POST",
+    headers: { "X-MBX-APIKEY": apiKey }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to create listenKey: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.listenKey;
+}
+async function keepAliveListenKey(apiKey, demo = false) {
+  const baseUrl = demo ? BASE_URL_TESTNET : BASE_URL;
+  const response = await fetch(`${baseUrl}/fapi/v1/listenKey`, {
+    method: "PUT",
+    headers: { "X-MBX-APIKEY": apiKey }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to keep-alive listenKey: ${response.status} ${response.statusText}`);
+  }
+}
+async function fetchAccountStatus(creds, demo) {
+  return signedGet(creds, "/fapi/v3/account", {}, demo);
+}
+async function fetchPositionRisk(creds, symbol, demo) {
+  const data = await signedGet(creds, "/fapi/v2/positionRisk", { symbol }, demo);
+  return data[0];
+}
+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 fetchAssetIndex(demo) {
+  const baseUrl = demo ? BASE_URL_TESTNET : BASE_URL;
+  const response = await fetch(`${baseUrl}/fapi/v1/assetIndex`);
+  if (!response.ok) {
+    throw new Error(`Binance API error: ${response.status} ${response.statusText}`);
+  }
+  return await response.json();
+}
+
+export { createListenKey, fetchAccountStatus, fetchAllPositionRisk, fetchAssetIndex, fetchPositionRisk, keepAliveListenKey, setLeverage };

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

@@ -0,0 +1,77 @@
+import { MarginMode } from '../../types.js';
+import '@pear-protocol/types';
+
+interface BinanceRawPositionRisk {
+    symbol: string;
+    leverage: string;
+    marginType: MarginMode;
+    isAutoAddMargin: string;
+    isolatedMargin: string;
+    positionAmt: string;
+    entryPrice: string;
+    breakEvenPrice: string;
+    unRealizedProfit: string;
+    liquidationPrice: string;
+    markPrice: string;
+    maxNotionalValue: string;
+    positionSide: string;
+    notional: string;
+    isolatedWallet: string;
+    updateTime: number;
+}
+interface BinanceRawAsset {
+    asset: string;
+    walletBalance: string;
+    availableBalance: string;
+    unrealizedProfit: string;
+    marginBalance: string;
+    initialMargin: string;
+    maintMargin: string;
+    marginAvailable: boolean;
+}
+interface BinanceRawAccountStatus {
+    totalWalletBalance: string;
+    totalMarginBalance: string;
+    availableBalance: string;
+    totalUnrealizedProfit: string;
+    totalInitialMargin: string;
+    totalMaintMargin: string;
+    multiAssetsMargin: boolean;
+    assets?: BinanceRawAsset[];
+}
+interface BinanceAssetIndex {
+    symbol: string;
+    time: number;
+    index: string;
+    bidBuffer: string;
+    askBuffer: string;
+    bidRate: string;
+    askRate: string;
+    autoExchangeBidBuffer: string;
+    autoExchangeAskBuffer: string;
+    autoExchangeBidRate: string;
+    autoExchangeAskRate: string;
+}
+interface BinanceRawUserDataEvent {
+    e?: string;
+    ac?: {
+        s: string;
+        l: string;
+    };
+    a?: {
+        B?: unknown[];
+        P?: unknown[];
+    };
+}
+interface BinanceRawLeverageResponse {
+    leverage: string;
+    maxNotionalValue: string;
+    symbol: string;
+}
+interface BinanceWsHandlers {
+    onUserDataEvent: (event: unknown) => void;
+    onWsApiResponse: (id: number, result: unknown) => void;
+    onClose: () => void;
+}
+
+export type { BinanceAssetIndex, BinanceRawAccountStatus, BinanceRawAsset, BinanceRawLeverageResponse, BinanceRawPositionRisk, BinanceRawUserDataEvent, BinanceWsHandlers };

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,21 @@
+import { BinanceUSDMCredentialsDTO } from '@pear-protocol/types';
+import { BinanceWsHandlers } from './types.js';
+import '../../types.js';
+
+declare class BinanceWs {
+    private userDataWs;
+    private wsApiWs;
+    private requestId;
+    private handlers;
+    private demo;
+    private creds;
+    constructor(handlers: BinanceWsHandlers, demo: boolean);
+    connectUserDataStream(listenKey: string): Promise<void>;
+    connectWsApi(creds: BinanceUSDMCredentialsDTO): Promise<void>;
+    nextRequestId(): number;
+    sendSignedRequest(id: number, method: string, params?: Record<string, unknown>): Promise<void>;
+    close(): void;
+    get isConnected(): boolean;
+}
+
+export { BinanceWs };

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

@@ -0,0 +1,85 @@
+import { hmacSha256Hex } from '../../../utils/hmac';
+import { connectWs, sendWs } from '../../../utils/ws';
+import { USER_DATA_STREAM_URL_TESTNET, USER_DATA_STREAM_URL, WS_API_URL_TESTNET, WS_API_URL } from './const';
+
+class BinanceWs {
+  userDataWs = null;
+  wsApiWs = null;
+  requestId = 1;
+  handlers;
+  demo;
+  creds = null;
+  constructor(handlers, demo) {
+    this.handlers = handlers;
+    this.demo = demo;
+  }
+  async connectUserDataStream(listenKey) {
+    const url = this.demo ? USER_DATA_STREAM_URL_TESTNET : USER_DATA_STREAM_URL;
+    this.userDataWs = await connectWs(`${url}/${listenKey}`);
+    this.userDataWs.addEventListener("message", (event) => {
+      try {
+        this.handlers.onUserDataEvent(JSON.parse(event.data));
+      } catch {
+      }
+    });
+    this.userDataWs.onclose = () => {
+      if (this.userDataWs) {
+        this.userDataWs = null;
+        this.handlers.onClose();
+      }
+    };
+    this.userDataWs.onerror = () => {
+    };
+  }
+  async connectWsApi(creds) {
+    this.creds = creds;
+    const url = this.demo ? WS_API_URL_TESTNET : WS_API_URL;
+    this.wsApiWs = await connectWs(url);
+    this.wsApiWs.addEventListener("message", (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        if (msg.id !== void 0 && msg.result !== void 0) {
+          this.handlers.onWsApiResponse(msg.id, msg.result);
+        }
+      } catch {
+      }
+    });
+    this.wsApiWs.onclose = () => {
+      if (this.wsApiWs) {
+        this.wsApiWs = null;
+        this.handlers.onClose();
+      }
+    };
+    this.wsApiWs.onerror = () => {
+    };
+  }
+  nextRequestId() {
+    return this.requestId++;
+  }
+  async sendSignedRequest(id, method, params = {}) {
+    if (!this.creds) return;
+    const timestamp = Date.now();
+    const allParams = { ...params, apiKey: this.creds.api_key, timestamp };
+    const queryString = Object.keys(allParams).sort().map((k) => `${k}=${allParams[k]}`).join("&");
+    const signature = await hmacSha256Hex(this.creds.api_secret, queryString);
+    sendWs(this.wsApiWs, { id, method, params: { ...allParams, signature } });
+  }
+  close() {
+    this.creds = null;
+    if (this.userDataWs) {
+      this.userDataWs.onclose = null;
+      this.userDataWs.close();
+      this.userDataWs = null;
+    }
+    if (this.wsApiWs) {
+      this.wsApiWs.onclose = null;
+      this.wsApiWs.close();
+      this.wsApiWs = null;
+    }
+  }
+  get isConnected() {
+    return this.userDataWs?.readyState === WebSocket.OPEN && this.wsApiWs?.readyState === WebSocket.OPEN;
+  }
+}
+
+export { BinanceWs };