@usherlabs/cex-broker 0.2.13 → 0.2.15

package/dist/helpers/travel-rule.d.ts

@@ -0,0 +1,44 @@
+import type { Exchange } from "@usherlabs/ccxt";
+import Joi from "joi";
+import type { PolicyConfig, TravelRuleQuestionnaire } from "../types";
+export declare const australiaQuestionnaireSchema: Joi.ObjectSchema<any>;
+export type TravelRuleDecision = {
+    mode: "standard";
+} | {
+    mode: "localentity";
+    questionnaire: TravelRuleQuestionnaire;
+} | {
+    mode: "denied";
+    error: string;
+};
+/**
+ * Decides whether a withdrawal must use Binance's travel-rule endpoint.
+ *
+ * Travel rule is opt-in per exchange via the `enabled` flag, so a non-AU account
+ * keeps using the standard endpoint. When enabled, the destination address must
+ * have a configured questionnaire; if it does not we fail closed rather than fall
+ * back to the standard endpoint (which would just reproduce the -4104 rejection).
+ */
+export declare function resolveTravelRuleDecision(policy: PolicyConfig, exchange: string, recipientAddress: string): TravelRuleDecision;
+/**
+ * Registers Binance's `localentity/withdraw/apply` endpoint on the exchange
+ * instance. No-op for non-Binance exchanges. Idempotent — ccxt just reassigns
+ * the generated implicit method if called again.
+ */
+export declare function registerBinanceTravelRuleWithdrawEndpoint(exchange: Exchange): void;
+type LocalEntityWithdrawArgs = {
+    code: string;
+    amount: number;
+    address: string;
+    network: string;
+    questionnaire: TravelRuleQuestionnaire;
+    params?: Record<string, string | number>;
+};
+/**
+ * Mirrors ccxt's `binance.withdraw` currency/network/precision handling, but
+ * targets the travel-rule endpoint and attaches the questionnaire. ccxt's
+ * `urlencode` applies `encodeURIComponent` to the value, satisfying Binance's
+ * requirement that the questionnaire JSON be URL-encoded in the request body.
+ */
+export declare function withdrawViaLocalEntity(broker: Exchange, args: LocalEntityWithdrawArgs): Promise<import("@usherlabs/ccxt").Transaction>;
+export {};

package/dist/index.js

@@ -270096,11 +270096,11 @@ var ccxt = Object.assign({ version: version2, Exchange, Precise, exchanges: Obje
 var ccxt_default = ccxt;
 
 // src/index.ts
-var import_joi2 = __toESM(require_lib4(), 1);
+var import_joi3 = __toESM(require_lib4(), 1);
 import { unwatchFile, watchFile } from "fs";
 
 // src/helpers/index.ts
-var import_joi = __toESM(require_lib4(), 1);
+var import_joi2 = __toESM(require_lib4(), 1);
 import fs from "fs";
 
 // src/helpers/exchange-credentials.ts
@@ -272784,6 +272784,81 @@ if (process.env.LOG_LEVEL !== "debug") {
 }
 var log = baseLogger;
 
+// src/helpers/travel-rule.ts
+var import_joi = __toESM(require_lib4(), 1);
+var isAnotherBeneficiary = import_joi.default.number().valid(2).required();
+var isIndividual = import_joi.default.number().valid(0).required();
+var isCorporate = import_joi.default.number().valid(1).required();
+var isSendToVasp = import_joi.default.number().valid(2).required();
+var isVaspOthers = import_joi.default.string().valid("others").required();
+function requiredWhen(base2, ref, is) {
+  return base2.when(ref, {
+    is,
+    then: import_joi.default.required(),
+    otherwise: import_joi.default.forbidden()
+  });
+}
+var australiaQuestionnaireSchema = import_joi.default.object({
+  isAddressOwner: import_joi.default.number().valid(1, 2).required(),
+  sendTo: import_joi.default.number().valid(1, 2).required(),
+  declaration: import_joi.default.boolean().valid(true).required(),
+  bnfType: requiredWhen(import_joi.default.number().valid(0, 1), "isAddressOwner", isAnotherBeneficiary),
+  bnfFirstName: requiredWhen(import_joi.default.string(), "bnfType", isIndividual),
+  bnfLastName: requiredWhen(import_joi.default.string(), "bnfType", isIndividual),
+  country: requiredWhen(import_joi.default.string(), "bnfType", isIndividual),
+  city: requiredWhen(import_joi.default.string(), "bnfType", isIndividual),
+  bnfCorpName: requiredWhen(import_joi.default.string(), "bnfType", isCorporate),
+  bnfCorpCountry: requiredWhen(import_joi.default.string(), "bnfType", isCorporate),
+  bnfCorpCity: requiredWhen(import_joi.default.string(), "bnfType", isCorporate),
+  vasp: requiredWhen(import_joi.default.string(), "sendTo", isSendToVasp),
+  vaspName: requiredWhen(import_joi.default.string(), "vasp", isVaspOthers)
+});
+function resolveTravelRuleDecision(policy, exchange, recipientAddress) {
+  const rules = policy.travelRule?.rule ?? [];
+  const exchangeNorm = exchange.trim().toUpperCase();
+  const entry = rules.find((rule) => rule.exchange.trim().toUpperCase() === exchangeNorm);
+  if (!entry || !entry.enabled) {
+    return { mode: "standard" };
+  }
+  const addressNorm = recipientAddress.trim().toLowerCase();
+  const match = Object.entries(entry.addresses).find(([address]) => address.trim().toLowerCase() === addressNorm);
+  if (!match) {
+    return {
+      mode: "denied",
+      error: `no travel-rule questionnaire configured for ${exchangeNorm} address ${recipientAddress}`
+    };
+  }
+  return { mode: "localentity", questionnaire: match[1].questionnaire };
+}
+function registerBinanceTravelRuleWithdrawEndpoint(exchange) {
+  if (exchange.id !== "binance") {
+    return;
+  }
+  exchange.defineRestApi({ sapi: { post: { "localentity/withdraw/apply": 4.0002 } } }, "request");
+}
+async function withdrawViaLocalEntity(broker, args) {
+  const exchange = broker;
+  if (typeof exchange.sapiPostLocalentityWithdrawApply !== "function") {
+    throw new Error("binance_localentity_withdraw_unavailable: travel-rule withdraw endpoint is not registered on this exchange instance");
+  }
+  broker.checkAddress(args.address);
+  await broker.loadMarkets();
+  const currency = broker.currency(args.code);
+  const networks = broker.safeDict(broker.options, "networks", {});
+  const networkUpper = args.network.trim().toUpperCase();
+  const mappedNetwork = broker.safeString(networks, networkUpper, networkUpper);
+  const request = {
+    ...args.params,
+    coin: currency.id,
+    address: args.address,
+    amount: broker.currencyToPrecision(args.code, args.amount),
+    network: mappedNetwork,
+    questionnaire: JSON.stringify(args.questionnaire)
+  };
+  const response = await exchange.sapiPostLocalentityWithdrawApply(request);
+  return broker.parseTransaction(response, currency);
+}
+
 // src/helpers/broker.ts
 class BrokerAccountPreconditionError extends Error {
   constructor(message) {
@@ -272808,6 +272883,7 @@ function applyCommonExchangeConfig(exchange) {
     recvWindow: 60000,
     adjustForTimeDifference: true
   });
+  registerBinanceTravelRuleWithdrawEndpoint(exchange);
 }
 function createBroker(cex3, credsOrMetadata) {
   let apiKey;
@@ -273224,36 +273300,47 @@ var verityHttpClientOverridePredicate = ({
 function loadPolicy(policyPath) {
   try {
     const policyData = fs.readFileSync(policyPath, "utf8");
-    const withdrawRuleEntrySchema = import_joi.default.object({
-      exchange: import_joi.default.string().required(),
-      network: import_joi.default.string().required(),
-      whitelist: import_joi.default.array().items(import_joi.default.string()).required(),
-      coins: import_joi.default.array().items(import_joi.default.string()).optional()
+    const withdrawRuleEntrySchema = import_joi2.default.object({
+      exchange: import_joi2.default.string().required(),
+      network: import_joi2.default.string().required(),
+      whitelist: import_joi2.default.array().items(import_joi2.default.string()).required(),
+      coins: import_joi2.default.array().items(import_joi2.default.string()).optional()
     });
-    const depositRuleEntrySchema = import_joi.default.object({
-      exchange: import_joi.default.string().required(),
-      network: import_joi.default.string().required(),
-      coins: import_joi.default.array().items(import_joi.default.string()).optional()
+    const depositRuleEntrySchema = import_joi2.default.object({
+      exchange: import_joi2.default.string().required(),
+      network: import_joi2.default.string().required(),
+      coins: import_joi2.default.array().items(import_joi2.default.string()).optional()
     });
-    const orderRuleSchema = import_joi.default.object({
-      markets: import_joi.default.array().items(import_joi.default.string()).required(),
-      limits: import_joi.default.array().items(import_joi.default.object({
-        from: import_joi.default.string().required(),
-        to: import_joi.default.string().required(),
-        min: import_joi.default.number().required(),
-        max: import_joi.default.number().required()
+    const orderRuleSchema = import_joi2.default.object({
+      markets: import_joi2.default.array().items(import_joi2.default.string()).required(),
+      limits: import_joi2.default.array().items(import_joi2.default.object({
+        from: import_joi2.default.string().required(),
+        to: import_joi2.default.string().required(),
+        min: import_joi2.default.number().required(),
+        max: import_joi2.default.number().required()
       })).default([])
     });
-    const policyConfigSchema = import_joi.default.object({
-      withdraw: import_joi.default.object({
-        rule: import_joi.default.array().items(withdrawRuleEntrySchema).min(1).required()
+    const travelRuleEntrySchema = import_joi2.default.object({
+      exchange: import_joi2.default.string().uppercase().valid("BINANCE").required(),
+      enabled: import_joi2.default.boolean().required(),
+      description: import_joi2.default.string().optional(),
+      addresses: import_joi2.default.object().pattern(import_joi2.default.string(), import_joi2.default.object({
+        questionnaire: australiaQuestionnaireSchema.required()
+      })).required()
+    });
+    const policyConfigSchema = import_joi2.default.object({
+      withdraw: import_joi2.default.object({
+        rule: import_joi2.default.array().items(withdrawRuleEntrySchema).min(1).required()
       }).required(),
-      deposit: import_joi.default.object({
-        rule: import_joi.default.array().items(depositRuleEntrySchema).optional()
+      deposit: import_joi2.default.object({
+        rule: import_joi2.default.array().items(depositRuleEntrySchema).optional()
       }).required(),
-      order: import_joi.default.object({
+      order: import_joi2.default.object({
         rule: orderRuleSchema.required()
-      }).required()
+      }).required(),
+      travelRule: import_joi2.default.object({
+        rule: import_joi2.default.array().items(travelRuleEntrySchema).required()
+      }).optional()
     });
     const { error, value } = policyConfigSchema.validate(JSON.parse(policyData));
     if (error) {
@@ -293067,8 +293154,22 @@ async function handleWithdraw(ctx) {
       message: `policy_withdrawal_denied: ${transferValidation.error}`
     }, null);
   }
+  const travelRule = resolveTravelRuleDecision(policy, cex3, transferValue.recipientAddress);
+  if (travelRule.mode === "denied") {
+    return ctx.wrappedCallback({
+      code: grpc10.status.FAILED_PRECONDITION,
+      message: `travel_rule_denied: ${travelRule.error}`
+    }, null);
+  }
   try {
-    const transaction = await broker.withdraw(symbol2, transferValue.amount, transferValue.recipientAddress, undefined, {
+    const transaction = travelRule.mode === "localentity" ? await withdrawViaLocalEntity(broker, {
+      code: symbol2,
+      amount: transferValue.amount,
+      address: transferValue.recipientAddress,
+      network: withdrawNetwork.exchangeNetworkId,
+      questionnaire: travelRule.questionnaire,
+      params: transferValue.params
+    }) : await broker.withdraw(symbol2, transferValue.amount, transferValue.recipientAddress, undefined, {
       ...transferValue.params ?? {},
       network: withdrawNetwork.exchangeNetworkId
     });
@@ -293238,15 +293339,12 @@ function createExecuteActionHandler(deps) {
 import * as grpc13 from "@grpc/grpc-js";
 
 // src/helpers/binance-user-data-stream.ts
+import { Buffer as Buffer2 } from "buffer";
 import { createHmac } from "crypto";
+import WebSocket2 from "ws";
 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 WebSocket2(url3);
 function getExchangeString(exchange, key) {
   const value = exchange[key];
   if (typeof value !== "string" || value.length === 0) {
@@ -293272,24 +293370,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) {
@@ -293305,11 +293485,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, {
@@ -293323,9 +293510,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;
@@ -293348,11 +293539,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() {
@@ -293376,6 +293574,7 @@ class BinanceSpotUserDataStream {
     }
     this.closeError = error48;
     this.closed = true;
+    this.queue.length = 0;
     this.flushWaiters();
     try {
       this.ws.close();
@@ -293403,16 +293602,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();
   }
 }
@@ -293459,7 +293691,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
@@ -293478,7 +293710,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,
@@ -293544,7 +293776,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"
           }),
@@ -293558,7 +293790,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"
           }),
@@ -293571,7 +293803,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"
             }),
@@ -293591,7 +293823,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,
@@ -293608,7 +293840,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}`
               }),
@@ -293624,7 +293856,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}`
               }),
@@ -293640,7 +293872,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}`
               }),
@@ -293657,7 +293889,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}`
               }),
@@ -293673,7 +293905,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}`
               }),
@@ -293689,7 +293921,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}`
               }),
@@ -293700,7 +293932,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,
@@ -293710,7 +293942,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: "",
@@ -294085,20 +294317,20 @@ class CEXBroker {
     this.brokers = createBrokerPool(configMap);
   }
   loadExchangeCredentials(creds) {
-    const schema = import_joi2.default.object().pattern(import_joi2.default.string().allow(...BrokerList).required(), import_joi2.default.object({
-      apiKey: import_joi2.default.string().required(),
-      apiSecret: import_joi2.default.string().required(),
-      role: import_joi2.default.string().valid("master", "subaccount").optional(),
-      email: import_joi2.default.string().optional(),
-      subAccountId: import_joi2.default.string().optional(),
-      uid: import_joi2.default.string().optional(),
-      secondaryKeys: import_joi2.default.array().items(import_joi2.default.object({
-        apiKey: import_joi2.default.string().required(),
-        apiSecret: import_joi2.default.string().required(),
-        role: import_joi2.default.string().valid("master", "subaccount").optional(),
-        email: import_joi2.default.string().optional(),
-        subAccountId: import_joi2.default.string().optional(),
-        uid: import_joi2.default.string().optional()
+    const schema = import_joi3.default.object().pattern(import_joi3.default.string().allow(...BrokerList).required(), import_joi3.default.object({
+      apiKey: import_joi3.default.string().required(),
+      apiSecret: import_joi3.default.string().required(),
+      role: import_joi3.default.string().valid("master", "subaccount").optional(),
+      email: import_joi3.default.string().optional(),
+      subAccountId: import_joi3.default.string().optional(),
+      uid: import_joi3.default.string().optional(),
+      secondaryKeys: import_joi3.default.array().items(import_joi3.default.object({
+        apiKey: import_joi3.default.string().required(),
+        apiSecret: import_joi3.default.string().required(),
+        role: import_joi3.default.string().valid("master", "subaccount").optional(),
+        email: import_joi3.default.string().optional(),
+        subAccountId: import_joi3.default.string().optional(),
+        uid: import_joi3.default.string().optional()
       })).default([])
     })).required();
     const { value, error: error48 } = schema.validate(creds);
@@ -294185,4 +294417,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=18334E4E9BE8A34F64756E2164756E21
+//# debugId=8F76D79C41F9E70764756E2164756E21