@usherlabs/cex-broker 0.2.37 → 0.2.40

package/dist/commands/cli.js

@@ -316623,9 +316623,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, [
@@ -316738,6 +316747,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) {
@@ -316748,12 +316765,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", {
@@ -316761,10 +316778,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) {
@@ -316812,7 +316829,7 @@ class DepositArchivePoller {
           network: network === undefined ? undefined : String(network),
           externalId: depositTxid,
           txid: depositTxid,
-          exchangeTimestamp: typeof creditedAt === "string" ? creditedAt : undefined,
+          exchangeTimestamp: normalizeTimestamp2(creditedAt),
           payload: record
         }
       }));
@@ -316845,6 +316862,7 @@ class DepositArchivePoller {
         this.#lastArchivedByTarget.delete(key);
       }
     }
+    return "ok";
   }
   #targetKey(target) {
     return `${target.exchangeId}|${target.account.label}|${target.code}`;
@@ -316986,387 +317004,1609 @@ class FillArchivePoller {
   }
 }
 
-// src/helpers/order-activity-tracker.ts
-var DEFAULT_MAX_AGE_MS = 6 * 60 * 60 * 1000;
-
-class OrderActivityTracker {
-  #entries = new Map;
-  #maxAgeMs;
-  constructor(options) {
-    this.#maxAgeMs = options?.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+// 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");
   }
-  record(exchangeId, accountLabel, symbol, now3 = Date.now()) {
-    const exchange = exchangeId.trim().toLowerCase();
-    const trimmedSymbol = symbol.trim();
-    if (!exchange || !accountLabel.trim() || !trimmedSymbol) {
-      return;
-    }
-    const key = `${exchange}|${accountLabel}|${trimmedSymbol}`;
-    this.#entries.set(key, {
-      exchangeId: exchange,
-      accountLabel,
-      symbol: trimmedSymbol,
-      lastActivityAt: now3
-    });
+  if (Object.is(value, -0)) {
+    return "0";
   }
-  list(now3 = Date.now()) {
-    const active = [];
-    for (const [key, entry] of this.#entries) {
-      if (now3 - entry.lastActivityAt > this.#maxAgeMs) {
-        this.#entries.delete(key);
-        continue;
-      }
-      active.push(entry);
-    }
-    return active;
+  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;
 }
-
-// src/helpers/otel.ts
-var import_api2 = __toESM(require_src5(), 1);
-var import_api_logs3 = __toESM(require_src7(), 1);
-var import_exporter_logs_otlp_http = __toESM(require_src14(), 1);
-var import_exporter_metrics_otlp_http = __toESM(require_src15(), 1);
-var import_resources = __toESM(require_src11(), 1);
-var import_sdk_logs = __toESM(require_src16(), 1);
-var import_sdk_metrics = __toESM(require_src12(), 1);
-var DEFAULT_SERVICE = "cex-broker";
-var DEFAULT_OTLP_PORT = 4318;
-var EXPORT_INTERVAL_MS = 5000;
-
-class BaseOtelSignal {
-  signal;
-  provider = null;
-  isEnabled = false;
-  serviceName;
-  constructor(config, signal) {
-    this.signal = signal;
-    this.serviceName = config?.serviceName ?? DEFAULT_SERVICE;
-    const endpointResolution = resolveOtlpEndpoint(this.signal, config);
-    if (!endpointResolution) {
-      log.info(`OTel ${signal} disabled: no OTLP endpoint or host provided`);
-      return;
-    }
-    try {
-      this.provider = this.createProvider(endpointResolution.endpoint, this.serviceName, endpointResolution.appendSignalPath);
-      this.onProviderCreated(this.provider);
-      this.isEnabled = true;
-      log.info(`OTel ${signal} enabled: ${endpointResolution.endpoint}`);
-    } catch (error) {
-      log.error(`Failed to initialize OTel ${signal}:`, error);
-      this.isEnabled = false;
-      this.provider = null;
+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);
   }
-  onProviderCreated(_provider) {}
-  onProviderClosed() {}
-  getProvider() {
-    return this.provider;
-  }
-  getServiceName() {
-    return this.serviceName;
-  }
-  isOtelEnabled() {
-    return this.isEnabled && this.provider !== null;
+  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;
   }
-  async close() {
-    if (!this.provider) {
-      return;
-    }
-    try {
-      await this.shutdownProvider(this.provider);
-      log.info(`OTel ${this.signal} provider shut down`);
-    } catch (error) {
-      log.error(`Error shutting down OTel ${this.signal} provider:`, error);
-    }
-    this.provider = null;
-    this.isEnabled = false;
-    this.onProviderClosed();
+  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 toAttributes(labels, service) {
-  const attrs = { ...labels, service };
-  for (const key of Object.keys(attrs)) {
-    const v = attrs[key];
-    if (typeof v !== "string" && typeof v !== "number") {
-      attrs[key] = String(v);
-    }
+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 attrs;
+  return value;
 }
-
-class OtelMetrics extends BaseOtelSignal {
-  counters = new Map;
-  histograms = new Map;
-  observableGauges = new Map;
-  constructor(config) {
-    super(config, "metrics");
+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;
   }
-  createProvider(endpoint, serviceName, appendSignalPath) {
-    const exporter = new import_exporter_metrics_otlp_http.OTLPMetricExporter({
-      url: appendOtlpPath(endpoint, "metrics", appendSignalPath)
-    });
-    const reader = new import_sdk_metrics.PeriodicExportingMetricReader({
-      exporter,
-      exportIntervalMillis: EXPORT_INTERVAL_MS
-    });
-    const resource = import_resources.resourceFromAttributes({
-      "service.name": serviceName
-    });
-    return new import_sdk_metrics.MeterProvider({
-      resource,
-      readers: [reader]
-    });
+  if (!Number.isSafeInteger(timestamp) || timestamp < 0) {
+    throw new Error(`${field} must be a non-negative millisecond timestamp`);
   }
-  onProviderCreated(provider) {
-    import_api2.metrics.setGlobalMeterProvider(provider);
+  return timestamp;
+}
+function assertCaptureContext(context2) {
+  if (!ARCHIVE_SOURCES.includes(context2.source)) {
+    throw new Error(`Unsupported archive source: ${context2.source}`);
   }
-  shutdownProvider(provider) {
-    return provider.shutdown();
+  if (!CAPTURE_FEEDS.includes(context2.feed)) {
+    throw new Error(`Unsupported capture feed: ${context2.feed}`);
   }
-  async initialize() {
-    if (this.isOtelEnabled()) {
-      log.info("OTel metrics initialized (storage is handled by the collector)");
-    }
+  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;
+
+class OrderActivityTracker {
+  #entries = new Map;
+  #maxAgeMs;
+  constructor(options) {
+    this.#maxAgeMs = options?.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+  }
+  record(exchangeId, accountLabel, symbol, now3 = Date.now()) {
+    const exchange = exchangeId.trim().toLowerCase();
+    const trimmedSymbol = symbol.trim();
+    if (!exchange || !accountLabel.trim() || !trimmedSymbol) {
+      return;
+    }
+    const key = `${exchange}|${accountLabel}|${trimmedSymbol}`;
+    this.#entries.set(key, {
+      exchangeId: exchange,
+      accountLabel,
+      symbol: trimmedSymbol,
+      lastActivityAt: now3
+    });
+  }
+  list(now3 = Date.now()) {
+    const active = [];
+    for (const [key, entry] of this.#entries) {
+      if (now3 - entry.lastActivityAt > this.#maxAgeMs) {
+        this.#entries.delete(key);
+        continue;
+      }
+      active.push(entry);
+    }
+    return active;
+  }
+}
+
+// src/helpers/otel.ts
+var import_api2 = __toESM(require_src5(), 1);
+var import_api_logs3 = __toESM(require_src7(), 1);
+var import_exporter_logs_otlp_http = __toESM(require_src14(), 1);
+var import_exporter_metrics_otlp_http = __toESM(require_src15(), 1);
+var import_resources = __toESM(require_src11(), 1);
+var import_sdk_logs = __toESM(require_src16(), 1);
+var import_sdk_metrics = __toESM(require_src12(), 1);
+var DEFAULT_SERVICE = "cex-broker";
+var DEFAULT_OTLP_PORT = 4318;
+var EXPORT_INTERVAL_MS = 5000;
+
+class BaseOtelSignal {
+  signal;
+  provider = null;
+  isEnabled = false;
+  serviceName;
+  constructor(config, signal) {
+    this.signal = signal;
+    this.serviceName = config?.serviceName ?? DEFAULT_SERVICE;
+    const endpointResolution = resolveOtlpEndpoint(this.signal, config);
+    if (!endpointResolution) {
+      log.info(`OTel ${signal} disabled: no OTLP endpoint or host provided`);
+      return;
+    }
+    try {
+      this.provider = this.createProvider(endpointResolution.endpoint, this.serviceName, endpointResolution.appendSignalPath);
+      this.onProviderCreated(this.provider);
+      this.isEnabled = true;
+      log.info(`OTel ${signal} enabled: ${endpointResolution.endpoint}`);
+    } catch (error) {
+      log.error(`Failed to initialize OTel ${signal}:`, error);
+      this.isEnabled = false;
+      this.provider = null;
+    }
+  }
+  onProviderCreated(_provider) {}
+  onProviderClosed() {}
+  getProvider() {
+    return this.provider;
+  }
+  getServiceName() {
+    return this.serviceName;
+  }
+  isOtelEnabled() {
+    return this.isEnabled && this.provider !== null;
+  }
+  async close() {
+    if (!this.provider) {
+      return;
+    }
+    try {
+      await this.shutdownProvider(this.provider);
+      log.info(`OTel ${this.signal} provider shut down`);
+    } catch (error) {
+      log.error(`Error shutting down OTel ${this.signal} provider:`, error);
+    }
+    this.provider = null;
+    this.isEnabled = false;
+    this.onProviderClosed();
+  }
+}
+function toAttributes(labels, service) {
+  const attrs = { ...labels, service };
+  for (const key of Object.keys(attrs)) {
+    const v = attrs[key];
+    if (typeof v !== "string" && typeof v !== "number") {
+      attrs[key] = String(v);
+    }
+  }
+  return attrs;
+}
+
+class OtelMetrics extends BaseOtelSignal {
+  counters = new Map;
+  histograms = new Map;
+  observableGauges = new Map;
+  constructor(config) {
+    super(config, "metrics");
+  }
+  createProvider(endpoint, serviceName, appendSignalPath) {
+    const exporter = new import_exporter_metrics_otlp_http.OTLPMetricExporter({
+      url: appendOtlpPath(endpoint, "metrics", appendSignalPath)
+    });
+    const reader = new import_sdk_metrics.PeriodicExportingMetricReader({
+      exporter,
+      exportIntervalMillis: EXPORT_INTERVAL_MS
+    });
+    const resource = import_resources.resourceFromAttributes({
+      "service.name": serviceName
+    });
+    return new import_sdk_metrics.MeterProvider({
+      resource,
+      readers: [reader]
+    });
+  }
+  onProviderCreated(provider) {
+    import_api2.metrics.setGlobalMeterProvider(provider);
+  }
+  shutdownProvider(provider) {
+    return provider.shutdown();
+  }
+  async initialize() {
+    if (this.isOtelEnabled()) {
+      log.info("OTel metrics initialized (storage is handled by the collector)");
+    }
+  }
+  async insertMetric(metric) {
+    if (!this.isOtelEnabled())
+      return;
+    const labels = metric.labels ? JSON.parse(metric.labels) : {};
+    try {
+      if (metric.metric_type === "counter") {
+        await this.recordCounter(metric.metric_name, metric.value, labels, metric.service);
+      } else if (metric.metric_type === "gauge") {
+        await this.recordGauge(metric.metric_name, metric.value, labels, metric.service);
+      } else {
+        await this.recordHistogram(metric.metric_name, metric.value, labels, metric.service);
+      }
+    } catch {}
+  }
+  async insertMetrics(metricsList) {
+    if (!this.isOtelEnabled() || metricsList.length === 0)
+      return;
+    for (const m of metricsList) {
+      await this.insertMetric(m);
+    }
+  }
+  async recordCounter(metricName, value, labels, service = this.getServiceName()) {
+    const provider = this.getProvider();
+    if (!this.isOtelEnabled() || !provider)
+      return;
+    try {
+      let counter = this.counters.get(metricName);
+      if (!counter) {
+        const meter = provider.getMeter("cex-broker-metrics", "1.0.0");
+        counter = meter.createCounter(metricName, { description: metricName });
+        this.counters.set(metricName, counter);
+      }
+      counter.add(value, toAttributes(labels, service));
+    } catch (error) {
+      log.error("Failed to record counter:", error);
+    }
+  }
+  async recordGauge(metricName, value, labels, service = this.getServiceName()) {
+    const provider = this.getProvider();
+    if (!this.isOtelEnabled() || !provider)
+      return;
+    try {
+      let hist = this.histograms.get(`gauge_${metricName}`);
+      if (!hist) {
+        const meter = provider.getMeter("cex-broker-metrics", "1.0.0");
+        hist = meter.createHistogram(`${metricName}_gauge`, {
+          description: metricName
+        });
+        this.histograms.set(`gauge_${metricName}`, hist);
+      }
+      hist.record(value, toAttributes(labels, service));
+    } catch (error) {
+      log.error("Failed to record gauge:", error);
+    }
+  }
+  async setObservableGauge(metricName, value, labels, service = this.getServiceName()) {
+    const provider = this.getProvider();
+    if (!this.isOtelEnabled() || !provider)
+      return;
+    try {
+      let state = this.observableGauges.get(metricName);
+      if (!state) {
+        const observations = new Map;
+        const instrument = provider.getMeter("cex-broker-metrics", "1.0.0").createObservableGauge(metricName, { description: metricName });
+        instrument.addCallback((result) => {
+          for (const observation of observations.values()) {
+            result.observe(observation.value, observation.attributes);
+          }
+        });
+        state = { instrument, observations };
+        this.observableGauges.set(metricName, state);
+      }
+      const attributes = toAttributes(labels, service);
+      state.observations.set(stableAttributeKey(attributes), {
+        value,
+        attributes
+      });
+    } catch (error) {
+      log.error("Failed to set observable gauge:", error);
+    }
+  }
+  async recordHistogram(metricName, value, labels, service = this.getServiceName()) {
+    const provider = this.getProvider();
+    if (!this.isOtelEnabled() || !provider)
+      return;
+    try {
+      let hist = this.histograms.get(metricName);
+      if (!hist) {
+        const meter = provider.getMeter("cex-broker-metrics", "1.0.0");
+        hist = meter.createHistogram(metricName, { description: metricName });
+        this.histograms.set(metricName, hist);
+      }
+      hist.record(value, toAttributes(labels, service));
+    } catch (error) {
+      log.error("Failed to record histogram:", error);
+    }
+  }
+}
+
+class OtelLogs extends BaseOtelSignal {
+  logger = null;
+  constructor(config) {
+    super(config, "logs");
+  }
+  createProvider(endpoint, serviceName, appendSignalPath) {
+    const exporter = new import_exporter_logs_otlp_http.OTLPLogExporter({
+      url: appendOtlpPath(endpoint, "logs", appendSignalPath)
+    });
+    const processor = new import_sdk_logs.BatchLogRecordProcessor(exporter);
+    const resource = import_resources.resourceFromAttributes({
+      "service.name": serviceName
+    });
+    return new import_sdk_logs.LoggerProvider({
+      resource,
+      processors: [processor]
+    });
+  }
+  onProviderCreated(provider) {
+    import_api_logs3.logs.setGlobalLoggerProvider(provider);
+    this.logger = provider.getLogger("cex-broker-logs", "1.0.0");
+  }
+  shutdownProvider(provider) {
+    return provider.forceFlush().then(() => provider.shutdown());
+  }
+  onProviderClosed() {
+    this.logger = null;
+  }
+  emit(record) {
+    if (!this.isOtelEnabled() || !this.logger) {
+      return;
+    }
+    this.logger.emit(record);
+  }
+}
+function resolveOtlpEndpoint(signal, config) {
+  if (config?.otlpEndpoint) {
+    return {
+      endpoint: normalizeOtlpEndpoint(config.otlpEndpoint),
+      appendSignalPath: true
+    };
+  }
+  const signalEndpoint = signal === "metrics" ? process.env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT : process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;
+  if (signalEndpoint) {
+    return {
+      endpoint: signalEndpoint,
+      appendSignalPath: false
+    };
+  }
+  if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+    return {
+      endpoint: normalizeOtlpEndpoint(process.env.OTEL_EXPORTER_OTLP_ENDPOINT),
+      appendSignalPath: true
+    };
+  }
+  if (config?.host) {
+    const protocol = config.protocol || "http";
+    const port = config.port ?? DEFAULT_OTLP_PORT;
+    return {
+      endpoint: `${protocol}://${config.host}:${port}`,
+      appendSignalPath: true
+    };
+  }
+  return null;
+}
+function appendOtlpPath(endpoint, signal, appendSignalPath) {
+  if (!appendSignalPath) {
+    return endpoint;
+  }
+  const baseEndpoint = normalizeOtlpEndpoint(endpoint);
+  return `${baseEndpoint}/v1/${signal}`;
+}
+function normalizeOtlpEndpoint(endpoint) {
+  return endpoint.replace(/\/v1\/(metrics|logs)\/?$/, "").replace(/\/+$/, "");
+}
+function getOtelHostFromEnv() {
+  return process.env.CEX_BROKER_OTEL_HOST ?? process.env.CEX_BROKER_CLICKHOUSE_HOST;
+}
+function getOtelPortFromEnv() {
+  const port = process.env.CEX_BROKER_OTEL_PORT ?? process.env.CEX_BROKER_CLICKHOUSE_PORT;
+  return port ? Number.parseInt(port, 10) : undefined;
+}
+function getOtelProtocolFromEnv() {
+  const protocol = process.env.CEX_BROKER_OTEL_PROTOCOL ?? process.env.CEX_BROKER_CLICKHOUSE_PROTOCOL;
+  return protocol || "http";
+}
+function createOtelMetricsFromEnv(options = {}) {
+  const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  const serviceName = process.env.OTEL_SERVICE_NAME || options.defaultServiceName || DEFAULT_SERVICE;
+  if (otlpEndpoint) {
+    return new OtelMetrics({
+      otlpEndpoint,
+      serviceName
+    });
+  }
+  if (options.allowLegacyBrokerConfig === false) {
+    return new OtelMetrics({ serviceName });
+  }
+  const host = getOtelHostFromEnv();
+  if (!host)
+    return new OtelMetrics({ serviceName });
+  const port = getOtelPortFromEnv();
+  const config = {
+    host,
+    port: port ?? DEFAULT_OTLP_PORT,
+    protocol: getOtelProtocolFromEnv(),
+    serviceName
+  };
+  return new OtelMetrics(config);
+}
+function stableAttributeKey(attributes) {
+  return JSON.stringify(Object.entries(attributes).sort(([left], [right]) => left.localeCompare(right)));
+}
+function createOtelLogsFromEnv() {
+  const logsEndpoint = process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;
+  const genericEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  const host = getOtelHostFromEnv();
+  if (logsEndpoint) {
+    return new OtelLogs({
+      serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
+    });
+  }
+  if (genericEndpoint) {
+    return new OtelLogs({
+      otlpEndpoint: genericEndpoint,
+      serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
+    });
   }
-  async insertMetric(metric) {
-    if (!this.isOtelEnabled())
+  if (!host) {
+    return new OtelLogs;
+  }
+  const port = getOtelPortFromEnv();
+  const config = {
+    host,
+    port: port ?? DEFAULT_OTLP_PORT,
+    protocol: getOtelProtocolFromEnv(),
+    serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
+  };
+  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;
-    const labels = metric.labels ? JSON.parse(metric.labels) : {};
+    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 {
-      if (metric.metric_type === "counter") {
-        await this.recordCounter(metric.metric_name, metric.value, labels, metric.service);
-      } else if (metric.metric_type === "gauge") {
-        await this.recordGauge(metric.metric_name, metric.value, labels, metric.service);
-      } else {
-        await this.recordHistogram(metric.metric_name, metric.value, labels, metric.service);
+      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
+    }));
   }
-  async insertMetrics(metricsList) {
-    if (!this.isOtelEnabled() || metricsList.length === 0)
+  handleMessage(data) {
+    if (this.closed) {
       return;
-    for (const m of metricsList) {
-      await this.insertMetric(m);
     }
-  }
-  async recordCounter(metricName, value, labels, service = this.getServiceName()) {
-    const provider = this.getProvider();
-    if (!this.isOtelEnabled() || !provider)
-      return;
+    let message;
     try {
-      let counter = this.counters.get(metricName);
-      if (!counter) {
-        const meter = provider.getMeter("cex-broker-metrics", "1.0.0");
-        counter = meter.createCounter(metricName, { description: metricName });
-        this.counters.set(metricName, counter);
-      }
-      counter.add(value, toAttributes(labels, service));
+      const decodedData = decodeMessageData(data);
+      message = typeof decodedData === "string" ? JSON.parse(decodedData) : decodedData;
     } catch (error) {
-      log.error("Failed to record counter:", error);
-    }
-  }
-  async recordGauge(metricName, value, labels, service = this.getServiceName()) {
-    const provider = this.getProvider();
-    if (!this.isOtelEnabled() || !provider)
+      this.fail(error instanceof Error ? error : new Error("Invalid Binance user-data message"), "protocol_error");
       return;
-    try {
-      let hist = this.histograms.get(`gauge_${metricName}`);
-      if (!hist) {
-        const meter = provider.getMeter("cex-broker-metrics", "1.0.0");
-        hist = meter.createHistogram(`${metricName}_gauge`, {
-          description: metricName
-        });
-        this.histograms.set(`gauge_${metricName}`, hist);
+    }
+    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;
       }
-      hist.record(value, toAttributes(labels, service));
-    } catch (error) {
-      log.error("Failed to record gauge:", error);
+      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 });
   }
-  async setObservableGauge(metricName, value, labels, service = this.getServiceName()) {
-    const provider = this.getProvider();
-    if (!this.isOtelEnabled() || !provider)
+  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;
-    try {
-      let state = this.observableGauges.get(metricName);
-      if (!state) {
-        const observations = new Map;
-        const instrument = provider.getMeter("cex-broker-metrics", "1.0.0").createObservableGauge(metricName, { description: metricName });
-        instrument.addCallback((result) => {
-          for (const observation of observations.values()) {
-            result.observe(observation.value, observation.attributes);
-          }
-        });
-        state = { instrument, observations };
-        this.observableGauges.set(metricName, state);
-      }
-      const attributes = toAttributes(labels, service);
-      state.observations.set(stableAttributeKey(attributes), {
-        value,
-        attributes
-      });
-    } catch (error) {
-      log.error("Failed to set observable gauge:", error);
     }
+    this.queue.push(event);
   }
-  async recordHistogram(metricName, value, labels, service = this.getServiceName()) {
-    const provider = this.getProvider();
-    if (!this.isOtelEnabled() || !provider)
+  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 {
-      let hist = this.histograms.get(metricName);
-      if (!hist) {
-        const meter = provider.getMeter("cex-broker-metrics", "1.0.0");
-        hist = meter.createHistogram(metricName, { description: metricName });
-        this.histograms.set(metricName, hist);
+      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);
       }
-      hist.record(value, toAttributes(labels, service));
-    } catch (error) {
-      log.error("Failed to record histogram:", error);
     }
   }
 }
+function isBinanceBalanceUserDataEvent(event) {
+  return event.e === "outboundAccountPosition" || event.e === "balanceUpdate" || event.e === "externalLockUpdate";
+}
+function isBinanceOrderUserDataEvent(event) {
+  return event.e === "executionReport" || event.e === "listStatus";
+}
 
-class OtelLogs extends BaseOtelSignal {
-  logger = null;
-  constructor(config) {
-    super(config, "logs");
+// 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;
   }
-  createProvider(endpoint, serviceName, appendSignalPath) {
-    const exporter = new import_exporter_logs_otlp_http.OTLPLogExporter({
-      url: appendOtlpPath(endpoint, "logs", appendSignalPath)
-    });
-    const processor = new import_sdk_logs.BatchLogRecordProcessor(exporter);
-    const resource = import_resources.resourceFromAttributes({
-      "service.name": serviceName
-    });
-    return new import_sdk_logs.LoggerProvider({
-      resource,
-      processors: [processor]
-    });
+  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);
   }
-  onProviderCreated(provider) {
-    import_api_logs3.logs.setGlobalLoggerProvider(provider);
-    this.logger = provider.getLogger("cex-broker-logs", "1.0.0");
+  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);
   }
-  shutdownProvider(provider) {
-    return provider.forceFlush().then(() => provider.shutdown());
+  async* [Symbol.asyncIterator]() {
+    while (true) {
+      const event = await this.#next();
+      if (!event)
+        return;
+      yield event;
+    }
   }
-  onProviderClosed() {
-    this.logger = null;
+  #matches(event) {
+    if (this.kind === "balance")
+      return isBinanceBalanceUserDataEvent(event);
+    if (!isBinanceOrderUserDataEvent(event))
+      return false;
+    return !this.marketId || event.s === this.marketId;
   }
-  emit(record) {
-    if (!this.isOtelEnabled() || !this.logger) {
-      return;
-    }
-    this.logger.emit(record);
+  #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 }));
   }
-}
-function resolveOtlpEndpoint(signal, config) {
-  if (config?.otlpEndpoint) {
-    return {
-      endpoint: normalizeOtlpEndpoint(config.otlpEndpoint),
-      appendSignalPath: true
+  #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
     };
   }
-  const signalEndpoint = signal === "metrics" ? process.env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT : process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;
-  if (signalEndpoint) {
-    return {
-      endpoint: signalEndpoint,
-      appendSignalPath: false
-    };
+  start() {
+    if (this.exchangeName !== "binance") {
+      this.#fail("unsupported_connector", "Configured exchange has no user-data supervisor");
+      return;
+    }
+    this.#run = this.#connectLoop();
   }
-  if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
-    return {
-      endpoint: normalizeOtlpEndpoint(process.env.OTEL_EXPORTER_OTLP_ENDPOINT),
-      appendSignalPath: true
-    };
+  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;
   }
-  if (config?.host) {
-    const protocol = config.protocol || "http";
-    const port = config.port ?? DEFAULT_OTLP_PORT;
-    return {
-      endpoint: `${protocol}://${config.host}:${port}`,
-      appendSignalPath: true
-    };
+  snapshot() {
+    return { ...this.#snapshot };
   }
-  return null;
-}
-function appendOtlpPath(endpoint, signal, appendSignalPath) {
-  if (!appendSignalPath) {
-    return endpoint;
+  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();
+    }
   }
-  const baseEndpoint = normalizeOtlpEndpoint(endpoint);
-  return `${baseEndpoint}/v1/${signal}`;
-}
-function normalizeOtlpEndpoint(endpoint) {
-  return endpoint.replace(/\/v1\/(metrics|logs)\/?$/, "").replace(/\/+$/, "");
-}
-function getOtelHostFromEnv() {
-  return process.env.CEX_BROKER_OTEL_HOST ?? process.env.CEX_BROKER_CLICKHOUSE_HOST;
-}
-function getOtelPortFromEnv() {
-  const port = process.env.CEX_BROKER_OTEL_PORT ?? process.env.CEX_BROKER_CLICKHOUSE_PORT;
-  return port ? Number.parseInt(port, 10) : undefined;
-}
-function getOtelProtocolFromEnv() {
-  const protocol = process.env.CEX_BROKER_OTEL_PROTOCOL ?? process.env.CEX_BROKER_CLICKHOUSE_PROTOCOL;
-  return protocol || "http";
-}
-function createOtelMetricsFromEnv(options = {}) {
-  const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-  const serviceName = process.env.OTEL_SERVICE_NAME || options.defaultServiceName || DEFAULT_SERVICE;
-  if (otlpEndpoint) {
-    return new OtelMetrics({
-      otlpEndpoint,
-      serviceName
-    });
+  #handleStreamFailure(failure) {
+    this.#fail(failure.kind, failure.reason);
   }
-  if (options.allowLegacyBrokerConfig === false) {
-    return new OtelMetrics({ serviceName });
+  #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?.();
+    });
   }
-  const host = getOtelHostFromEnv();
-  if (!host)
-    return new OtelMetrics({ serviceName });
-  const port = getOtelPortFromEnv();
-  const config = {
-    host,
-    port: port ?? DEFAULT_OTLP_PORT,
-    protocol: getOtelProtocolFromEnv(),
-    serviceName
-  };
-  return new OtelMetrics(config);
 }
-function stableAttributeKey(attributes) {
-  return JSON.stringify(Object.entries(attributes).sort(([left], [right]) => left.localeCompare(right)));
-}
-function createOtelLogsFromEnv() {
-  const logsEndpoint = process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;
-  const genericEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-  const host = getOtelHostFromEnv();
-  if (logsEndpoint) {
-    return new OtelLogs({
-      serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
-    });
+
+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");
+    }
   }
-  if (genericEndpoint) {
-    return new OtelLogs({
-      otlpEndpoint: genericEndpoint,
-      serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
-    });
+  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 });
   }
-  if (!host) {
-    return new OtelLogs;
+  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());
   }
-  const port = getOtelPortFromEnv();
-  const config = {
-    host,
-    port: port ?? DEFAULT_OTLP_PORT,
-    protocol: getOtelProtocolFromEnv(),
-    serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
-  };
-  return new OtelLogs(config);
 }
 
 // src/server.ts
@@ -318209,9 +319449,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;
@@ -318223,7 +319463,7 @@ function defineLazy(object, key, getter) {
       return value;
     },
     set(v) {
-      Object.defineProperty(object, key, {
+      Object.defineProperty(object, key2, {
         value: v
       });
     },
@@ -318255,11 +319495,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++) {
@@ -318323,8 +319563,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++;
     }
   }
@@ -318467,13 +319707,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;
@@ -318492,13 +319732,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;
@@ -318515,8 +319755,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.");
       }
     }
@@ -318569,23 +319809,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);
@@ -318601,22 +319841,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]
           });
         }
       }
@@ -320366,19 +321606,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) {
@@ -320403,18 +321643,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) {
@@ -320450,12 +321690,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;
@@ -320478,14 +321718,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) {
@@ -320501,23 +321741,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) {
@@ -320803,17 +322043,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 };
   }
@@ -320969,30 +322209,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) {
@@ -321005,16 +322245,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");
           }
@@ -321024,30 +322264,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;
         }
@@ -321074,15 +322314,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)
@@ -321090,10 +322330,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",
@@ -321105,15 +322345,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()))
       });
     }
@@ -321443,12 +322683,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);
@@ -328307,8 +329547,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;
   };
@@ -328375,20 +329615,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];
           }
         }
       }
@@ -328400,11 +329640,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];
             }
           }
         }
@@ -328495,8 +329735,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;
@@ -328787,15 +330027,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 {
@@ -329060,9 +330300,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";
@@ -330619,11 +331859,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}`);
 }
@@ -330809,9 +332049,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);
@@ -330955,20 +332195,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) {
@@ -331333,7 +332573,7 @@ async function handleDeposit(ctx) {
           network: depositNetwork?.exchangeNetworkId,
           externalId: depositTxid,
           txid: depositTxid,
-          exchangeTimestamp: typeof creditedAt === "string" ? creditedAt : undefined,
+          exchangeTimestamp: normalizeTimestamp2(creditedAt),
           payload: deposit
         }
       });
@@ -331554,320 +332794,118 @@ function parseOrderBookCallPayload(payload, request) {
   }
   if (parsedStart.timestamp >= parsedEnd.timestamp) {
     return {
-      kind: "error",
-      message: "ValidationError: start must be before end"
-    };
-  }
-  const parsedCadence = parseCadence(payloadValue(payload, "cadence"));
-  if (!parsedCadence.ok) {
-    return { kind: "error", message: parsedCadence.message };
-  }
-  return {
-    kind: "order_book",
-    payload: {
-      ...parsed,
-      start: parsedStart.value,
-      end: parsedEnd.value,
-      cadence: parsedCadence.value
-    }
-  };
-}
-function parseOptionalDepthLimit(value) {
-  const parsed = parsePositiveInteger(nonEmptyString(value), "depthLimit");
-  return parsed.ok ? parsed.value : undefined;
-}
-function scalarByAlias(payload, aliases) {
-  for (const alias of aliases) {
-    const value = payload[alias];
-    if (isScalar(value)) {
-      return value;
-    }
-  }
-  return;
-}
-function normalizeSide(payload, side, depthLimit) {
-  const rawLevels = payload[side];
-  if (!Array.isArray(rawLevels)) {
-    throw new Error(`Malformed order book: ${side} must be an array`);
-  }
-  return rawLevels.slice(0, depthLimit).map((level, index2) => {
-    if (!Array.isArray(level) || level.length < 2) {
-      throw new Error(`Malformed order book: ${side}[${index2}] must be [price, amount]`);
-    }
-    const price = Number(level[0]);
-    const amount = Number(level[1]);
-    if (!Number.isFinite(price) || !Number.isFinite(amount)) {
-      throw new Error(`Malformed order book: ${side}[${index2}] must be numeric`);
-    }
-    return [price, amount];
-  });
-}
-function normalizeOrderBookSnapshot(orderBook, options) {
-  if (!isRecord(orderBook)) {
-    throw new Error("Malformed order book: expected object");
-  }
-  const receivedTimestamp = options.receivedTimestamp ?? Date.now();
-  const timestamp = scalarByAlias(orderBook, ["timestamp"]) ?? receivedTimestamp;
-  const sequence = scalarByAlias(orderBook, [
-    "sequence",
-    "updateId",
-    "lastUpdateId",
-    "nonce"
-  ]);
-  const normalized = {
-    bids: normalizeSide(orderBook, "bids", options.depthLimit),
-    asks: normalizeSide(orderBook, "asks", options.depthLimit),
-    timestamp,
-    receivedTimestamp,
-    exchange: options.exchange,
-    symbol: options.symbol,
-    depthLimit: options.depthLimit
-  };
-  if (sequence !== undefined) {
-    normalized.sequence = sequence;
-  }
-  return normalized;
-}
-function supportsBrokerMethod(broker, method) {
-  const fn = broker[method];
-  const hasValue = broker.has?.[method];
-  return typeof fn === "function" && hasValue !== false;
-}
-function buildOrderBookCapability(broker, payload) {
-  return {
-    exchange: payload.exchange,
-    symbol: payload.symbol,
-    provider: "ccxt_order_book",
-    maxDepth: payload.depthLimit,
-    timestampPrecision: "milliseconds",
-    constructionMode: payload.constructionMode,
-    supportsCurrentSnapshot: supportsBrokerMethod(broker, "fetchOrderBook"),
-    supportsLiveStream: supportsBrokerMethod(broker, "watchOrderBook"),
-    supportsHistoricalSnapshots: false,
-    supportsSampledTopN: false,
-    supportsExactL2Reconstruction: false
-  };
-}
-function buildHistoricalOrderBookUnsupported(payload) {
-  return {
-    exchange: payload.exchange,
-    symbol: payload.symbol,
-    provider: "ccxt_order_book",
-    constructionMode: payload.constructionMode,
-    depthLimit: payload.depthLimit,
-    start: payload.start,
-    end: payload.end,
-    cadence: payload.cadence,
-    unsupported: true,
-    unsupportedReason: HISTORICAL_ORDER_BOOK_PROVIDER_UNSUPPORTED
-  };
-}
-
-// src/handlers/execute-action/order-book-call.ts
-var grpc4 = __toESM(require_src3(), 1);
-
-// 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;
+      kind: "error",
+      message: "ValidationError: start must be before end"
+    };
   }
-  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)]));
+  const parsedCadence = parseCadence(payloadValue(payload, "cadence"));
+  if (!parsedCadence.ok) {
+    return { kind: "error", message: parsedCadence.message };
   }
-  return value;
+  return {
+    kind: "order_book",
+    payload: {
+      ...parsed,
+      start: parsedStart.value,
+      end: parsedEnd.value,
+      cadence: parsedCadence.value
+    }
+  };
 }
-function sha256Canonical(value) {
-  return createHash3("sha256").update(canonicalSerialize(omitChecksumFields(value))).digest("hex");
+function parseOptionalDepthLimit(value) {
+  const parsed = parsePositiveInteger(nonEmptyString(value), "depthLimit");
+  return parsed.ok ? parsed.value : undefined;
 }
-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`);
+function scalarByAlias(payload, aliases) {
+  for (const alias of aliases) {
+    const value = payload[alias];
+    if (isScalar(value)) {
+      return value;
+    }
   }
-  return timestamp;
+  return;
 }
-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}`);
+function normalizeSide(payload, side, depthLimit) {
+  const rawLevels = payload[side];
+  if (!Array.isArray(rawLevels)) {
+    throw new Error(`Malformed order book: ${side} must be an array`);
   }
-  if (!SOURCE_MODES.includes(context2.sourceMode)) {
-    throw new Error(`Unsupported source mode: ${context2.sourceMode}`);
+  return rawLevels.slice(0, depthLimit).map((level, index2) => {
+    if (!Array.isArray(level) || level.length < 2) {
+      throw new Error(`Malformed order book: ${side}[${index2}] must be [price, amount]`);
+    }
+    const price = Number(level[0]);
+    const amount = Number(level[1]);
+    if (!Number.isFinite(price) || !Number.isFinite(amount)) {
+      throw new Error(`Malformed order book: ${side}[${index2}] must be numeric`);
+    }
+    return [price, amount];
+  });
+}
+function normalizeOrderBookSnapshot(orderBook, options) {
+  if (!isRecord(orderBook)) {
+    throw new Error("Malformed order book: expected object");
   }
-  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`);
+  const receivedTimestamp = options.receivedTimestamp ?? Date.now();
+  const timestamp = scalarByAlias(orderBook, ["timestamp"]) ?? receivedTimestamp;
+  const sequence = scalarByAlias(orderBook, [
+    "sequence",
+    "updateId",
+    "lastUpdateId",
+    "nonce"
+  ]);
+  const normalized = {
+    bids: normalizeSide(orderBook, "bids", options.depthLimit),
+    asks: normalizeSide(orderBook, "asks", options.depthLimit),
+    timestamp,
+    receivedTimestamp,
+    exchange: options.exchange,
+    symbol: options.symbol,
+    depthLimit: options.depthLimit
+  };
+  if (sequence !== undefined) {
+    normalized.sequence = sequence;
   }
+  return normalized;
 }
-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
-  });
+function supportsBrokerMethod(broker, method) {
+  const fn = broker[method];
+  const hasValue = broker.has?.[method];
+  return typeof fn === "function" && hasValue !== false;
+}
+function buildOrderBookCapability(broker, payload) {
   return {
-    rawCaptureId,
-    rawCaptureScope: input.scope,
-    rawChecksum,
-    redactedPayload,
-    eventTimeMs,
-    receivedTimeMs,
-    checksumAlgorithm: context2.checksumAlgorithm
+    exchange: payload.exchange,
+    symbol: payload.symbol,
+    provider: "ccxt_order_book",
+    maxDepth: payload.depthLimit,
+    timestampPrecision: "milliseconds",
+    constructionMode: payload.constructionMode,
+    supportsCurrentSnapshot: supportsBrokerMethod(broker, "fetchOrderBook"),
+    supportsLiveStream: supportsBrokerMethod(broker, "watchOrderBook"),
+    supportsHistoricalSnapshots: false,
+    supportsSampledTopN: false,
+    supportsExactL2Reconstruction: false
   };
 }
-function captureCoreFields(context2, rawCapture) {
-  assertCaptureContext(context2);
+function buildHistoricalOrderBookUnsupported(payload) {
   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
+    exchange: payload.exchange,
+    symbol: payload.symbol,
+    provider: "ccxt_order_book",
+    constructionMode: payload.constructionMode,
+    depthLimit: payload.depthLimit,
+    start: payload.start,
+    end: payload.end,
+    cadence: payload.cadence,
+    unsupported: true,
+    unsupportedReason: HISTORICAL_ORDER_BOOK_PROVIDER_UNSUPPORTED
   };
 }
 
+// src/handlers/execute-action/order-book-call.ts
+var grpc4 = __toESM(require_src3(), 1);
+
 // src/helpers/market-data-archive/canonical-orderbook.ts
 class OrderBookValidationError extends Error {
   reason;
@@ -332035,46 +333073,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);
@@ -332199,47 +333197,14 @@ var DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT = 25;
 var MAX_ORDERBOOK_ARCHIVE_DEPTH_LIMIT = 500;
 function getOrderbookArchiveDepthLimit() {
   const raw = process.env.CEX_BROKER_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
-  if (!raw) {
-    return DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
-  }
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    return DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
-  }
-  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;
+  if (!raw) {
+    return DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
   }
-  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;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
   }
+  return Math.min(parsed, MAX_ORDERBOOK_ARCHIVE_DEPTH_LIMIT);
 }
 
 // src/helpers/market-data-archive/parse-stream.ts
@@ -332336,10 +333301,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;
@@ -332356,9 +333321,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",
@@ -332372,19 +333347,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 };
 }
@@ -332394,13 +333371,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 };
@@ -332480,10 +333458,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) {
@@ -332525,7 +333512,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(() => {
@@ -332570,7 +333557,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(() => {
@@ -333997,383 +334984,173 @@ function createExecuteActionHandler(deps) {
         }, null);
       }
       const normalizedCex = cex3.trim().toLowerCase();
-      const metadata = call.metadata;
-      const selectedBrokerAccount = selectBrokerAccountForCex(normalizedCex, brokers, metadata);
-      const broker = selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, call.metadata) ?? (isPublicMarketDataAction(action, call.request.payload) ? createPublicBroker(normalizedCex) : null);
-      if (!broker) {
-        return wrappedCallback({
-          code: grpc12.status.UNAUTHENTICATED,
-          message: `This Exchange is not registered and No API metadata was found`
-        }, null);
-      }
-      const verity = { proof: "" };
-      const applyVerityToBroker = (targetBroker) => {
-        if (!useVerity)
-          return;
-        const override = buildHttpClientOverrideFromMetadata(metadata, verityProverUrl, (proof, notaryPubKey) => {
-          verity.proof = proof;
-          log.debug(`Verity proof:`, { proof, notaryPubKey });
-        });
-        targetBroker.setHttpClientOverride(override, verityHttpClientOverridePredicate);
-      };
-      const preludeCtx = {
-        call,
-        wrappedCallback,
-        action,
-        policy,
-        brokers,
-        metadata,
-        normalizedCex,
-        cex: cex3,
-        symbol: symbol2,
-        selectedBrokerAccount,
-        broker,
-        verity,
-        applyVerityToBroker,
-        useVerity,
-        verityProverUrl,
-        otelMetrics,
-        brokerArchiver,
-        orderActivityTracker,
-        withdrawalObservationTracker
-      };
-      if (action === Action.Call) {
-        const handled = await handleOrderBookCall(preludeCtx);
-        if (handled)
-          return;
-      }
-      applyVerityToBroker(broker);
-      const ctx = { ...preludeCtx, broker };
-      await dispatchExecuteAction(ctx);
-    } catch (error48) {
-      safeLogError("ExecuteAction unhandled error", error48);
-      return wrappedCallback({
-        code: grpc12.status.INTERNAL,
-        message: "ExecuteAction failed unexpectedly"
-      }, null);
-    }
-  };
-}
-// src/handlers/subscribe/broker-lifecycle.ts
-class SubscribeBrokerLifecycle {
-  #brokers = new Map;
-  #closing = new Map;
-  #shuttingDown = false;
-  register(broker, context2) {
-    this.#brokers.set(broker, context2);
-    if (this.#shuttingDown) {
-      this.close(broker);
-    }
-  }
-  close(broker) {
-    const existing = this.#closing.get(broker);
-    if (existing) {
-      return existing;
-    }
-    const context2 = this.#brokers.get(broker) ?? {
-      cex: "unknown",
-      symbol: "unknown"
-    };
-    this.#brokers.delete(broker);
-    const closing = (async () => {
-      try {
-        await broker.close();
-        log.debug("Request-scoped Subscribe broker closed", context2);
-        return "closed";
-      } catch (error48) {
-        log.warn("Failed to close request-scoped Subscribe broker", {
-          ...context2,
-          error: error48
-        });
-        return "failed";
-      } finally {
-        this.#closing.delete(broker);
-      }
-    })();
-    this.#closing.set(broker, closing);
-    return closing;
-  }
-  async closeAll() {
-    this.#shuttingDown = true;
-    let failed = 0;
-    while (this.#brokers.size > 0 || this.#closing.size > 0) {
-      const inFlight = [...this.#closing.values()];
-      const fresh = [...this.#brokers.keys()].map((broker) => this.close(broker));
-      const outcomes = await Promise.all([...fresh, ...inFlight]);
-      failed += outcomes.filter((outcome) => outcome === "failed").length;
-    }
-    if (failed > 0) {
-      throw new Error(`${failed} request-scoped Subscribe broker(s) failed to close`);
-    }
-  }
-}
-// src/handlers/subscribe/handler.ts
-var grpc13 = __toESM(require_src3(), 1);
-
-// src/helpers/binance-user-data-stream.ts
-import { Buffer as Buffer2 } from "node:buffer";
-import { createHmac } from "node:crypto";
-var BINANCE_SPOT_WS_API_URL = "wss://ws-api.binance.com:443/ws-api/v3";
-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;
+      const metadata = call.metadata;
+      const selectedBrokerAccount = selectBrokerAccountForCex(normalizedCex, brokers, metadata);
+      const broker = selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, call.metadata) ?? (isPublicMarketDataAction(action, call.request.payload) ? createPublicBroker(normalizedCex) : null);
+      if (!broker) {
+        return wrappedCallback({
+          code: grpc12.status.UNAUTHENTICATED,
+          message: `This Exchange is not registered and No API metadata was found`
+        }, null);
       }
-      yield event;
-    }
-  }
-  close() {
-    if (this.closed) {
-      return;
+      const verity = { proof: "" };
+      const applyVerityToBroker = (targetBroker) => {
+        if (!useVerity)
+          return;
+        const override = buildHttpClientOverrideFromMetadata(metadata, verityProverUrl, (proof, notaryPubKey) => {
+          verity.proof = proof;
+          log.debug(`Verity proof:`, { proof, notaryPubKey });
+        });
+        targetBroker.setHttpClientOverride(override, verityHttpClientOverridePredicate);
+      };
+      const preludeCtx = {
+        call,
+        wrappedCallback,
+        action,
+        policy,
+        brokers,
+        metadata,
+        normalizedCex,
+        cex: cex3,
+        symbol: symbol2,
+        selectedBrokerAccount,
+        broker,
+        verity,
+        applyVerityToBroker,
+        useVerity,
+        verityProverUrl,
+        otelMetrics,
+        brokerArchiver,
+        orderActivityTracker,
+        withdrawalObservationTracker
+      };
+      if (action === Action.Call) {
+        const handled = await handleOrderBookCall(preludeCtx);
+        if (handled)
+          return;
+      }
+      applyVerityToBroker(broker);
+      const ctx = { ...preludeCtx, broker };
+      await dispatchExecuteAction(ctx);
+    } catch (error48) {
+      safeLogError("ExecuteAction unhandled error", error48);
+      return wrappedCallback({
+        code: grpc12.status.INTERNAL,
+        message: "ExecuteAction failed unexpectedly"
+      }, null);
     }
-    this.closed = true;
-    this.queue.length = 0;
-    try {
-      this.ws.close();
-    } catch {}
-    this.flushWaiters();
-  }
-  handleClose(code, reason) {
-    if (this.closed) {
-      return;
+  };
+}
+// src/handlers/subscribe/broker-lifecycle.ts
+class SubscribeBrokerLifecycle {
+  #brokers = new Map;
+  #closing = new Map;
+  #shuttingDown = false;
+  register(broker, context2) {
+    this.#brokers.set(broker, context2);
+    if (this.#shuttingDown) {
+      this.close(broker);
     }
-    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;
+  close(broker) {
+    const existing = this.#closing.get(broker);
+    if (existing) {
+      return existing;
     }
-    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;
+    const context2 = this.#brokers.get(broker) ?? {
+      cex: "unknown",
+      symbol: "unknown"
+    };
+    this.#brokers.delete(broker);
+    const closing = (async () => {
+      try {
+        await broker.close();
+        log.debug("Request-scoped Subscribe broker closed", context2);
+        return "closed";
+      } catch (error48) {
+        log.warn("Failed to close request-scoped Subscribe broker", {
+          ...context2,
+          error: error48
+        });
+        return "failed";
+      } finally {
+        this.#closing.delete(broker);
       }
-      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 });
+    })();
+    this.#closing.set(broker, closing);
+    return closing;
   }
-  push(event) {
-    if (this.closed) {
-      return;
-    }
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      waiter.resolve(event);
-      return;
+  async closeAll() {
+    this.#shuttingDown = true;
+    let failed = 0;
+    while (this.#brokers.size > 0 || this.#closing.size > 0) {
+      const inFlight = [...this.#closing.values()];
+      const fresh = [...this.#brokers.keys()].map((broker) => this.close(broker));
+      const outcomes = await Promise.all([...fresh, ...inFlight]);
+      failed += outcomes.filter((outcome) => outcome === "failed").length;
     }
-    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;
+    if (failed > 0) {
+      throw new Error(`${failed} request-scoped Subscribe broker(s) failed to close`);
     }
-    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 });
-    });
+}
+// src/handlers/subscribe/handler.ts
+var grpc13 = __toESM(require_src3(), 1);
+
+// src/helpers/binance-user-data-normalization.ts
+function requireQuantity(entry, key2) {
+  const value = entry[key2];
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value;
   }
-  fail(error48) {
-    if (this.closeError) {
-      return;
-    }
-    this.closeError = error48;
-    this.closed = true;
-    this.queue.length = 0;
-    this.flushWaiters();
-    try {
-      this.ws.close();
-    } catch {}
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
   }
-  flushWaiters() {
-    const error48 = this.closeError;
-    for (const waiter of this.waiters.splice(0)) {
-      if (error48) {
-        waiter.reject(error48);
-      } else {
-        waiter.resolve(null);
-      }
+  throw new Error(`Invalid Binance balance quantity: ${key2}`);
+}
+async function normalizeBinanceSpotBalanceEvent(exchange, event) {
+  if (event.e !== "outboundAccountPosition") {
+    return exchange.fetchBalance({ type: "spot" });
+  }
+  if (!Array.isArray(event.B)) {
+    throw new Error("Invalid Binance outboundAccountPosition balances");
+  }
+  const timestamp = typeof event.E === "number" && Number.isFinite(event.E) ? event.E : undefined;
+  const balance = {
+    info: event,
+    ...timestamp !== undefined && {
+      timestamp,
+      datetime: new Date(timestamp).toISOString()
+    }
+  };
+  for (const rawEntry of event.B) {
+    const entry = asRecord(rawEntry);
+    const asset = entry?.a;
+    if (!entry || typeof asset !== "string" || asset.length === 0) {
+      throw new Error("Invalid Binance outboundAccountPosition asset");
     }
+    balance[asset] = {
+      free: requireQuantity(entry, "f"),
+      used: requireQuantity(entry, "l")
+    };
   }
+  return exchange.safeBalance(balance);
 }
-function isBinanceBalanceUserDataEvent(event) {
-  return event.e === "outboundAccountPosition" || event.e === "balanceUpdate" || event.e === "externalLockUpdate";
+function getTradeId(value) {
+  if (typeof value === "number" && Number.isFinite(value) || typeof value === "string" && value.length > 0) {
+    const tradeId = String(value);
+    return tradeId === "-1" ? undefined : tradeId;
+  }
+  return;
 }
-function isBinanceOrderUserDataEvent(event) {
-  return event.e === "executionReport" || event.e === "listStatus";
+function normalizeBinanceExecutionReport(exchange, event) {
+  const parsed = asRecord(exchange.parseWsOrder(event));
+  if (!parsed) {
+    throw new Error("Binance executionReport did not parse as an order");
+  }
+  const { fee: _fee, fees: _fees, ...order } = parsed;
+  const tradeId = getTradeId(event.t);
+  return tradeId === undefined ? order : { ...order, tradeId };
 }
 // src/helpers/market-data-archive/ohlcv-bootstrap.ts
 var DEFAULT_OHLCV_BOOTSTRAP_LIMIT = 100;
@@ -334495,12 +335272,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()) {
@@ -334521,17 +335300,6 @@ async function streamBinanceUserData(call, broker, symbol2, subscriptionType, is
         }
       }
       const receivedTimestamp = Date.now();
-      if (!await writeSubscribeFrame(call, isClosed, {
-        data: JSON.stringify({
-          subscriptionId: message.subscriptionId,
-          event
-        }),
-        timestamp: receivedTimestamp,
-        symbol: symbol2,
-        type: subscriptionType
-      })) {
-        break;
-      }
       const archiveSubscriptionType = subscriptionType === SubscriptionType.BALANCE ? "BALANCE" : "ORDERS";
       archiveSubscribeStreamInBackground(archiveContext?.archiver, {
         exchange: archiveContext?.exchange ?? "binance",
@@ -334552,6 +335320,18 @@ async function streamBinanceUserData(call, broker, symbol2, subscriptionType, is
           receivedTimestamp
         });
       }
+      if (subscriptionType === SubscriptionType.ORDERS && event.e === "listStatus") {
+        continue;
+      }
+      const data = subscriptionType === SubscriptionType.BALANCE ? await normalizeBinanceSpotBalanceEvent(broker, event) : normalizeBinanceExecutionReport(broker, event);
+      if (!await writeSubscribeFrame(call, isClosed, {
+        data: JSON.stringify(data),
+        timestamp: receivedTimestamp,
+        symbol: symbol2,
+        type: subscriptionType
+      })) {
+        break;
+      }
     }
   } finally {
     userDataStream.close();
@@ -334591,7 +335371,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();
@@ -334726,7 +335512,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) {
@@ -335120,7 +335927,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({
@@ -335139,7 +335946,8 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
       whitelistIps,
       otelMetrics,
       brokerArchiver,
-      brokerLifecycle: subscribeBrokerLifecycle
+      brokerLifecycle: subscribeBrokerLifecycle,
+      userDataStreamSupervisor
     })
   });
   return server;
@@ -335283,13 +336091,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() ?? "";
@@ -335318,9 +336127,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() ?? "";
@@ -335438,6 +336247,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();
     }
@@ -335449,6 +336262,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();
     }
@@ -335472,7 +336293,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);