@usherlabs/cex-broker 0.2.13 → 0.2.14

package/dist/commands/cli.js

@@ -330285,15 +330285,11 @@ function createExecuteActionHandler(deps) {
 var grpc13 = __toESM(require_src3(), 1);
 
 // src/helpers/binance-user-data-stream.ts
+import { Buffer as Buffer2 } from "node:buffer";
 import { createHmac } from "node:crypto";
 var BINANCE_SPOT_WS_API_URL = "wss://ws-api.binance.com:443/ws-api/v3";
-function getWebSocketConstructor() {
-  const WebSocketCtor = globalThis.WebSocket;
-  if (!WebSocketCtor) {
-    throw new Error("WebSocket is not available in this runtime");
-  }
-  return WebSocketCtor;
-}
+var DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS = 16;
+var createWebSocket = (url3) => new wrapper_default(url3);
 function getExchangeString(exchange, key) {
   const value = exchange[key];
   if (typeof value !== "string" || value.length === 0) {
@@ -330319,24 +330315,106 @@ function getBinanceSpotWsApiUrl(exchange) {
   const urls = exchange.urls;
   return urls?.api?.ws?.["ws-api"]?.spot ?? BINANCE_SPOT_WS_API_URL;
 }
+function getRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function getMessage(value) {
+  if (value instanceof Error) {
+    return value.message;
+  }
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  const record2 = getRecord(value);
+  const message = record2?.message;
+  return typeof message === "string" && message.length > 0 ? message : null;
+}
+function getOptionalExchangeString(exchange, key) {
+  const value = exchange[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function redactDiagnosticMessage(message, secretValues) {
+  let redacted = message;
+  for (const value of secretValues) {
+    if (value.length > 0) {
+      redacted = redacted.split(value).join("[redacted]");
+    }
+  }
+  return redacted.replace(/(\b(?:apiKey|secret|signature)\b\s*=\s*)[^\s&,;)]+/gi, "$1[redacted]").replace(/("(?:apiKey|secret|signature)"\s*:\s*")[^"]*(")/gi, "$1[redacted]$2");
+}
+function formatBinanceUserDataWebSocketError(event, secretValues) {
+  const record2 = getRecord(event);
+  const message = getMessage(record2?.error) ?? getMessage(record2?.message) ?? getMessage(event);
+  const safeMessage = message === null ? null : redactDiagnosticMessage(message, secretValues);
+  return new Error(safeMessage ? `Binance user-data WebSocket error: ${safeMessage}` : "Binance user-data WebSocket error");
+}
+function getCloseReason(value) {
+  if (typeof value === "string") {
+    return value.length > 0 ? value : null;
+  }
+  if (Buffer2.isBuffer(value)) {
+    const reason = value.toString("utf8");
+    return reason.length > 0 ? reason : null;
+  }
+  if (value instanceof Uint8Array) {
+    const reason = Buffer2.from(value).toString("utf8");
+    return reason.length > 0 ? reason : null;
+  }
+  return null;
+}
+function formatBinanceUserDataWebSocketClose(codeOrEvent, reasonOrUndefined, secretValues) {
+  const record2 = getRecord(codeOrEvent);
+  const code = record2 ? record2.code : codeOrEvent;
+  const reason = getCloseReason(record2 ? record2.reason : reasonOrUndefined);
+  const safeReason = reason === null ? null : redactDiagnosticMessage(reason, secretValues);
+  const details = [
+    typeof code === "number" || typeof code === "string" ? `code=${code}` : null,
+    safeReason ? `reason=${safeReason}` : null
+  ].filter((detail) => detail !== null);
+  return new Error(details.length > 0 ? `Binance user-data WebSocket closed unexpectedly (${details.join(", ")})` : "Binance user-data WebSocket closed unexpectedly");
+}
+function decodeMessageData(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (Buffer2.isBuffer(data)) {
+    return data.toString("utf8");
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer2.from(data).toString("utf8");
+  }
+  if (ArrayBuffer.isView(data)) {
+    return Buffer2.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
+  }
+  if (Array.isArray(data) && data.every((item) => Buffer2.isBuffer(item))) {
+    return Buffer2.concat(data).toString("utf8");
+  }
+  return data;
+}
 
 class BinanceSpotUserDataStream {
   exchange;
   ws;
+  secretValues;
   requestId = `user-data-${Date.now()}-${Math.random()}`;
+  maxBufferedEvents;
   queue = [];
   waiters = [];
   closed = false;
   closeError = null;
   subscriptionId = null;
-  constructor(exchange) {
+  constructor(exchange, options = {}) {
     this.exchange = exchange;
-    const WebSocketCtor = getWebSocketConstructor();
-    this.ws = new WebSocketCtor(getBinanceSpotWsApiUrl(exchange));
-    this.ws.onopen = () => this.subscribe();
-    this.ws.onmessage = (message) => this.handleMessage(message.data);
-    this.ws.onerror = (error48) => this.fail(error48 instanceof Error ? error48 : new Error("Binance user-data WebSocket error"));
-    this.ws.onclose = () => this.close();
+    this.maxBufferedEvents = options.maxBufferedEvents ?? DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS;
+    this.secretValues = [
+      getOptionalExchangeString(exchange, "apiKey"),
+      getOptionalExchangeString(exchange, "secret")
+    ].filter((value) => value !== null);
+    this.ws = createWebSocket(getBinanceSpotWsApiUrl(exchange));
+    this.ws.on("open", () => this.subscribe());
+    this.ws.on("message", (data) => this.handleMessage(data));
+    this.ws.on("error", (error48) => this.fail(formatBinanceUserDataWebSocketError(error48, this.secretValues)));
+    this.ws.on("close", (code, reason) => this.handleClose(code, reason));
   }
   async* [Symbol.asyncIterator]() {
     while (true) {
@@ -330352,11 +330430,18 @@ class BinanceSpotUserDataStream {
       return;
     }
     this.closed = true;
+    this.queue.length = 0;
     try {
       this.ws.close();
     } catch {}
     this.flushWaiters();
   }
+  handleClose(code, reason) {
+    if (this.closed) {
+      return;
+    }
+    this.fail(formatBinanceUserDataWebSocketClose(code, reason, this.secretValues));
+  }
   subscribe() {
     const apiKey = getExchangeString(this.exchange, "apiKey");
     const signedParams = signUserDataStreamParams(this.exchange, {
@@ -330370,9 +330455,13 @@ class BinanceSpotUserDataStream {
     }));
   }
   handleMessage(data) {
+    if (this.closed) {
+      return;
+    }
     let message;
     try {
-      message = typeof data === "string" ? JSON.parse(data) : data;
+      const decodedData = decodeMessageData(data);
+      message = typeof decodedData === "string" ? JSON.parse(decodedData) : decodedData;
     } catch (error48) {
       this.fail(error48 instanceof Error ? error48 : new Error("Invalid Binance user-data message"));
       return;
@@ -330395,11 +330484,18 @@ class BinanceSpotUserDataStream {
     this.push({ subscriptionId, event: message.event });
   }
   push(event) {
+    if (this.closed) {
+      return;
+    }
     const waiter = this.waiters.shift();
     if (waiter) {
       waiter.resolve(event);
       return;
     }
+    if (this.queue.length >= this.maxBufferedEvents) {
+      this.fail(new Error(`Binance user-data stream buffered event limit exceeded (${this.maxBufferedEvents}); downstream consumer is not keeping up`));
+      return;
+    }
     this.queue.push(event);
   }
   nextEvent() {
@@ -330423,6 +330519,7 @@ class BinanceSpotUserDataStream {
     }
     this.closeError = error48;
     this.closed = true;
+    this.queue.length = 0;
     this.flushWaiters();
     try {
       this.ws.close();
@@ -330450,16 +330547,49 @@ function isBinanceOrderUserDataEvent(event) {
 function isBinanceSpotAccountSubscription(cex3, subscriptionType, marketTypeInput) {
   return cex3 === "binance" && parseMarketType(marketTypeInput) === "spot" && (subscriptionType === SubscriptionType.BALANCE || subscriptionType === SubscriptionType.ORDERS);
 }
-function writeSubscribeFrame(call, isClosed, frame) {
+function waitForSubscribeDrain(call, isClosed) {
+  if (isClosed() || call.destroyed) {
+    return Promise.resolve(false);
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    const cleanup = () => {
+      call.off("drain", onDrain);
+      call.off("close", onClosed);
+      call.off("cancelled", onClosed);
+      call.off("end", onClosed);
+      call.off("error", onClosed);
+    };
+    const settle2 = (drained) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve(drained && !isClosed() && !call.destroyed);
+    };
+    const onDrain = () => settle2(true);
+    const onClosed = () => settle2(false);
+    call.once("drain", onDrain);
+    call.once("close", onClosed);
+    call.once("cancelled", onClosed);
+    call.once("end", onClosed);
+    call.once("error", onClosed);
+  });
+}
+async function writeSubscribeFrame(call, isClosed, frame) {
   if (isClosed() || call.destroyed) {
     return false;
   }
-  call.write(frame);
-  return true;
+  const canContinue = call.write(frame);
+  if (canContinue) {
+    return true;
+  }
+  return waitForSubscribeDrain(call, isClosed);
 }
-function writeSubscribeError(call, isClosed, frame) {
-  writeSubscribeFrame(call, isClosed, frame);
-  if (!isClosed() && !call.destroyed) {
+async function writeSubscribeError(call, isClosed, frame) {
+  const frameWritten = await writeSubscribeFrame(call, isClosed, frame);
+  if (frameWritten && !isClosed() && !call.destroyed) {
     call.end();
   }
 }
@@ -330506,7 +330636,7 @@ async function streamBinanceUserData(call, broker, symbol2, subscriptionType, is
           continue;
         }
       }
-      if (!writeSubscribeFrame(call, isClosed, {
+      if (!await writeSubscribeFrame(call, isClosed, {
         data: JSON.stringify({
           subscriptionId: message.subscriptionId,
           event
@@ -330525,7 +330655,7 @@ async function streamBinanceUserData(call, broker, symbol2, subscriptionType, is
 async function runCcxtSubscribeLoop(call, isClosed, symbol2, subscriptionType, watch) {
   while (!isClosed()) {
     const data = await watch();
-    if (!writeSubscribeFrame(call, isClosed, {
+    if (!await writeSubscribeFrame(call, isClosed, {
       data: JSON.stringify(data),
       timestamp: Date.now(),
       symbol: symbol2,
@@ -330591,7 +330721,7 @@ function createSubscribeHandler(deps) {
         type: subscriptionTypeName
       });
       if (!cex3 || !symbol2) {
-        writeSubscribeError(call, isStreamClosed, {
+        await writeSubscribeError(call, isStreamClosed, {
           data: JSON.stringify({
             error: "cex, symbol, and type are required"
           }),
@@ -330605,7 +330735,7 @@ function createSubscribeHandler(deps) {
       const selectedBroker = selectBroker(brokers[normalizedCex], metadata) ?? createBroker(normalizedCex, metadata);
       const broker = selectedBroker ?? createPublicBroker(normalizedCex);
       if (!broker) {
-        writeSubscribeError(call, isStreamClosed, {
+        await writeSubscribeError(call, isStreamClosed, {
           data: JSON.stringify({
             error: "Exchange not registered and no API metadata found"
           }),
@@ -330618,7 +330748,7 @@ function createSubscribeHandler(deps) {
       const resolvedSymbol = await resolveSubscriptionSymbol(broker, symbol2, options?.marketType);
       if (isBinanceSpotAccountSubscription(normalizedCex, subscriptionType, options?.marketType)) {
         if (!selectedBroker) {
-          writeSubscribeError(call, isStreamClosed, {
+          await writeSubscribeError(call, isStreamClosed, {
             data: JSON.stringify({
               error: "Binance account subscriptions require API credentials"
             }),
@@ -330638,7 +330768,7 @@ function createSubscribeHandler(deps) {
               const depthLimit = parseOptionalDepthLimit(options?.depthLimit ?? options?.limit);
               const orderbook = depthLimit === undefined ? await broker.watchOrderBook(resolvedSymbol) : await broker.watchOrderBook(resolvedSymbol, depthLimit);
               const receivedTimestamp = Date.now();
-              if (!writeSubscribeFrame(call, isStreamClosed, {
+              if (!await writeSubscribeFrame(call, isStreamClosed, {
                 data: JSON.stringify(normalizeOrderBookSnapshot(orderbook, {
                   exchange: normalizedCex,
                   symbol: resolvedSymbol,
@@ -330655,7 +330785,7 @@ function createSubscribeHandler(deps) {
           } catch (error48) {
             log.error(`Error fetching orderbook for ${resolvedSymbol} on ${cex3}:`, error48);
             const message = getErrorMessage(error48);
-            writeSubscribeError(call, isStreamClosed, {
+            await writeSubscribeError(call, isStreamClosed, {
               data: JSON.stringify({
                 error: `Failed to fetch orderbook: ${message}`
               }),
@@ -330671,7 +330801,7 @@ function createSubscribeHandler(deps) {
           } catch (error48) {
             const message = getErrorMessage(error48);
             log.error(`Error fetching trades for ${resolvedSymbol} on ${cex3}:`, error48);
-            writeSubscribeError(call, isStreamClosed, {
+            await writeSubscribeError(call, isStreamClosed, {
               data: JSON.stringify({
                 error: `Failed to fetch trades: ${message}`
               }),
@@ -330687,7 +330817,7 @@ function createSubscribeHandler(deps) {
           } catch (error48) {
             const message = getErrorMessage(error48);
             log.error(`Error fetching ticker for ${resolvedSymbol} on ${cex3}:`, error48);
-            writeSubscribeError(call, isStreamClosed, {
+            await writeSubscribeError(call, isStreamClosed, {
               data: JSON.stringify({
                 error: `Failed to fetch ticker: ${message}`
               }),
@@ -330704,7 +330834,7 @@ function createSubscribeHandler(deps) {
           } catch (error48) {
             log.error(`Error fetching OHLCV for ${resolvedSymbol} on ${cex3}:`, error48);
             const message = getErrorMessage(error48);
-            writeSubscribeError(call, isStreamClosed, {
+            await writeSubscribeError(call, isStreamClosed, {
               data: JSON.stringify({
                 error: `Failed to fetch OHLCV: ${message}`
               }),
@@ -330720,7 +330850,7 @@ function createSubscribeHandler(deps) {
           } catch (error48) {
             const message = getErrorMessage(error48);
             log.error(`Error fetching balance for ${cex3}:`, error48);
-            writeSubscribeError(call, isStreamClosed, {
+            await writeSubscribeError(call, isStreamClosed, {
               data: JSON.stringify({
                 error: `Failed to fetch balance: ${message}`
               }),
@@ -330736,7 +330866,7 @@ function createSubscribeHandler(deps) {
           } catch (error48) {
             log.error(`Error fetching orders for ${resolvedSymbol} on ${cex3}:`, error48);
             const message = getErrorMessage(error48);
-            writeSubscribeError(call, isStreamClosed, {
+            await writeSubscribeError(call, isStreamClosed, {
               data: JSON.stringify({
                 error: `Failed to fetch orders: ${message}`
               }),
@@ -330747,7 +330877,7 @@ function createSubscribeHandler(deps) {
           }
           break;
         default:
-          writeSubscribeError(call, isStreamClosed, {
+          await writeSubscribeError(call, isStreamClosed, {
             data: JSON.stringify({ error: "Invalid subscription type" }),
             timestamp: Date.now(),
             symbol: symbol2,
@@ -330757,7 +330887,7 @@ function createSubscribeHandler(deps) {
     } catch (error48) {
       log.error("Error in Subscribe stream:", error48);
       const message = getErrorMessage(error48);
-      writeSubscribeError(call, isStreamClosed, {
+      await writeSubscribeError(call, isStreamClosed, {
         data: JSON.stringify({ error: `Internal server error: ${message}` }),
         timestamp: Date.now(),
         symbol: "",

package/dist/helpers/binance-user-data-stream.d.ts

@@ -1,22 +1,39 @@
 import type { Exchange } from "@usherlabs/ccxt";
 export declare const BINANCE_SPOT_WS_API_URL = "wss://ws-api.binance.com:443/ws-api/v3";
+export declare const DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS = 16;
 export type BinanceUserDataEvent = {
     subscriptionId: number;
     event: Record<string, unknown>;
 };
+type WebSocketLike = {
+    on(event: "open", listener: () => void): unknown;
+    on(event: "message", listener: (data: unknown) => void): unknown;
+    on(event: "error", listener: (error: unknown) => void): unknown;
+    on(event: "close", listener: (code: unknown, reason: unknown) => void): unknown;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+};
+type WebSocketFactory = (url: string) => WebSocketLike;
+type BinanceSpotUserDataStreamOptions = {
+    maxBufferedEvents?: number;
+};
+export declare function setBinanceUserDataWebSocketFactoryForTests(factory: WebSocketFactory): () => void;
 export declare function getBinanceSpotWsApiUrl(exchange: Exchange): string;
 export declare class BinanceSpotUserDataStream implements AsyncIterable<BinanceUserDataEvent> {
     private readonly exchange;
     private readonly ws;
+    private readonly secretValues;
     private readonly requestId;
+    private readonly maxBufferedEvents;
     private readonly queue;
     private readonly waiters;
     private closed;
     private closeError;
     private subscriptionId;
-    constructor(exchange: Exchange);
+    constructor(exchange: Exchange, options?: BinanceSpotUserDataStreamOptions);
     [Symbol.asyncIterator](): AsyncIterator<BinanceUserDataEvent>;
     close(): void;
+    private handleClose;
     private subscribe;
     private handleMessage;
     private push;
@@ -26,3 +43,4 @@ export declare class BinanceSpotUserDataStream implements AsyncIterable<BinanceU
 }
 export declare function isBinanceBalanceUserDataEvent(event: Record<string, unknown>): boolean;
 export declare function isBinanceOrderUserDataEvent(event: Record<string, unknown>): boolean;
+export {};