@usherlabs/cex-broker 0.2.38 → 0.2.41

package/dist/index.js

@@ -4,25 +4,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -26363,7 +26381,7 @@ var require_tracestate_impl = __commonJS((exports) => {
           const value = listMember.slice(i2 + 1, part.length);
           if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value)) {
             agg.set(key, value);
-          } else {}
+          }
         }
         return agg;
       }, new Map);
@@ -35496,7 +35514,7 @@ var require_TraceState = __commonJS((exports) => {
           const value = listMember.slice(i2 + 1, part.length);
           if ((0, validators_1.validateKey)(key) && (0, validators_1.validateValue)(value)) {
             agg.set(key, value);
-          } else {}
+          }
         }
         return agg;
       }, new Map);
@@ -291220,7 +291238,9 @@ function buildMarketMetadataSnapshotRow(input) {
 // src/helpers/broker-execution-archive/writer.ts
 var import_api_logs2 = __toESM(require_src4(), 1);
 import { closeSync, fsyncSync, openSync, writeSync } from "node:fs";
-import { request as httpRequest2 } from "node:http";
+import {
+  request as httpRequest2
+} from "node:http";
 import { request as httpsRequest2 } from "node:https";
 var BROKER_EXECUTION_ARCHIVE_TABLES = new Set([
   "broker_execution.order_events",
@@ -291293,6 +291313,7 @@ class BrokerExecutionArchiver {
   flushIntervalMs;
   forwarderTimeoutMs;
   queue = [];
+  enqueueTimes = new WeakMap;
   stats = {
     enqueued: 0,
     shed: 0,
@@ -291301,6 +291322,16 @@ class BrokerExecutionArchiver {
   };
   flushTimer = null;
   flushInFlight = null;
+  inFlightBatch = null;
+  inFlightStartedAtMs = null;
+  lastFailureAtMs = null;
+  lastShedAtMs = null;
+  lastSuccessAtMs = null;
+  lastFailureEventSequence = null;
+  lastShedEventSequence = null;
+  lastSuccessEventSequence = null;
+  lastSinkLatencyMs = null;
+  healthEventSequence = 0;
   lastShedWarnAtMs = 0;
   closing = false;
   closed = false;
@@ -291334,6 +291365,7 @@ class BrokerExecutionArchiver {
     }
     try {
       this.flushTimer = setInterval(() => {
+        this.emitArchiveHealthMetrics();
         this.flush();
       }, this.flushIntervalMs);
       this.flushTimer.unref?.();
@@ -291377,32 +291409,34 @@ class BrokerExecutionArchiver {
       row: { ...row.row, source: this.source }
     };
     if (this.queue.length >= this.maxQueueSize) {
-      const shedRow = this.queue[0];
-      if (shedRow) {
-        this.appendLossRecords([shedRow], "queue_shed");
+      const shedEntry = this.queue[0];
+      if (shedEntry) {
+        this.appendLossRecords([shedEntry], "queue_shed");
         this.queue.shift();
       }
       this.stats.shed += 1;
+      this.recordHealthEvent("shed");
       this.recordArchiveMetric("cex_archive_rows_shed_total", {
-        table: shedRow?.table ?? "unknown",
+        table: shedEntry?.table ?? "unknown",
         source: this.source,
-        feed: shedRow ? archiveFeed(shedRow) : "NON_MARKET"
+        feed: shedEntry ? archiveFeed(shedEntry) : "NON_MARKET"
       });
       this.recordArchiveMetric("cex_archive_queue_saturated_rows_total", {
-        table: shedRow?.table ?? "unknown",
+        table: shedEntry?.table ?? "unknown",
         source: this.source,
-        feed: shedRow ? archiveFeed(shedRow) : "NON_MARKET"
+        feed: shedEntry ? archiveFeed(shedEntry) : "NON_MARKET"
       });
       const now3 = Date.now();
       if (now3 - this.lastShedWarnAtMs >= SHED_WARN_INTERVAL_MS) {
         log.warn("Archive queue full: shedding oldest rows", {
           shed_total: this.stats.shed,
           queue_max: this.maxQueueSize,
-          table: shedRow?.table ?? "unknown"
+          table: shedEntry?.table ?? "unknown"
         });
         this.lastShedWarnAtMs = now3;
       }
     }
+    this.enqueueTimes.set(archiveRow, Date.now());
     this.queue.push(archiveRow);
     this.stats.enqueued += 1;
     this.recordArchiveMetric("cex_archive_rows_enqueued_total", {
@@ -291410,6 +291444,7 @@ class BrokerExecutionArchiver {
       source: this.source,
       feed: archiveFeed(archiveRow)
     });
+    this.emitArchiveHealthMetrics();
     if (this.queue.length >= this.batchSize) {
       this.flush();
     }
@@ -291424,14 +291459,19 @@ class BrokerExecutionArchiver {
     if (this.flushInFlight) {
       return this.flushInFlight;
     }
+    const inFlightState = {};
     const inFlight = this.flushBatch().then(() => {
       return;
     }).finally(() => {
+      if (this.flushInFlight !== inFlightState.promise) {
+        return;
+      }
       this.flushInFlight = null;
       if (!this.closed && !this.closing && this.enabled && this.queue.length >= this.batchSize) {
         queueMicrotask(() => void this.flush());
       }
     });
+    inFlightState.promise = inFlight;
     this.flushInFlight = inFlight;
     return inFlight;
   }
@@ -291478,6 +291518,79 @@ class BrokerExecutionArchiver {
   getQueueDepth() {
     return this.queue.length;
   }
+  getHealthSnapshot() {
+    const now3 = Date.now();
+    const oldestPendingAtMs = this.oldestPendingEnqueueAtMs();
+    const oldestPendingAgeMs = oldestPendingAtMs === null ? 0 : Math.max(0, now3 - oldestPendingAtMs);
+    const inFlightAgeMs = this.inFlightStartedAtMs === null ? 0 : Math.max(0, now3 - this.inFlightStartedAtMs);
+    const lastUnhealthyEventSequence = Math.max(this.lastFailureEventSequence ?? Number.NEGATIVE_INFINITY, this.lastShedEventSequence ?? Number.NEGATIVE_INFINITY);
+    const recoveredFromEvents = lastUnhealthyEventSequence === Number.NEGATIVE_INFINITY || this.lastSuccessEventSequence !== null && this.lastSuccessEventSequence > lastUnhealthyEventSequence;
+    const healthy = this.enabled && !this.closing && !this.closed && this.queue.length < this.maxQueueSize && oldestPendingAgeMs <= this.forwarderTimeoutMs && inFlightAgeMs <= this.forwarderTimeoutMs && recoveredFromEvents;
+    return {
+      healthy,
+      queue_depth: this.queue.length,
+      oldest_pending_age_ms: oldestPendingAgeMs,
+      shed_total: this.stats.shed,
+      last_failure_at: this.lastFailureAtMs,
+      last_shed_at: this.lastShedAtMs,
+      last_success_at: this.lastSuccessAtMs,
+      sink_latency_ms: this.lastSinkLatencyMs,
+      sink_errors_total: this.stats.forwarderFailures,
+      in_flight: this.inFlightBatch !== null,
+      in_flight_age_ms: inFlightAgeMs
+    };
+  }
+  oldestPendingEnqueueAtMs() {
+    let oldest = null;
+    for (const entry of this.queue) {
+      const enqueuedAtMs = this.enqueueTimes.get(entry);
+      if (enqueuedAtMs === undefined) {
+        continue;
+      }
+      oldest = oldest === null ? enqueuedAtMs : Math.min(oldest, enqueuedAtMs);
+    }
+    for (const entry of this.inFlightBatch ?? []) {
+      const enqueuedAtMs = this.enqueueTimes.get(entry);
+      if (enqueuedAtMs === undefined) {
+        continue;
+      }
+      oldest = oldest === null ? enqueuedAtMs : Math.min(oldest, enqueuedAtMs);
+    }
+    return oldest;
+  }
+  recordHealthEvent(event) {
+    const eventSequence = ++this.healthEventSequence;
+    const eventTimestampMs = Date.now();
+    switch (event) {
+      case "failure":
+        this.lastFailureAtMs = eventTimestampMs;
+        this.lastFailureEventSequence = eventSequence;
+        return;
+      case "shed":
+        this.lastShedAtMs = eventTimestampMs;
+        this.lastShedEventSequence = eventSequence;
+        return;
+      case "success":
+        this.lastSuccessAtMs = eventTimestampMs;
+        this.lastSuccessEventSequence = eventSequence;
+        return;
+    }
+  }
+  emitArchiveHealthMetrics() {
+    const snapshot = this.getHealthSnapshot();
+    const labels = { source: this.source };
+    this.recordArchiveObservableGauge("cex_archive_health", snapshot.healthy ? 1 : 0, labels);
+    this.recordArchiveGauge("cex_archive_queue_depth", snapshot.queue_depth, labels);
+    this.recordArchiveGauge("cex_archive_oldest_pending_age_ms", snapshot.oldest_pending_age_ms, labels);
+    this.recordArchiveGauge("cex_archive_shed_total", snapshot.shed_total, labels);
+    this.recordArchiveGauge("cex_archive_last_failure_at", snapshot.last_failure_at ?? 0, labels);
+    this.recordArchiveGauge("cex_archive_last_shed_at", snapshot.last_shed_at ?? 0, labels);
+    this.recordArchiveGauge("cex_archive_last_success_at", snapshot.last_success_at ?? 0, labels);
+    this.recordArchiveGauge("cex_archive_sink_latency_ms", snapshot.sink_latency_ms ?? 0, labels);
+    this.recordArchiveGauge("cex_archive_sink_errors_total", snapshot.sink_errors_total, labels);
+    this.recordArchiveGauge("cex_archive_in_flight", snapshot.in_flight ? 1 : 0, labels);
+    this.recordArchiveGauge("cex_archive_in_flight_age_ms", snapshot.in_flight_age_ms, labels);
+  }
   closeLossJournal() {
     if (this.deadLetterFd === undefined) {
       return;
@@ -291500,8 +291613,9 @@ class BrokerExecutionArchiver {
       this.appendLossRecords([dropped], "queue_shed");
       this.queue.shift();
       this.stats.shed += 1;
+      this.recordHealthEvent("shed");
       this.recordArchiveMetric("cex_archive_rows_shed_total", {
-        table: dropped?.table ?? "unknown",
+        table: dropped.table,
         source: this.source,
         feed: archiveFeed(dropped)
       });
@@ -291560,6 +291674,8 @@ class BrokerExecutionArchiver {
     if (batch.length === 0) {
       return true;
     }
+    this.inFlightBatch = batch;
+    this.inFlightStartedAtMs = Date.now();
     for (const entry of batch) {
       if (isBrokerExecutionArchiveTable(entry.table)) {
         this.emitOtelLog(entry);
@@ -291570,8 +291686,15 @@ class BrokerExecutionArchiver {
         await this.postToForwarder(batch);
       } catch (error) {
         this.stats.forwarderFailures += 1;
-        this.queue.push(...batch);
-        this.enforceQueueBound();
+        this.recordHealthEvent("failure");
+        this.lastSinkLatencyMs = Math.max(0, Date.now() - (this.inFlightStartedAtMs ?? Date.now()));
+        this.queue.unshift(...batch);
+        try {
+          this.enforceQueueBound();
+        } finally {
+          this.clearInFlightBatch(batch);
+          this.emitArchiveHealthMetrics();
+        }
         this.recordArchiveMetric("cex_archive_forwarder_failures_total", {
           count: batch.length
         });
@@ -291580,14 +291703,26 @@ class BrokerExecutionArchiver {
       }
     }
     this.stats.flushed += batch.length;
+    this.recordHealthEvent("success");
+    this.lastSinkLatencyMs = Math.max(0, Date.now() - (this.inFlightStartedAtMs ?? Date.now()));
+    this.clearInFlightBatch(batch);
     this.recordFlushHealth(batch);
+    this.emitArchiveHealthMetrics();
     return true;
   }
+  clearInFlightBatch(batch) {
+    if (this.inFlightBatch !== batch) {
+      return;
+    }
+    this.inFlightBatch = null;
+    this.inFlightStartedAtMs = null;
+  }
   recordFlushHealth(batch) {
     const countByTable = new Map;
     for (const entry of batch) {
-      const key = `${entry.table}\x00${archiveFeed(entry)}`;
-      const grouped = countByTable.get(key) ?? { row: entry, count: 0 };
+      const row = entry;
+      const key = `${row.table}\x00${archiveFeed(row)}`;
+      const grouped = countByTable.get(key) ?? { row, count: 0 };
       grouped.count += 1;
       countByTable.set(key, grouped);
     }
@@ -291605,9 +291740,14 @@ class BrokerExecutionArchiver {
       await this.otelMetrics?.recordCounter(metricName, value, labels);
     } catch {}
   }
-  async recordArchiveGauge(metricName, value) {
+  async recordArchiveGauge(metricName, value, labels = {}) {
+    try {
+      await this.otelMetrics?.recordGauge(metricName, value, labels);
+    } catch {}
+  }
+  async recordArchiveObservableGauge(metricName, value, labels) {
     try {
-      await this.otelMetrics?.recordGauge(metricName, value, {});
+      await this.otelMetrics?.setObservableGauge(metricName, value, labels);
     } catch {}
   }
   emitOtelLog(entry) {
@@ -291644,27 +291784,136 @@ class BrokerExecutionArchiver {
       headers.authorization = `Bearer ${this.forwarderAuthToken}`;
     }
     return new Promise((resolve, reject) => {
-      const req = doRequest(url2, {
-        method: "POST",
-        headers,
-        timeout: this.forwarderTimeoutMs
-      }, (res) => {
-        res.on("data", () => {});
-        res.on("end", () => {
-          const status = res.statusCode ?? 0;
-          if (status < 200 || status >= 300) {
-            reject(new Error(`Archive forwarder returned ${status} ${res.statusMessage ?? ""}`));
-            return;
-          }
+      let req;
+      let response;
+      let settled = false;
+      let requestClosed = false;
+      let requestCloseFailureScheduled = false;
+      let responseClosed = false;
+      let responseEnded = false;
+      let outerTimer;
+      function cleanupRequestListeners() {
+        req?.removeListener("error", onRequestError);
+        req?.removeListener("timeout", onRequestTimeout);
+        req?.removeListener("close", onRequestClose);
+      }
+      function cleanupResponseListeners() {
+        response?.removeListener("data", onResponseData);
+        response?.removeListener("end", onResponseEnd);
+        response?.removeListener("aborted", onResponseAborted);
+        response?.removeListener("error", onResponseError);
+        response?.removeListener("close", onResponseClose);
+      }
+      function onRequestClose() {
+        requestClosed = true;
+        if (!settled && !response && !requestCloseFailureScheduled) {
+          requestCloseFailureScheduled = true;
+          queueMicrotask(() => {
+            if (!settled && !response) {
+              settle2(new Error("Archive forwarder request closed before response headers"), false, true);
+            }
+          });
+        }
+        if (settled) {
+          cleanupRequestListeners();
+        }
+      }
+      function onRequestError(error) {
+        if (!settled) {
+          settle2(error, true);
+        } else {
+          cleanupRequestListeners();
+        }
+      }
+      function onRequestTimeout() {
+        settle2(new Error("Archive forwarder socket timed out"), true);
+      }
+      function onResponseData() {}
+      function onResponseEnd() {
+        responseEnded = true;
+        if (!response?.complete) {
+          settle2(new Error("Archive forwarder response was incomplete"), true);
+          return;
+        }
+        const status = response.statusCode ?? 0;
+        if (status < 200 || status >= 300) {
+          settle2(new Error(`Archive forwarder returned ${status} ${response.statusMessage ?? ""}`), false);
+          return;
+        }
+        settle2(undefined, false);
+      }
+      function onResponseAborted() {
+        settle2(new Error("Archive forwarder response was aborted"), true);
+      }
+      function onResponseError(error) {
+        if (!settled) {
+          settle2(error, true);
+        }
+      }
+      function onResponseClose() {
+        responseClosed = true;
+        if (!settled && !responseEnded) {
+          settle2(new Error("Archive forwarder response closed before completion"), true);
+          return;
+        }
+        cleanupResponseListeners();
+      }
+      function settle2(error, destroyRequest, retainClosedRequestError = false) {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        if (outerTimer) {
+          clearTimeout(outerTimer);
+          outerTimer = undefined;
+        }
+        response?.removeListener("data", onResponseData);
+        response?.removeListener("end", onResponseEnd);
+        response?.removeListener("aborted", onResponseAborted);
+        if (responseClosed) {
+          cleanupResponseListeners();
+        }
+        if (destroyRequest && req && !requestClosed) {
+          req.destroy(error);
+        } else if (retainClosedRequestError && req && requestClosed) {
+          req.removeListener("timeout", onRequestTimeout);
+          req.removeListener("close", onRequestClose);
+        } else if (!req || requestClosed) {
+          cleanupRequestListeners();
+        }
+        if (error) {
+          reject(error);
+        } else {
           resolve();
+        }
+      }
+      outerTimer = setTimeout(() => {
+        settle2(new Error("Archive forwarder request deadline exceeded"), true);
+      }, this.forwarderTimeoutMs);
+      try {
+        req = doRequest(url2, {
+          method: "POST",
+          headers,
+          timeout: this.forwarderTimeoutMs
+        }, (nextResponse) => {
+          response = nextResponse;
+          response.on("data", onResponseData);
+          response.on("end", onResponseEnd);
+          response.on("aborted", onResponseAborted);
+          response.on("error", onResponseError);
+          response.on("close", onResponseClose);
+          if (settled) {
+            response.resume();
+          }
         });
-      });
-      req.on("error", reject);
-      req.on("timeout", () => {
-        req.destroy(new Error("Archive forwarder request timed out"));
-      });
-      req.write(body);
-      req.end();
+        req.on("error", onRequestError);
+        req.on("timeout", onRequestTimeout);
+        req.on("close", onRequestClose);
+        req.write(body);
+        req.end();
+      } catch (error) {
+        settle2(error instanceof Error ? error : new Error(String(error)), true);
+      }
     });
   }
 }
@@ -292137,9 +292386,18 @@ class AccountBalanceArchivePoller {
 // src/helpers/deposit-archive-poller.ts
 var DEFAULT_CONFIG2 = {
   pollIntervalMs: 60000,
+  fetchTimeoutMs: 30000,
   lookbackMs: 24 * 60 * 60 * 1000,
   depositsLimit: 50
 };
+function withTimeout(promise, timeoutMs, label) {
+  let timer;
+  const expiry = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    timer.unref?.();
+  });
+  return Promise.race([promise, expiry]).finally(() => clearTimeout(timer));
+}
 var ALL_CURRENCIES_CODE = "*";
 function depositTimestamp(record) {
   const observedAt = depositField(record, [
@@ -292252,6 +292510,14 @@ class DepositArchivePoller {
     return true;
   }
   async#pollOne(target) {
+    let outcome = "error";
+    try {
+      outcome = await this.#pollTarget(target);
+    } finally {
+      this.params.metrics?.recordCounter("cex_deposit_poller_polls_total", 1, { exchange: target.exchangeId, outcome });
+    }
+  }
+  async#pollTarget(target) {
     const exchange = target.account.exchange;
     const key = this.#targetKey(target);
     if (typeof exchange.fetchDeposits !== "function" || exchange.has?.fetchDeposits === false) {
@@ -292262,12 +292528,12 @@ class DepositArchivePoller {
           account: target.account.label
         });
       }
-      return;
+      return "unsupported";
     }
     const since = this.#cursors.get(key) ?? Date.now() - this.#config.lookbackMs;
     let deposits;
     try {
-      deposits = await exchange.fetchDeposits(undefined, since, this.#config.depositsLimit);
+      deposits = await withTimeout(exchange.fetchDeposits(undefined, since, this.#config.depositsLimit), this.#config.fetchTimeoutMs, "fetchDeposits");
     } catch (error) {
       this.params.metrics?.recordCounter("cex_deposit_poller_errors_total", 1, { exchange: target.exchangeId });
       log.warn("Deposit archive poll failed", {
@@ -292275,10 +292541,10 @@ class DepositArchivePoller {
         account: target.account.label,
         error
       });
-      return;
+      return "error";
     }
     if (!Array.isArray(deposits) || deposits.length === 0) {
-      return;
+      return "ok";
     }
     let archived = 0;
     for (const deposit of deposits) {
@@ -292326,7 +292592,7 @@ class DepositArchivePoller {
           network: network === undefined ? undefined : String(network),
           externalId: depositTxid,
           txid: depositTxid,
-          exchangeTimestamp: typeof creditedAt === "string" ? creditedAt : undefined,
+          exchangeTimestamp: normalizeTimestamp2(creditedAt),
           payload: record
         }
       }));
@@ -292359,6 +292625,7 @@ class DepositArchivePoller {
         this.#lastArchivedByTarget.delete(key);
       }
     }
+    return "ok";
   }
   #targetKey(target) {
     return `${target.exchangeId}|${target.account.label}|${target.code}`;
@@ -292500,6 +292767,309 @@ class FillArchivePoller {
   }
 }
 
+// src/helpers/market-data-archive/capture-contract.ts
+import { createHash as createHash3 } from "node:crypto";
+var MARKET_CAPTURE_SCHEMA_VERSION = "1.0.0";
+var CHECKSUM_ALGORITHM = "sha256-canonical-json-v1";
+var ARCHIVE_SOURCES = ["broker_read", "broker_write"];
+var CAPTURE_FEEDS = [
+  "ORDERBOOK",
+  "TICKER",
+  "TRADES",
+  "OHLCV"
+];
+var SOURCE_MODES = [
+  "broker_live_stream_v1",
+  "broker_live_sampling_v1",
+  "broker_current_snapshot_v1",
+  "broker_bootstrap_fetch_v1",
+  "external_ccxt_fallback_v1",
+  "external_hummingbot_fallback_v1",
+  "legacy_migration_v1"
+];
+var RAW_CAPTURE_SCOPES = [
+  "ccxt_normalized_object",
+  "broker_visible_payload",
+  "exchange_wire_frame"
+];
+var CHECKSUM_FIELDS = new Set([
+  "normalized_row_checksum",
+  "raw_checksum",
+  "checksum"
+]);
+function canonicalDecimal(value) {
+  if (!Number.isFinite(value)) {
+    throw new Error("Canonical numbers must be finite");
+  }
+  if (Object.is(value, -0)) {
+    return "0";
+  }
+  const rendered = String(value).toLowerCase();
+  if (!rendered.includes("e")) {
+    return rendered;
+  }
+  const [coefficient = "0", exponentText = "0"] = rendered.split("e");
+  const exponent = Number.parseInt(exponentText, 10);
+  const negative = coefficient.startsWith("-");
+  const unsigned = negative ? coefficient.slice(1) : coefficient;
+  const [integer = "0", fraction = ""] = unsigned.split(".");
+  const digits = `${integer}${fraction}`;
+  const decimalIndex = integer.length + exponent;
+  let result;
+  if (decimalIndex <= 0) {
+    result = `0.${"0".repeat(-decimalIndex)}${digits}`;
+  } else if (decimalIndex >= digits.length) {
+    result = `${digits}${"0".repeat(decimalIndex - digits.length)}`;
+  } else {
+    result = `${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
+  }
+  return negative ? `-${result}` : result;
+}
+function serializeCanonical(value, stack) {
+  if (value === null)
+    return "null";
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (typeof value === "number")
+    return canonicalDecimal(value);
+  if (typeof value === "bigint")
+    return value.toString(10);
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw new Error("Canonical timestamps must be valid");
+    }
+    return value.getTime().toString(10);
+  }
+  if (Array.isArray(value)) {
+    if (stack.has(value))
+      throw new Error("Canonical values must be acyclic");
+    stack.add(value);
+    const result = `[${value.map((entry) => entry === undefined ? "null" : serializeCanonical(entry, stack)).join(",")}]`;
+    stack.delete(value);
+    return result;
+  }
+  if (typeof value === "object") {
+    if (stack.has(value))
+      throw new Error("Canonical values must be acyclic");
+    stack.add(value);
+    const entries = Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([left], [right]) => left.localeCompare(right));
+    const result = `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${serializeCanonical(entry, stack)}`).join(",")}}`;
+    stack.delete(value);
+    return result;
+  }
+  throw new Error(`Unsupported canonical value type: ${typeof value}`);
+}
+function canonicalSerialize(value) {
+  return serializeCanonical(value, new Set);
+}
+function omitChecksumFields(value) {
+  if (Array.isArray(value))
+    return value.map(omitChecksumFields);
+  if (value && typeof value === "object" && !(value instanceof Date)) {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !CHECKSUM_FIELDS.has(key)).map(([key, entry]) => [key, omitChecksumFields(entry)]));
+  }
+  return value;
+}
+function sha256Canonical(value) {
+  return createHash3("sha256").update(canonicalSerialize(omitChecksumFields(value))).digest("hex");
+}
+function normalizeTimestampMs(value, field) {
+  let timestamp;
+  if (value instanceof Date) {
+    timestamp = value.getTime();
+  } else if (typeof value === "number") {
+    timestamp = value;
+  } else if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    timestamp = Number(value.trim());
+  } else if (typeof value === "string") {
+    timestamp = Date.parse(value);
+  } else {
+    timestamp = Number.NaN;
+  }
+  if (!Number.isSafeInteger(timestamp) || timestamp < 0) {
+    throw new Error(`${field} must be a non-negative millisecond timestamp`);
+  }
+  return timestamp;
+}
+function assertCaptureContext(context2) {
+  if (!ARCHIVE_SOURCES.includes(context2.source)) {
+    throw new Error(`Unsupported archive source: ${context2.source}`);
+  }
+  if (!CAPTURE_FEEDS.includes(context2.feed)) {
+    throw new Error(`Unsupported capture feed: ${context2.feed}`);
+  }
+  if (!SOURCE_MODES.includes(context2.sourceMode)) {
+    throw new Error(`Unsupported source mode: ${context2.sourceMode}`);
+  }
+  for (const [field, value] of [
+    ["deployment_id", context2.deploymentId],
+    ["capture_bundle_id", context2.captureBundleId],
+    ["exchange", context2.exchange],
+    ["symbol", context2.symbol],
+    ["provider", context2.provider]
+  ]) {
+    if (!value.trim())
+      throw new Error(`${field} must not be empty`);
+  }
+}
+function createRawCapture(context2, input) {
+  assertCaptureContext(context2);
+  if (!RAW_CAPTURE_SCOPES.includes(input.scope)) {
+    throw new Error(`Unsupported raw capture scope: ${input.scope}`);
+  }
+  const eventTimeMs = normalizeTimestampMs(input.eventTimeMs, "event_time_ms");
+  const receivedTimeMs = normalizeTimestampMs(input.receivedTimeMs, "received_time_ms");
+  const redactedPayload = redactStreamPayload(input.payload);
+  const rawChecksum = sha256Canonical(redactedPayload);
+  const rawCaptureId = sha256Canonical({
+    capture_bundle_id: context2.captureBundleId,
+    exchange: context2.exchange.trim().toLowerCase(),
+    feed: context2.feed,
+    raw_capture_scope: input.scope,
+    raw_payload_sha256: rawChecksum,
+    schema_version: context2.schemaVersion,
+    source_mode: context2.sourceMode,
+    source_symbol: context2.symbol.trim(),
+    source_time_ms: eventTimeMs
+  });
+  return {
+    rawCaptureId,
+    rawCaptureScope: input.scope,
+    rawChecksum,
+    redactedPayload,
+    eventTimeMs,
+    receivedTimeMs,
+    checksumAlgorithm: context2.checksumAlgorithm
+  };
+}
+function captureCoreFields(context2, rawCapture) {
+  assertCaptureContext(context2);
+  return {
+    source: context2.source,
+    deployment_id: context2.deploymentId,
+    capture_bundle_id: context2.captureBundleId,
+    exchange: context2.exchange.trim().toLowerCase(),
+    symbol: context2.symbol.trim(),
+    trading_pair: context2.symbol.trim().replace("/", "-"),
+    source_symbol: context2.symbol.trim(),
+    asset_type: context2.assetType,
+    feed: context2.feed,
+    provider: context2.provider,
+    source_mode: context2.sourceMode,
+    source_time_ms: rawCapture.eventTimeMs,
+    received_time_ms: rawCapture.receivedTimeMs,
+    raw_capture_id: rawCapture.rawCaptureId,
+    raw_capture_scope: rawCapture.rawCaptureScope,
+    schema_version: context2.schemaVersion,
+    checksum_algorithm: context2.checksumAlgorithm,
+    raw_checksum: rawCapture.rawChecksum,
+    provenance_complete: context2.provenanceComplete ? 1 : 0
+  };
+}
+
+// src/helpers/market-data-archive/capture-context.ts
+function createMarketCaptureContext(input) {
+  const environment = input.environment ?? "development";
+  const deploymentId = input.deploymentId.trim();
+  if (!deploymentId)
+    throw new Error("deployment_id must not be empty");
+  const configuredBundle = input.captureBundleId?.trim();
+  if (environment === "production" && !configuredBundle) {
+    throw new Error("capture_bundle_id is required for production market capture");
+  }
+  const exchange = input.exchange.trim().toLowerCase();
+  const symbol = input.symbol.trim();
+  if (!exchange || !symbol) {
+    throw new Error("exchange and symbol are required for market capture");
+  }
+  return {
+    source: input.source,
+    deploymentId,
+    captureBundleId: configuredBundle ?? `development:${deploymentId}`,
+    exchange,
+    symbol,
+    assetType: input.assetType,
+    feed: input.feed,
+    provider: input.provider?.trim() || `ccxt:${exchange}`,
+    sourceMode: input.sourceMode,
+    schemaVersion: MARKET_CAPTURE_SCHEMA_VERSION,
+    checksumAlgorithm: CHECKSUM_ALGORITHM,
+    provenanceComplete: true,
+    timeframe: input.timeframe,
+    accountSelector: input.accountSelector
+  };
+}
+function resolveMarketCaptureArchiveState(input) {
+  if (!input.archiveEnabled) {
+    return { enabled: false, reason: "archive_disabled" };
+  }
+  if (!input.marketArchiveEnabled) {
+    return { enabled: false, reason: "market_archive_disabled" };
+  }
+  const environment = input.environment?.trim() || "development";
+  if (environment !== "development" && environment !== "production") {
+    return { enabled: false, reason: "invalid_capture_environment" };
+  }
+  if (environment === "production") {
+    const deploymentId = input.deploymentId?.trim();
+    if (!deploymentId || deploymentId === "unknown") {
+      return { enabled: false, reason: "missing_deployment_id" };
+    }
+    if (!input.captureBundleId?.trim()) {
+      return { enabled: false, reason: "missing_capture_bundle_id" };
+    }
+  }
+  return { enabled: true };
+}
+function assertMarketCaptureArchiveStartable(state) {
+  if (state.enabled || state.reason === "archive_disabled" || state.reason === "market_archive_disabled") {
+    return;
+  }
+  throw new Error(`Refusing to start: canonical market-data archival was requested but its capture identity is incomplete (${state.reason}). ` + "Set CEX_BROKER_MARKET_CAPTURE_ENVIRONMENT, CEX_BROKER_DEPLOYMENT_ID and CEX_BROKER_CAPTURE_BUNDLE_ID, " + "or disable archival explicitly via CEX_BROKER_MARKET_ARCHIVE_ENABLED.");
+}
+function captureEnvironmentFromEnv(value = process.env.CEX_BROKER_MARKET_CAPTURE_ENVIRONMENT) {
+  const environment = value?.trim() || "development";
+  if (environment !== "development" && environment !== "production") {
+    throw new Error("CEX_BROKER_MARKET_CAPTURE_ENVIRONMENT must be development or production");
+  }
+  return environment;
+}
+
+// src/helpers/market-data-archive/orderbook-sampler.ts
+var DEFAULT_ORDERBOOK_INTERVAL_MS = 1000;
+function getOrderbookIntervalMs() {
+  const raw = process.env.CEX_BROKER_ORDERBOOK_INTERVAL_MS ?? process.env.CEX_BROKER_ORDERBOOK_TOB_INTERVAL_MS;
+  if (!raw) {
+    return DEFAULT_ORDERBOOK_INTERVAL_MS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ORDERBOOK_INTERVAL_MS;
+}
+function isMarketArchiveEnabled() {
+  return process.env.CEX_BROKER_MARKET_ARCHIVE_ENABLED !== "false";
+}
+
+class OrderbookSampler {
+  intervalMs;
+  lastEmitMs = null;
+  constructor(intervalMs = getOrderbookIntervalMs()) {
+    this.intervalMs = intervalMs;
+  }
+  shouldEmit(nowMs = Date.now()) {
+    if (this.lastEmitMs !== null && nowMs < this.lastEmitMs) {
+      this.lastEmitMs = nowMs;
+      return true;
+    }
+    if (this.lastEmitMs !== null && nowMs - this.lastEmitMs < this.intervalMs) {
+      return false;
+    }
+    this.lastEmitMs = nowMs;
+    return true;
+  }
+}
+
 // src/helpers/order-activity-tracker.ts
 var DEFAULT_MAX_AGE_MS = 6 * 60 * 60 * 1000;
 
@@ -292883,6 +293453,925 @@ function createOtelLogsFromEnv() {
   return new OtelLogs(config);
 }
 
+// src/helpers/stream-health-publisher.ts
+import { createHash as createHash4, randomUUID } from "node:crypto";
+import {
+  closeSync as closeSync2,
+  fsyncSync as fsyncSync2,
+  openSync as openSync2,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { request as httpRequest3 } from "node:http";
+import { request as httpsRequest3 } from "node:https";
+import { dirname } from "node:path";
+var SOURCE = "broker_write";
+var TABLE = "broker_stream_health.snapshots";
+var PRODUCER_ID = "cex-broker-user-data";
+var STATE_VERSION = 1;
+var HEARTBEAT_MS = 30000;
+var FORWARDER_TIMEOUT_MS = 3000;
+var IDENTIFIER = /^[a-z0-9][a-z0-9:_-]{0,127}$/;
+function identifier(value, name) {
+  const normalized = value.trim().toLowerCase();
+  if (!IDENTIFIER.test(normalized)) {
+    throw new Error(`${name} must be a lower-case stream-health identifier`);
+  }
+  return normalized;
+}
+function counter(value) {
+  if (!/^(0|[1-9]\d*)$/.test(value)) {
+    throw new Error("Invalid persisted stream-health counter");
+  }
+  return BigInt(value);
+}
+function next(value) {
+  return (counter(value) + 1n).toString();
+}
+function key(snapshot) {
+  return `exchange:${snapshot.exchange}|account:${snapshot.accountSelector}|stream:${snapshot.streamKind}|scope:${snapshot.accountScope}`;
+}
+function registryRevision(snapshots) {
+  const rows = snapshots.map((snapshot) => ({
+    exchange: snapshot.exchange,
+    account_selector: snapshot.accountSelector,
+    account_role: snapshot.accountRole ?? null,
+    stream_kind: snapshot.streamKind,
+    account_scope: snapshot.accountScope,
+    registry_status: snapshot.registryStatus
+  })).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+  return createHash4("sha256").update(JSON.stringify(rows)).digest("hex");
+}
+function validState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const state = value;
+  return state.version === STATE_VERSION && state.producerId === PRODUCER_ID && typeof state.producerEpoch === "string" && typeof state.runId === "string" && typeof state.nextBatchSequence === "string" && state.nextStreamSequences !== null && typeof state.nextStreamSequences === "object" && (state.pendingBody === undefined || typeof state.pendingBody === "string");
+}
+function forwarderPost(url2, body, authToken, timeoutMs) {
+  const request = url2.protocol === "http:" ? httpRequest3 : httpsRequest3;
+  const headers = {
+    "content-type": "application/json",
+    "content-length": Buffer.byteLength(body)
+  };
+  if (authToken)
+    headers.authorization = `Bearer ${authToken}`;
+  return new Promise((resolve, reject) => {
+    const req = request(url2, { method: "POST", headers, timeout: timeoutMs }, (res) => {
+      res.on("data", () => {});
+      res.on("end", () => {
+        const status = res.statusCode ?? 0;
+        if (status < 200 || status >= 300) {
+          reject(new Error(`Stream health forwarder returned ${status}`));
+          return;
+        }
+        resolve();
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => req.destroy(new Error("Stream health forwarder timed out")));
+    req.write(body);
+    req.end();
+  });
+}
+
+class StreamHealthPublisher {
+  #deploymentId;
+  #statePath;
+  #heartbeatMs;
+  #post;
+  #state;
+  #advanceRun;
+  #snapshots = [];
+  #dirty = false;
+  #closed = false;
+  #pumping = null;
+  #heartbeat = null;
+  #retry = null;
+  #retryAttempt = 0;
+  constructor(options) {
+    this.#deploymentId = identifier(options.deploymentId, "deployment_id");
+    this.#statePath = options.statePath.trim();
+    if (!this.#statePath) {
+      throw new Error("CEX_BROKER_STREAM_HEALTH_STATE_PATH is required");
+    }
+    this.#heartbeatMs = options.heartbeatIntervalMs ?? HEARTBEAT_MS;
+    if (!Number.isInteger(this.#heartbeatMs) || this.#heartbeatMs < 1 || this.#heartbeatMs > 60000) {
+      throw new Error("Stream health heartbeat interval must be between 1 and 60000ms");
+    }
+    let url2;
+    try {
+      url2 = new URL(options.forwarderUrl.trim());
+    } catch (error) {
+      throw new Error("CEX_BROKER_ARCHIVE_FORWARDER_URL must be valid", {
+        cause: error
+      });
+    }
+    if (url2.protocol !== "http:" && url2.protocol !== "https:") {
+      throw new Error("CEX_BROKER_ARCHIVE_FORWARDER_URL must use HTTP(S)");
+    }
+    this.#post = options.post ?? ((body) => forwarderPost(url2, body, options.forwarderAuthToken, options.forwarderTimeoutMs ?? FORWARDER_TIMEOUT_MS));
+    const loaded = this.#read();
+    this.#state = loaded ?? {
+      version: STATE_VERSION,
+      producerId: PRODUCER_ID,
+      producerEpoch: "1",
+      runId: randomUUID(),
+      nextBatchSequence: "1",
+      nextStreamSequences: {}
+    };
+    counter(this.#state.producerEpoch);
+    counter(this.#state.nextBatchSequence);
+    for (const value of Object.values(this.#state.nextStreamSequences))
+      counter(value);
+    this.#advanceRun = loaded !== null;
+    if (!loaded)
+      this.#persist();
+  }
+  start() {
+    if (this.#closed || this.#heartbeat)
+      return;
+    this.#heartbeat = setInterval(() => {
+      if (this.#snapshots.length > 0) {
+        this.#dirty = true;
+        this.#schedule();
+      }
+    }, this.#heartbeatMs);
+    this.#heartbeat.unref?.();
+    if (this.#state.pendingBody || this.#dirty)
+      this.#schedule();
+  }
+  publish(snapshots) {
+    if (this.#closed)
+      return;
+    this.#snapshots = snapshots.map((snapshot) => ({ ...snapshot }));
+    this.#dirty = true;
+    this.#schedule();
+  }
+  async close(snapshots, timeoutMs = FORWARDER_TIMEOUT_MS) {
+    if (this.#closed)
+      return;
+    if (this.#heartbeat)
+      clearInterval(this.#heartbeat);
+    this.#heartbeat = null;
+    if (this.#retry)
+      clearTimeout(this.#retry);
+    this.#retry = null;
+    this.#snapshots = snapshots.map((snapshot) => ({ ...snapshot }));
+    this.#dirty = this.#snapshots.length > 0;
+    this.#schedule();
+    await Promise.race([
+      this.#waitForIdle(),
+      new Promise((resolve) => setTimeout(resolve, timeoutMs))
+    ]);
+    this.#closed = true;
+    if (this.#retry)
+      clearTimeout(this.#retry);
+    this.#retry = null;
+  }
+  #schedule() {
+    if (this.#closed || this.#pumping)
+      return;
+    this.#pumping = this.#pump().finally(() => {
+      this.#pumping = null;
+      if (!this.#closed && !this.#retry && (this.#state.pendingBody || this.#dirty))
+        this.#schedule();
+    });
+  }
+  async#pump() {
+    if (this.#state.pendingBody && !await this.#deliver())
+      return;
+    if (!this.#dirty || this.#snapshots.length === 0)
+      return;
+    if (this.#advanceRun) {
+      this.#state.producerEpoch = next(this.#state.producerEpoch);
+      this.#state.runId = randomUUID();
+      this.#state.nextBatchSequence = "1";
+      this.#state.nextStreamSequences = {};
+      this.#advanceRun = false;
+      this.#persist();
+    }
+    this.#dirty = false;
+    this.#state.pendingBody = this.#body(this.#snapshots);
+    this.#persist();
+    await this.#deliver();
+  }
+  async#deliver() {
+    const body = this.#state.pendingBody;
+    if (!body)
+      return true;
+    try {
+      await this.#post(body);
+      this.#state.pendingBody = undefined;
+      this.#persist();
+      this.#retryAttempt = 0;
+      return true;
+    } catch {
+      this.#retryLater();
+      return false;
+    }
+  }
+  #body(snapshots) {
+    const ordered3 = [...snapshots].sort((left, right) => key(left).localeCompare(key(right)));
+    if (ordered3.length === 0 || ordered3.length > 1000) {
+      throw new Error("Stream health requires between one and 1000 registry rows");
+    }
+    const batchSequence = this.#state.nextBatchSequence;
+    this.#state.nextBatchSequence = next(batchSequence);
+    const heartbeatAt = new Date().toISOString();
+    const active = ordered3.filter((snapshot) => snapshot.registryStatus === "active").length;
+    const rows = ordered3.map((snapshot) => {
+      const streamKey = key(snapshot);
+      const sequence = this.#state.nextStreamSequences[streamKey] ?? "1";
+      this.#state.nextStreamSequences[streamKey] = next(sequence);
+      return {
+        table: TABLE,
+        row: {
+          producer_id: PRODUCER_ID,
+          producer_epoch: this.#state.producerEpoch,
+          run_id: this.#state.runId,
+          batch_sequence: batchSequence,
+          batch_snapshot_count: String(ordered3.length),
+          batch_active_stream_count: String(active),
+          registry_revision: registryRevision(ordered3),
+          registry_status: snapshot.registryStatus,
+          retired_at: snapshot.retiredAt,
+          exchange: snapshot.exchange,
+          account_selector: snapshot.accountSelector,
+          account_role: snapshot.accountRole ?? null,
+          stream_kind: snapshot.streamKind,
+          account_scope: snapshot.accountScope,
+          sequence,
+          state: snapshot.state,
+          state_changed_at: snapshot.stateChangedAt,
+          last_connected_at: snapshot.lastConnectedAt,
+          last_authenticated_at: snapshot.lastAuthenticatedAt,
+          last_received_at: snapshot.lastReceivedAt,
+          heartbeat_at: heartbeatAt,
+          connect_attempt_count: snapshot.connectAttemptCount,
+          reconnect_count: snapshot.reconnectCount,
+          error_count: snapshot.errorCount,
+          last_failure_kind: snapshot.lastFailureKind,
+          last_failure_reason: snapshot.lastFailureReason,
+          traffic_mode: snapshot.trafficMode,
+          source_watermark: snapshot.sourceWatermark
+        }
+      };
+    });
+    return JSON.stringify({
+      source: SOURCE,
+      deployment_id: this.#deploymentId,
+      rows
+    });
+  }
+  #retryLater() {
+    if (this.#closed || this.#retry)
+      return;
+    const delay = Math.min(1000 * 2 ** this.#retryAttempt, 30000);
+    this.#retryAttempt += 1;
+    this.#retry = setTimeout(() => {
+      this.#retry = null;
+      this.#schedule();
+    }, delay);
+    this.#retry.unref?.();
+  }
+  async#waitForIdle() {
+    while (this.#pumping)
+      await this.#pumping;
+  }
+  #read() {
+    try {
+      const parsed = JSON.parse(readFileSync(this.#statePath, "utf8"));
+      if (!validState(parsed))
+        throw new Error("invalid state shape");
+      return parsed;
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return null;
+      throw new Error("Stream health state cannot be read", { cause: error });
+    }
+  }
+  #persist() {
+    const parent = dirname(this.#statePath);
+    try {
+      if (!statSync(parent).isDirectory())
+        throw new Error("state parent is not a directory");
+    } catch (error) {
+      throw new Error("Stream health state directory is unavailable", {
+        cause: error
+      });
+    }
+    const temporary = `${this.#statePath}.${process.pid}.${randomUUID()}.tmp`;
+    let fd2;
+    try {
+      fd2 = openSync2(temporary, "wx", 384);
+      writeFileSync(fd2, JSON.stringify(this.#state));
+      fsyncSync2(fd2);
+      closeSync2(fd2);
+      fd2 = undefined;
+      renameSync(temporary, this.#statePath);
+      const parentFd = openSync2(parent, "r");
+      try {
+        fsyncSync2(parentFd);
+      } finally {
+        closeSync2(parentFd);
+      }
+    } catch (error) {
+      if (fd2 !== undefined)
+        closeSync2(fd2);
+      try {
+        unlinkSync(temporary);
+      } catch {}
+      throw new Error("Stream health state cannot be persisted", {
+        cause: error
+      });
+    }
+  }
+}
+function streamHealthPublisherConfigFromEnv(env = process.env) {
+  if (env.CEX_BROKER_ARCHIVE_ENABLED !== "true") {
+    throw new Error("Configured account user streams require CEX_BROKER_ARCHIVE_ENABLED=true");
+  }
+  const deploymentId = env.CEX_BROKER_DEPLOYMENT_ID?.trim();
+  const forwarderUrl = env.CEX_BROKER_ARCHIVE_FORWARDER_URL?.trim();
+  const statePath = env.CEX_BROKER_STREAM_HEALTH_STATE_PATH?.trim();
+  if (!deploymentId || !forwarderUrl || !statePath) {
+    throw new Error("Configured account user streams require deployment, forwarder, and persistent state configuration");
+  }
+  return {
+    deploymentId,
+    forwarderUrl,
+    statePath,
+    forwarderAuthToken: env.CEX_BROKER_ARCHIVE_FORWARDER_TOKEN?.trim() || undefined
+  };
+}
+
+// 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";
+var DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS = 16;
+var createWebSocket = (url2) => new wrapper_default(url2);
+var userDataRequestCounter = 0;
+function getExchangeString(exchange, key2) {
+  const value = exchange[key2];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Binance user-data stream requires exchange.${key2}`);
+  }
+  return value;
+}
+function sortedQuery(params) {
+  return Object.entries(params).sort(([left], [right]) => left.localeCompare(right)).map(([key2, value]) => `${encodeURIComponent(key2)}=${encodeURIComponent(String(value))}`).join("&");
+}
+function signUserDataStreamParams(exchange, params) {
+  const signParams = exchange.signParams;
+  if (typeof signParams === "function") {
+    return signParams.call(exchange, params);
+  }
+  const secret = getExchangeString(exchange, "secret");
+  return {
+    ...params,
+    signature: createHmac("sha256", secret).update(sortedQuery(params)).digest("hex")
+  };
+}
+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 record = getRecord(value);
+  const message = record?.message;
+  return typeof message === "string" && message.length > 0 ? message : null;
+}
+function getOptionalExchangeString(exchange, key2) {
+  const value = exchange[key2];
+  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 record = getRecord(event);
+  const message = getMessage(record?.error) ?? getMessage(record?.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 record = getRecord(codeOrEvent);
+  const code = record ? record.code : codeOrEvent;
+  const reason = getCloseReason(record ? record.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()}-${userDataRequestCounter++}`;
+  maxBufferedEvents;
+  observer;
+  queue = [];
+  waiters = [];
+  closed = false;
+  closeError = null;
+  subscriptionId = null;
+  constructor(exchange, options = {}) {
+    this.exchange = exchange;
+    this.maxBufferedEvents = options.maxBufferedEvents ?? DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS;
+    this.observer = options.observer;
+    this.secretValues = [
+      getOptionalExchangeString(exchange, "apiKey"),
+      getOptionalExchangeString(exchange, "secret")
+    ].filter((value) => value !== null);
+    this.ws = createWebSocket(getBinanceSpotWsApiUrl(exchange));
+    this.ws.on("open", () => {
+      this.observer?.onConnected?.();
+      this.subscribe();
+    });
+    this.ws.on("message", (data) => this.handleMessage(data));
+    this.ws.on("error", (error) => this.fail(formatBinanceUserDataWebSocketError(error, this.secretValues), "transport_error"));
+    this.ws.on("close", (code, reason) => this.handleClose(code, reason));
+  }
+  async* [Symbol.asyncIterator]() {
+    while (true) {
+      const event = await this.nextEvent();
+      if (!event) {
+        break;
+      }
+      yield event;
+    }
+  }
+  close() {
+    if (this.closed) {
+      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), "remote_closed");
+  }
+  subscribe() {
+    const apiKey = getExchangeString(this.exchange, "apiKey");
+    const signedParams = signUserDataStreamParams(this.exchange, {
+      apiKey,
+      timestamp: Date.now()
+    });
+    this.ws.send(JSON.stringify({
+      id: this.requestId,
+      method: "userDataStream.subscribe.signature",
+      params: signedParams
+    }));
+  }
+  handleMessage(data) {
+    if (this.closed) {
+      return;
+    }
+    let message;
+    try {
+      const decodedData = decodeMessageData(data);
+      message = typeof decodedData === "string" ? JSON.parse(decodedData) : decodedData;
+    } catch (error) {
+      this.fail(error instanceof Error ? error : new Error("Invalid Binance user-data message"), "protocol_error");
+      return;
+    }
+    if ("id" in message && message.id === this.requestId) {
+      if (message.status !== 200) {
+        this.fail(new Error(message.error?.msg ?? message.error?.message ?? `Binance user-data subscription failed with status ${message.status}`), "auth_failed");
+        return;
+      }
+      this.subscriptionId = message.result?.subscriptionId ?? null;
+      this.observer?.onAuthenticated?.();
+      return;
+    }
+    if ("status" in message && typeof message.status === "number" && message.status !== 200) {
+      const errorMessage = message.error?.msg ?? message.error?.message ?? `Binance user-data request failed with status ${message.status}`;
+      const errorCode2 = message.error?.code;
+      this.fail(new Error(typeof errorCode2 === "number" ? `${errorMessage} (code ${errorCode2})` : errorMessage), "protocol_error");
+      return;
+    }
+    if (!("event" in message) || !message.event) {
+      return;
+    }
+    const subscriptionId = message.subscriptionId ?? this.subscriptionId;
+    if (subscriptionId === null || subscriptionId === undefined) {
+      return;
+    }
+    this.push({ subscriptionId, event: message.event });
+  }
+  push(event) {
+    if (this.closed) {
+      return;
+    }
+    this.observer?.onEvent?.(event);
+    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`), "backpressure");
+      return;
+    }
+    this.queue.push(event);
+  }
+  nextEvent() {
+    const event = this.queue.shift();
+    if (event) {
+      return Promise.resolve(event);
+    }
+    if (this.closeError) {
+      return Promise.reject(this.closeError);
+    }
+    if (this.closed) {
+      return Promise.resolve(null);
+    }
+    return new Promise((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
+  }
+  fail(error, kind) {
+    if (this.closeError) {
+      return;
+    }
+    this.closeError = error;
+    this.observer?.onFailure?.({ kind, reason: error.message });
+    this.closed = true;
+    this.queue.length = 0;
+    this.flushWaiters();
+    try {
+      this.ws.close();
+    } catch {}
+  }
+  flushWaiters() {
+    const error = this.closeError;
+    for (const waiter of this.waiters.splice(0)) {
+      if (error) {
+        waiter.reject(error);
+      } else {
+        waiter.resolve(null);
+      }
+    }
+  }
+}
+function isBinanceBalanceUserDataEvent(event) {
+  return event.e === "outboundAccountPosition" || event.e === "balanceUpdate" || event.e === "externalLockUpdate";
+}
+function isBinanceOrderUserDataEvent(event) {
+  return event.e === "executionReport" || event.e === "listStatus";
+}
+
+// src/helpers/user-data-stream-supervisor.ts
+var MAX_SUBSCRIBER_EVENTS = 16;
+function now3() {
+  return new Date().toISOString();
+}
+function retryDelay(attempt) {
+  return Math.min(1000 * 2 ** attempt, 30000);
+}
+function safeFailureReason(exchange, reason) {
+  const secrets = [exchange.apiKey, exchange.secret].filter((value) => typeof value === "string" && value.length > 0);
+  return redactSecretLiterals(reason, secrets).replace(/\s+/g, " ").trim().slice(0, 256);
+}
+
+class Subscriber {
+  kind;
+  marketId;
+  onClose;
+  #queue = [];
+  #waiters = [];
+  #closed = false;
+  #error = null;
+  constructor(kind, marketId, onClose) {
+    this.kind = kind;
+    this.marketId = marketId;
+    this.onClose = onClose;
+  }
+  push(message) {
+    if (this.#closed || !this.#matches(message.event))
+      return;
+    const waiter = this.#waiters.shift();
+    if (waiter) {
+      waiter.resolve(message);
+      return;
+    }
+    if (this.#queue.length >= MAX_SUBSCRIBER_EVENTS) {
+      this.#fail(new Error("Configured account user-data subscriber fell behind"));
+      return;
+    }
+    this.#queue.push(message);
+  }
+  close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    this.#queue.length = 0;
+    this.onClose();
+    for (const waiter of this.#waiters.splice(0))
+      waiter.resolve(null);
+  }
+  async* [Symbol.asyncIterator]() {
+    while (true) {
+      const event = await this.#next();
+      if (!event)
+        return;
+      yield event;
+    }
+  }
+  #matches(event) {
+    if (this.kind === "balance")
+      return isBinanceBalanceUserDataEvent(event);
+    if (!isBinanceOrderUserDataEvent(event))
+      return false;
+    return !this.marketId || event.s === this.marketId;
+  }
+  #next() {
+    const event = this.#queue.shift();
+    if (event)
+      return Promise.resolve(event);
+    if (this.#error)
+      return Promise.reject(this.#error);
+    if (this.#closed)
+      return Promise.resolve(null);
+    return new Promise((resolve, reject) => this.#waiters.push({ resolve, reject }));
+  }
+  #fail(error) {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    this.#error = error;
+    this.#queue.length = 0;
+    this.onClose();
+    for (const waiter of this.#waiters.splice(0))
+      waiter.reject(error);
+  }
+}
+
+class AccountWorker {
+  exchangeName;
+  account;
+  onChange;
+  #subscribers = new Set;
+  #snapshot;
+  #stopping = false;
+  #stream = null;
+  #retryTimer = null;
+  #retryResolve = null;
+  #run = null;
+  #failureObserved = false;
+  #attempts = 0;
+  constructor(exchangeName, account, onChange) {
+    this.exchangeName = exchangeName;
+    this.account = account;
+    this.onChange = onChange;
+    const timestamp = now3();
+    this.#snapshot = {
+      exchange: exchangeName,
+      accountSelector: account.label,
+      accountRole: account.role,
+      streamKind: "user_data",
+      accountScope: "spot",
+      registryStatus: "active",
+      retiredAt: null,
+      state: "connecting",
+      stateChangedAt: timestamp,
+      lastConnectedAt: null,
+      lastAuthenticatedAt: null,
+      lastReceivedAt: null,
+      connectAttemptCount: "0",
+      reconnectCount: "0",
+      errorCount: "0",
+      lastFailureKind: "none",
+      lastFailureReason: "",
+      trafficMode: "event_driven",
+      sourceWatermark: null
+    };
+  }
+  start() {
+    if (this.exchangeName !== "binance") {
+      this.#fail("unsupported_connector", "Configured exchange has no user-data supervisor");
+      return;
+    }
+    this.#run = this.#connectLoop();
+  }
+  subscribe(options) {
+    if (this.#stopping)
+      throw new Error("Configured account user-data supervisor is stopping");
+    const subscriber = new Subscriber(options.kind, options.marketId, () => {
+      this.#subscribers.delete(subscriber);
+    });
+    this.#subscribers.add(subscriber);
+    return subscriber;
+  }
+  snapshot() {
+    return { ...this.#snapshot };
+  }
+  async stop() {
+    this.#stopping = true;
+    if (this.#retryTimer)
+      clearTimeout(this.#retryTimer);
+    this.#retryTimer = null;
+    this.#retryResolve?.();
+    this.#retryResolve = null;
+    this.#stream?.close();
+    await this.#run;
+    this.#transition("disconnected", "shutdown", "Broker shutdown");
+    for (const subscriber of [...this.#subscribers])
+      subscriber.close();
+  }
+  #transition(state, failureKind, failureReason) {
+    const timestamp = now3();
+    if (this.#snapshot.state !== state) {
+      this.#snapshot.state = state;
+      this.#snapshot.stateChangedAt = timestamp;
+    }
+    if (failureKind) {
+      this.#snapshot.lastFailureKind = failureKind;
+      this.#snapshot.lastFailureReason = failureReason ?? "";
+    }
+    this.onChange();
+  }
+  #connected() {
+    this.#snapshot.lastConnectedAt = now3();
+    this.#transition("connected");
+  }
+  #authenticated() {
+    this.#snapshot.lastAuthenticatedAt = now3();
+    this.onChange();
+  }
+  #received(message) {
+    this.#snapshot.lastReceivedAt = now3();
+    const eventTimestamp = message.event.E;
+    this.#snapshot.sourceWatermark = typeof eventTimestamp === "number" || typeof eventTimestamp === "string" ? String(eventTimestamp).slice(0, 512) : null;
+    for (const subscriber of this.#subscribers)
+      subscriber.push(message);
+    this.onChange();
+  }
+  #fail(kind, reason) {
+    this.#failureObserved = true;
+    this.#snapshot.errorCount = (BigInt(this.#snapshot.errorCount) + 1n).toString();
+    this.#transition("error", kind, safeFailureReason(this.account.exchange, reason));
+  }
+  async#connectLoop() {
+    while (!this.#stopping) {
+      if (this.#attempts > 0) {
+        this.#snapshot.reconnectCount = (BigInt(this.#snapshot.reconnectCount) + 1n).toString();
+      }
+      this.#attempts += 1;
+      this.#snapshot.connectAttemptCount = String(this.#attempts);
+      this.#failureObserved = false;
+      this.#transition("connecting");
+      const stream4 = new BinanceSpotUserDataStream(this.account.exchange, {
+        observer: {
+          onConnected: () => this.#connected(),
+          onAuthenticated: () => this.#authenticated(),
+          onEvent: (message) => this.#received(message),
+          onFailure: (failure) => this.#handleStreamFailure(failure)
+        }
+      });
+      this.#stream = stream4;
+      try {
+        for await (const _event of stream4) {}
+      } catch (error) {
+        if (!this.#stopping && !this.#failureObserved) {
+          this.#fail("transport_error", error instanceof Error ? error.message : "User-data stream failed");
+        }
+      } finally {
+        stream4.close();
+        if (this.#stream === stream4)
+          this.#stream = null;
+      }
+      if (!this.#stopping)
+        await this.#waitForRetry();
+    }
+  }
+  #handleStreamFailure(failure) {
+    this.#fail(failure.kind, failure.reason);
+  }
+  #waitForRetry() {
+    return new Promise((resolve) => {
+      const delay = retryDelay(Math.max(this.#attempts - 1, 0));
+      this.#retryResolve = resolve;
+      this.#retryTimer = setTimeout(() => {
+        this.#retryTimer = null;
+        this.#retryResolve = null;
+        resolve();
+      }, delay);
+      this.#retryTimer.unref?.();
+    });
+  }
+}
+
+class UserDataStreamSupervisor {
+  options;
+  #workers = new Map;
+  #started = false;
+  constructor(options) {
+    this.options = options;
+    for (const [exchange, pool] of Object.entries(options.brokers)) {
+      for (const account of [pool.primary, ...pool.secondaryBrokers]) {
+        const normalizedExchange = exchange.trim().toLowerCase();
+        const worker = new AccountWorker(normalizedExchange, account, () => this.#publish());
+        this.#workers.set(`${normalizedExchange}|${account.label}`, worker);
+      }
+    }
+    if (this.#workers.size === 0) {
+      throw new Error("User-data supervisor requires at least one configured account");
+    }
+  }
+  start() {
+    if (this.#started)
+      return;
+    this.#started = true;
+    this.options.publisher.start();
+    for (const worker of this.#workers.values())
+      worker.start();
+    this.#publish();
+  }
+  subscribe(options) {
+    const exchange = options.exchange.trim().toLowerCase();
+    const worker = this.#workers.get(`${exchange}|${options.accountSelector}`);
+    if (!worker)
+      throw new Error("Configured account user-data stream is unavailable");
+    return worker.subscribe({ kind: options.kind, marketId: options.marketId });
+  }
+  async close() {
+    for (const worker of this.#workers.values())
+      await worker.stop();
+    await this.options.publisher.close(this.#snapshots());
+  }
+  #snapshots() {
+    return [...this.#workers.values()].map((worker) => worker.snapshot());
+  }
+  #publish() {
+    if (!this.#started)
+      return;
+    this.options.publisher.publish(this.#snapshots());
+  }
+}
+
 // src/server.ts
 import * as grpc14 from "@grpc/grpc-js";
 
@@ -293723,9 +295212,9 @@ function floatSafeRemainder(val, step) {
   return valInt % stepInt / 10 ** decCount;
 }
 var EVALUATING = Symbol("evaluating");
-function defineLazy(object, key, getter) {
+function defineLazy(object, key2, getter) {
   let value = undefined;
-  Object.defineProperty(object, key, {
+  Object.defineProperty(object, key2, {
     get() {
       if (value === EVALUATING) {
         return;
@@ -293737,7 +295226,7 @@ function defineLazy(object, key, getter) {
       return value;
     },
     set(v) {
-      Object.defineProperty(object, key, {
+      Object.defineProperty(object, key2, {
         value: v
       });
     },
@@ -293769,11 +295258,11 @@ function cloneDef(schema) {
 function getElementAtPath(obj, path) {
   if (!path)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path.reduce((acc, key2) => acc?.[key2], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys2 = Object.keys(promisesObj);
-  const promises = keys2.map((key) => promisesObj[key]);
+  const promises = keys2.map((key2) => promisesObj[key2]);
   return Promise.all(promises).then((results) => {
     const resolvedObj = {};
     for (let i2 = 0;i2 < keys2.length; i2++) {
@@ -293837,8 +295326,8 @@ function shallowClone(o) {
 }
 function numKeys(data) {
   let keyCount = 0;
-  for (const key in data) {
-    if (Object.prototype.hasOwnProperty.call(data, key)) {
+  for (const key2 in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key2)) {
       keyCount++;
     }
   }
@@ -293981,13 +295470,13 @@ function pick(schema, mask2) {
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape = {};
-      for (const key in mask2) {
-        if (!(key in currDef.shape)) {
-          throw new Error(`Unrecognized key: "${key}"`);
+      for (const key2 in mask2) {
+        if (!(key2 in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key2}"`);
         }
-        if (!mask2[key])
+        if (!mask2[key2])
           continue;
-        newShape[key] = currDef.shape[key];
+        newShape[key2] = currDef.shape[key2];
       }
       assignProp(this, "shape", newShape);
       return newShape;
@@ -294006,13 +295495,13 @@ function omit5(schema, mask2) {
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape = { ...schema._zod.def.shape };
-      for (const key in mask2) {
-        if (!(key in currDef.shape)) {
-          throw new Error(`Unrecognized key: "${key}"`);
+      for (const key2 in mask2) {
+        if (!(key2 in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key2}"`);
         }
-        if (!mask2[key])
+        if (!mask2[key2])
           continue;
-        delete newShape[key];
+        delete newShape[key2];
       }
       assignProp(this, "shape", newShape);
       return newShape;
@@ -294029,8 +295518,8 @@ function extend4(schema, shape) {
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     const existingShape = schema._zod.def.shape;
-    for (const key in shape) {
-      if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
+    for (const key2 in shape) {
+      if (Object.getOwnPropertyDescriptor(existingShape, key2) !== undefined) {
         throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
       }
     }
@@ -294083,23 +295572,23 @@ function partial(Class, schema, mask2) {
       const oldShape = schema._zod.def.shape;
       const shape = { ...oldShape };
       if (mask2) {
-        for (const key in mask2) {
-          if (!(key in oldShape)) {
-            throw new Error(`Unrecognized key: "${key}"`);
+        for (const key2 in mask2) {
+          if (!(key2 in oldShape)) {
+            throw new Error(`Unrecognized key: "${key2}"`);
           }
-          if (!mask2[key])
+          if (!mask2[key2])
             continue;
-          shape[key] = Class ? new Class({
+          shape[key2] = Class ? new Class({
             type: "optional",
-            innerType: oldShape[key]
-          }) : oldShape[key];
+            innerType: oldShape[key2]
+          }) : oldShape[key2];
         }
       } else {
-        for (const key in oldShape) {
-          shape[key] = Class ? new Class({
+        for (const key2 in oldShape) {
+          shape[key2] = Class ? new Class({
             type: "optional",
-            innerType: oldShape[key]
-          }) : oldShape[key];
+            innerType: oldShape[key2]
+          }) : oldShape[key2];
         }
       }
       assignProp(this, "shape", shape);
@@ -294115,22 +295604,22 @@ function required(Class, schema, mask2) {
       const oldShape = schema._zod.def.shape;
       const shape = { ...oldShape };
       if (mask2) {
-        for (const key in mask2) {
-          if (!(key in shape)) {
-            throw new Error(`Unrecognized key: "${key}"`);
+        for (const key2 in mask2) {
+          if (!(key2 in shape)) {
+            throw new Error(`Unrecognized key: "${key2}"`);
           }
-          if (!mask2[key])
+          if (!mask2[key2])
             continue;
-          shape[key] = new Class({
+          shape[key2] = new Class({
             type: "nonoptional",
-            innerType: oldShape[key]
+            innerType: oldShape[key2]
           });
         }
       } else {
-        for (const key in oldShape) {
-          shape[key] = new Class({
+        for (const key2 in oldShape) {
+          shape[key2] = new Class({
             type: "nonoptional",
-            innerType: oldShape[key]
+            innerType: oldShape[key2]
           });
         }
       }
@@ -295880,19 +297369,19 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     return payload;
   };
 });
-function handlePropertyResult(result, final, key, input, isOptionalOut) {
+function handlePropertyResult(result, final, key2, input, isOptionalOut) {
   if (result.issues.length) {
-    if (isOptionalOut && !(key in input)) {
+    if (isOptionalOut && !(key2 in input)) {
       return;
     }
-    final.issues.push(...prefixIssues(key, result.issues));
+    final.issues.push(...prefixIssues(key2, result.issues));
   }
   if (result.value === undefined) {
-    if (key in input) {
-      final.value[key] = undefined;
+    if (key2 in input) {
+      final.value[key2] = undefined;
     }
   } else {
-    final.value[key] = result.value;
+    final.value[key2] = result.value;
   }
 }
 function normalizeDef(def) {
@@ -295917,18 +297406,18 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
   const _catchall = def.catchall._zod;
   const t = _catchall.def.type;
   const isOptionalOut = _catchall.optout === "optional";
-  for (const key in input) {
-    if (keySet.has(key))
+  for (const key2 in input) {
+    if (keySet.has(key2))
       continue;
     if (t === "never") {
-      unrecognized.push(key);
+      unrecognized.push(key2);
       continue;
     }
-    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+    const r = _catchall.run({ value: input[key2], issues: [] }, ctx);
     if (r instanceof Promise) {
-      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
+      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input, isOptionalOut)));
     } else {
-      handlePropertyResult(r, payload, key, input, isOptionalOut);
+      handlePropertyResult(r, payload, key2, input, isOptionalOut);
     }
   }
   if (unrecognized.length) {
@@ -295964,12 +297453,12 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   defineLazy(inst._zod, "propValues", () => {
     const shape = def.shape;
     const propValues = {};
-    for (const key in shape) {
-      const field = shape[key]._zod;
+    for (const key2 in shape) {
+      const field = shape[key2]._zod;
       if (field.values) {
-        propValues[key] ?? (propValues[key] = new Set);
+        propValues[key2] ?? (propValues[key2] = new Set);
         for (const v of field.values)
-          propValues[key].add(v);
+          propValues[key2].add(v);
       }
     }
     return propValues;
@@ -295992,14 +297481,14 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     payload.value = {};
     const proms = [];
     const shape = value.shape;
-    for (const key of value.keys) {
-      const el = shape[key];
+    for (const key2 of value.keys) {
+      const el = shape[key2];
       const isOptionalOut = el._zod.optout === "optional";
-      const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+      const r = el._zod.run({ value: input[key2], issues: [] }, ctx);
       if (r instanceof Promise) {
-        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input, isOptionalOut)));
       } else {
-        handlePropertyResult(r, payload, key, input, isOptionalOut);
+        handlePropertyResult(r, payload, key2, input, isOptionalOut);
       }
     }
     if (!catchall) {
@@ -296015,23 +297504,23 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   const generateFastpass = (shape) => {
     const doc = new Doc(["shape", "payload", "ctx"]);
     const normalized = _normalized.value;
-    const parseStr = (key) => {
-      const k = esc(key);
+    const parseStr = (key2) => {
+      const k = esc(key2);
       return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
     };
     doc.write(`const input = payload.value;`);
     const ids = Object.create(null);
-    let counter = 0;
-    for (const key of normalized.keys) {
-      ids[key] = `key_${counter++}`;
+    let counter2 = 0;
+    for (const key2 of normalized.keys) {
+      ids[key2] = `key_${counter2++}`;
     }
     doc.write(`const newResult = {};`);
-    for (const key of normalized.keys) {
-      const id2 = ids[key];
-      const k = esc(key);
-      const schema = shape[key];
+    for (const key2 of normalized.keys) {
+      const id2 = ids[key2];
+      const k = esc(key2);
+      const schema = shape[key2];
       const isOptionalOut = schema?._zod?.optout === "optional";
-      doc.write(`const ${id2} = ${parseStr(key)};`);
+      doc.write(`const ${id2} = ${parseStr(key2)};`);
       if (isOptionalOut) {
         doc.write(`
         if (${id2}.issues.length) {
@@ -296317,17 +297806,17 @@ function mergeValues(a, b2) {
   }
   if (isPlainObject2(a) && isPlainObject2(b2)) {
     const bKeys = Object.keys(b2);
-    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
+    const sharedKeys = Object.keys(a).filter((key2) => bKeys.indexOf(key2) !== -1);
     const newObj = { ...a, ...b2 };
-    for (const key of sharedKeys) {
-      const sharedValue = mergeValues(a[key], b2[key]);
+    for (const key2 of sharedKeys) {
+      const sharedValue = mergeValues(a[key2], b2[key2]);
       if (!sharedValue.valid) {
         return {
           valid: false,
-          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
+          mergeErrorPath: [key2, ...sharedValue.mergeErrorPath]
         };
       }
-      newObj[key] = sharedValue.data;
+      newObj[key2] = sharedValue.data;
     }
     return { valid: true, data: newObj };
   }
@@ -296483,30 +297972,30 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
     if (values2) {
       payload.value = {};
       const recordKeys = new Set;
-      for (const key of values2) {
-        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
-          recordKeys.add(typeof key === "number" ? key.toString() : key);
-          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+      for (const key2 of values2) {
+        if (typeof key2 === "string" || typeof key2 === "number" || typeof key2 === "symbol") {
+          recordKeys.add(typeof key2 === "number" ? key2.toString() : key2);
+          const result = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
           if (result instanceof Promise) {
             proms.push(result.then((result2) => {
               if (result2.issues.length) {
-                payload.issues.push(...prefixIssues(key, result2.issues));
+                payload.issues.push(...prefixIssues(key2, result2.issues));
               }
-              payload.value[key] = result2.value;
+              payload.value[key2] = result2.value;
             }));
           } else {
             if (result.issues.length) {
-              payload.issues.push(...prefixIssues(key, result.issues));
+              payload.issues.push(...prefixIssues(key2, result.issues));
             }
-            payload.value[key] = result.value;
+            payload.value[key2] = result.value;
           }
         }
       }
       let unrecognized;
-      for (const key in input) {
-        if (!recordKeys.has(key)) {
+      for (const key2 in input) {
+        if (!recordKeys.has(key2)) {
           unrecognized = unrecognized ?? [];
-          unrecognized.push(key);
+          unrecognized.push(key2);
         }
       }
       if (unrecognized && unrecognized.length > 0) {
@@ -296519,16 +298008,16 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
       }
     } else {
       payload.value = {};
-      for (const key of Reflect.ownKeys(input)) {
-        if (key === "__proto__")
+      for (const key2 of Reflect.ownKeys(input)) {
+        if (key2 === "__proto__")
           continue;
-        let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+        let keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
         if (keyResult instanceof Promise) {
           throw new Error("Async schemas not supported in object keys currently");
         }
-        const checkNumericKey = typeof key === "string" && number3.test(key) && keyResult.issues.length;
+        const checkNumericKey = typeof key2 === "string" && number3.test(key2) && keyResult.issues.length;
         if (checkNumericKey) {
-          const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
+          const retryResult = def.keyType._zod.run({ value: Number(key2), issues: [] }, ctx);
           if (retryResult instanceof Promise) {
             throw new Error("Async schemas not supported in object keys currently");
           }
@@ -296538,30 +298027,30 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
         }
         if (keyResult.issues.length) {
           if (def.mode === "loose") {
-            payload.value[key] = input[key];
+            payload.value[key2] = input[key2];
           } else {
             payload.issues.push({
               code: "invalid_key",
               origin: "record",
               issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-              input: key,
-              path: [key],
+              input: key2,
+              path: [key2],
               inst
             });
           }
           continue;
         }
-        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+        const result = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
         if (result instanceof Promise) {
           proms.push(result.then((result2) => {
             if (result2.issues.length) {
-              payload.issues.push(...prefixIssues(key, result2.issues));
+              payload.issues.push(...prefixIssues(key2, result2.issues));
             }
             payload.value[keyResult.value] = result2.value;
           }));
         } else {
           if (result.issues.length) {
-            payload.issues.push(...prefixIssues(key, result.issues));
+            payload.issues.push(...prefixIssues(key2, result.issues));
           }
           payload.value[keyResult.value] = result.value;
         }
@@ -296588,15 +298077,15 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
     }
     const proms = [];
     payload.value = new Map;
-    for (const [key, value] of input) {
-      const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+    for (const [key2, value] of input) {
+      const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
       const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
       if (keyResult instanceof Promise || valueResult instanceof Promise) {
         proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
-          handleMapResult(keyResult2, valueResult2, payload, key, input, inst, ctx);
+          handleMapResult(keyResult2, valueResult2, payload, key2, input, inst, ctx);
         }));
       } else {
-        handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
+        handleMapResult(keyResult, valueResult, payload, key2, input, inst, ctx);
       }
     }
     if (proms.length)
@@ -296604,10 +298093,10 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
     return payload;
   };
 });
-function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
+function handleMapResult(keyResult, valueResult, final, key2, input, inst, ctx) {
   if (keyResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key)) {
-      final.issues.push(...prefixIssues(key, keyResult.issues));
+    if (propertyKeyTypes.has(typeof key2)) {
+      final.issues.push(...prefixIssues(key2, keyResult.issues));
     } else {
       final.issues.push({
         code: "invalid_key",
@@ -296619,15 +298108,15 @@ function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
     }
   }
   if (valueResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key)) {
-      final.issues.push(...prefixIssues(key, valueResult.issues));
+    if (propertyKeyTypes.has(typeof key2)) {
+      final.issues.push(...prefixIssues(key2, valueResult.issues));
     } else {
       final.issues.push({
         origin: "map",
         code: "invalid_element",
         input,
         inst,
-        key,
+        key: key2,
         issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
       });
     }
@@ -296957,12 +298446,12 @@ var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
     return handlePipeResult(left, def.out, ctx);
   };
 });
-function handlePipeResult(left, next, ctx) {
+function handlePipeResult(left, next2, ctx) {
   if (left.issues.length) {
     left.aborted = true;
     return left;
   }
-  return next._zod.run({ value: left.value, issues: left.issues }, ctx);
+  return next2._zod.run({ value: left.value, issues: left.issues }, ctx);
 }
 var $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => {
   $ZodType.init(inst, def);
@@ -303821,8 +305310,8 @@ function extractDefs(ctx, schema) {
     if (defId)
       seen.defId = defId;
     const schema2 = seen.schema;
-    for (const key in schema2) {
-      delete schema2[key];
+    for (const key2 in schema2) {
+      delete schema2[key2];
     }
     schema2.$ref = ref;
   };
@@ -303889,20 +305378,20 @@ function finalize(ctx, schema) {
       Object.assign(schema2, _cached);
       const isParentRef = zodSchema._zod.parent === ref;
       if (isParentRef) {
-        for (const key in schema2) {
-          if (key === "$ref" || key === "allOf")
+        for (const key2 in schema2) {
+          if (key2 === "$ref" || key2 === "allOf")
             continue;
-          if (!(key in _cached)) {
-            delete schema2[key];
+          if (!(key2 in _cached)) {
+            delete schema2[key2];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key in schema2) {
-          if (key === "$ref" || key === "allOf")
+        for (const key2 in schema2) {
+          if (key2 === "$ref" || key2 === "allOf")
             continue;
-          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
-            delete schema2[key];
+          if (key2 in refSeen.def && JSON.stringify(schema2[key2]) === JSON.stringify(refSeen.def[key2])) {
+            delete schema2[key2];
           }
         }
       }
@@ -303914,11 +305403,11 @@ function finalize(ctx, schema) {
       if (parentSeen?.schema.$ref) {
         schema2.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key in schema2) {
-            if (key === "$ref" || key === "allOf")
+          for (const key2 in schema2) {
+            if (key2 === "$ref" || key2 === "allOf")
               continue;
-            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
-              delete schema2[key];
+            if (key2 in parentSeen.def && JSON.stringify(schema2[key2]) === JSON.stringify(parentSeen.def[key2])) {
+              delete schema2[key2];
             }
           }
         }
@@ -303940,7 +305429,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id2 = ctx.external.registry.get(schema)?.id;
     if (!id2)
@@ -304009,8 +305498,8 @@ function isTransforming(_schema, _ctx) {
     return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
   }
   if (def.type === "object") {
-    for (const key in def.shape) {
-      if (isTransforming(def.shape[key], ctx))
+    for (const key2 in def.shape) {
+      if (isTransforming(def.shape[key2], ctx))
         return true;
     }
     return false;
@@ -304188,7 +305677,7 @@ var literalProcessor = (schema, ctx, json3, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -304301,15 +305790,15 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json3.type = "object";
   json3.properties = {};
   const shape = def.shape;
-  for (const key in shape) {
-    json3.properties[key] = process2(shape[key], ctx, {
+  for (const key2 in shape) {
+    json3.properties[key2] = process2(shape[key2], ctx, {
       ...params,
-      path: [...params.path, "properties", key]
+      path: [...params.path, "properties", key2]
     });
   }
   const allKeys = new Set(Object.keys(shape));
-  const requiredKeys = new Set([...allKeys].filter((key) => {
-    const v = def.shape[key]._zod;
+  const requiredKeys = new Set([...allKeys].filter((key2) => {
+    const v = def.shape[key2]._zod;
     if (ctx.io === "input") {
       return v.optin === undefined;
     } else {
@@ -304574,9 +306063,9 @@ function toJSONSchema(input, params) {
     };
     ctx2.external = external;
     for (const entry of registry2._idmap.entries()) {
-      const [key, schema] = entry;
+      const [key2, schema] = entry;
       extractDefs(ctx2, schema);
-      schemas[key] = finalize(ctx2, schema);
+      schemas[key2] = finalize(ctx2, schema);
     }
     if (Object.keys(defs).length > 0) {
       const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -306133,11 +307622,11 @@ function resolveRef(ref, ctx) {
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
   if (path[0] === defsKey) {
-    const key = path[1];
-    if (!key || !ctx.defs[key]) {
+    const key2 = path[1];
+    if (!key2 || !ctx.defs[key2]) {
       throw new Error(`Reference not found: ${ref}`);
     }
-    return ctx.defs[key];
+    return ctx.defs[key2];
   }
   throw new Error(`Reference not found: ${ref}`);
 }
@@ -306323,9 +307812,9 @@ function convertBaseSchema(schema, ctx) {
       const shape = {};
       const properties = schema.properties || {};
       const requiredSet = new Set(schema.required || []);
-      for (const [key, propSchema] of Object.entries(properties)) {
+      for (const [key2, propSchema] of Object.entries(properties)) {
         const propZodSchema = convertSchema(propSchema, ctx);
-        shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
+        shape[key2] = requiredSet.has(key2) ? propZodSchema : propZodSchema.optional();
       }
       if (schema.propertyNames) {
         const keySchema = convertSchema(schema.propertyNames, ctx);
@@ -306469,20 +307958,20 @@ function convertSchema(schema, ctx) {
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
-  for (const key of coreMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+  for (const key2 of coreMetadataKeys) {
+    if (key2 in schema) {
+      extraMeta[key2] = schema[key2];
     }
   }
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
-  for (const key of contentMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+  for (const key2 of contentMetadataKeys) {
+    if (key2 in schema) {
+      extraMeta[key2] = schema[key2];
     }
   }
-  for (const key of Object.keys(schema)) {
-    if (!RECOGNIZED_KEYS.has(key)) {
-      extraMeta[key] = schema[key];
+  for (const key2 of Object.keys(schema)) {
+    if (!RECOGNIZED_KEYS.has(key2)) {
+      extraMeta[key2] = schema[key2];
     }
   }
   if (Object.keys(extraMeta).length > 0) {
@@ -306847,7 +308336,7 @@ async function handleDeposit(ctx) {
           network: depositNetwork?.exchangeNetworkId,
           externalId: depositTxid,
           txid: depositTxid,
-          exchangeTimestamp: typeof creditedAt === "string" ? creditedAt : undefined,
+          exchangeTimestamp: normalizeTimestamp2(creditedAt),
           payload: deposit
         }
       });
@@ -307180,208 +308669,6 @@ function buildHistoricalOrderBookUnsupported(payload) {
 // src/handlers/execute-action/order-book-call.ts
 import * as grpc4 from "@grpc/grpc-js";
 
-// src/helpers/market-data-archive/capture-contract.ts
-import { createHash as createHash3 } from "node:crypto";
-var MARKET_CAPTURE_SCHEMA_VERSION = "1.0.0";
-var CHECKSUM_ALGORITHM = "sha256-canonical-json-v1";
-var ARCHIVE_SOURCES = ["broker_read", "broker_write"];
-var CAPTURE_FEEDS = [
-  "ORDERBOOK",
-  "TICKER",
-  "TRADES",
-  "OHLCV"
-];
-var SOURCE_MODES = [
-  "broker_live_stream_v1",
-  "broker_live_sampling_v1",
-  "broker_current_snapshot_v1",
-  "broker_bootstrap_fetch_v1",
-  "external_ccxt_fallback_v1",
-  "external_hummingbot_fallback_v1",
-  "legacy_migration_v1"
-];
-var RAW_CAPTURE_SCOPES = [
-  "ccxt_normalized_object",
-  "broker_visible_payload",
-  "exchange_wire_frame"
-];
-var CHECKSUM_FIELDS = new Set([
-  "normalized_row_checksum",
-  "raw_checksum",
-  "checksum"
-]);
-function canonicalDecimal(value) {
-  if (!Number.isFinite(value)) {
-    throw new Error("Canonical numbers must be finite");
-  }
-  if (Object.is(value, -0)) {
-    return "0";
-  }
-  const rendered = String(value).toLowerCase();
-  if (!rendered.includes("e")) {
-    return rendered;
-  }
-  const [coefficient = "0", exponentText = "0"] = rendered.split("e");
-  const exponent = Number.parseInt(exponentText, 10);
-  const negative = coefficient.startsWith("-");
-  const unsigned = negative ? coefficient.slice(1) : coefficient;
-  const [integer2 = "0", fraction = ""] = unsigned.split(".");
-  const digits = `${integer2}${fraction}`;
-  const decimalIndex = integer2.length + exponent;
-  let result;
-  if (decimalIndex <= 0) {
-    result = `0.${"0".repeat(-decimalIndex)}${digits}`;
-  } else if (decimalIndex >= digits.length) {
-    result = `${digits}${"0".repeat(decimalIndex - digits.length)}`;
-  } else {
-    result = `${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
-  }
-  return negative ? `-${result}` : result;
-}
-function serializeCanonical(value, stack) {
-  if (value === null)
-    return "null";
-  if (typeof value === "string")
-    return JSON.stringify(value);
-  if (typeof value === "boolean")
-    return value ? "true" : "false";
-  if (typeof value === "number")
-    return canonicalDecimal(value);
-  if (typeof value === "bigint")
-    return value.toString(10);
-  if (value instanceof Date) {
-    if (Number.isNaN(value.getTime())) {
-      throw new Error("Canonical timestamps must be valid");
-    }
-    return value.getTime().toString(10);
-  }
-  if (Array.isArray(value)) {
-    if (stack.has(value))
-      throw new Error("Canonical values must be acyclic");
-    stack.add(value);
-    const result = `[${value.map((entry) => entry === undefined ? "null" : serializeCanonical(entry, stack)).join(",")}]`;
-    stack.delete(value);
-    return result;
-  }
-  if (typeof value === "object") {
-    if (stack.has(value))
-      throw new Error("Canonical values must be acyclic");
-    stack.add(value);
-    const entries = Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([left], [right]) => left.localeCompare(right));
-    const result = `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${serializeCanonical(entry, stack)}`).join(",")}}`;
-    stack.delete(value);
-    return result;
-  }
-  throw new Error(`Unsupported canonical value type: ${typeof value}`);
-}
-function canonicalSerialize(value) {
-  return serializeCanonical(value, new Set);
-}
-function omitChecksumFields(value) {
-  if (Array.isArray(value))
-    return value.map(omitChecksumFields);
-  if (value && typeof value === "object" && !(value instanceof Date)) {
-    return Object.fromEntries(Object.entries(value).filter(([key]) => !CHECKSUM_FIELDS.has(key)).map(([key, entry]) => [key, omitChecksumFields(entry)]));
-  }
-  return value;
-}
-function sha256Canonical(value) {
-  return createHash3("sha256").update(canonicalSerialize(omitChecksumFields(value))).digest("hex");
-}
-function normalizeTimestampMs(value, field) {
-  let timestamp;
-  if (value instanceof Date) {
-    timestamp = value.getTime();
-  } else if (typeof value === "number") {
-    timestamp = value;
-  } else if (typeof value === "string" && /^\d+$/.test(value.trim())) {
-    timestamp = Number(value.trim());
-  } else if (typeof value === "string") {
-    timestamp = Date.parse(value);
-  } else {
-    timestamp = Number.NaN;
-  }
-  if (!Number.isSafeInteger(timestamp) || timestamp < 0) {
-    throw new Error(`${field} must be a non-negative millisecond timestamp`);
-  }
-  return timestamp;
-}
-function assertCaptureContext(context2) {
-  if (!ARCHIVE_SOURCES.includes(context2.source)) {
-    throw new Error(`Unsupported archive source: ${context2.source}`);
-  }
-  if (!CAPTURE_FEEDS.includes(context2.feed)) {
-    throw new Error(`Unsupported capture feed: ${context2.feed}`);
-  }
-  if (!SOURCE_MODES.includes(context2.sourceMode)) {
-    throw new Error(`Unsupported source mode: ${context2.sourceMode}`);
-  }
-  for (const [field, value] of [
-    ["deployment_id", context2.deploymentId],
-    ["capture_bundle_id", context2.captureBundleId],
-    ["exchange", context2.exchange],
-    ["symbol", context2.symbol],
-    ["provider", context2.provider]
-  ]) {
-    if (!value.trim())
-      throw new Error(`${field} must not be empty`);
-  }
-}
-function createRawCapture(context2, input) {
-  assertCaptureContext(context2);
-  if (!RAW_CAPTURE_SCOPES.includes(input.scope)) {
-    throw new Error(`Unsupported raw capture scope: ${input.scope}`);
-  }
-  const eventTimeMs = normalizeTimestampMs(input.eventTimeMs, "event_time_ms");
-  const receivedTimeMs = normalizeTimestampMs(input.receivedTimeMs, "received_time_ms");
-  const redactedPayload = redactStreamPayload(input.payload);
-  const rawChecksum = sha256Canonical(redactedPayload);
-  const rawCaptureId = sha256Canonical({
-    capture_bundle_id: context2.captureBundleId,
-    exchange: context2.exchange.trim().toLowerCase(),
-    feed: context2.feed,
-    raw_capture_scope: input.scope,
-    raw_payload_sha256: rawChecksum,
-    schema_version: context2.schemaVersion,
-    source_mode: context2.sourceMode,
-    source_symbol: context2.symbol.trim(),
-    source_time_ms: eventTimeMs
-  });
-  return {
-    rawCaptureId,
-    rawCaptureScope: input.scope,
-    rawChecksum,
-    redactedPayload,
-    eventTimeMs,
-    receivedTimeMs,
-    checksumAlgorithm: context2.checksumAlgorithm
-  };
-}
-function captureCoreFields(context2, rawCapture) {
-  assertCaptureContext(context2);
-  return {
-    source: context2.source,
-    deployment_id: context2.deploymentId,
-    capture_bundle_id: context2.captureBundleId,
-    exchange: context2.exchange.trim().toLowerCase(),
-    symbol: context2.symbol.trim(),
-    trading_pair: context2.symbol.trim().replace("/", "-"),
-    source_symbol: context2.symbol.trim(),
-    asset_type: context2.assetType,
-    feed: context2.feed,
-    provider: context2.provider,
-    source_mode: context2.sourceMode,
-    source_time_ms: rawCapture.eventTimeMs,
-    received_time_ms: rawCapture.receivedTimeMs,
-    raw_capture_id: rawCapture.rawCaptureId,
-    raw_capture_scope: rawCapture.rawCaptureScope,
-    schema_version: context2.schemaVersion,
-    checksum_algorithm: context2.checksumAlgorithm,
-    raw_checksum: rawCapture.rawChecksum,
-    provenance_complete: context2.provenanceComplete ? 1 : 0
-  };
-}
-
 // src/helpers/market-data-archive/canonical-orderbook.ts
 class OrderBookValidationError extends Error {
   reason;
@@ -307549,46 +308836,6 @@ function buildCanonicalOrderBookRows(input) {
   };
 }
 
-// src/helpers/market-data-archive/capture-context.ts
-function createMarketCaptureContext(input) {
-  const environment = input.environment ?? "development";
-  const deploymentId = input.deploymentId.trim();
-  if (!deploymentId)
-    throw new Error("deployment_id must not be empty");
-  const configuredBundle = input.captureBundleId?.trim();
-  if (environment === "production" && !configuredBundle) {
-    throw new Error("capture_bundle_id is required for production market capture");
-  }
-  const exchange = input.exchange.trim().toLowerCase();
-  const symbol2 = input.symbol.trim();
-  if (!exchange || !symbol2) {
-    throw new Error("exchange and symbol are required for market capture");
-  }
-  return {
-    source: input.source,
-    deploymentId,
-    captureBundleId: configuredBundle ?? `development:${deploymentId}`,
-    exchange,
-    symbol: symbol2,
-    assetType: input.assetType,
-    feed: input.feed,
-    provider: input.provider?.trim() || `ccxt:${exchange}`,
-    sourceMode: input.sourceMode,
-    schemaVersion: MARKET_CAPTURE_SCHEMA_VERSION,
-    checksumAlgorithm: CHECKSUM_ALGORITHM,
-    provenanceComplete: true,
-    timeframe: input.timeframe,
-    accountSelector: input.accountSelector
-  };
-}
-function captureEnvironmentFromEnv(value = process.env.CEX_BROKER_MARKET_CAPTURE_ENVIRONMENT) {
-  const environment = value?.trim() || "development";
-  if (environment !== "development" && environment !== "production") {
-    throw new Error("CEX_BROKER_MARKET_CAPTURE_ENVIRONMENT must be development or production");
-  }
-  return environment;
-}
-
 // src/helpers/market-data-archive/ohlcv-bar-tracker.ts
 function isFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value);
@@ -307723,39 +308970,6 @@ function getOrderbookArchiveDepthLimit() {
   return Math.min(parsed, MAX_ORDERBOOK_ARCHIVE_DEPTH_LIMIT);
 }
 
-// src/helpers/market-data-archive/orderbook-sampler.ts
-var DEFAULT_ORDERBOOK_INTERVAL_MS = 1000;
-function getOrderbookIntervalMs() {
-  const raw = process.env.CEX_BROKER_ORDERBOOK_INTERVAL_MS ?? process.env.CEX_BROKER_ORDERBOOK_TOB_INTERVAL_MS;
-  if (!raw) {
-    return DEFAULT_ORDERBOOK_INTERVAL_MS;
-  }
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ORDERBOOK_INTERVAL_MS;
-}
-function isMarketArchiveEnabled() {
-  return process.env.CEX_BROKER_MARKET_ARCHIVE_ENABLED !== "false";
-}
-
-class OrderbookSampler {
-  intervalMs;
-  lastEmitMs = null;
-  constructor(intervalMs = getOrderbookIntervalMs()) {
-    this.intervalMs = intervalMs;
-  }
-  shouldEmit(nowMs = Date.now()) {
-    if (this.lastEmitMs !== null && nowMs < this.lastEmitMs) {
-      this.lastEmitMs = nowMs;
-      return true;
-    }
-    if (this.lastEmitMs !== null && nowMs - this.lastEmitMs < this.intervalMs) {
-      return false;
-    }
-    this.lastEmitMs = nowMs;
-    return true;
-  }
-}
-
 // src/helpers/market-data-archive/parse-stream.ts
 function isFiniteNumber2(value) {
   return typeof value === "number" && Number.isFinite(value);
@@ -307850,10 +309064,10 @@ function parseTicker(value, fallbackMs) {
     ["change", record2.change],
     ["percentage", record2.percentage]
   ];
-  for (const [key, rawValue] of fields) {
+  for (const [key2, rawValue] of fields) {
     const numeric = toNumber2(rawValue);
     if (numeric !== undefined) {
-      parsed[key] = numeric;
+      parsed[key2] = numeric;
     }
   }
   return parsed;
@@ -307870,9 +309084,19 @@ function withNormalizedChecksum(record2) {
     normalized_row_checksum: sha256Canonical(compact)
   };
 }
+function legacyMarketFields(context2, rawCapture) {
+  return {
+    account_selector: context2.accountSelector,
+    broker_observed_timestamp: new Date(rawCapture.receivedTimeMs).toISOString()
+  };
+}
+function legacyDecimal8(value) {
+  return value === undefined ? undefined : Number(value.toFixed(8));
+}
 function buildCanonicalCexStreamEventRow(context2, rawCapture) {
   const row = withNormalizedChecksum({
     ...captureCoreFields(context2, rawCapture),
+    ...legacyMarketFields(context2, rawCapture),
     stream_type: context2.feed,
     event_time_ms: rawCapture.eventTimeMs,
     payload_encoding: "canonical_json_v1",
@@ -307886,19 +309110,21 @@ function buildCanonicalTickerEventRow(context2, rawCapture, ticker) {
   }
   const row = withNormalizedChecksum({
     ...captureCoreFields(context2, rawCapture),
+    ...legacyMarketFields(context2, rawCapture),
     source_time_ms: ticker.eventTimeMs,
     event_time_ms: ticker.eventTimeMs,
-    last: ticker.last,
-    bid: ticker.bid,
-    ask: ticker.ask,
-    high: ticker.high,
-    low: ticker.low,
-    open: ticker.open,
-    close: ticker.close,
-    base_volume: ticker.baseVolume,
-    quote_volume: ticker.quoteVolume,
-    change: ticker.change,
-    percentage: ticker.percentage
+    last: legacyDecimal8(ticker.last),
+    bid: legacyDecimal8(ticker.bid),
+    ask: legacyDecimal8(ticker.ask),
+    high: legacyDecimal8(ticker.high),
+    low: legacyDecimal8(ticker.low),
+    open: legacyDecimal8(ticker.open),
+    close: legacyDecimal8(ticker.close),
+    base_volume: legacyDecimal8(ticker.baseVolume),
+    quote_volume: legacyDecimal8(ticker.quoteVolume),
+    change: legacyDecimal8(ticker.change),
+    percentage: legacyDecimal8(ticker.percentage),
+    payload_json: JSON.stringify(rawCapture.redactedPayload)
   });
   return { table: "market_data.cex_ticker_events", row };
 }
@@ -307908,13 +309134,14 @@ function buildCanonicalTradeRow(context2, rawCapture, trade) {
   }
   const row = withNormalizedChecksum({
     ...captureCoreFields(context2, rawCapture),
+    ...legacyMarketFields(context2, rawCapture),
     source_time_ms: trade.eventTimeMs,
     trade_id: trade.tradeId,
     event_time_ms: trade.eventTimeMs,
     side: trade.side,
-    price: trade.price,
-    amount: trade.amount,
-    cost: trade.cost,
+    price: legacyDecimal8(trade.price),
+    amount: legacyDecimal8(trade.amount),
+    cost: legacyDecimal8(trade.cost),
     taker_or_maker: trade.takerOrMaker
   });
   return { table: "market_data.cex_trades", row };
@@ -307994,10 +309221,19 @@ function resolveCaptureContext(archiver, input, feed, sourceMode) {
     environment: captureEnvironmentFromEnv()
   });
 }
+function canArchiveMarketData(archiver) {
+  return resolveMarketCaptureArchiveState({
+    archiveEnabled: archiver?.isEnabled() ?? false,
+    marketArchiveEnabled: isMarketArchiveEnabled(),
+    environment: process.env.CEX_BROKER_MARKET_CAPTURE_ENVIRONMENT,
+    deploymentId: archiver?.getDeploymentId(),
+    captureBundleId: process.env.CEX_BROKER_CAPTURE_BUNDLE_ID
+  }).enabled;
+}
 function archiveOrderbookInBackground(archiver, otelMetrics, input, options) {
   const labels = watchLabels("orderbook", input, archiver, "ORDERBOOK");
   recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
-  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
+  if (!canArchiveMarketData(archiver)) {
     return;
   }
   if (options?.sampledOut) {
@@ -308039,7 +309275,7 @@ function archiveOrderbookInBackground(archiver, otelMetrics, input, options) {
 function archiveOhlcvInBackground(archiver, otelMetrics, tracker, input) {
   const labels = watchLabels("ohlcv", input, archiver, "OHLCV");
   recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
-  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
+  if (!canArchiveMarketData(archiver)) {
     return;
   }
   queueMicrotask(() => {
@@ -308084,7 +309320,7 @@ function createOhlcvBarTracker() {
 function archiveMarketRowsInBackground(archiver, otelMetrics, stream4, input, feed, enqueueRows) {
   const labels = watchLabels(stream4, input, archiver, feed);
   recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
-  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
+  if (!canArchiveMarketData(archiver)) {
     return;
   }
   queueMicrotask(() => {
@@ -309624,282 +310860,16 @@ class SubscribeBrokerLifecycle {
 // src/handlers/subscribe/handler.ts
 import * as grpc13 from "@grpc/grpc-js";
 
-// 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";
-var DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS = 16;
-var createWebSocket = (url3) => new wrapper_default(url3);
-var userDataRequestCounter = 0;
-function getExchangeString(exchange, key) {
-  const value = exchange[key];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`Binance user-data stream requires exchange.${key}`);
-  }
-  return value;
-}
-function sortedQuery(params) {
-  return Object.entries(params).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
-}
-function signUserDataStreamParams(exchange, params) {
-  const signParams = exchange.signParams;
-  if (typeof signParams === "function") {
-    return signParams.call(exchange, params);
-  }
-  const secret = getExchangeString(exchange, "secret");
-  return {
-    ...params,
-    signature: createHmac("sha256", secret).update(sortedQuery(params)).digest("hex")
-  };
-}
-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()}-${userDataRequestCounter++}`;
-  maxBufferedEvents;
-  queue = [];
-  waiters = [];
-  closed = false;
-  closeError = null;
-  subscriptionId = null;
-  constructor(exchange, options = {}) {
-    this.exchange = exchange;
-    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) {
-      const event = await this.nextEvent();
-      if (!event) {
-        break;
-      }
-      yield event;
-    }
-  }
-  close() {
-    if (this.closed) {
-      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, {
-      apiKey,
-      timestamp: Date.now()
-    });
-    this.ws.send(JSON.stringify({
-      id: this.requestId,
-      method: "userDataStream.subscribe.signature",
-      params: signedParams
-    }));
-  }
-  handleMessage(data) {
-    if (this.closed) {
-      return;
-    }
-    let message;
-    try {
-      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;
-    }
-    if ("id" in message && message.id === this.requestId) {
-      if (message.status !== 200) {
-        this.fail(new Error(message.error?.msg ?? message.error?.message ?? `Binance user-data subscription failed with status ${message.status}`));
-        return;
-      }
-      this.subscriptionId = message.result?.subscriptionId ?? null;
-      return;
-    }
-    if ("status" in message && typeof message.status === "number" && message.status !== 200) {
-      const errorMessage = message.error?.msg ?? message.error?.message ?? `Binance user-data request failed with status ${message.status}`;
-      const errorCode2 = message.error?.code;
-      this.fail(new Error(typeof errorCode2 === "number" ? `${errorMessage} (code ${errorCode2})` : errorMessage));
-      return;
-    }
-    if (!("event" in message) || !message.event) {
-      return;
-    }
-    const subscriptionId = message.subscriptionId ?? this.subscriptionId;
-    if (subscriptionId === null || subscriptionId === undefined) {
-      return;
-    }
-    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() {
-    const event = this.queue.shift();
-    if (event) {
-      return Promise.resolve(event);
-    }
-    if (this.closeError) {
-      return Promise.reject(this.closeError);
-    }
-    if (this.closed) {
-      return Promise.resolve(null);
-    }
-    return new Promise((resolve, reject) => {
-      this.waiters.push({ resolve, reject });
-    });
-  }
-  fail(error48) {
-    if (this.closeError) {
-      return;
-    }
-    this.closeError = error48;
-    this.closed = true;
-    this.queue.length = 0;
-    this.flushWaiters();
-    try {
-      this.ws.close();
-    } catch {}
-  }
-  flushWaiters() {
-    const error48 = this.closeError;
-    for (const waiter of this.waiters.splice(0)) {
-      if (error48) {
-        waiter.reject(error48);
-      } else {
-        waiter.resolve(null);
-      }
-    }
-  }
-}
-function isBinanceBalanceUserDataEvent(event) {
-  return event.e === "outboundAccountPosition" || event.e === "balanceUpdate" || event.e === "externalLockUpdate";
-}
-function isBinanceOrderUserDataEvent(event) {
-  return event.e === "executionReport" || event.e === "listStatus";
-}
-
 // src/helpers/binance-user-data-normalization.ts
-function requireQuantity(entry, key) {
-  const value = entry[key];
+function requireQuantity(entry, key2) {
+  const value = entry[key2];
   if (typeof value === "string" && value.trim().length > 0) {
     return value;
   }
   if (typeof value === "number" && Number.isFinite(value)) {
     return String(value);
   }
-  throw new Error(`Invalid Binance balance quantity: ${key}`);
+  throw new Error(`Invalid Binance balance quantity: ${key2}`);
 }
 async function normalizeBinanceSpotBalanceEvent(exchange, event) {
   if (event.e !== "outboundAccountPosition") {
@@ -310065,12 +311035,14 @@ async function getBinanceMarketId(broker, symbol2) {
   }
   return symbol2.replace("/", "").toUpperCase();
 }
-async function streamBinanceUserData(call, broker, symbol2, subscriptionType, isClosed, archiveContext) {
-  const userDataStream = new BinanceSpotUserDataStream(broker);
-  call.once("close", () => userDataStream.close());
-  call.once("cancelled", () => userDataStream.close());
-  call.once("error", () => userDataStream.close());
-  const marketId = subscriptionType === SubscriptionType.ORDERS ? await getBinanceMarketId(broker, symbol2) : null;
+async function streamBinanceUserData(call, broker, symbol2, subscriptionType, isClosed, archiveContext, userDataSource, knownMarketId) {
+  const userDataStream = userDataSource ?? new BinanceSpotUserDataStream(broker);
+  if (!userDataSource) {
+    call.once("close", () => userDataStream.close());
+    call.once("cancelled", () => userDataStream.close());
+    call.once("error", () => userDataStream.close());
+  }
+  const marketId = knownMarketId ?? (subscriptionType === SubscriptionType.ORDERS ? await getBinanceMarketId(broker, symbol2) : null);
   try {
     for await (const message of userDataStream) {
       if (isClosed()) {
@@ -310162,7 +311134,13 @@ async function runCcxtSubscribeLoop(call, isClosed, symbol2, subscriptionType, w
   }
 }
 function createSubscribeHandler(deps) {
-  const { brokers, whitelistIps, otelMetrics, brokerArchiver } = deps;
+  const {
+    brokers,
+    whitelistIps,
+    otelMetrics,
+    brokerArchiver,
+    userDataStreamSupervisor
+  } = deps;
   const brokerLifecycle = deps.brokerLifecycle ?? new SubscribeBrokerLifecycle;
   return async (call) => {
     const subscribeStartTime = Date.now();
@@ -310297,7 +311275,28 @@ function createSubscribeHandler(deps) {
           });
           return;
         }
-        await streamBinanceUserData(call, accountBroker, resolvedSymbol, subscriptionType, isStreamClosed, streamArchiveContext);
+        const marketId = subscriptionType === SubscriptionType.ORDERS ? await getBinanceMarketId(accountBroker, resolvedSymbol) : undefined;
+        let userDataSource;
+        if (selectedBrokerAccount) {
+          if (!userDataStreamSupervisor) {
+            await writeSubscribeError(call, isStreamClosed, {
+              data: JSON.stringify({
+                error: "Configured account user-data supervisor is unavailable"
+              }),
+              timestamp: Date.now(),
+              symbol: resolvedSymbol,
+              type: subscriptionType
+            });
+            return;
+          }
+          userDataSource = userDataStreamSupervisor.subscribe({
+            exchange: normalizedCex,
+            accountSelector: selectedBrokerAccount.label,
+            kind: subscriptionType === SubscriptionType.BALANCE ? "balance" : "orders",
+            marketId
+          });
+        }
+        await streamBinanceUserData(call, accountBroker, resolvedSymbol, subscriptionType, isStreamClosed, streamArchiveContext, userDataSource, marketId);
         return;
       }
       switch (subscriptionType) {
@@ -310691,7 +311690,7 @@ var CEX_BROKER_PACKAGE_DEFINITION = protoLoader.fromJSON(node_descriptor_default
 // src/server.ts
 var grpcObj = grpc14.loadPackageDefinition(CEX_BROKER_PACKAGE_DEFINITION);
 var cexNode = grpcObj.cex_broker;
-function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, otelMetrics, brokerArchiver, orderActivityTracker, withdrawalObservationTracker, subscribeBrokerLifecycle) {
+function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, otelMetrics, brokerArchiver, orderActivityTracker, withdrawalObservationTracker, subscribeBrokerLifecycle, userDataStreamSupervisor) {
   const server = new grpc14.Server;
   server.addService(cexNode.cex_service.service, {
     ExecuteAction: createExecuteActionHandler({
@@ -310710,7 +311709,8 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
       whitelistIps,
       otelMetrics,
       brokerArchiver,
-      brokerLifecycle: subscribeBrokerLifecycle
+      brokerLifecycle: subscribeBrokerLifecycle,
+      userDataStreamSupervisor
     })
   });
   return server;
@@ -310854,13 +311854,14 @@ class CEXBroker {
   fillArchivePoller;
   depositArchivePoller;
   accountBalanceArchivePoller;
+  userDataStreamSupervisor;
   loadEnvConfig() {
     log.info("\uD83D\uDD27 Loading CEX_BROKER_ environment variables:");
     const configMap = {};
-    for (const [key, value] of Object.entries(process.env)) {
-      if (!key.startsWith("CEX_BROKER_"))
+    for (const [key2, value] of Object.entries(process.env)) {
+      if (!key2.startsWith("CEX_BROKER_"))
         continue;
-      let match = key.match(/^CEX_BROKER_(\w+)_(API_(KEY|SECRET)|ROLE|EMAIL|SUBACCOUNTID|UID)_(\d+)$/);
+      let match = key2.match(/^CEX_BROKER_(\w+)_(API_(KEY|SECRET)|ROLE|EMAIL|SUBACCOUNTID|UID)_(\d+)$/);
       if (match) {
         const broker2 = match[1]?.toLowerCase() ?? "";
         const type3 = match[2]?.toLowerCase() ?? "";
@@ -310889,9 +311890,9 @@ class CEXBroker {
         }
         continue;
       }
-      match = key.match(/^CEX_BROKER_(\w+)_(API_(KEY|SECRET)|ROLE|EMAIL|SUBACCOUNTID|UID)$/);
+      match = key2.match(/^CEX_BROKER_(\w+)_(API_(KEY|SECRET)|ROLE|EMAIL|SUBACCOUNTID|UID)$/);
       if (!match) {
-        log.warn(`⚠️ Skipping unrecognized env var: ${key}`);
+        log.warn(`⚠️ Skipping unrecognized env var: ${key2}`);
         continue;
       }
       const broker = match[1]?.toLowerCase() ?? "";
@@ -311009,6 +312010,10 @@ class CEXBroker {
     if (this.server) {
       await this.server.forceShutdown();
     }
+    if (this.userDataStreamSupervisor) {
+      await this.userDataStreamSupervisor.close();
+      this.userDataStreamSupervisor = undefined;
+    }
     if (this.brokerArchiver) {
       await this.brokerArchiver.close();
     }
@@ -311020,6 +312025,14 @@ class CEXBroker {
     }
   }
   async run() {
+    const marketArchiveState = resolveMarketCaptureArchiveState({
+      archiveEnabled: this.brokerArchiver?.isEnabled() ?? false,
+      marketArchiveEnabled: isMarketArchiveEnabled(),
+      environment: process.env.CEX_BROKER_MARKET_CAPTURE_ENVIRONMENT,
+      deploymentId: this.brokerArchiver?.getDeploymentId(),
+      captureBundleId: process.env.CEX_BROKER_CAPTURE_BUNDLE_ID
+    });
+    assertMarketCaptureArchiveStartable(marketArchiveState);
     if (this.server) {
       await this.server.forceShutdown();
     }
@@ -311043,7 +312056,15 @@ class CEXBroker {
     if (this.otelMetrics?.isOtelEnabled()) {
       await this.otelMetrics.initialize();
     }
-    this.server = getServer(this.policy, this.brokers, this.whitelistIps, this.useVerity, this.#verityProverUrl, this.otelMetrics, this.brokerArchiver, this.orderActivityTracker, this.withdrawalObservationTracker, undefined);
+    if (!this.userDataStreamSupervisor && Object.keys(this.brokers).length > 0) {
+      const publisher = new StreamHealthPublisher(streamHealthPublisherConfigFromEnv());
+      this.userDataStreamSupervisor = new UserDataStreamSupervisor({
+        brokers: this.brokers,
+        publisher
+      });
+      this.userDataStreamSupervisor.start();
+    }
+    this.server = getServer(this.policy, this.brokers, this.whitelistIps, this.useVerity, this.#verityProverUrl, this.otelMetrics, this.brokerArchiver, this.orderActivityTracker, this.withdrawalObservationTracker, undefined, this.userDataStreamSupervisor);
     this.server.bindAsync(`0.0.0.0:${this.port}`, grpc15.ServerCredentials.createInsecure(), (err2, port) => {
       if (err2) {
         log.error(err2);
@@ -311088,4 +312109,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=4F503765D539243C64756E2164756E21
+//# debugId=14D3F8955E8B1FB864756E2164756E21