@usherlabs/cex-broker 0.2.18 → 0.2.19

package/dist/commands/cli.js

@@ -313774,9 +313774,6 @@ function createBrokerPool(cfg) {
   }
   return pool;
 }
-function selectBroker(brokers, metadata) {
-  return selectBrokerAccount(brokers, metadata)?.exchange ?? null;
-}
 function getCurrentBrokerSelector(metadata) {
   const use_secondary_key = metadata.get("use-secondary-key");
   if (!use_secondary_key || use_secondary_key.length === 0) {
@@ -314996,262 +314993,1034 @@ function validateDeposit(policy, exchange, network, ticker) {
   return { valid: true };
 }
 
-// src/helpers/otel.ts
-var import_api2 = __toESM(require_src5(), 1);
-var import_api_logs2 = __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;
+// src/helpers/shared/guards.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? value : undefined;
+}
 
-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;
+// src/helpers/order-telemetry.ts
+var NUMERIC_METRICS = [
+  ["requestedQuantity", "cex_market_action_requested_quantity"],
+  ["requestedNotional", "cex_market_action_requested_notional"],
+  ["executedBaseQuantity", "cex_market_action_executed_base_quantity"],
+  ["executedQuoteQuantity", "cex_market_action_executed_quote_quantity"],
+  ["averageExecutionPrice", "cex_market_action_average_execution_price"],
+  ["filledAmount", "cex_market_action_filled_amount"],
+  ["remainingAmount", "cex_market_action_remaining_amount"],
+  ["feeAmount", "cex_market_action_fee_amount"],
+  ["feeRate", "cex_market_action_fee_rate"]
+];
+var REDACTED_ERROR_MESSAGE = "redacted_error";
+async function emitOrderExecutionTelemetry(otelMetrics, context2, order, error) {
+  try {
+    const telemetry = buildOrderExecutionTelemetry(context2, order, error);
+    log.info("CEX market action execution telemetry", telemetry);
+    const labels = {
+      action: telemetry.action,
+      cex: telemetry.cex,
+      account: telemetry.accountLabel,
+      symbol: telemetry.symbol,
+      side: telemetry.side,
+      order_type: telemetry.orderType,
+      status: telemetry.status
+    };
+    await otelMetrics?.recordCounter("cex_market_action_executions_total", 1, {
+      ...labels,
+      result: error ? "error" : "ok"
+    });
+    for (const [key, metricName] of NUMERIC_METRICS) {
+      const value = telemetry[key];
+      if (typeof value === "number" && Number.isFinite(value)) {
+        await otelMetrics?.recordHistogram(metricName, value, labels);
+      }
     }
+    return telemetry;
+  } catch (telemetryError) {
     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;
+      log.error("Failed to emit CEX order telemetry", {
+        error: telemetryError
+      });
+    } catch {}
+    return;
+  }
+}
+function buildOrderExecutionTelemetry(context2, order, error) {
+  const record = asRecord(order);
+  const info = asRecord(record?.info);
+  const fees = getFees(record, info);
+  const fee = summarizeFees(fees);
+  const executedBaseQuantity = firstNumber(record?.filled, info?.executedQty, info?.cumExecQty) ?? computeFilledFromAmount(record);
+  const executedQuoteQuantity = firstNumber(record?.cost, info?.cummulativeQuoteQty, info?.cumQuote, info?.cumExecValue);
+  const averageExecutionPrice = firstNumber(record?.average, info?.avgPrice) ?? computeAveragePrice(executedBaseQuantity, executedQuoteQuantity);
+  const exchangeTimestamp = normalizeTimestamp(firstValue(record?.timestamp, info?.time, info?.transactTime, record?.datetime));
+  const status = firstString(record?.status, info?.status) ?? (error ? "failed" : "unknown");
+  const errorRecord = error instanceof Error ? error : undefined;
+  return compactUndefined({
+    event: "cex_market_action_execution",
+    action: context2.action,
+    cex: context2.cex.trim().toLowerCase() || "unknown",
+    accountLabel: context2.accountLabel ?? "unknown",
+    symbol: firstString(record?.symbol, info?.symbol, context2.symbol) ?? "unknown",
+    side: firstString(record?.side, info?.side, context2.side) ?? "unknown",
+    orderType: firstString(record?.type, info?.type, context2.orderType) ?? "unknown",
+    orderId: firstString(record?.id, info?.orderId, info?.orderID),
+    clientOrderId: firstString(context2.clientOrderId, record?.clientOrderId, record?.clientOrderID, record?.clientOid, info?.clientOrderId, info?.clientOrderID, info?.clientOid),
+    idempotencyId: context2.idempotencyId,
+    makerActionId: context2.makerActionId,
+    status: status.toLowerCase(),
+    requestedQuantity: context2.requestedQuantity ?? firstNumber(record?.amount),
+    requestedNotional: context2.requestedNotional,
+    executedBaseQuantity,
+    executedQuoteQuantity,
+    averageExecutionPrice,
+    filledAmount: firstNumber(record?.filled, info?.executedQty),
+    remainingAmount: firstNumber(record?.remaining, info?.remainingQty),
+    feeAmount: fee.amount,
+    feeCurrency: fee.currency,
+    feeRate: fee.rate,
+    exchangeTimestamp,
+    brokerObservedTimestamp: context2.brokerObservedTimestamp ?? new Date().toISOString(),
+    errorType: errorRecord?.name,
+    errorMessage: errorRecord ? REDACTED_ERROR_MESSAGE : undefined
+  });
+}
+function emitOrderExecutionTelemetryInBackground(otelMetrics, context2, order, error) {
+  emitOrderExecutionTelemetry(otelMetrics, context2, order, error).catch((telemetryError) => {
+    try {
+      log.warn("Telemetry emit failed", { error: telemetryError });
+    } catch {
+      console.warn("Telemetry emit failed", telemetryError);
+    }
+  });
+}
+function extractOrderTelemetryIds(params) {
+  const record = params ?? {};
+  return {
+    clientOrderId: firstString(record.clientOrderId, record.clientOrderID, record.newClientOrderId, record.clientOid),
+    idempotencyId: firstString(record.idempotencyId, record.idempotencyID, record.idempotencyKey, record.requestId, record.requestID),
+    makerActionId: firstString(record.makerActionId, record.maker_action_id, record.actionId, record.action_id)
+  };
+}
+function firstValue(...values2) {
+  return values2.find((value) => value !== undefined && value !== null);
+}
+function firstString(...values2) {
+  for (const value of values2) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return String(value);
     }
   }
-  onProviderCreated(_provider) {}
-  onProviderClosed() {}
-  getProvider() {
-    return this.provider;
+  return;
+}
+function firstNumber(...values2) {
+  for (const value of values2) {
+    const numberValue = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+    if (Number.isFinite(numberValue)) {
+      return numberValue;
+    }
   }
-  getServiceName() {
-    return this.serviceName;
+  return;
+}
+function computeFilledFromAmount(record) {
+  const amount = firstNumber(record?.amount);
+  const remaining = firstNumber(record?.remaining);
+  if (amount === undefined || remaining === undefined) {
+    return;
   }
-  isOtelEnabled() {
-    return this.isEnabled && this.provider !== null;
+  return amount - remaining;
+}
+function computeAveragePrice(executedBaseQuantity, executedQuoteQuantity) {
+  if (executedBaseQuantity === undefined || executedQuoteQuantity === undefined || executedBaseQuantity === 0) {
+    return;
   }
-  async close() {
-    if (!this.provider) {
-      return;
+  return executedQuoteQuantity / executedBaseQuantity;
+}
+function normalizeTimestamp(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  const timestamp = firstNumber(value);
+  if (timestamp === undefined) {
+    return;
+  }
+  const date = new Date(timestamp);
+  return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+function getFees(record, info) {
+  const fees = [];
+  if (record?.fee)
+    fees.push(record.fee);
+  if (Array.isArray(record?.fees))
+    fees.push(...record.fees);
+  if (Array.isArray(record?.trades)) {
+    for (const trade of record.trades) {
+      const tradeRecord = asRecord(trade);
+      if (tradeRecord?.fee)
+        fees.push(tradeRecord.fee);
+      if (Array.isArray(tradeRecord?.fees))
+        fees.push(...tradeRecord.fees);
     }
-    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);
+  }
+  if (Array.isArray(info?.fills)) {
+    for (const fill of info.fills) {
+      const fillRecord = asRecord(fill);
+      const commission = firstNumber(fillRecord?.commission);
+      if (commission !== undefined) {
+        fees.push({
+          cost: commission,
+          currency: firstString(fillRecord?.commissionAsset)
+        });
+      }
     }
-    this.provider = null;
-    this.isEnabled = false;
-    this.onProviderClosed();
   }
+  return fees;
 }
-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 summarizeFees(fees) {
+  let amount = 0;
+  let amountFound = false;
+  let currency;
+  let rate;
+  for (const rawFee of fees) {
+    const fee = asRecord(rawFee);
+    if (!fee)
+      continue;
+    const cost = firstNumber(fee.cost, fee.amount);
+    if (cost !== undefined) {
+      amount += cost;
+      amountFound = true;
     }
+    currency ??= firstString(fee.currency);
+    rate ??= firstNumber(fee.rate);
   }
-  return attrs;
+  return {
+    amount: amountFound ? amount : undefined,
+    currency,
+    rate
+  };
+}
+function compactUndefined(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
 }
 
-class OtelMetrics extends BaseOtelSignal {
-  counters = new Map;
-  histograms = new Map;
-  constructor(config) {
-    super(config, "metrics");
+// src/helpers/broker-execution-archive/redact.ts
+import { createHash } from "node:crypto";
+var SECRET_KEY_PATTERN = /\b(api[_-]?key|api[_-]?secret|secret|signature|passphrase|password|token|credential)\b/i;
+var SECRET_VALUE_PATTERN = /(\b(?:apiKey|api_key|apiSecret|api_secret|secret|signature|passphrase|password|token)\b\s*[=:]\s*)[^\s&,;)}\]]+/gi;
+var SECRET_JSON_PATTERN = /("(?:apiKey|api_key|apiSecret|api_secret|secret|signature|passphrase|password|token)"\s*:\s*")[^"]*(")/gi;
+function redactSecretLiterals(value, secretLiterals = []) {
+  let redacted = value;
+  for (const literal of secretLiterals) {
+    if (literal.length > 0) {
+      redacted = redacted.split(literal).join("[redacted]");
+    }
   }
-  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]
-    });
+  return redacted.replace(SECRET_VALUE_PATTERN, "$1[redacted]").replace(SECRET_JSON_PATTERN, "$1[redacted]$2");
+}
+function redactUnknownValue(value, secretLiterals) {
+  if (value === null || value === undefined) {
+    return value;
   }
-  onProviderCreated(provider) {
-    import_api2.metrics.setGlobalMeterProvider(provider);
+  if (typeof value === "string") {
+    return redactSecretLiterals(value, secretLiterals);
   }
-  shutdownProvider(provider) {
-    return provider.shutdown();
+  if (typeof value === "number" || typeof value === "boolean") {
+    return value;
   }
-  async initialize() {
-    if (this.isOtelEnabled()) {
-      log.info("OTel metrics initialized (storage is handled by the collector)");
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactUnknownValue(entry, secretLiterals));
+  }
+  if (typeof value === "object") {
+    const record = value;
+    const redacted = {};
+    for (const [key, entry] of Object.entries(record)) {
+      if (SECRET_KEY_PATTERN.test(key)) {
+        redacted[key] = "[redacted]";
+        continue;
+      }
+      redacted[key] = redactUnknownValue(entry, secretLiterals);
     }
+    return redacted;
   }
-  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 {}
+  return String(value);
+}
+function redactStreamPayload(payload, secretLiterals = []) {
+  if (Array.isArray(payload)) {
+    return {
+      items: payload.map((entry) => redactUnknownValue(entry, secretLiterals))
+    };
   }
-  async insertMetrics(metricsList) {
-    if (!this.isOtelEnabled() || metricsList.length === 0)
+  const record = asRecord(payload);
+  if (!record) {
+    return {};
+  }
+  return redactUnknownValue(record, secretLiterals);
+}
+function hashMarketMetadata(payload) {
+  if (payload === undefined || payload === null) {
+    return;
+  }
+  try {
+    const normalized = JSON.stringify(payload);
+    if (!normalized || normalized === "{}") {
       return;
-    for (const m of metricsList) {
-      await this.insertMetric(m);
     }
+    return createHash("sha256").update(normalized).digest("hex");
+  } catch {
+    return;
   }
-  async recordCounter(metricName, value, labels, service = this.getServiceName()) {
-    const provider = this.getProvider();
-    if (!this.isOtelEnabled() || !provider)
-      return;
+}
+
+// src/helpers/broker-execution-archive/types.ts
+var BROKER_WRITE_SOURCE = "broker_write";
+
+// src/helpers/broker-execution-archive/rows.ts
+function firstString2(...values2) {
+  for (const value of values2) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return String(value);
+    }
+  }
+  return;
+}
+function compactUndefined2(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+function buildCommonArchiveTags(input) {
+  return {
+    source: BROKER_WRITE_SOURCE,
+    deployment_id: input.deploymentId,
+    account_selector: input.accountSelector ?? "unknown",
+    exchange: input.exchange.trim().toLowerCase() || "unknown",
+    symbol: input.symbol?.trim() || "unknown",
+    broker_observed_timestamp: input.brokerObservedTimestamp ?? new Date().toISOString()
+  };
+}
+function buildOrderEventArchiveRow(input) {
+  const { tags, telemetry, action } = input;
+  return {
+    table: "broker_execution.order_events",
+    row: compactUndefined2({
+      ...tags,
+      event_kind: input.eventKind ?? "execute_action",
+      action,
+      subscription_type: input.subscriptionType,
+      order_id: telemetry.orderId,
+      client_order_id: telemetry.clientOrderId,
+      idempotency_id: telemetry.idempotencyId,
+      maker_action_id: telemetry.makerActionId,
+      market_metadata_hash: input.marketMetadataHash,
+      status: telemetry.status,
+      side: telemetry.side,
+      order_type: telemetry.orderType,
+      requested_quantity: telemetry.requestedQuantity,
+      requested_notional: telemetry.requestedNotional,
+      executed_base_quantity: telemetry.executedBaseQuantity,
+      executed_quote_quantity: telemetry.executedQuoteQuantity,
+      average_execution_price: telemetry.averageExecutionPrice,
+      filled_amount: telemetry.filledAmount,
+      remaining_amount: telemetry.remainingAmount,
+      fee_amount: telemetry.feeAmount,
+      fee_currency: telemetry.feeCurrency,
+      fee_rate: telemetry.feeRate,
+      exchange_timestamp: telemetry.exchangeTimestamp,
+      error_type: telemetry.errorType,
+      error_message: telemetry.errorMessage,
+      payload_json: JSON.stringify(telemetry)
+    })
+  };
+}
+function buildSubscribeStreamArchiveRow(input) {
+  const redactedPayload = redactStreamPayload(input.streamPayload, input.secretLiterals);
+  const record = asRecord(input.streamPayload);
+  const info = asRecord(record?.info);
+  return {
+    table: "broker_execution.order_events",
+    row: compactUndefined2({
+      ...input.tags,
+      event_kind: "subscribe_stream",
+      subscription_type: input.subscriptionType,
+      order_id: firstString2(record?.id, record?.orderId, record?.i, info?.orderId, info?.i),
+      client_order_id: firstString2(record?.clientOrderId, record?.clientOrderID, record?.c, info?.clientOrderId, info?.c),
+      status: firstString2(record?.status, record?.X, info?.status, info?.X)?.toLowerCase(),
+      payload_json: JSON.stringify(redactedPayload)
+    })
+  };
+}
+function buildMarketMetadataSnapshotRow(input) {
+  const redactedSnapshot = redactStreamPayload(input.marketSnapshot);
+  const metadataHash = hashMarketMetadata(redactedSnapshot);
+  return {
+    table: "broker_execution.market_metadata_snapshots",
+    row: compactUndefined2({
+      ...input.tags,
+      client_order_id: input.clientOrderId,
+      order_id: input.orderId,
+      maker_action_id: input.makerActionId,
+      idempotency_id: input.idempotencyId,
+      market_metadata_hash: metadataHash,
+      snapshot_json: JSON.stringify(redactedSnapshot)
+    })
+  };
+}
+
+// src/helpers/broker-execution-archive/capture.ts
+function archiveOrderExecutionInBackground(archiver, context2, order, error, options) {
+  if (!archiver?.isEnabled()) {
+    return;
+  }
+  queueMicrotask(() => {
     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);
+      const telemetry = buildOrderExecutionTelemetry(context2, order, error);
+      const tags = buildCommonArchiveTags({
+        deploymentId: archiver.getDeploymentId(),
+        accountSelector: context2.accountLabel,
+        exchange: context2.cex,
+        symbol: telemetry.symbol,
+        brokerObservedTimestamp: telemetry.brokerObservedTimestamp
+      });
+      archiver.enqueue(buildOrderEventArchiveRow({
+        tags,
+        action: context2.action,
+        telemetry,
+        marketMetadataHash: options?.marketMetadataHash
+      }));
+    } catch (archiveError) {
+      log.warn("Failed to archive order execution", { error: archiveError });
     }
+  });
+}
+function archiveSubscribeStreamInBackground(archiver, input) {
+  if (!archiver?.isEnabled()) {
+    return;
   }
-  async recordGauge(metricName, value, labels, service = this.getServiceName()) {
-    const provider = this.getProvider();
-    if (!this.isOtelEnabled() || !provider)
-      return;
+  queueMicrotask(() => {
     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);
+      const tags = buildCommonArchiveTags({
+        deploymentId: archiver.getDeploymentId(),
+        accountSelector: input.accountSelector,
+        exchange: input.exchange,
+        symbol: input.symbol
+      });
+      archiver.enqueue(buildSubscribeStreamArchiveRow({
+        tags,
+        subscriptionType: input.subscriptionType,
+        streamPayload: input.streamPayload,
+        secretLiterals: input.secretLiterals
+      }));
+    } catch (archiveError) {
+      log.warn("Failed to archive subscribe stream event", {
+        error: archiveError
+      });
     }
+  });
+}
+async function captureMarketMetadataSnapshot(archiver, broker, input) {
+  if (!archiver?.canPersistMarketMetadataSnapshot()) {
+    return;
   }
-  async recordHistogram(metricName, value, labels, service = this.getServiceName()) {
-    const provider = this.getProvider();
-    if (!this.isOtelEnabled() || !provider)
+  try {
+    const fetchOrderBook = broker.fetchOrderBook;
+    if (typeof fetchOrderBook !== "function") {
       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);
     }
+    const orderBook = await fetchOrderBook.call(broker, input.symbol, 5);
+    const record = asRecord(orderBook);
+    const snapshot = {
+      action: input.action,
+      symbol: input.symbol,
+      bids: record?.bids,
+      asks: record?.asks,
+      timestamp: record?.timestamp ?? Date.now(),
+      datetime: record?.datetime,
+      nonce: record?.nonce
+    };
+    const tags = buildCommonArchiveTags({
+      deploymentId: archiver.getDeploymentId(),
+      accountSelector: input.accountSelector,
+      exchange: input.exchange,
+      symbol: input.symbol,
+      brokerObservedTimestamp: input.brokerObservedTimestamp
+    });
+    const row = buildMarketMetadataSnapshotRow({
+      tags,
+      clientOrderId: input.clientOrderId,
+      orderId: input.orderId,
+      makerActionId: input.makerActionId,
+      idempotencyId: input.idempotencyId,
+      marketSnapshot: snapshot
+    });
+    archiver.enqueue(row);
+    const hash4 = row.row.market_metadata_hash;
+    return typeof hash4 === "string" ? hash4 : undefined;
+  } catch (archiveError) {
+    log.warn("Failed to capture market metadata snapshot", {
+      error: archiveError
+    });
+    return;
   }
 }
+// src/helpers/broker-execution-archive/writer.ts
+var import_api_logs2 = __toESM(require_src7(), 1);
 
-class OtelLogs extends BaseOtelSignal {
-  logger = null;
-  constructor(config) {
-    super(config, "logs");
+// src/helpers/market-data-archive/types.ts
+var MARKET_ARCHIVE_TABLES = new Set([
+  "market_data.orderbook_snapshots",
+  "market_data.candles",
+  "market_data.cex_stream_events",
+  "market_data.cex_ticker_events",
+  "market_data.cex_trades"
+]);
+function isMarketArchiveTable(table) {
+  return MARKET_ARCHIVE_TABLES.has(table);
+}
+
+// src/helpers/broker-execution-archive/writer.ts
+var DEFAULT_MAX_QUEUE_SIZE = 1e4;
+var DEFAULT_BATCH_SIZE = 10;
+var DEFAULT_FLUSH_INTERVAL_MS = 1000;
+var DEFAULT_FORWARDER_TIMEOUT_MS = 3000;
+var DEFAULT_ARCHIVE_FORWARDER_PATH = "/archive";
+var DEFAULT_ARCHIVE_FORWARDER_PORT = 8090;
+function isArchiveOtelLogsEnabled() {
+  return process.env.CEX_BROKER_ARCHIVE_OTEL_LOGS_ENABLED === "true";
+}
+function resolveArchiveForwarderUrlFromEnv() {
+  const explicit = process.env.CEX_BROKER_ARCHIVE_FORWARDER_URL?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const host = process.env.CEX_BROKER_ARCHIVE_FORWARDER_HOST?.trim() || process.env.CEX_BROKER_CLICKHOUSE_HOST?.trim();
+  if (!host) {
+    return;
   }
-  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
+  const protocol = process.env.CEX_BROKER_CLICKHOUSE_PROTOCOL || "http";
+  const port = parsePositiveInt(process.env.CEX_BROKER_ARCHIVE_FORWARDER_PORT, DEFAULT_ARCHIVE_FORWARDER_PORT);
+  const path = process.env.CEX_BROKER_ARCHIVE_FORWARDER_PATH?.trim() || DEFAULT_ARCHIVE_FORWARDER_PATH;
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${protocol}://${host}:${port}${normalizedPath}`;
+}
+
+class BrokerExecutionArchiver {
+  deploymentId;
+  otelLogs;
+  otelMetrics;
+  forwarderUrl;
+  maxQueueSize;
+  batchSize;
+  flushIntervalMs;
+  forwarderTimeoutMs;
+  queue = [];
+  stats = {
+    enqueued: 0,
+    shed: 0,
+    flushed: 0,
+    forwarderFailures: 0
+  };
+  flushTimer = null;
+  flushInFlight = null;
+  closed = false;
+  loggedMissingMarketForwarder = false;
+  enabled;
+  forwarderAuthToken;
+  constructor(options) {
+    this.deploymentId = options.deploymentId?.trim() || process.env.CEX_BROKER_DEPLOYMENT_ID?.trim() || "unknown";
+    this.otelLogs = options.otelLogs;
+    this.otelMetrics = options.otelMetrics;
+    this.forwarderUrl = options.forwarderUrl?.trim();
+    this.maxQueueSize = options.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+    this.batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+    this.flushIntervalMs = options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+    this.forwarderTimeoutMs = options.forwarderTimeoutMs ?? DEFAULT_FORWARDER_TIMEOUT_MS;
+    this.enabled = options.enabled;
+    this.forwarderAuthToken = process.env.CEX_BROKER_ARCHIVE_FORWARDER_TOKEN?.trim() || undefined;
+    if (this.enabled) {
+      this.flushTimer = setInterval(() => {
+        this.flush().catch((error) => {
+          log.warn("Broker execution archive flush failed", { error });
+        });
+      }, this.flushIntervalMs);
+      this.flushTimer.unref?.();
+    }
+  }
+  static disabled() {
+    return new BrokerExecutionArchiver({ enabled: false });
+  }
+  static create(options) {
+    const hasSink = Boolean(options.otelLogs?.isOtelEnabled()) || Boolean(options.forwarderUrl);
+    const enabled = process.env.CEX_BROKER_ARCHIVE_ENABLED !== "false" && hasSink;
+    return new BrokerExecutionArchiver({ ...options, enabled });
+  }
+  getDeploymentId() {
+    return this.deploymentId;
+  }
+  isEnabled() {
+    return this.enabled && !this.closed && (Boolean(this.otelLogs) || Boolean(this.forwarderUrl));
+  }
+  canPersistMarketMetadataSnapshot() {
+    return this.isEnabled() && (Boolean(this.otelLogs?.isOtelEnabled()) || Boolean(this.forwarderUrl));
+  }
+  enqueue(row) {
+    if (!this.enabled || this.closed || !this.otelLogs && !this.forwarderUrl) {
+      return;
+    }
+    if (isMarketArchiveTable(row.table) && !this.forwarderUrl) {
+      if (!this.loggedMissingMarketForwarder) {
+        this.loggedMissingMarketForwarder = true;
+        log.warn("Market data archive row dropped: configure CEX_BROKER_ARCHIVE_FORWARDER_URL or CEX_BROKER_CLICKHOUSE_HOST", { table: row.table });
+      }
+      return;
+    }
+    if (this.queue.length >= this.maxQueueSize) {
+      this.queue.shift();
+      this.stats.shed += 1;
+      this.recordArchiveMetric("cex_archive_rows_shed_total", {
+        table: row.table
+      });
+    }
+    this.queue.push(row);
+    this.stats.enqueued += 1;
+    this.recordArchiveMetric("cex_archive_rows_enqueued_total", {
+      table: row.table
     });
-    return new import_sdk_logs.LoggerProvider({
-      resource,
-      processors: [processor]
+    if (this.queue.length >= this.batchSize) {
+      this.flush().catch((error) => {
+        log.warn("Broker execution archive flush failed", { error });
+      });
+    }
+  }
+  enqueueInBackground(row) {
+    queueMicrotask(() => this.enqueue(row));
+  }
+  async flush() {
+    if (!this.enabled || this.closed || this.queue.length === 0) {
+      return;
+    }
+    if (this.flushInFlight) {
+      return this.flushInFlight;
+    }
+    const inFlight = this.flushBatch().then(() => {
+      return;
+    }).finally(() => {
+      this.flushInFlight = null;
     });
+    this.flushInFlight = inFlight;
+    return inFlight;
   }
-  onProviderCreated(provider) {
-    import_api_logs2.logs.setGlobalLoggerProvider(provider);
-    this.logger = provider.getLogger("cex-broker-logs", "1.0.0");
+  async close() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    while (this.queue.length > 0 || this.flushInFlight) {
+      if (this.flushInFlight) {
+        await this.flushInFlight;
+        continue;
+      }
+      const depthBefore = this.queue.length;
+      const flushed = await this.flushBatch();
+      if (!flushed && this.queue.length >= depthBefore && depthBefore > 0) {
+        const dropped = this.queue.length;
+        this.queue.length = 0;
+        log.warn(`Archive shutdown dropped ${dropped} undelivered row(s) after forwarder failure`);
+        break;
+      }
+    }
+    this.closed = true;
   }
-  shutdownProvider(provider) {
-    return provider.forceFlush().then(() => provider.shutdown());
+  getStats() {
+    return { ...this.stats };
   }
-  onProviderClosed() {
-    this.logger = null;
+  getQueueDepth() {
+    return this.queue.length;
   }
-  emit(record) {
-    if (!this.isOtelEnabled() || !this.logger) {
-      return;
+  enforceQueueBound() {
+    while (this.queue.length > this.maxQueueSize) {
+      const dropped = this.queue.shift();
+      this.stats.shed += 1;
+      this.recordArchiveMetric("cex_archive_rows_shed_total", {
+        table: dropped?.table ?? "unknown"
+      });
     }
-    this.logger.emit(record);
   }
-}
-function resolveOtlpEndpoint(signal, config) {
-  if (config?.otlpEndpoint) {
-    return {
-      endpoint: normalizeOtlpEndpoint(config.otlpEndpoint),
-      appendSignalPath: true
-    };
+  async flushBatch() {
+    const batch = this.queue.splice(0, this.batchSize);
+    if (batch.length === 0) {
+      return true;
+    }
+    for (const entry of batch) {
+      if (!isMarketArchiveTable(entry.table)) {
+        this.emitOtelLog(entry);
+      }
+    }
+    if (this.forwarderUrl) {
+      try {
+        await this.postToForwarder(batch);
+      } catch (error) {
+        this.stats.forwarderFailures += 1;
+        this.queue.push(...batch);
+        this.enforceQueueBound();
+        this.recordArchiveMetric("cex_archive_forwarder_failures_total", {
+          count: batch.length
+        });
+        log.warn("Broker execution archive forwarder failed", { error });
+        return false;
+      }
+    }
+    this.stats.flushed += batch.length;
+    return 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
-    };
+  async recordArchiveMetric(metricName, labels) {
+    try {
+      await this.otelMetrics?.recordCounter(metricName, 1, labels);
+    } catch {}
   }
-  if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
-    return {
-      endpoint: normalizeOtlpEndpoint(process.env.OTEL_EXPORTER_OTLP_ENDPOINT),
-      appendSignalPath: true
-    };
+  emitOtelLog(entry) {
+    if (!this.otelLogs?.isOtelEnabled()) {
+      return;
+    }
+    try {
+      this.otelLogs.emit({
+        body: entry.table,
+        severityNumber: import_api_logs2.SeverityNumber.INFO,
+        severityText: "INFO",
+        attributes: flattenArchiveAttributes(entry)
+      });
+    } catch (error) {
+      log.warn("Broker execution archive OTLP emit failed", { error });
+    }
   }
-  if (config?.host) {
-    const protocol = config.protocol || "http";
-    const port = config.port ?? DEFAULT_OTLP_PORT;
-    return {
-      endpoint: `${protocol}://${config.host}:${port}`,
-      appendSignalPath: true
+  async postToForwarder(batch) {
+    if (!this.forwarderUrl || batch.length === 0) {
+      return;
+    }
+    const controller = new AbortController;
+    const timeout2 = setTimeout(() => controller.abort(), this.forwarderTimeoutMs);
+    const headers = {
+      "content-type": "application/json"
     };
+    if (this.forwarderAuthToken) {
+      headers.authorization = `Bearer ${this.forwarderAuthToken}`;
+    }
+    try {
+      const response = await fetch(this.forwarderUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          source: "broker_write",
+          deployment_id: this.deploymentId,
+          rows: batch
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Archive forwarder returned ${response.status} ${response.statusText}`);
+      }
+    } finally {
+      clearTimeout(timeout2);
+    }
   }
-  return null;
 }
-function appendOtlpPath(endpoint, signal, appendSignalPath) {
-  if (!appendSignalPath) {
-    return endpoint;
+function flattenArchiveAttributes(entry) {
+  const attributes = {
+    ch_table: entry.table
+  };
+  for (const [key, value] of Object.entries(entry.row)) {
+    if (value === undefined || value === null) {
+      continue;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      attributes[key] = value;
+    } else {
+      attributes[key] = JSON.stringify(value);
+    }
   }
-  const baseEndpoint = normalizeOtlpEndpoint(endpoint);
-  return `${baseEndpoint}/v1/${signal}`;
+  return attributes;
 }
-function normalizeOtlpEndpoint(endpoint) {
-  return endpoint.replace(/\/v1\/(metrics|logs)\/?$/, "").replace(/\/+$/, "");
+function createBrokerExecutionArchiverFromEnv(otelLogs, otelMetrics) {
+  const forwarderUrl = resolveArchiveForwarderUrlFromEnv();
+  const archiveOtelLogs = isArchiveOtelLogsEnabled() ? otelLogs : undefined;
+  return BrokerExecutionArchiver.create({
+    otelLogs: archiveOtelLogs,
+    otelMetrics,
+    forwarderUrl,
+    deploymentId: process.env.CEX_BROKER_DEPLOYMENT_ID,
+    maxQueueSize: parsePositiveInt(process.env.CEX_BROKER_ARCHIVE_QUEUE_MAX, DEFAULT_MAX_QUEUE_SIZE),
+    batchSize: parsePositiveInt(process.env.CEX_BROKER_ARCHIVE_BATCH_SIZE, DEFAULT_BATCH_SIZE),
+    flushIntervalMs: parsePositiveInt(process.env.CEX_BROKER_ARCHIVE_FLUSH_INTERVAL_MS, DEFAULT_FLUSH_INTERVAL_MS)
+  });
 }
-function getOtelHostFromEnv() {
-  return process.env.CEX_BROKER_OTEL_HOST ?? process.env.CEX_BROKER_CLICKHOUSE_HOST;
+function parsePositiveInt(value, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+// 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;
+  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 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;
@@ -315328,14 +316097,6 @@ function safeLogError(context2, error) {
   }
 }
 
-// src/helpers/shared/guards.ts
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function asRecord(value) {
-  return isRecord(value) ? value : undefined;
-}
-
 // src/helpers/treasury-discovery.ts
 function callArgs(args, params) {
   const argsArray = Array.isArray(args) ? [...args] : [];
@@ -329734,215 +330495,6 @@ async function handleInternalTransfer(ctx) {
 
 // src/handlers/execute-action/orders.ts
 var grpc6 = __toESM(require_src3(), 1);
-
-// src/helpers/order-telemetry.ts
-var NUMERIC_METRICS = [
-  ["requestedQuantity", "cex_market_action_requested_quantity"],
-  ["requestedNotional", "cex_market_action_requested_notional"],
-  ["executedBaseQuantity", "cex_market_action_executed_base_quantity"],
-  ["executedQuoteQuantity", "cex_market_action_executed_quote_quantity"],
-  ["averageExecutionPrice", "cex_market_action_average_execution_price"],
-  ["filledAmount", "cex_market_action_filled_amount"],
-  ["remainingAmount", "cex_market_action_remaining_amount"],
-  ["feeAmount", "cex_market_action_fee_amount"],
-  ["feeRate", "cex_market_action_fee_rate"]
-];
-var REDACTED_ERROR_MESSAGE = "redacted_error";
-async function emitOrderExecutionTelemetry(otelMetrics, context2, order, error48) {
-  try {
-    const telemetry = buildOrderExecutionTelemetry(context2, order, error48);
-    log.info("CEX market action execution telemetry", telemetry);
-    const labels = {
-      action: telemetry.action,
-      cex: telemetry.cex,
-      account: telemetry.accountLabel,
-      symbol: telemetry.symbol,
-      side: telemetry.side,
-      order_type: telemetry.orderType,
-      status: telemetry.status
-    };
-    await otelMetrics?.recordCounter("cex_market_action_executions_total", 1, {
-      ...labels,
-      result: error48 ? "error" : "ok"
-    });
-    for (const [key, metricName] of NUMERIC_METRICS) {
-      const value = telemetry[key];
-      if (typeof value === "number" && Number.isFinite(value)) {
-        await otelMetrics?.recordHistogram(metricName, value, labels);
-      }
-    }
-    return telemetry;
-  } catch (telemetryError) {
-    try {
-      log.error("Failed to emit CEX order telemetry", {
-        error: telemetryError
-      });
-    } catch {}
-    return;
-  }
-}
-function buildOrderExecutionTelemetry(context2, order, error48) {
-  const record2 = asRecord(order);
-  const info = asRecord(record2?.info);
-  const fees = getFees(record2, info);
-  const fee = summarizeFees(fees);
-  const executedBaseQuantity = firstNumber(record2?.filled, info?.executedQty, info?.cumExecQty) ?? computeFilledFromAmount(record2);
-  const executedQuoteQuantity = firstNumber(record2?.cost, info?.cummulativeQuoteQty, info?.cumQuote, info?.cumExecValue);
-  const averageExecutionPrice = firstNumber(record2?.average, info?.avgPrice) ?? computeAveragePrice(executedBaseQuantity, executedQuoteQuantity);
-  const exchangeTimestamp = normalizeTimestamp(firstValue(record2?.timestamp, info?.time, info?.transactTime, record2?.datetime));
-  const status6 = firstString(record2?.status, info?.status) ?? (error48 ? "failed" : "unknown");
-  const errorRecord = error48 instanceof Error ? error48 : undefined;
-  return compactUndefined({
-    event: "cex_market_action_execution",
-    action: context2.action,
-    cex: context2.cex.trim().toLowerCase() || "unknown",
-    accountLabel: context2.accountLabel ?? "unknown",
-    symbol: firstString(record2?.symbol, info?.symbol, context2.symbol) ?? "unknown",
-    side: firstString(record2?.side, info?.side, context2.side) ?? "unknown",
-    orderType: firstString(record2?.type, info?.type, context2.orderType) ?? "unknown",
-    orderId: firstString(record2?.id, info?.orderId, info?.orderID),
-    clientOrderId: firstString(context2.clientOrderId, record2?.clientOrderId, record2?.clientOrderID, record2?.clientOid, info?.clientOrderId, info?.clientOrderID, info?.clientOid),
-    idempotencyId: context2.idempotencyId,
-    makerActionId: context2.makerActionId,
-    status: status6.toLowerCase(),
-    requestedQuantity: context2.requestedQuantity ?? firstNumber(record2?.amount),
-    requestedNotional: context2.requestedNotional,
-    executedBaseQuantity,
-    executedQuoteQuantity,
-    averageExecutionPrice,
-    filledAmount: firstNumber(record2?.filled, info?.executedQty),
-    remainingAmount: firstNumber(record2?.remaining, info?.remainingQty),
-    feeAmount: fee.amount,
-    feeCurrency: fee.currency,
-    feeRate: fee.rate,
-    exchangeTimestamp,
-    brokerObservedTimestamp: context2.brokerObservedTimestamp ?? new Date().toISOString(),
-    errorType: errorRecord?.name,
-    errorMessage: errorRecord ? REDACTED_ERROR_MESSAGE : undefined
-  });
-}
-function emitOrderExecutionTelemetryInBackground(otelMetrics, context2, order, error48) {
-  emitOrderExecutionTelemetry(otelMetrics, context2, order, error48).catch((telemetryError) => {
-    try {
-      log.warn("Telemetry emit failed", { error: telemetryError });
-    } catch {
-      console.warn("Telemetry emit failed", telemetryError);
-    }
-  });
-}
-function extractOrderTelemetryIds(params) {
-  const record2 = params ?? {};
-  return {
-    clientOrderId: firstString(record2.clientOrderId, record2.clientOrderID, record2.newClientOrderId, record2.clientOid),
-    idempotencyId: firstString(record2.idempotencyId, record2.idempotencyID, record2.idempotencyKey, record2.requestId, record2.requestID),
-    makerActionId: firstString(record2.makerActionId, record2.maker_action_id, record2.actionId, record2.action_id)
-  };
-}
-function firstValue(...values2) {
-  return values2.find((value) => value !== undefined && value !== null);
-}
-function firstString(...values2) {
-  for (const value of values2) {
-    if (typeof value === "string" && value.trim()) {
-      return value.trim();
-    }
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return String(value);
-    }
-  }
-  return;
-}
-function firstNumber(...values2) {
-  for (const value of values2) {
-    const numberValue = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
-    if (Number.isFinite(numberValue)) {
-      return numberValue;
-    }
-  }
-  return;
-}
-function computeFilledFromAmount(record2) {
-  const amount = firstNumber(record2?.amount);
-  const remaining = firstNumber(record2?.remaining);
-  if (amount === undefined || remaining === undefined) {
-    return;
-  }
-  return amount - remaining;
-}
-function computeAveragePrice(executedBaseQuantity, executedQuoteQuantity) {
-  if (executedBaseQuantity === undefined || executedQuoteQuantity === undefined || executedBaseQuantity === 0) {
-    return;
-  }
-  return executedQuoteQuantity / executedBaseQuantity;
-}
-function normalizeTimestamp(value) {
-  if (typeof value === "string" && value.trim()) {
-    return value.trim();
-  }
-  const timestamp = firstNumber(value);
-  if (timestamp === undefined) {
-    return;
-  }
-  const date5 = new Date(timestamp);
-  return Number.isNaN(date5.getTime()) ? undefined : date5.toISOString();
-}
-function getFees(record2, info) {
-  const fees = [];
-  if (record2?.fee)
-    fees.push(record2.fee);
-  if (Array.isArray(record2?.fees))
-    fees.push(...record2.fees);
-  if (Array.isArray(record2?.trades)) {
-    for (const trade of record2.trades) {
-      const tradeRecord = asRecord(trade);
-      if (tradeRecord?.fee)
-        fees.push(tradeRecord.fee);
-      if (Array.isArray(tradeRecord?.fees))
-        fees.push(...tradeRecord.fees);
-    }
-  }
-  if (Array.isArray(info?.fills)) {
-    for (const fill of info.fills) {
-      const fillRecord = asRecord(fill);
-      const commission = firstNumber(fillRecord?.commission);
-      if (commission !== undefined) {
-        fees.push({
-          cost: commission,
-          currency: firstString(fillRecord?.commissionAsset)
-        });
-      }
-    }
-  }
-  return fees;
-}
-function summarizeFees(fees) {
-  let amount = 0;
-  let amountFound = false;
-  let currency;
-  let rate;
-  for (const rawFee of fees) {
-    const fee = asRecord(rawFee);
-    if (!fee)
-      continue;
-    const cost = firstNumber(fee.cost, fee.amount);
-    if (cost !== undefined) {
-      amount += cost;
-      amountFound = true;
-    }
-    currency ??= firstString(fee.currency);
-    rate ??= firstNumber(fee.rate);
-  }
-  return {
-    amount: amountFound ? amount : undefined,
-    currency,
-    rate
-  };
-}
-function compactUndefined(record2) {
-  return Object.fromEntries(Object.entries(record2).filter(([, value]) => value !== undefined));
-}
-
-// src/handlers/execute-action/orders.ts
 async function handleCreateOrder(ctx) {
   const {
     call,
@@ -329959,7 +330511,8 @@ async function handleCreateOrder(ctx) {
     applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    otelMetrics,
+    brokerArchiver
   } = ctx;
   const verityProof = verity.proof;
   const orderValue = parsePayloadForAction(ctx, CreateOrderPayloadSchema);
@@ -329985,8 +330538,18 @@ async function handleCreateOrder(ctx) {
       side: resolution.side,
       requestedQuantity: resolution.amountBase ?? orderValue.amount
     };
+    const telemetryIds = extractOrderTelemetryIds(orderValue.params);
+    const submissionTimestamp = new Date().toISOString();
+    const marketMetadataHash = await captureMarketMetadataSnapshot(brokerArchiver, broker, {
+      exchange: cex3,
+      accountSelector: selectedBrokerAccount?.label,
+      symbol: resolution.symbol,
+      action: "CreateOrder",
+      brokerObservedTimestamp: submissionTimestamp,
+      ...telemetryIds
+    });
     const order = await broker.createOrder(resolution.symbol, orderValue.orderType, resolution.side, resolution.amountBase ?? orderValue.amount, orderValue.price, orderValue.params ?? {});
-    emitOrderExecutionTelemetryInBackground(otelMetrics, {
+    const createOrderContext = {
       action: "CreateOrder",
       cex: cex3,
       accountLabel: selectedBrokerAccount?.label,
@@ -329995,12 +330558,15 @@ async function handleCreateOrder(ctx) {
       orderType: orderValue.orderType,
       requestedQuantity: resolvedOrderTelemetry.requestedQuantity,
       requestedNotional: orderValue.amount * orderValue.price,
-      ...extractOrderTelemetryIds(orderValue.params)
-    }, order);
+      brokerObservedTimestamp: submissionTimestamp,
+      ...telemetryIds
+    };
+    emitOrderExecutionTelemetryInBackground(otelMetrics, createOrderContext, order);
+    archiveOrderExecutionInBackground(brokerArchiver, createOrderContext, order, undefined, { marketMetadataHash });
     ctx.wrappedCallback(null, { result: JSON.stringify({ ...order }) });
   } catch (error48) {
     safeLogError("Order Creation failed", error48);
-    emitOrderExecutionTelemetryInBackground(otelMetrics, {
+    const failedCreateContext = {
       action: "CreateOrder",
       cex: cex3,
       accountLabel: selectedBrokerAccount?.label,
@@ -330010,7 +330576,9 @@ async function handleCreateOrder(ctx) {
       requestedQuantity: resolvedOrderTelemetry.requestedQuantity ?? orderValue.amount,
       requestedNotional: orderValue.amount * orderValue.price,
       ...extractOrderTelemetryIds(orderValue.params)
-    }, undefined, error48);
+    };
+    emitOrderExecutionTelemetryInBackground(otelMetrics, failedCreateContext, undefined, error48);
+    archiveOrderExecutionInBackground(brokerArchiver, failedCreateContext, undefined, error48);
     ctx.wrappedCallback({
       code: grpc6.status.INTERNAL,
       message: "Order Creation failed"
@@ -330033,7 +330601,8 @@ async function handleGetOrderDetails(ctx) {
     applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    otelMetrics,
+    brokerArchiver
   } = ctx;
   const verityProof = verity.proof;
   const getOrderValue = parsePayloadForAction(ctx, GetOrderDetailsPayloadSchema);
@@ -330047,13 +330616,15 @@ async function handleGetOrderDetails(ctx) {
       }, null);
     }
     const orderDetails = await broker.fetchOrder(getOrderValue.orderId, symbol2, { ...getOrderValue.params });
-    emitOrderExecutionTelemetryInBackground(otelMetrics, {
+    const getOrderContext = {
       action: "GetOrderDetails",
       cex: cex3,
       accountLabel: selectedBrokerAccount?.label,
       symbol: symbol2,
       ...extractOrderTelemetryIds(getOrderValue.params)
-    }, orderDetails);
+    };
+    emitOrderExecutionTelemetryInBackground(otelMetrics, getOrderContext, orderDetails);
+    archiveOrderExecutionInBackground(brokerArchiver, getOrderContext, orderDetails);
     ctx.wrappedCallback(null, {
       result: JSON.stringify({
         orderId: orderDetails.id,
@@ -330068,6 +330639,15 @@ async function handleGetOrderDetails(ctx) {
     });
   } catch (error48) {
     safeLogError(`Error fetching order details from ${cex3}`, error48);
+    const failedGetOrderContext = {
+      action: "GetOrderDetails",
+      cex: cex3,
+      accountLabel: selectedBrokerAccount?.label,
+      symbol: symbol2,
+      ...extractOrderTelemetryIds(getOrderValue.params)
+    };
+    emitOrderExecutionTelemetryInBackground(otelMetrics, failedGetOrderContext, undefined, error48);
+    archiveOrderExecutionInBackground(brokerArchiver, failedGetOrderContext, undefined, error48);
     ctx.wrappedCallback({
       code: grpc6.status.INTERNAL,
       message: `Failed to fetch order details from ${cex3}`
@@ -330090,19 +330670,44 @@ async function handleCancelOrder(ctx) {
     applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    otelMetrics,
+    brokerArchiver
   } = ctx;
   const verityProof = verity.proof;
   const cancelOrderValue = parsePayloadForAction(ctx, CancelOrderPayloadSchema);
   if (cancelOrderValue === null)
     return;
   try {
+    if (!broker) {
+      return ctx.wrappedCallback({
+        code: grpc6.status.INVALID_ARGUMENT,
+        message: `Invalid CEX key: ${cex3}. Supported keys: ${Object.keys(brokers).join(", ")}`
+      }, null);
+    }
+    const cancelOrderContext = {
+      action: "CancelOrder",
+      cex: cex3,
+      accountLabel: selectedBrokerAccount?.label,
+      symbol: symbol2,
+      ...extractOrderTelemetryIds(cancelOrderValue.params)
+    };
     const cancelledOrder = await broker.cancelOrder(cancelOrderValue.orderId, symbol2, cancelOrderValue.params ?? {});
+    emitOrderExecutionTelemetryInBackground(otelMetrics, cancelOrderContext, cancelledOrder);
+    archiveOrderExecutionInBackground(brokerArchiver, cancelOrderContext, cancelledOrder);
     ctx.wrappedCallback(null, {
       result: JSON.stringify({ ...cancelledOrder })
     });
   } catch (error48) {
     safeLogError(`Error cancelling order from ${cex3}`, error48);
+    const failedCancelContext = {
+      action: "CancelOrder",
+      cex: cex3,
+      accountLabel: selectedBrokerAccount?.label,
+      symbol: symbol2,
+      ...extractOrderTelemetryIds(cancelOrderValue.params)
+    };
+    emitOrderExecutionTelemetryInBackground(otelMetrics, failedCancelContext, undefined, error48);
+    archiveOrderExecutionInBackground(brokerArchiver, failedCancelContext, undefined, error48);
     ctx.wrappedCallback({
       code: grpc6.status.INTERNAL,
       message: `Failed to cancel order from ${cex3}`
@@ -330823,7 +331428,8 @@ function createExecuteActionHandler(deps) {
     whitelistIps,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    otelMetrics,
+    brokerArchiver
   } = deps;
   return async (call, callback) => {
     const startTime = Date.now();
@@ -330901,7 +331507,8 @@ function createExecuteActionHandler(deps) {
         applyVerityToBroker,
         useVerity,
         verityProverUrl,
-        otelMetrics
+        otelMetrics,
+        brokerArchiver
       };
       if (action === Action.Call) {
         const handled = await handleOrderBookCall(preludeCtx);
@@ -331038,157 +331645,799 @@ function decodeMessageData(data) {
   return data;
 }
 
-class BinanceSpotUserDataStream {
-  exchange;
-  ws;
-  secretValues;
-  requestId = `user-data-${Date.now()}-${Math.random()}`;
-  maxBufferedEvents;
-  queue = [];
-  waiters = [];
-  closed = false;
-  closeError = null;
-  subscriptionId = null;
-  constructor(exchange, 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));
+class BinanceSpotUserDataStream {
+  exchange;
+  ws;
+  secretValues;
+  requestId = `user-data-${Date.now()}-${Math.random()}`;
+  maxBufferedEvents;
+  queue = [];
+  waiters = [];
+  closed = false;
+  closeError = null;
+  subscriptionId = null;
+  constructor(exchange, options = {}) {
+    this.exchange = exchange;
+    this.maxBufferedEvents = options.maxBufferedEvents ?? DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS;
+    this.secretValues = [
+      getOptionalExchangeString(exchange, "apiKey"),
+      getOptionalExchangeString(exchange, "secret")
+    ].filter((value) => value !== null);
+    this.ws = createWebSocket(getBinanceSpotWsApiUrl(exchange));
+    this.ws.on("open", () => this.subscribe());
+    this.ws.on("message", (data) => this.handleMessage(data));
+    this.ws.on("error", (error48) => this.fail(formatBinanceUserDataWebSocketError(error48, this.secretValues)));
+    this.ws.on("close", (code, reason) => this.handleClose(code, reason));
+  }
+  async* [Symbol.asyncIterator]() {
+    while (true) {
+      const event = await this.nextEvent();
+      if (!event) {
+        break;
+      }
+      yield event;
+    }
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.queue.length = 0;
+    try {
+      this.ws.close();
+    } catch {}
+    this.flushWaiters();
+  }
+  handleClose(code, reason) {
+    if (this.closed) {
+      return;
+    }
+    this.fail(formatBinanceUserDataWebSocketClose(code, reason, this.secretValues));
+  }
+  subscribe() {
+    const apiKey = getExchangeString(this.exchange, "apiKey");
+    const signedParams = signUserDataStreamParams(this.exchange, {
+      apiKey,
+      timestamp: Date.now()
+    });
+    this.ws.send(JSON.stringify({
+      id: this.requestId,
+      method: "userDataStream.subscribe.signature",
+      params: signedParams
+    }));
+  }
+  handleMessage(data) {
+    if (this.closed) {
+      return;
+    }
+    let message;
+    try {
+      const decodedData = decodeMessageData(data);
+      message = typeof decodedData === "string" ? JSON.parse(decodedData) : decodedData;
+    } catch (error48) {
+      this.fail(error48 instanceof Error ? error48 : new Error("Invalid Binance user-data message"));
+      return;
+    }
+    if ("id" in message && message.id === this.requestId) {
+      if (message.status !== 200) {
+        this.fail(new Error(message.error?.msg ?? message.error?.message ?? `Binance user-data subscription failed with status ${message.status}`));
+        return;
+      }
+      this.subscriptionId = message.result?.subscriptionId ?? null;
+      return;
+    }
+    if (!("event" in message) || !message.event) {
+      return;
+    }
+    const subscriptionId = message.subscriptionId ?? this.subscriptionId;
+    if (subscriptionId === null || subscriptionId === undefined) {
+      return;
+    }
+    this.push({ subscriptionId, event: message.event });
+  }
+  push(event) {
+    if (this.closed) {
+      return;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve(event);
+      return;
+    }
+    if (this.queue.length >= this.maxBufferedEvents) {
+      this.fail(new Error(`Binance user-data stream buffered event limit exceeded (${this.maxBufferedEvents}); downstream consumer is not keeping up`));
+      return;
+    }
+    this.queue.push(event);
+  }
+  nextEvent() {
+    const event = this.queue.shift();
+    if (event) {
+      return Promise.resolve(event);
+    }
+    if (this.closeError) {
+      return Promise.reject(this.closeError);
+    }
+    if (this.closed) {
+      return Promise.resolve(null);
+    }
+    return new Promise((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
+  }
+  fail(error48) {
+    if (this.closeError) {
+      return;
+    }
+    this.closeError = error48;
+    this.closed = true;
+    this.queue.length = 0;
+    this.flushWaiters();
+    try {
+      this.ws.close();
+    } catch {}
+  }
+  flushWaiters() {
+    const error48 = this.closeError;
+    for (const waiter of this.waiters.splice(0)) {
+      if (error48) {
+        waiter.reject(error48);
+      } else {
+        waiter.resolve(null);
+      }
+    }
+  }
+}
+function isBinanceBalanceUserDataEvent(event) {
+  return event.e === "outboundAccountPosition" || event.e === "balanceUpdate" || event.e === "externalLockUpdate";
+}
+function isBinanceOrderUserDataEvent(event) {
+  return event.e === "executionReport" || event.e === "listStatus";
+}
+
+// src/helpers/market-data-archive/ohlcv-bar-tracker.ts
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function parseOhlcvBar(value) {
+  if (!Array.isArray(value) || value.length < 6) {
+    return null;
+  }
+  const [openTimeMs, open, high, low, close, volume, quoteVolume] = value;
+  if (!isFiniteNumber(openTimeMs) || !isFiniteNumber(open) || !isFiniteNumber(high) || !isFiniteNumber(low) || !isFiniteNumber(close) || !isFiniteNumber(volume)) {
+    return null;
+  }
+  const bar = {
+    openTimeMs,
+    open,
+    high,
+    low,
+    close,
+    volume
+  };
+  if (isFiniteNumber(quoteVolume)) {
+    bar.quoteVolume = quoteVolume;
+  }
+  return bar;
+}
+function extractOhlcvBars(payload) {
+  if (!Array.isArray(payload) || payload.length === 0) {
+    return [];
+  }
+  const rawBars = Array.isArray(payload[0]) ? payload : [payload];
+  const byOpenTime = new Map;
+  for (const entry of rawBars) {
+    const bar = parseOhlcvBar(entry);
+    if (bar) {
+      byOpenTime.set(bar.openTimeMs, bar);
+    }
+  }
+  return [...byOpenTime.values()].sort((a, b2) => a.openTimeMs - b2.openTimeMs);
+}
+class OhlcvBarTracker {
+  lastOpenTimeMs = null;
+  lastBar = null;
+  process(payload, brokerVersion) {
+    const bars = extractOhlcvBars(payload);
+    if (bars.length === 0) {
+      return [];
+    }
+    if (bars.length === 1) {
+      const [bar] = bars;
+      return bar ? this.processSingleBar(bar, brokerVersion) : [];
+    }
+    return this.processBatch(bars, brokerVersion);
+  }
+  processSingleBar(currentBar, brokerVersion) {
+    if (this.lastOpenTimeMs !== null && currentBar.openTimeMs < this.lastOpenTimeMs) {
+      return [];
+    }
+    const candidates = [];
+    if (this.lastOpenTimeMs !== null && this.lastBar !== null && currentBar.openTimeMs !== this.lastOpenTimeMs) {
+      candidates.push({
+        bar: this.lastBar,
+        isClosed: true,
+        brokerVersion
+      });
+    }
+    candidates.push({
+      bar: currentBar,
+      isClosed: false,
+      brokerVersion
+    });
+    this.lastOpenTimeMs = currentBar.openTimeMs;
+    this.lastBar = currentBar;
+    return candidates;
+  }
+  processBatch(bars, brokerVersion) {
+    const firstBar = bars[0];
+    const lastBar = bars[bars.length - 1];
+    if (!firstBar || !lastBar) {
+      return [];
+    }
+    if (this.lastOpenTimeMs !== null && lastBar.openTimeMs < this.lastOpenTimeMs) {
+      return [];
+    }
+    const candidates = [];
+    if (this.lastBar !== null && this.lastOpenTimeMs !== null && !bars.some((bar) => bar.openTimeMs === this.lastOpenTimeMs) && this.lastOpenTimeMs < firstBar.openTimeMs) {
+      candidates.push({
+        bar: this.lastBar,
+        isClosed: true,
+        brokerVersion
+      });
+    }
+    for (let index2 = 0;index2 < bars.length - 1; index2 += 1) {
+      const bar = bars[index2];
+      if (bar) {
+        candidates.push({
+          bar,
+          isClosed: true,
+          brokerVersion
+        });
+      }
+    }
+    candidates.push({
+      bar: lastBar,
+      isClosed: false,
+      brokerVersion
+    });
+    this.lastOpenTimeMs = lastBar.openTimeMs;
+    this.lastBar = lastBar;
+    return candidates;
+  }
+}
+
+// src/helpers/market-data-archive/orderbook-sampler.ts
+var DEFAULT_ORDERBOOK_INTERVAL_MS = 1000;
+function getOrderbookIntervalMs() {
+  const raw = process.env.CEX_BROKER_ORDERBOOK_INTERVAL_MS ?? process.env.CEX_BROKER_ORDERBOOK_TOB_INTERVAL_MS;
+  if (!raw) {
+    return DEFAULT_ORDERBOOK_INTERVAL_MS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ORDERBOOK_INTERVAL_MS;
+}
+function isMarketArchiveEnabled() {
+  return process.env.CEX_BROKER_MARKET_ARCHIVE_ENABLED !== "false";
+}
+
+class OrderbookSampler {
+  intervalMs;
+  lastEmitMs = null;
+  constructor(intervalMs = getOrderbookIntervalMs()) {
+    this.intervalMs = intervalMs;
+  }
+  shouldEmit(nowMs = Date.now()) {
+    if (this.lastEmitMs !== null && nowMs < this.lastEmitMs) {
+      this.lastEmitMs = nowMs;
+      return true;
+    }
+    if (this.lastEmitMs !== null && nowMs - this.lastEmitMs < this.intervalMs) {
+      return false;
+    }
+    this.lastEmitMs = nowMs;
+    return true;
+  }
+}
+
+// src/helpers/market-data-archive/parse-stream.ts
+function isFiniteNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function toNumber2(value) {
+  if (isFiniteNumber2(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return;
+}
+function toStringId(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return;
+}
+function scalarTimestampMs(value, fallbackMs) {
+  const numeric = toNumber2(value);
+  if (numeric !== undefined) {
+    return numeric < 1000000000000 ? numeric * 1000 : numeric;
+  }
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return fallbackMs;
+}
+function parseTrade(value, fallbackMs = Date.now()) {
+  const record2 = asRecord(value);
+  if (!record2) {
+    return null;
+  }
+  const tradeId = toStringId(record2.id);
+  const price = toNumber2(record2.price);
+  const amount = toNumber2(record2.amount);
+  const side = typeof record2.side === "string" ? record2.side.toLowerCase() : undefined;
+  if (!tradeId || price === undefined || amount === undefined || !side) {
+    return null;
+  }
+  const parsed = {
+    tradeId,
+    eventTimeMs: scalarTimestampMs(record2.timestamp, fallbackMs),
+    side,
+    price,
+    amount
+  };
+  const cost = toNumber2(record2.cost);
+  if (cost !== undefined) {
+    parsed.cost = cost;
+  }
+  if (typeof record2.takerOrMaker === "string") {
+    parsed.takerOrMaker = record2.takerOrMaker;
+  }
+  return parsed;
+}
+function extractTrades(payload, fallbackMs = Date.now()) {
+  if (Array.isArray(payload)) {
+    return payload.map((entry) => parseTrade(entry, fallbackMs)).filter((entry) => entry !== null);
+  }
+  const single = parseTrade(payload, fallbackMs);
+  return single ? [single] : [];
+}
+function parseTicker(value, fallbackMs) {
+  const record2 = asRecord(value);
+  if (!record2) {
+    return null;
+  }
+  const parsed = {
+    eventTimeMs: scalarTimestampMs(record2.timestamp, fallbackMs)
+  };
+  const fields = [
+    ["last", record2.last],
+    ["bid", record2.bid],
+    ["ask", record2.ask],
+    ["high", record2.high],
+    ["low", record2.low],
+    ["open", record2.open],
+    ["close", record2.close],
+    ["baseVolume", record2.baseVolume],
+    ["quoteVolume", record2.quoteVolume],
+    ["change", record2.change],
+    ["percentage", record2.percentage]
+  ];
+  for (const [key, rawValue] of fields) {
+    const numeric = toNumber2(rawValue);
+    if (numeric !== undefined) {
+      parsed[key] = numeric;
+    }
+  }
+  return parsed;
+}
+
+// src/helpers/market-data-archive/orderbook-depth.ts
+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);
+}
+function splitOrderBookSide(levels, limit) {
+  const prices = [];
+  const sizes = [];
+  for (const level of levels.slice(0, limit)) {
+    if (!Array.isArray(level) || level.length < 2) {
+      continue;
+    }
+    const price = level[0];
+    const size = level[1];
+    if (price === undefined || size === undefined || !Number.isFinite(price) || !Number.isFinite(size)) {
+      continue;
+    }
+    prices.push(price);
+    sizes.push(size);
+  }
+  return { prices, sizes };
+}
+
+// src/helpers/market-data-archive/rows.ts
+function compactUndefined3(record2) {
+  return Object.fromEntries(Object.entries(record2).filter(([, value]) => value !== undefined));
+}
+function scalarTimestampMs2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    if (/^\d+$/.test(value)) {
+      const numeric = Number.parseInt(value, 10);
+      if (Number.isFinite(numeric)) {
+        return numeric;
+      }
+    }
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return Date.now();
+}
+function parseSequence(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    return Number.parseInt(value, 10);
+  }
+  return;
+}
+function topOfBookLevel(levels) {
+  const level = levels[0];
+  if (!level || level.length < 2) {
+    return null;
+  }
+  const price = level[0];
+  const size = level[1];
+  if (price === undefined || size === undefined || !Number.isFinite(price) || !Number.isFinite(size)) {
+    return null;
+  }
+  return { price, size };
+}
+function computeSpreadBps(bestBid, bestAsk) {
+  if (bestBid <= 0 || bestAsk <= 0 || bestAsk < bestBid) {
+    return 0;
+  }
+  const mid = (bestBid + bestAsk) / 2;
+  if (mid <= 0) {
+    return 0;
+  }
+  return (bestAsk - bestBid) / mid * 1e4;
+}
+function buildOrderbookArchiveTags(input, receivedTimeMs) {
+  return buildCommonArchiveTags({
+    deploymentId: input.deploymentId,
+    accountSelector: input.accountSelector,
+    exchange: input.exchange,
+    symbol: input.symbol,
+    brokerObservedTimestamp: new Date(receivedTimeMs).toISOString()
+  });
+}
+function buildOrderbookSnapshotRow(input) {
+  const bid = topOfBookLevel(input.snapshot.bids);
+  const ask = topOfBookLevel(input.snapshot.asks);
+  if (!bid || !ask) {
+    return null;
+  }
+  const archiveDepthLimit = getOrderbookArchiveDepthLimit();
+  const bids = splitOrderBookSide(input.snapshot.bids, archiveDepthLimit);
+  const asks = splitOrderBookSide(input.snapshot.asks, archiveDepthLimit);
+  if (bids.prices.length === 0 || asks.prices.length === 0) {
+    return null;
+  }
+  const eventTimeMs = scalarTimestampMs2(input.snapshot.timestamp);
+  const receivedTimeMs = input.snapshot.receivedTimestamp;
+  const mid = (bid.price + ask.price) / 2;
+  const sequence = parseSequence(input.snapshot.sequence);
+  return {
+    table: "market_data.orderbook_snapshots",
+    row: compactUndefined3({
+      ...buildOrderbookArchiveTags(input, receivedTimeMs),
+      asset_type: input.assetType,
+      event_time_ms: eventTimeMs,
+      received_time_ms: receivedTimeMs,
+      best_bid: bid.price,
+      best_ask: ask.price,
+      bid_size: bid.size,
+      ask_size: ask.size,
+      mid,
+      spread_bps: computeSpreadBps(bid.price, ask.price),
+      depth_limit: archiveDepthLimit,
+      bid_levels: bids.prices.length,
+      ask_levels: asks.prices.length,
+      bids_price: bids.prices,
+      bids_size: bids.sizes,
+      asks_price: asks.prices,
+      asks_size: asks.sizes,
+      sequence
+    })
+  };
+}
+function buildCandleRow(input) {
+  const { context: context2, bar, isClosed, brokerVersion, receivedTimestamp } = input;
+  const tags = buildCommonArchiveTags({
+    deploymentId: context2.deploymentId,
+    accountSelector: context2.accountSelector,
+    exchange: context2.exchange,
+    symbol: context2.symbol,
+    brokerObservedTimestamp: new Date(receivedTimestamp).toISOString()
+  });
+  return {
+    table: "market_data.candles",
+    row: compactUndefined3({
+      ...tags,
+      asset_type: context2.assetType,
+      timeframe: context2.timeframe ?? "1m",
+      open_time_ms: bar.openTimeMs,
+      open: bar.open,
+      high: bar.high,
+      low: bar.low,
+      close: bar.close,
+      volume: bar.volume,
+      quote_volume: bar.quoteVolume,
+      is_closed: isClosed ? 1 : 0,
+      broker_version: brokerVersion
+    })
+  };
+}
+function buildCexStreamEventRow(input) {
+  const receivedTimeMs = input.receivedTimestamp;
+  const redactedPayload = redactStreamPayload(input.payload);
+  const tags = buildCommonArchiveTags({
+    deploymentId: input.deploymentId,
+    accountSelector: input.accountSelector,
+    exchange: input.exchange,
+    symbol: input.symbol,
+    brokerObservedTimestamp: new Date(receivedTimeMs).toISOString()
+  });
+  return {
+    table: "market_data.cex_stream_events",
+    row: compactUndefined3({
+      ...tags,
+      asset_type: input.assetType,
+      stream_type: input.streamType,
+      event_time_ms: input.eventTimeMs ?? receivedTimeMs,
+      received_time_ms: receivedTimeMs,
+      payload_json: JSON.stringify(redactedPayload)
+    })
+  };
+}
+function buildCexTickerEventRow(input, ticker) {
+  const receivedTimeMs = input.receivedTimestamp;
+  const tags = buildCommonArchiveTags({
+    deploymentId: input.deploymentId,
+    accountSelector: input.accountSelector,
+    exchange: input.exchange,
+    symbol: input.symbol,
+    brokerObservedTimestamp: new Date(receivedTimeMs).toISOString()
+  });
+  return {
+    table: "market_data.cex_ticker_events",
+    row: compactUndefined3({
+      ...tags,
+      asset_type: input.assetType,
+      event_time_ms: ticker.eventTimeMs,
+      received_time_ms: receivedTimeMs,
+      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,
+      payload_json: JSON.stringify(redactStreamPayload(input.payload))
+    })
+  };
+}
+function buildCexTradeRow(input, trade) {
+  const receivedTimeMs = input.receivedTimestamp;
+  const tags = buildCommonArchiveTags({
+    deploymentId: input.deploymentId,
+    accountSelector: input.accountSelector,
+    exchange: input.exchange,
+    symbol: input.symbol,
+    brokerObservedTimestamp: new Date(receivedTimeMs).toISOString()
+  });
+  return {
+    table: "market_data.cex_trades",
+    row: compactUndefined3({
+      ...tags,
+      asset_type: input.assetType,
+      trade_id: trade.tradeId,
+      event_time_ms: trade.eventTimeMs,
+      received_time_ms: receivedTimeMs,
+      side: trade.side,
+      price: trade.price,
+      amount: trade.amount,
+      cost: trade.cost,
+      taker_or_maker: trade.takerOrMaker
+    })
+  };
+}
+
+// src/helpers/market-data-archive/capture.ts
+async function recordWatchMetric(otelMetrics, metricName, labels) {
+  try {
+    await otelMetrics?.recordCounter(metricName, 1, labels);
+  } catch {}
+}
+function watchLabels(stream4, input) {
+  return {
+    stream: stream4,
+    exchange: input.exchange,
+    symbol: input.symbol
+  };
+}
+function archiveOrderbookInBackground(archiver, otelMetrics, input, options) {
+  const labels = watchLabels("orderbook", input);
+  recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
+  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
+    return;
   }
-  async* [Symbol.asyncIterator]() {
-    while (true) {
-      const event = await this.nextEvent();
-      if (!event) {
-        break;
-      }
-      yield event;
-    }
+  if (options?.sampledOut) {
+    recordWatchMetric(otelMetrics, "cex_watch_frames_sampled_out_total", labels);
+    return;
   }
-  close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    this.queue.length = 0;
+  queueMicrotask(() => {
     try {
-      this.ws.close();
-    } catch {}
-    this.flushWaiters();
-  }
-  handleClose(code, reason) {
-    if (this.closed) {
-      return;
+      const row = buildOrderbookSnapshotRow(input);
+      if (row) {
+        archiver.enqueue(row);
+        recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
+      }
+    } catch (error48) {
+      log.warn("Failed to archive orderbook snapshot", { error: error48 });
     }
-    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
-    }));
+  });
+}
+function archiveOhlcvInBackground(archiver, otelMetrics, tracker, input) {
+  const labels = watchLabels("ohlcv", input);
+  recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
+  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
+    return;
   }
-  handleMessage(data) {
-    if (this.closed) {
-      return;
-    }
-    let message;
+  queueMicrotask(() => {
     try {
-      const decodedData = decodeMessageData(data);
-      message = typeof decodedData === "string" ? JSON.parse(decodedData) : decodedData;
+      const candidates = tracker.process(input.payload, input.receivedTimestamp);
+      for (const candidate of candidates) {
+        const row = buildCandleRow({
+          context: input,
+          bar: candidate.bar,
+          isClosed: candidate.isClosed,
+          brokerVersion: candidate.brokerVersion,
+          receivedTimestamp: input.receivedTimestamp
+        });
+        archiver.enqueue(row);
+      }
+      if (candidates.length > 0) {
+        recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
+      }
     } catch (error48) {
-      this.fail(error48 instanceof Error ? error48 : new Error("Invalid Binance user-data message"));
-      return;
+      log.warn("Failed to archive OHLCV candle", { error: error48 });
     }
-    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;
+  });
+}
+function createOrderbookSampler() {
+  return new OrderbookSampler;
+}
+function createOhlcvBarTracker() {
+  return new OhlcvBarTracker;
+}
+function archiveMarketRowsInBackground(archiver, otelMetrics, stream4, input, enqueueRows) {
+  const labels = watchLabels(stream4, input);
+  recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
+  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
+    return;
+  }
+  queueMicrotask(() => {
+    try {
+      const rows = enqueueRows();
+      for (const row of rows) {
+        archiver.enqueue(row);
       }
-      this.subscriptionId = message.result?.subscriptionId ?? null;
-      return;
-    }
-    if (!("event" in message) || !message.event) {
-      return;
-    }
-    const subscriptionId = message.subscriptionId ?? this.subscriptionId;
-    if (subscriptionId === null || subscriptionId === undefined) {
-      return;
+      if (rows.length > 0) {
+        recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
+      }
+    } catch (error48) {
+      log.warn(`Failed to archive ${stream4} market data`, { error: error48 });
     }
-    this.push({ subscriptionId, event: message.event });
+  });
+}
+function archiveTradesInBackground(archiver, otelMetrics, input) {
+  archiveMarketRowsInBackground(archiver, otelMetrics, "trades", input, () => extractTrades(input.payload, input.receivedTimestamp).map((trade) => buildCexTradeRow(input, trade)));
+}
+function archiveTickerInBackground(archiver, otelMetrics, input) {
+  archiveMarketRowsInBackground(archiver, otelMetrics, "ticker", input, () => {
+    const ticker = parseTicker(input.payload, input.receivedTimestamp);
+    return ticker ? [buildCexTickerEventRow(input, ticker)] : [];
+  });
+}
+function archiveCexStreamEventInBackground(archiver, otelMetrics, input) {
+  archiveMarketRowsInBackground(archiver, otelMetrics, "stream", input, () => [
+    buildCexStreamEventRow(input)
+  ]);
+}
+// src/helpers/market-data-archive/ohlcv-bootstrap.ts
+var DEFAULT_OHLCV_BOOTSTRAP_LIMIT = 100;
+var MAX_OHLCV_BOOTSTRAP_LIMIT = 1000;
+function resolveOhlcvBootstrapLimit(optionValue) {
+  const raw = optionValue?.trim() || process.env.CEX_BROKER_OHLCV_ARCHIVE_BOOTSTRAP_LIMIT?.trim();
+  if (raw === "0" || raw?.toLowerCase() === "false") {
+    return 0;
   }
-  push(event) {
-    if (this.closed) {
-      return;
-    }
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      waiter.resolve(event);
-      return;
-    }
-    if (this.queue.length >= this.maxBufferedEvents) {
-      this.fail(new Error(`Binance user-data stream buffered event limit exceeded (${this.maxBufferedEvents}); downstream consumer is not keeping up`));
-      return;
-    }
-    this.queue.push(event);
+  if (!raw) {
+    return DEFAULT_OHLCV_BOOTSTRAP_LIMIT;
   }
-  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 });
-    });
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return DEFAULT_OHLCV_BOOTSTRAP_LIMIT;
   }
-  fail(error48) {
-    if (this.closeError) {
-      return;
-    }
-    this.closeError = error48;
-    this.closed = true;
-    this.queue.length = 0;
-    this.flushWaiters();
-    try {
-      this.ws.close();
-    } catch {}
+  return Math.min(parsed, MAX_OHLCV_BOOTSTRAP_LIMIT);
+}
+
+// src/helpers/market-data-archive/ohlcv-history.ts
+function supportsFetchOhlcv(broker) {
+  const fetchOHLCV = broker.fetchOHLCV;
+  const hasValue = broker.has?.fetchOHLCV;
+  return typeof fetchOHLCV === "function" && hasValue !== false;
+}
+async function bootstrapOhlcvHistory(broker, archiver, otelMetrics, tracker, input, options) {
+  const limit = resolveOhlcvBootstrapLimit(options?.bootstrapLimit);
+  if (limit <= 0 || !supportsFetchOhlcv(broker)) {
+    return null;
   }
-  flushWaiters() {
-    const error48 = this.closeError;
-    for (const waiter of this.waiters.splice(0)) {
-      if (error48) {
-        waiter.reject(error48);
-      } else {
-        waiter.resolve(null);
-      }
+  try {
+    const fetchOHLCV = broker.fetchOHLCV.bind(broker);
+    const payload = await fetchOHLCV(input.symbol, input.timeframe ?? "1m", undefined, limit);
+    if (!Array.isArray(payload) || payload.length === 0) {
+      return null;
     }
+    const receivedTimestamp = Date.now();
+    archiveOhlcvInBackground(archiver, otelMetrics, tracker, {
+      ...input,
+      payload,
+      receivedTimestamp
+    });
+    return payload;
+  } catch (error48) {
+    log.warn("OHLCV bootstrap fetch failed", {
+      error: error48,
+      symbol: input.symbol,
+      exchange: input.exchange,
+      timeframe: input.timeframe
+    });
+    return null;
   }
 }
-function isBinanceBalanceUserDataEvent(event) {
-  return event.e === "outboundAccountPosition" || event.e === "balanceUpdate" || event.e === "externalLockUpdate";
-}
-function isBinanceOrderUserDataEvent(event) {
-  return event.e === "executionReport" || event.e === "listStatus";
-}
-
 // src/handlers/subscribe/handler.ts
 function isBinanceSpotAccountSubscription(cex3, subscriptionType, marketTypeInput) {
   return cex3 === "binance" && parseMarketType(marketTypeInput) === "spot" && (subscriptionType === SubscriptionType.BALANCE || subscriptionType === SubscriptionType.ORDERS);
@@ -331257,7 +332506,7 @@ async function getBinanceMarketId(broker, symbol2) {
   }
   return symbol2.replace("/", "").toUpperCase();
 }
-async function streamBinanceUserData(call, broker, symbol2, subscriptionType, isClosed) {
+async function streamBinanceUserData(call, broker, symbol2, subscriptionType, isClosed, archiveContext) {
   const userDataStream = new BinanceSpotUserDataStream(broker);
   call.once("close", () => userDataStream.close());
   call.once("cancelled", () => userDataStream.close());
@@ -331282,37 +332531,78 @@ async function streamBinanceUserData(call, broker, symbol2, subscriptionType, is
           continue;
         }
       }
+      const receivedTimestamp = Date.now();
       if (!await writeSubscribeFrame(call, isClosed, {
         data: JSON.stringify({
           subscriptionId: message.subscriptionId,
           event
         }),
-        timestamp: Date.now(),
+        timestamp: receivedTimestamp,
         symbol: symbol2,
         type: subscriptionType
       })) {
         break;
       }
+      const archiveSubscriptionType = subscriptionType === SubscriptionType.BALANCE ? "BALANCE" : "ORDERS";
+      archiveSubscribeStreamInBackground(archiveContext?.archiver, {
+        exchange: archiveContext?.exchange ?? "binance",
+        accountSelector: archiveContext?.accountSelector,
+        symbol: symbol2,
+        subscriptionType: archiveSubscriptionType,
+        streamPayload: event
+      });
+      if (archiveContext) {
+        archiveCexStreamEventInBackground(archiveContext.archiver, archiveContext.otelMetrics, {
+          deploymentId: archiveContext.deploymentId,
+          exchange: archiveContext.exchange,
+          symbol: symbol2,
+          assetType: archiveContext.assetType,
+          accountSelector: archiveContext.accountSelector,
+          streamType: archiveSubscriptionType,
+          payload: event,
+          receivedTimestamp
+        });
+      }
     }
   } finally {
     userDataStream.close();
   }
 }
-async function runCcxtSubscribeLoop(call, isClosed, symbol2, subscriptionType, watch) {
+async function runCcxtSubscribeLoop(call, isClosed, symbol2, subscriptionType, watch, archiveContext) {
   while (!isClosed()) {
     const data = await watch();
+    const receivedTimestamp = Date.now();
     if (!await writeSubscribeFrame(call, isClosed, {
       data: JSON.stringify(data),
-      timestamp: Date.now(),
+      timestamp: receivedTimestamp,
       symbol: symbol2,
       type: subscriptionType
     })) {
       break;
     }
+    if (archiveContext?.archiveSubscriptionType) {
+      archiveSubscribeStreamInBackground(archiveContext.archiver, {
+        exchange: archiveContext.exchange,
+        accountSelector: archiveContext.accountSelector,
+        symbol: symbol2,
+        subscriptionType: archiveContext.archiveSubscriptionType,
+        streamPayload: data
+      });
+      archiveCexStreamEventInBackground(archiveContext.archiver, archiveContext.otelMetrics, {
+        deploymentId: archiveContext.deploymentId,
+        exchange: archiveContext.exchange,
+        symbol: symbol2,
+        assetType: archiveContext.assetType,
+        accountSelector: archiveContext.accountSelector,
+        streamType: archiveContext.archiveSubscriptionType,
+        payload: data,
+        receivedTimestamp
+      });
+    }
   }
 }
 function createSubscribeHandler(deps) {
-  const { brokers, whitelistIps, otelMetrics } = deps;
+  const { brokers, whitelistIps, otelMetrics, brokerArchiver } = deps;
   return async (call) => {
     const subscribeStartTime = Date.now();
     let streamClosed = false;
@@ -331378,7 +332668,9 @@ function createSubscribeHandler(deps) {
         return;
       }
       const normalizedCex = cex3.trim().toLowerCase();
-      const selectedBroker = selectBroker(brokers[normalizedCex], metadata) ?? createBroker(normalizedCex, metadata);
+      const brokerPool = brokers[normalizedCex];
+      const selectedBrokerAccount = selectBrokerAccount(brokerPool, metadata);
+      const selectedBroker = selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, metadata);
       const broker = selectedBroker ?? createPublicBroker(normalizedCex);
       if (!broker) {
         await writeSubscribeError(call, isStreamClosed, {
@@ -331392,8 +332684,19 @@ function createSubscribeHandler(deps) {
         return;
       }
       const resolvedSymbol = await resolveSubscriptionSymbol(broker, symbol2, options?.marketType);
+      const assetType = parseMarketType(options?.marketType);
+      const deploymentId = brokerArchiver?.getDeploymentId() ?? "unknown";
+      const streamArchiveContext = {
+        archiver: brokerArchiver,
+        otelMetrics,
+        exchange: normalizedCex,
+        accountSelector: selectedBrokerAccount?.label,
+        deploymentId,
+        assetType
+      };
       if (isBinanceSpotAccountSubscription(normalizedCex, subscriptionType, options?.marketType)) {
-        if (!selectedBroker) {
+        const accountBroker = selectedBrokerAccount?.exchange ?? selectedBroker;
+        if (!accountBroker) {
           await writeSubscribeError(call, isStreamClosed, {
             data: JSON.stringify({
               error: "Binance account subscriptions require API credentials"
@@ -331404,29 +332707,42 @@ function createSubscribeHandler(deps) {
           });
           return;
         }
-        await streamBinanceUserData(call, selectedBroker, resolvedSymbol, subscriptionType, isStreamClosed);
+        await streamBinanceUserData(call, accountBroker, resolvedSymbol, subscriptionType, isStreamClosed, streamArchiveContext);
         return;
       }
       switch (subscriptionType) {
         case SubscriptionType.ORDERBOOK:
           try {
+            const orderbookSampler = createOrderbookSampler();
             while (!isStreamClosed()) {
               const depthLimit = parseOptionalDepthLimit(options?.depthLimit ?? options?.limit);
               const orderbook = depthLimit === undefined ? await broker.watchOrderBook(resolvedSymbol) : await broker.watchOrderBook(resolvedSymbol, depthLimit);
               const receivedTimestamp = Date.now();
+              const normalizedSnapshot = normalizeOrderBookSnapshot(orderbook, {
+                exchange: normalizedCex,
+                symbol: resolvedSymbol,
+                depthLimit: depthLimit ?? Math.max(Array.isArray(orderbook?.bids) ? orderbook.bids.length : 0, Array.isArray(orderbook?.asks) ? orderbook.asks.length : 0),
+                receivedTimestamp
+              });
               if (!await writeSubscribeFrame(call, isStreamClosed, {
-                data: JSON.stringify(normalizeOrderBookSnapshot(orderbook, {
-                  exchange: normalizedCex,
-                  symbol: resolvedSymbol,
-                  depthLimit: depthLimit ?? Math.max(Array.isArray(orderbook?.bids) ? orderbook.bids.length : 0, Array.isArray(orderbook?.asks) ? orderbook.asks.length : 0),
-                  receivedTimestamp
-                })),
+                data: JSON.stringify(normalizedSnapshot),
                 timestamp: receivedTimestamp,
                 symbol: resolvedSymbol,
                 type: subscriptionType
               })) {
                 break;
               }
+              const shouldArchive = orderbookSampler.shouldEmit(receivedTimestamp);
+              archiveOrderbookInBackground(brokerArchiver, otelMetrics, {
+                deploymentId,
+                exchange: normalizedCex,
+                symbol: resolvedSymbol,
+                assetType,
+                accountSelector: selectedBrokerAccount?.label,
+                snapshot: normalizedSnapshot
+              }, {
+                sampledOut: !shouldArchive
+              });
             }
           } catch (error48) {
             log.error(`Error fetching orderbook for ${resolvedSymbol} on ${cex3}:`, error48);
@@ -331443,7 +332759,27 @@ function createSubscribeHandler(deps) {
           break;
         case SubscriptionType.TRADES:
           try {
-            await runCcxtSubscribeLoop(call, isStreamClosed, resolvedSymbol, subscriptionType, () => broker.watchTrades(resolvedSymbol));
+            while (!isStreamClosed()) {
+              const data = await broker.watchTrades(resolvedSymbol);
+              const receivedTimestamp = Date.now();
+              if (!await writeSubscribeFrame(call, isStreamClosed, {
+                data: JSON.stringify(data),
+                timestamp: receivedTimestamp,
+                symbol: resolvedSymbol,
+                type: subscriptionType
+              })) {
+                break;
+              }
+              archiveTradesInBackground(brokerArchiver, otelMetrics, {
+                deploymentId,
+                exchange: normalizedCex,
+                symbol: resolvedSymbol,
+                assetType,
+                accountSelector: selectedBrokerAccount?.label,
+                payload: data,
+                receivedTimestamp
+              });
+            }
           } catch (error48) {
             const message = getErrorMessage(error48);
             log.error(`Error fetching trades for ${resolvedSymbol} on ${cex3}:`, error48);
@@ -331459,7 +332795,27 @@ function createSubscribeHandler(deps) {
           break;
         case SubscriptionType.TICKER:
           try {
-            await runCcxtSubscribeLoop(call, isStreamClosed, resolvedSymbol, subscriptionType, () => broker.watchTicker(resolvedSymbol));
+            while (!isStreamClosed()) {
+              const data = await broker.watchTicker(resolvedSymbol);
+              const receivedTimestamp = Date.now();
+              if (!await writeSubscribeFrame(call, isStreamClosed, {
+                data: JSON.stringify(data),
+                timestamp: receivedTimestamp,
+                symbol: resolvedSymbol,
+                type: subscriptionType
+              })) {
+                break;
+              }
+              archiveTickerInBackground(brokerArchiver, otelMetrics, {
+                deploymentId,
+                exchange: normalizedCex,
+                symbol: resolvedSymbol,
+                assetType,
+                accountSelector: selectedBrokerAccount?.label,
+                payload: data,
+                receivedTimestamp
+              });
+            }
           } catch (error48) {
             const message = getErrorMessage(error48);
             log.error(`Error fetching ticker for ${resolvedSymbol} on ${cex3}:`, error48);
@@ -331476,7 +332832,53 @@ function createSubscribeHandler(deps) {
         case SubscriptionType.OHLCV:
           try {
             const timeframe = options?.timeframe || "1m";
-            await runCcxtSubscribeLoop(call, isStreamClosed, resolvedSymbol, subscriptionType, () => broker.fetchOHLCVWs(resolvedSymbol, timeframe));
+            const ohlcvBarTracker = createOhlcvBarTracker();
+            const ohlcvArchiveInput = {
+              deploymentId,
+              exchange: normalizedCex,
+              symbol: resolvedSymbol,
+              assetType,
+              timeframe,
+              accountSelector: selectedBrokerAccount?.label,
+              receivedTimestamp: Date.now(),
+              payload: []
+            };
+            const bootstrapPayload = await bootstrapOhlcvHistory(broker, brokerArchiver, otelMetrics, ohlcvBarTracker, ohlcvArchiveInput, { bootstrapLimit: options?.bootstrapLimit });
+            let ohlcvStreamActive = true;
+            if (bootstrapPayload) {
+              const bootstrapTimestamp = Date.now();
+              const bootstrapSent = await writeSubscribeFrame(call, isStreamClosed, {
+                data: JSON.stringify(bootstrapPayload),
+                timestamp: bootstrapTimestamp,
+                symbol: resolvedSymbol,
+                type: subscriptionType
+              });
+              if (!bootstrapSent) {
+                ohlcvStreamActive = false;
+              }
+            }
+            while (ohlcvStreamActive && !isStreamClosed()) {
+              const data = await broker.fetchOHLCVWs(resolvedSymbol, timeframe);
+              const receivedTimestamp = Date.now();
+              if (!await writeSubscribeFrame(call, isStreamClosed, {
+                data: JSON.stringify(data),
+                timestamp: receivedTimestamp,
+                symbol: resolvedSymbol,
+                type: subscriptionType
+              })) {
+                break;
+              }
+              archiveOhlcvInBackground(brokerArchiver, otelMetrics, ohlcvBarTracker, {
+                deploymentId,
+                exchange: normalizedCex,
+                symbol: resolvedSymbol,
+                assetType,
+                timeframe,
+                accountSelector: selectedBrokerAccount?.label,
+                payload: data,
+                receivedTimestamp
+              });
+            }
           } catch (error48) {
             log.error(`Error fetching OHLCV for ${resolvedSymbol} on ${cex3}:`, error48);
             const message = getErrorMessage(error48);
@@ -331492,7 +332894,10 @@ function createSubscribeHandler(deps) {
           break;
         case SubscriptionType.BALANCE:
           try {
-            await runCcxtSubscribeLoop(call, isStreamClosed, symbol2, subscriptionType, () => broker.watchBalance());
+            await runCcxtSubscribeLoop(call, isStreamClosed, symbol2, subscriptionType, () => broker.watchBalance(), {
+              ...streamArchiveContext,
+              archiveSubscriptionType: "BALANCE"
+            });
           } catch (error48) {
             const message = getErrorMessage(error48);
             log.error(`Error fetching balance for ${cex3}:`, error48);
@@ -331508,7 +332913,10 @@ function createSubscribeHandler(deps) {
           break;
         case SubscriptionType.ORDERS:
           try {
-            await runCcxtSubscribeLoop(call, isStreamClosed, resolvedSymbol, subscriptionType, () => broker.watchOrders(resolvedSymbol));
+            await runCcxtSubscribeLoop(call, isStreamClosed, resolvedSymbol, subscriptionType, () => broker.watchOrders(resolvedSymbol), {
+              ...streamArchiveContext,
+              archiveSubscriptionType: "ORDERS"
+            });
           } catch (error48) {
             log.error(`Error fetching orders for ${resolvedSymbol} on ${cex3}:`, error48);
             const message = getErrorMessage(error48);
@@ -331689,7 +333097,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) {
+function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, otelMetrics, brokerArchiver) {
   const server = new grpc14.Server;
   server.addService(cexNode.cex_service.service, {
     ExecuteAction: createExecuteActionHandler({
@@ -331698,12 +333106,14 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
       whitelistIps,
       useVerity,
       verityProverUrl,
-      otelMetrics
+      otelMetrics,
+      brokerArchiver
     }),
     Subscribe: createSubscribeHandler({
       brokers,
       whitelistIps,
-      otelMetrics
+      otelMetrics,
+      brokerArchiver
     })
   });
   return server;
@@ -331840,6 +333250,7 @@ class CEXBroker {
   useVerity = false;
   otelMetrics;
   otelLogs;
+  brokerArchiver;
   depositReconciler;
   loadEnvConfig() {
     log.info("\uD83D\uDD27 Loading CEX_BROKER_ environment variables:");
@@ -331951,6 +333362,7 @@ class CEXBroker {
       this.otelMetrics = createOtelMetricsFromEnv();
       this.otelLogs = createOtelLogsFromEnv();
     }
+    this.brokerArchiver = createBrokerExecutionArchiverFromEnv(this.otelLogs, this.otelMetrics);
     this.loadExchangeCredentials(apiCredentials);
     this.whitelistIps = [
       ...(config2 ?? { whitelistIps: [] }).whitelistIps ?? [],
@@ -331983,6 +333395,9 @@ class CEXBroker {
     if (this.server) {
       await this.server.forceShutdown();
     }
+    if (this.brokerArchiver) {
+      await this.brokerArchiver.close();
+    }
     if (this.otelMetrics) {
       await this.otelMetrics.close();
     }
@@ -332002,7 +333417,7 @@ 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.server = getServer(this.policy, this.brokers, this.whitelistIps, this.useVerity, this.#verityProverUrl, this.otelMetrics, this.brokerArchiver);
     this.server.bindAsync(`0.0.0.0:${this.port}`, grpc15.ServerCredentials.createInsecure(), (err2, port) => {
       if (err2) {
         log.error(err2);