@usherlabs/cex-broker 0.2.18 → 0.2.20

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,479 +314993,1257 @@ 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;
-    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);
+}
+
+// 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);
     }
   }
-  async recordGauge(metricName, value, labels, service = this.getServiceName()) {
-    const provider = this.getProvider();
-    if (!this.isOtelEnabled() || !provider)
-      return;
+  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 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 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 recordHistogram(metricName, value, labels, service = this.getServiceName()) {
-    const provider = this.getProvider();
-    if (!this.isOtelEnabled() || !provider)
-      return;
+  queueMicrotask(() => {
     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 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
+      });
     }
-  }
+  });
 }
-
-class OtelLogs extends BaseOtelSignal {
-  logger = null;
-  constructor(config) {
-    super(config, "logs");
+async function captureMarketMetadataSnapshot(archiver, broker, input) {
+  if (!archiver?.canPersistMarketMetadataSnapshot()) {
+    return;
   }
-  createProvider(endpoint, serviceName, appendSignalPath) {
-    const exporter = new import_exporter_logs_otlp_http.OTLPLogExporter({
-      url: appendOtlpPath(endpoint, "logs", appendSignalPath)
+  try {
+    const fetchOrderBook = broker.fetchOrderBook;
+    if (typeof fetchOrderBook !== "function") {
+      return;
+    }
+    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 processor = new import_sdk_logs.BatchLogRecordProcessor(exporter);
-    const resource = import_resources.resourceFromAttributes({
-      "service.name": serviceName
+    const row = buildMarketMetadataSnapshotRow({
+      tags,
+      clientOrderId: input.clientOrderId,
+      orderId: input.orderId,
+      makerActionId: input.makerActionId,
+      idempotencyId: input.idempotencyId,
+      marketSnapshot: snapshot
     });
-    return new import_sdk_logs.LoggerProvider({
-      resource,
-      processors: [processor]
+    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;
   }
-  onProviderCreated(provider) {
-    import_api_logs2.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;
+}
+// src/helpers/broker-execution-archive/writer.ts
+var import_api_logs2 = __toESM(require_src7(), 1);
+import { request as httpRequest2 } from "node:http";
+import { request as httpsRequest2 } from "node:https";
+
+// 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;
   }
-  emit(record) {
-    if (!this.isOtelEnabled() || !this.logger) {
-      return;
+  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?.();
     }
-    this.logger.emit(record);
   }
-}
-function resolveOtlpEndpoint(signal, config) {
-  if (config?.otlpEndpoint) {
-    return {
-      endpoint: normalizeOtlpEndpoint(config.otlpEndpoint),
-      appendSignalPath: true
-    };
+  static disabled() {
+    return new BrokerExecutionArchiver({ enabled: false });
   }
-  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
-    };
+  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 });
   }
-  if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
-    return {
-      endpoint: normalizeOtlpEndpoint(process.env.OTEL_EXPORTER_OTLP_ENDPOINT),
-      appendSignalPath: true
-    };
+  getDeploymentId() {
+    return this.deploymentId;
   }
-  if (config?.host) {
-    const protocol = config.protocol || "http";
-    const port = config.port ?? DEFAULT_OTLP_PORT;
-    return {
-      endpoint: `${protocol}://${config.host}:${port}`,
-      appendSignalPath: true
-    };
+  isEnabled() {
+    return this.enabled && !this.closed && (Boolean(this.otelLogs) || Boolean(this.forwarderUrl));
   }
-  return null;
-}
-function appendOtlpPath(endpoint, signal, appendSignalPath) {
-  if (!appendSignalPath) {
-    return endpoint;
+  canPersistMarketMetadataSnapshot() {
+    return this.isEnabled() && (Boolean(this.otelLogs?.isOtelEnabled()) || Boolean(this.forwarderUrl));
   }
-  const baseEndpoint = normalizeOtlpEndpoint(endpoint);
-  return `${baseEndpoint}/v1/${signal}`;
-}
-function normalizeOtlpEndpoint(endpoint) {
-  return endpoint.replace(/\/v1\/(metrics|logs)\/?$/, "").replace(/\/+$/, "");
-}
-function getOtelHostFromEnv() {
-  return process.env.CEX_BROKER_OTEL_HOST ?? process.env.CEX_BROKER_CLICKHOUSE_HOST;
-}
-function getOtelPortFromEnv() {
-  const port = process.env.CEX_BROKER_OTEL_PORT ?? process.env.CEX_BROKER_CLICKHOUSE_PORT;
-  return port ? Number.parseInt(port, 10) : undefined;
-}
-function getOtelProtocolFromEnv() {
-  const protocol = process.env.CEX_BROKER_OTEL_PROTOCOL ?? process.env.CEX_BROKER_CLICKHOUSE_PROTOCOL;
-  return protocol || "http";
-}
-function createOtelMetricsFromEnv() {
-  const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-  const host = getOtelHostFromEnv();
-  if (otlpEndpoint) {
-    return new OtelMetrics({
-      otlpEndpoint: otlpEndpoint.replace(/\/v1\/metrics\/?$/, ""),
-      serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
+  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
     });
+    if (this.queue.length >= this.batchSize) {
+      this.flush().catch((error) => {
+        log.warn("Broker execution archive flush failed", { error });
+      });
+    }
   }
-  if (!host) {
-    return new OtelMetrics;
+  enqueueInBackground(row) {
+    queueMicrotask(() => this.enqueue(row));
   }
-  const port = getOtelPortFromEnv();
-  const config = {
-    host,
-    port: port ?? DEFAULT_OTLP_PORT,
-    protocol: getOtelProtocolFromEnv(),
-    serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
-  };
-  return new OtelMetrics(config);
-}
-function createOtelLogsFromEnv() {
-  const logsEndpoint = process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;
-  const genericEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-  const host = getOtelHostFromEnv();
-  if (logsEndpoint) {
-    return new OtelLogs({
-      serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
+  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;
   }
-  if (genericEndpoint) {
-    return new OtelLogs({
-      otlpEndpoint: genericEndpoint,
-      serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
-    });
+  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;
   }
-  if (!host) {
-    return new OtelLogs;
+  getStats() {
+    return { ...this.stats };
   }
-  const port = getOtelPortFromEnv();
-  const config = {
-    host,
-    port: port ?? DEFAULT_OTLP_PORT,
-    protocol: getOtelProtocolFromEnv(),
-    serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
-  };
-  return new OtelLogs(config);
-}
-
-// src/server.ts
-var grpc14 = __toESM(require_src3(), 1);
-
-// src/handlers/execute-action/deposit.ts
-var grpc3 = __toESM(require_src3(), 1);
-
-// src/helpers/shared/errors.ts
-function getErrorMessage(error) {
-  return error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
-}
-function safeLogError(context2, error) {
-  try {
-    log.error(context2, { error });
-  } catch {
-    console.error(context2, error);
+  getQueueDepth() {
+    return this.queue.length;
   }
-}
-
-// 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] : [];
-  if (params && Object.keys(params).length > 0) {
-    argsArray.push(params);
+  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"
+      });
+    }
   }
-  return argsArray;
-}
-async function handleTreasuryDiscoveryCall(broker, functionName, args, params) {
-  const discoveryBroker = broker;
-  if (functionName === "fetchMarkets") {
-    if (typeof discoveryBroker.fetchMarkets === "function" && discoveryBroker.has?.fetchMarkets !== false) {
-      return {
-        handled: true,
-        result: await discoveryBroker.fetchMarkets(...callArgs(args, params))
-      };
+  async flushBatch() {
+    const batch = this.queue.splice(0, this.batchSize);
+    if (batch.length === 0) {
+      return true;
     }
-    if (typeof discoveryBroker.loadMarkets === "function") {
-      const loaded = await discoveryBroker.loadMarkets(false, params);
-      const markets = loaded && typeof loaded === "object" && !Array.isArray(loaded) ? Object.values(loaded) : Object.values(discoveryBroker.markets ?? {});
-      return { handled: true, result: markets };
+    for (const entry of batch) {
+      if (!isMarketArchiveTable(entry.table)) {
+        this.emitOtelLog(entry);
+      }
     }
-    throw new Error("venue_discovery_unavailable: fetchMarkets unavailable on broker");
+    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;
   }
-  if (functionName === "fetchCurrencies") {
-    if (typeof discoveryBroker.fetchCurrencies === "function" && discoveryBroker.has?.fetchCurrencies !== false) {
-      return {
-        handled: true,
-        result: await discoveryBroker.fetchCurrencies(...callArgs(args, params))
-      };
+  async recordArchiveMetric(metricName, labels) {
+    try {
+      await this.otelMetrics?.recordCounter(metricName, 1, labels);
+    } catch {}
+  }
+  emitOtelLog(entry) {
+    if (!this.otelLogs?.isOtelEnabled()) {
+      return;
     }
-    if (discoveryBroker.currencies && Object.keys(discoveryBroker.currencies).length > 0) {
-      return { handled: true, result: discoveryBroker.currencies };
+    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 });
     }
-    throw new Error("venue_discovery_unavailable: fetchCurrencies unavailable on broker");
   }
-  return { handled: false };
+  postToForwarder(batch) {
+    if (!this.forwarderUrl || batch.length === 0) {
+      return Promise.resolve();
+    }
+    const body = JSON.stringify({
+      source: "broker_write",
+      deployment_id: this.deploymentId,
+      rows: batch
+    });
+    const url2 = new URL(this.forwarderUrl);
+    const doRequest = url2.protocol === "http:" ? httpRequest2 : httpsRequest2;
+    const headers = {
+      "content-type": "application/json",
+      "content-length": Buffer.byteLength(body)
+    };
+    if (this.forwarderAuthToken) {
+      headers.authorization = `Bearer ${this.forwarderAuthToken}`;
+    }
+    return new Promise((resolve, reject) => {
+      const req = doRequest(url2, {
+        method: "POST",
+        headers,
+        timeout: this.forwarderTimeoutMs
+      }, (res) => {
+        res.on("data", () => {});
+        res.on("end", () => {
+          const status = res.statusCode ?? 0;
+          if (status < 200 || status >= 300) {
+            reject(new Error(`Archive forwarder returned ${status} ${res.statusMessage ?? ""}`));
+            return;
+          }
+          resolve();
+        });
+      });
+      req.on("error", reject);
+      req.on("timeout", () => {
+        req.destroy(new Error("Archive forwarder request timed out"));
+      });
+      req.write(body);
+      req.end();
+    });
+  }
 }
-async function fetchCurrencyMetadata(broker, assetCode) {
-  const discoveryBroker = broker;
-  const normalizedAsset = assetCode.trim().toUpperCase();
-  if (typeof discoveryBroker.fetchCurrencies === "function" && discoveryBroker.has?.fetchCurrencies !== false) {
-    const currencies = await discoveryBroker.fetchCurrencies();
-    return currencies[normalizedAsset];
+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);
+    }
   }
-  return discoveryBroker.currencies?.[normalizedAsset];
+  return attributes;
 }
-
-// src/helpers/transfer-network.ts
-function networkAliasSet(brokerNetworkId, networkKey) {
-  const aliases = new Set([
-    brokerNetworkId,
-    networkKey.trim().toUpperCase()
-  ]);
-  if (brokerNetworkId === "BNB") {
-    aliases.add("BNB");
-    aliases.add("BSC");
-    aliases.add("BEP20");
+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 parsePositiveInt(value, fallback) {
+  if (!value) {
+    return fallback;
   }
-  return [...aliases].filter((alias) => alias.length > 0);
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
-function buildTransferNetworkEvidence(currencyInfo) {
-  const rawNetworks = isRecord(currencyInfo.networks) ? currencyInfo.networks : {};
-  const networks = {};
-  const aliases = {};
-  for (const [networkKey, networkValue] of Object.entries(rawNetworks)) {
-    const networkRecord = isRecord(networkValue) ? networkValue : {};
-    const exchangeNetworkId = String(networkRecord.id ?? networkRecord.network ?? networkKey);
-    const brokerNetworkId = normalizeBrokerNetworkId(String(networkRecord.network ?? networkKey));
-    const evidence = {
-      operatorAlias: networkKey,
-      brokerNetworkId,
-      exchangeNetworkId,
-      networkKey
-    };
-    networks[networkKey] = {
-      ...networkRecord,
-      operatorAlias: networkKey,
-      brokerNetworkId,
-      exchangeNetworkId
-    };
-    for (const alias of networkAliasSet(brokerNetworkId, networkKey)) {
-      aliases[alias] = { ...evidence, operatorAlias: alias };
+// 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;
     }
   }
-  return { networks, aliases };
-}
-async function resolveTransferNetwork(broker, assetCode, operatorAlias) {
-  const requestedAlias = operatorAlias.trim().toUpperCase();
-  const brokerNetworkId = normalizeBrokerNetworkId(requestedAlias);
-  let currencyInfo = null;
-  try {
-    currencyInfo = await fetchCurrencyMetadata(broker, assetCode);
-  } catch (error) {
-    safeLogError(`Network discovery failed for ${assetCode}/${operatorAlias}; using operator alias as exchange network id`, error);
+  onProviderCreated(_provider) {}
+  onProviderClosed() {}
+  getProvider() {
+    return this.provider;
   }
-  if (currencyInfo) {
-    const evidence = buildTransferNetworkEvidence(currencyInfo);
-    const resolved = evidence.aliases[requestedAlias] ?? evidence.aliases[brokerNetworkId];
-    if (resolved) {
-      return { ...resolved, operatorAlias: requestedAlias, brokerNetworkId };
+  getServiceName() {
+    return this.serviceName;
+  }
+  isOtelEnabled() {
+    return this.isEnabled && this.provider !== null;
+  }
+  async close() {
+    if (!this.provider) {
+      return;
     }
-    throw new Error(`network_alias_unresolved: ${assetCode}/${requestedAlias} is not available in discovered transfer networks`);
+    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();
   }
-  return {
-    operatorAlias: requestedAlias,
-    brokerNetworkId,
-    exchangeNetworkId: requestedAlias,
-    networkKey: null
-  };
+}
+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;
 }
 
-// node_modules/zod/v4/classic/external.js
-var exports_external = {};
-__export(exports_external, {
-  xor: () => xor,
-  xid: () => xid2,
-  void: () => _void2,
-  uuidv7: () => uuidv7,
-  uuidv6: () => uuidv6,
-  uuidv4: () => uuidv4,
-  uuid: () => uuid5,
-  util: () => exports_util,
-  url: () => url2,
-  uppercase: () => _uppercase,
-  unknown: () => unknown,
-  union: () => union,
-  undefined: () => _undefined3,
-  ulid: () => ulid2,
-  uint64: () => uint64,
-  uint32: () => uint32,
-  tuple: () => tuple,
-  trim: () => _trim,
+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;
+  return port ? Number.parseInt(port, 10) : undefined;
+}
+function getOtelProtocolFromEnv() {
+  const protocol = process.env.CEX_BROKER_OTEL_PROTOCOL ?? process.env.CEX_BROKER_CLICKHOUSE_PROTOCOL;
+  return protocol || "http";
+}
+function createOtelMetricsFromEnv() {
+  const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  const host = getOtelHostFromEnv();
+  if (otlpEndpoint) {
+    return new OtelMetrics({
+      otlpEndpoint: otlpEndpoint.replace(/\/v1\/metrics\/?$/, ""),
+      serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
+    });
+  }
+  if (!host) {
+    return new OtelMetrics;
+  }
+  const port = getOtelPortFromEnv();
+  const config = {
+    host,
+    port: port ?? DEFAULT_OTLP_PORT,
+    protocol: getOtelProtocolFromEnv(),
+    serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
+  };
+  return new OtelMetrics(config);
+}
+function createOtelLogsFromEnv() {
+  const logsEndpoint = process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;
+  const genericEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  const host = getOtelHostFromEnv();
+  if (logsEndpoint) {
+    return new OtelLogs({
+      serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
+    });
+  }
+  if (genericEndpoint) {
+    return new OtelLogs({
+      otlpEndpoint: genericEndpoint,
+      serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
+    });
+  }
+  if (!host) {
+    return new OtelLogs;
+  }
+  const port = getOtelPortFromEnv();
+  const config = {
+    host,
+    port: port ?? DEFAULT_OTLP_PORT,
+    protocol: getOtelProtocolFromEnv(),
+    serviceName: process.env.OTEL_SERVICE_NAME || DEFAULT_SERVICE
+  };
+  return new OtelLogs(config);
+}
+
+// src/server.ts
+var grpc14 = __toESM(require_src3(), 1);
+
+// src/handlers/execute-action/deposit.ts
+var grpc3 = __toESM(require_src3(), 1);
+
+// src/helpers/shared/errors.ts
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
+}
+function safeLogError(context2, error) {
+  try {
+    log.error(context2, { error });
+  } catch {
+    console.error(context2, error);
+  }
+}
+
+// src/helpers/treasury-discovery.ts
+function callArgs(args, params) {
+  const argsArray = Array.isArray(args) ? [...args] : [];
+  if (params && Object.keys(params).length > 0) {
+    argsArray.push(params);
+  }
+  return argsArray;
+}
+async function handleTreasuryDiscoveryCall(broker, functionName, args, params) {
+  const discoveryBroker = broker;
+  if (functionName === "fetchMarkets") {
+    if (typeof discoveryBroker.fetchMarkets === "function" && discoveryBroker.has?.fetchMarkets !== false) {
+      return {
+        handled: true,
+        result: await discoveryBroker.fetchMarkets(...callArgs(args, params))
+      };
+    }
+    if (typeof discoveryBroker.loadMarkets === "function") {
+      const loaded = await discoveryBroker.loadMarkets(false, params);
+      const markets = loaded && typeof loaded === "object" && !Array.isArray(loaded) ? Object.values(loaded) : Object.values(discoveryBroker.markets ?? {});
+      return { handled: true, result: markets };
+    }
+    throw new Error("venue_discovery_unavailable: fetchMarkets unavailable on broker");
+  }
+  if (functionName === "fetchCurrencies") {
+    if (typeof discoveryBroker.fetchCurrencies === "function" && discoveryBroker.has?.fetchCurrencies !== false) {
+      return {
+        handled: true,
+        result: await discoveryBroker.fetchCurrencies(...callArgs(args, params))
+      };
+    }
+    if (discoveryBroker.currencies && Object.keys(discoveryBroker.currencies).length > 0) {
+      return { handled: true, result: discoveryBroker.currencies };
+    }
+    throw new Error("venue_discovery_unavailable: fetchCurrencies unavailable on broker");
+  }
+  return { handled: false };
+}
+async function fetchCurrencyMetadata(broker, assetCode) {
+  const discoveryBroker = broker;
+  const normalizedAsset = assetCode.trim().toUpperCase();
+  if (typeof discoveryBroker.fetchCurrencies === "function" && discoveryBroker.has?.fetchCurrencies !== false) {
+    const currencies = await discoveryBroker.fetchCurrencies();
+    return currencies[normalizedAsset];
+  }
+  return discoveryBroker.currencies?.[normalizedAsset];
+}
+
+// src/helpers/transfer-network.ts
+function networkAliasSet(brokerNetworkId, networkKey) {
+  const aliases = new Set([
+    brokerNetworkId,
+    networkKey.trim().toUpperCase()
+  ]);
+  if (brokerNetworkId === "BNB") {
+    aliases.add("BNB");
+    aliases.add("BSC");
+    aliases.add("BEP20");
+  }
+  return [...aliases].filter((alias) => alias.length > 0);
+}
+function buildTransferNetworkEvidence(currencyInfo) {
+  const rawNetworks = isRecord(currencyInfo.networks) ? currencyInfo.networks : {};
+  const networks = {};
+  const aliases = {};
+  for (const [networkKey, networkValue] of Object.entries(rawNetworks)) {
+    const networkRecord = isRecord(networkValue) ? networkValue : {};
+    const exchangeNetworkId = String(networkRecord.id ?? networkRecord.network ?? networkKey);
+    const brokerNetworkId = normalizeBrokerNetworkId(String(networkRecord.network ?? networkKey));
+    const evidence = {
+      operatorAlias: networkKey,
+      brokerNetworkId,
+      exchangeNetworkId,
+      networkKey
+    };
+    networks[networkKey] = {
+      ...networkRecord,
+      operatorAlias: networkKey,
+      brokerNetworkId,
+      exchangeNetworkId
+    };
+    for (const alias of networkAliasSet(brokerNetworkId, networkKey)) {
+      aliases[alias] = { ...evidence, operatorAlias: alias };
+    }
+  }
+  return { networks, aliases };
+}
+async function resolveTransferNetwork(broker, assetCode, operatorAlias) {
+  const requestedAlias = operatorAlias.trim().toUpperCase();
+  const brokerNetworkId = normalizeBrokerNetworkId(requestedAlias);
+  let currencyInfo = null;
+  try {
+    currencyInfo = await fetchCurrencyMetadata(broker, assetCode);
+  } catch (error) {
+    safeLogError(`Network discovery failed for ${assetCode}/${operatorAlias}; using operator alias as exchange network id`, error);
+  }
+  if (currencyInfo) {
+    const evidence = buildTransferNetworkEvidence(currencyInfo);
+    const resolved = evidence.aliases[requestedAlias] ?? evidence.aliases[brokerNetworkId];
+    if (resolved) {
+      return { ...resolved, operatorAlias: requestedAlias, brokerNetworkId };
+    }
+    throw new Error(`network_alias_unresolved: ${assetCode}/${requestedAlias} is not available in discovered transfer networks`);
+  }
+  return {
+    operatorAlias: requestedAlias,
+    brokerNetworkId,
+    exchangeNetworkId: requestedAlias,
+    networkKey: null
+  };
+}
+
+// node_modules/zod/v4/classic/external.js
+var exports_external = {};
+__export(exports_external, {
+  xor: () => xor,
+  xid: () => xid2,
+  void: () => _void2,
+  uuidv7: () => uuidv7,
+  uuidv6: () => uuidv6,
+  uuidv4: () => uuidv4,
+  uuid: () => uuid5,
+  util: () => exports_util,
+  url: () => url2,
+  uppercase: () => _uppercase,
+  unknown: () => unknown,
+  union: () => union,
+  undefined: () => _undefined3,
+  ulid: () => ulid2,
+  uint64: () => uint64,
+  uint32: () => uint32,
+  tuple: () => tuple,
+  trim: () => _trim,
   treeifyError: () => treeifyError,
   transform: () => transform,
   toUpperCase: () => _toUpperCase,
@@ -329709,240 +330484,31 @@ async function handleInternalTransfer(ctx) {
       result: JSON.stringify(result)
     });
   } catch (error48) {
-    safeLogError("InternalTransfer failed", error48);
-    if (error48 instanceof BrokerAccountPreconditionError) {
-      return ctx.wrappedCallback({
-        code: grpc5.status.FAILED_PRECONDITION,
-        message: getErrorMessage(error48)
-      }, null);
-    }
-    const msg = getErrorMessage(error48);
-    let code;
-    if (msg.includes("Unsupported transfer direction")) {
-      code = grpc5.status.INVALID_ARGUMENT;
-    } else if (msg.includes("unavailable in this CCXT build")) {
-      code = grpc5.status.UNIMPLEMENTED;
-    } else {
-      code = mapCcxtErrorToGrpcStatus(error48) ?? grpc5.status.INTERNAL;
-    }
-    ctx.wrappedCallback({
-      code,
-      message: `InternalTransfer failed: ${msg}`
-    }, null);
-  }
-}
-
-// 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;
+    safeLogError("InternalTransfer failed", error48);
+    if (error48 instanceof BrokerAccountPreconditionError) {
+      return ctx.wrappedCallback({
+        code: grpc5.status.FAILED_PRECONDITION,
+        message: getErrorMessage(error48)
+      }, null);
     }
-    currency ??= firstString(fee.currency);
-    rate ??= firstNumber(fee.rate);
+    const msg = getErrorMessage(error48);
+    let code;
+    if (msg.includes("Unsupported transfer direction")) {
+      code = grpc5.status.INVALID_ARGUMENT;
+    } else if (msg.includes("unavailable in this CCXT build")) {
+      code = grpc5.status.UNIMPLEMENTED;
+    } else {
+      code = mapCcxtErrorToGrpcStatus(error48) ?? grpc5.status.INTERNAL;
+    }
+    ctx.wrappedCallback({
+      code,
+      message: `InternalTransfer failed: ${msg}`
+    }, null);
   }
-  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
+var grpc6 = __toESM(require_src3(), 1);
 async function handleCreateOrder(ctx) {
   const {
     call,
@@ -329959,7 +330525,8 @@ async function handleCreateOrder(ctx) {
     applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    otelMetrics,
+    brokerArchiver
   } = ctx;
   const verityProof = verity.proof;
   const orderValue = parsePayloadForAction(ctx, CreateOrderPayloadSchema);
@@ -329985,8 +330552,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 +330572,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 +330590,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 +330615,8 @@ async function handleGetOrderDetails(ctx) {
     applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    otelMetrics,
+    brokerArchiver
   } = ctx;
   const verityProof = verity.proof;
   const getOrderValue = parsePayloadForAction(ctx, GetOrderDetailsPayloadSchema);
@@ -330047,13 +330630,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 +330653,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 +330684,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}`
@@ -330479,31 +331098,229 @@ async function handleFetchBalances(ctx) {
       const partial2 = await broker.fetchTotalBalance(params);
       responseBalances = partial2 ?? {};
     }
-    if (symbol2) {
-      if (typeof responseBalances[symbol2] === "number") {
-        responseBalances = {
-          [symbol2]: responseBalances[symbol2] ?? 0
-        };
-      } else {
-        responseBalances = {};
-      }
+    if (symbol2) {
+      if (typeof responseBalances[symbol2] === "number") {
+        responseBalances = {
+          [symbol2]: responseBalances[symbol2] ?? 0
+        };
+      } else {
+        responseBalances = {};
+      }
+    }
+    ctx.wrappedCallback(null, {
+      proof: ctx.verity.proof,
+      result: JSON.stringify({
+        balances: responseBalances,
+        balanceType
+      })
+    });
+  } catch (error48) {
+    safeLogError(`Error fetching balance from ${cex3}`, error48);
+    ctx.wrappedCallback({
+      code: grpc7.status.INTERNAL,
+      message: `Failed to fetch balance from ${cex3}`
+    }, null);
+  }
+}
+async function handleFetchTicker(ctx) {
+  const {
+    call,
+    wrappedCallback,
+    policy,
+    brokers,
+    metadata,
+    normalizedCex,
+    cex: cex3,
+    symbol: symbol2,
+    selectedBrokerAccount,
+    broker,
+    verity,
+    applyVerityToBroker,
+    useVerity,
+    verityProverUrl,
+    otelMetrics
+  } = ctx;
+  const verityProof = verity.proof;
+  if (!symbol2) {
+    return ctx.wrappedCallback({
+      code: grpc7.status.INVALID_ARGUMENT,
+      message: `ValidationError: Symbol required`
+    }, null);
+  }
+  try {
+    const ticker = await broker.fetchTicker(symbol2);
+    ctx.wrappedCallback(null, {
+      proof: ctx.verity.proof,
+      result: JSON.stringify(ticker)
+    });
+  } catch (error48) {
+    safeLogError(`Error fetching ticker from ${cex3}`, error48);
+    ctx.wrappedCallback({
+      code: grpc7.status.INTERNAL,
+      message: `Failed to fetch ticker from ${cex3}`
+    }, null);
+  }
+}
+async function handlePassThrough(ctx) {
+  if (ctx.action === Action.FetchCurrency)
+    return handleFetchCurrency(ctx);
+  if (ctx.action === Action.FetchAccountId)
+    return handleFetchAccountId(ctx);
+  if (ctx.action === Action.FetchFees)
+    return handleFetchFees(ctx);
+  if (ctx.action === Action.FetchDepositAddresses)
+    return handleFetchDepositAddresses(ctx);
+  if (ctx.action === Action.FetchBalances)
+    return handleFetchBalances(ctx);
+  if (ctx.action === Action.FetchTicker)
+    return handleFetchTicker(ctx);
+}
+
+// src/handlers/execute-action/perp-config.ts
+var grpc8 = __toESM(require_src3(), 1);
+function exchangeSupports(broker, capability) {
+  return broker.has?.[capability] === true;
+}
+function extractPerpConfigs(positions) {
+  return positions.map((position) => ({
+    symbol: typeof position.symbol === "string" ? position.symbol : undefined,
+    leverage: typeof position.leverage === "number" ? position.leverage : undefined,
+    marginMode: typeof position.marginMode === "string" ? position.marginMode : undefined
+  }));
+}
+async function handleGetPerpConfigState(ctx) {
+  const { wrappedCallback, cex: cex3, normalizedCex, broker } = ctx;
+  const payload = parsePayloadForAction(ctx, GetPerpConfigStatePayloadSchema);
+  if (payload === null) {
+    return;
+  }
+  if (!broker) {
+    return wrappedCallback({
+      code: grpc8.status.INVALID_ARGUMENT,
+      message: `Invalid CEX key: ${cex3}`
+    }, null);
+  }
+  const exchange = broker;
+  if (!exchangeSupports(exchange, "fetchPositions")) {
+    return wrappedCallback({
+      code: grpc8.status.UNIMPLEMENTED,
+      message: `${normalizedCex} does not support fetchPositions`
+    }, null);
+  }
+  try {
+    const symbols = payload.symbol ? [payload.symbol] : undefined;
+    const positions = await exchange.fetchPositions?.(symbols, payload.params);
+    ctx.wrappedCallback(null, {
+      result: JSON.stringify({
+        exchange: normalizedCex,
+        configs: extractPerpConfigs(positions ?? []),
+        positions: positions ?? []
+      })
+    });
+  } catch (error48) {
+    safeLogError(`GetPerpConfigState failed for ${cex3}`, error48);
+    ctx.wrappedCallback({
+      code: grpc8.status.INTERNAL,
+      message: getErrorMessage(error48)
+    }, null);
+  }
+}
+async function handleSetPerpConfigState(ctx) {
+  const { wrappedCallback, cex: cex3, normalizedCex, broker } = ctx;
+  const payload = parsePayloadForAction(ctx, SetPerpConfigStatePayloadSchema);
+  if (payload === null) {
+    return;
+  }
+  if (!broker) {
+    return wrappedCallback({
+      code: grpc8.status.INVALID_ARGUMENT,
+      message: `Invalid CEX key: ${cex3}`
+    }, null);
+  }
+  const exchange = broker;
+  if (!exchangeSupports(exchange, "setLeverage")) {
+    return wrappedCallback({
+      code: grpc8.status.UNIMPLEMENTED,
+      message: `${normalizedCex} does not support setLeverage`
+    }, null);
+  }
+  try {
+    const response = await exchange.setLeverage?.(payload.leverage, payload.symbol, {
+      marginMode: payload.marginMode ?? "cross",
+      ...payload.params
+    });
+    ctx.wrappedCallback(null, {
+      result: JSON.stringify({
+        exchange: normalizedCex,
+        symbol: payload.symbol,
+        leverage: payload.leverage,
+        marginMode: payload.marginMode ?? "cross",
+        response
+      })
+    });
+  } catch (error48) {
+    safeLogError(`SetPerpConfigState failed for ${cex3}`, error48);
+    ctx.wrappedCallback({
+      code: grpc8.status.INTERNAL,
+      message: getErrorMessage(error48)
+    }, null);
+  }
+}
+async function handlePerpConfig(ctx) {
+  if (ctx.action === Action.GetPerpConfigState) {
+    return handleGetPerpConfigState(ctx);
+  }
+  if (ctx.action === Action.SetPerpConfigState) {
+    return handleSetPerpConfigState(ctx);
+  }
+}
+
+// src/handlers/execute-action/treasury-call.ts
+var grpc9 = __toESM(require_src3(), 1);
+async function handleTreasuryCall(ctx) {
+  const { broker } = ctx;
+  const callValue = parsePayloadForAction(ctx, CallPayloadSchema);
+  if (callValue === null)
+    return;
+  try {
+    if (callValue.functionName.startsWith("_") || callValue.functionName.includes("constructor") || callValue.functionName.includes("prototype")) {
+      return ctx.wrappedCallback({
+        code: grpc9.status.PERMISSION_DENIED,
+        message: "Access to the requested function is denied"
+      }, null);
+    }
+    const argsArray = callArgs(callValue.args, callValue.params ?? {});
+    const treasuryDiscovery = await handleTreasuryDiscoveryCall(broker, callValue.functionName, callValue.args, callValue.params ?? {});
+    if (treasuryDiscovery.handled) {
+      return ctx.wrappedCallback(null, {
+        proof: ctx.verity.proof,
+        result: JSON.stringify(treasuryDiscovery.result)
+      });
+    }
+    const fn = broker[callValue.functionName];
+    if (typeof fn !== "function" || broker.has?.[callValue.functionName] === false) {
+      return ctx.wrappedCallback({
+        code: grpc9.status.INVALID_ARGUMENT,
+        message: `Function not found on broker: ${callValue.functionName}`
+      }, null);
     }
+    const result = await fn.apply(broker, argsArray);
     ctx.wrappedCallback(null, {
       proof: ctx.verity.proof,
-      result: JSON.stringify({
-        balances: responseBalances,
-        balanceType
-      })
+      result: JSON.stringify(result)
     });
   } catch (error48) {
-    safeLogError(`Error fetching balance from ${cex3}`, error48);
-    ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
-      message: `Failed to fetch balance from ${cex3}`
-    }, null);
+    safeLogError("Call failed", error48);
+    rejectWithGrpcError(ctx, error48, {
+      message: getErrorMessage(error48),
+      preferStableMessageOnly: true
+    });
   }
 }
-async function handleFetchTicker(ctx) {
+
+// src/handlers/execute-action/withdraw.ts
+var grpc10 = __toESM(require_src3(), 1);
+async function handleWithdraw(ctx) {
   const {
     call,
     wrappedCallback,
@@ -330524,671 +331341,1117 @@ async function handleFetchTicker(ctx) {
   const verityProof = verity.proof;
   if (!symbol2) {
     return ctx.wrappedCallback({
-      code: grpc7.status.INVALID_ARGUMENT,
+      code: grpc10.status.INVALID_ARGUMENT,
       message: `ValidationError: Symbol required`
     }, null);
   }
+  const transferValue = parsePayloadForAction(ctx, WithdrawPayloadSchema);
+  if (transferValue === null)
+    return;
+  let withdrawNetwork;
   try {
-    const ticker = await broker.fetchTicker(symbol2);
+    withdrawNetwork = await resolveTransferNetwork(broker, symbol2, transferValue.chain);
+  } catch (error48) {
+    const message = getErrorMessage(error48);
+    return ctx.wrappedCallback({
+      code: stableGrpcErrorCode(message) ?? grpc10.status.INVALID_ARGUMENT,
+      message
+    }, null);
+  }
+  const transferValidation = validateWithdraw(policy, cex3, withdrawNetwork.brokerNetworkId, transferValue.recipientAddress, transferValue.amount, symbol2);
+  if (!transferValidation.valid) {
+    return ctx.wrappedCallback({
+      code: grpc10.status.PERMISSION_DENIED,
+      message: `policy_withdrawal_denied: ${transferValidation.error}`
+    }, null);
+  }
+  const travelRule = resolveTravelRuleDecision(policy, cex3, transferValue.recipientAddress);
+  if (travelRule.mode === "denied") {
+    return ctx.wrappedCallback({
+      code: grpc10.status.FAILED_PRECONDITION,
+      message: `travel_rule_denied: ${travelRule.error}`
+    }, null);
+  }
+  try {
+    const transaction = travelRule.mode === "localentity" ? await withdrawViaLocalEntity(broker, {
+      code: symbol2,
+      amount: transferValue.amount,
+      address: transferValue.recipientAddress,
+      network: withdrawNetwork.exchangeNetworkId,
+      questionnaire: travelRule.questionnaire,
+      params: transferValue.params
+    }) : await broker.withdraw(symbol2, transferValue.amount, transferValue.recipientAddress, undefined, {
+      ...transferValue.params ?? {},
+      network: withdrawNetwork.exchangeNetworkId
+    });
+    log.info(`Withdraw Result: ${JSON.stringify(transaction)}`);
     ctx.wrappedCallback(null, {
       proof: ctx.verity.proof,
-      result: JSON.stringify(ticker)
+      result: JSON.stringify({
+        ...transaction,
+        operatorAlias: withdrawNetwork.operatorAlias,
+        brokerNetworkId: withdrawNetwork.brokerNetworkId,
+        exchangeNetworkId: withdrawNetwork.exchangeNetworkId
+      })
     });
   } catch (error48) {
-    safeLogError(`Error fetching ticker from ${cex3}`, error48);
+    safeLogError("Withdraw failed", error48);
+    const code = mapCcxtErrorToGrpcStatus(error48) ?? grpc10.status.INTERNAL;
     ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
-      message: `Failed to fetch ticker from ${cex3}`
+      code,
+      message: `Withdraw failed: ${getErrorMessage(error48)}`
+    }, null);
+  }
+}
+
+// src/handlers/execute-action/registry.ts
+var ACTION_HANDLERS = {
+  [Action.Deposit]: handleDeposit,
+  [Action.Withdraw]: handleWithdraw,
+  [Action.Call]: handleTreasuryCall,
+  [Action.InternalTransfer]: handleInternalTransfer,
+  [Action.CreateOrder]: handleOrders,
+  [Action.GetOrderDetails]: handleOrders,
+  [Action.CancelOrder]: handleOrders,
+  [Action.FetchCurrency]: handlePassThrough,
+  [Action.FetchAccountId]: handlePassThrough,
+  [Action.FetchFees]: handlePassThrough,
+  [Action.FetchDepositAddresses]: handlePassThrough,
+  [Action.FetchBalances]: handlePassThrough,
+  [Action.FetchTicker]: handlePassThrough,
+  [Action.GetPerpConfigState]: handlePerpConfig,
+  [Action.SetPerpConfigState]: handlePerpConfig
+};
+async function dispatchExecuteAction(ctx) {
+  const handler = ACTION_HANDLERS[ctx.action];
+  if (!handler) {
+    ctx.wrappedCallback({
+      code: grpc11.status.INVALID_ARGUMENT,
+      message: "Invalid Action"
     }, null);
+    return;
+  }
+  await handler(ctx);
+}
+
+// src/handlers/execute-action/handler.ts
+function createExecuteActionHandler(deps) {
+  const {
+    policy,
+    brokers,
+    whitelistIps,
+    useVerity,
+    verityProverUrl,
+    otelMetrics,
+    brokerArchiver
+  } = deps;
+  return async (call, callback) => {
+    const startTime = Date.now();
+    const { action: rawAction, cex: cex3, symbol: symbol2 } = call.request;
+    const action = resolveAction(rawAction);
+    let actionCompleted = false;
+    const wrappedCallback = (error48, value) => {
+      if (!actionCompleted) {
+        actionCompleted = true;
+        const latency = Date.now() - startTime;
+        const actionName = getActionName(action);
+        otelMetrics?.recordHistogram("execute_action_duration_ms", latency, {
+          action: actionName,
+          cex: cex3 || "unknown"
+        });
+        if (error48) {
+          otelMetrics?.recordCounter("execute_action_errors_total", 1, {
+            action: actionName,
+            cex: cex3 || "unknown",
+            error_type: error48.code ? grpc12.status[error48.code] || "unknown" : "unknown"
+          });
+        } else {
+          otelMetrics?.recordCounter("execute_action_success_total", 1, {
+            action: actionName,
+            cex: cex3 || "unknown"
+          });
+        }
+      }
+      callback(error48, value);
+    };
+    try {
+      log.info(`Request - ExecuteAction:`, { action, cex: cex3, symbol: symbol2 });
+      otelMetrics?.recordCounter("execute_action_requests_total", 1, {
+        action: getActionName(action),
+        cex: cex3 || "unknown"
+      });
+      if (!authenticateRequest(call, whitelistIps)) {
+        return wrappedCallback({
+          code: grpc12.status.PERMISSION_DENIED,
+          message: "Access denied: Unauthorized IP"
+        }, null);
+      }
+      if (!action || !cex3) {
+        return wrappedCallback({
+          code: grpc12.status.INVALID_ARGUMENT,
+          message: "`action` AND `cex` fields are required"
+        }, null);
+      }
+      const normalizedCex = cex3.trim().toLowerCase();
+      const metadata = call.metadata;
+      const selectedBrokerAccount = selectBrokerAccountForCex(normalizedCex, brokers, metadata);
+      const verity = { proof: "" };
+      const applyVerityToBroker = (targetBroker) => {
+        if (!useVerity)
+          return;
+        const override = buildHttpClientOverrideFromMetadata(metadata, verityProverUrl, (proof, notaryPubKey) => {
+          verity.proof = proof;
+          log.debug(`Verity proof:`, { proof, notaryPubKey });
+        });
+        targetBroker.setHttpClientOverride(override, verityHttpClientOverridePredicate);
+      };
+      const preludeCtx = {
+        call,
+        wrappedCallback,
+        action,
+        policy,
+        brokers,
+        metadata,
+        normalizedCex,
+        cex: cex3,
+        symbol: symbol2,
+        selectedBrokerAccount,
+        broker: selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, metadata),
+        verity,
+        applyVerityToBroker,
+        useVerity,
+        verityProverUrl,
+        otelMetrics,
+        brokerArchiver
+      };
+      if (action === Action.Call) {
+        const handled = await handleOrderBookCall(preludeCtx);
+        if (handled)
+          return;
+      }
+      const broker = selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, metadata);
+      if (!broker) {
+        return wrappedCallback({
+          code: grpc12.status.UNAUTHENTICATED,
+          message: `This Exchange is not registered and No API metadata was found`
+        }, null);
+      }
+      applyVerityToBroker(broker);
+      const ctx = { ...preludeCtx, broker };
+      await dispatchExecuteAction(ctx);
+    } catch (error48) {
+      safeLogError("ExecuteAction unhandled error", error48);
+      return wrappedCallback({
+        code: grpc12.status.INTERNAL,
+        message: "ExecuteAction failed unexpectedly"
+      }, null);
+    }
+  };
+}
+// src/handlers/subscribe/handler.ts
+var grpc13 = __toESM(require_src3(), 1);
+
+// src/helpers/binance-user-data-stream.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { createHmac } from "node:crypto";
+var BINANCE_SPOT_WS_API_URL = "wss://ws-api.binance.com:443/ws-api/v3";
+var DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS = 16;
+var createWebSocket = (url3) => new wrapper_default(url3);
+function getExchangeString(exchange, key) {
+  const value = exchange[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Binance user-data stream requires exchange.${key}`);
+  }
+  return value;
+}
+function sortedQuery(params) {
+  return Object.entries(params).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
+}
+function signUserDataStreamParams(exchange, params) {
+  const signParams = exchange.signParams;
+  if (typeof signParams === "function") {
+    return signParams.call(exchange, params);
   }
+  const secret = getExchangeString(exchange, "secret");
+  return {
+    ...params,
+    signature: createHmac("sha256", secret).update(sortedQuery(params)).digest("hex")
+  };
 }
-async function handlePassThrough(ctx) {
-  if (ctx.action === Action.FetchCurrency)
-    return handleFetchCurrency(ctx);
-  if (ctx.action === Action.FetchAccountId)
-    return handleFetchAccountId(ctx);
-  if (ctx.action === Action.FetchFees)
-    return handleFetchFees(ctx);
-  if (ctx.action === Action.FetchDepositAddresses)
-    return handleFetchDepositAddresses(ctx);
-  if (ctx.action === Action.FetchBalances)
-    return handleFetchBalances(ctx);
-  if (ctx.action === Action.FetchTicker)
-    return handleFetchTicker(ctx);
-}
-
-// src/handlers/execute-action/perp-config.ts
-var grpc8 = __toESM(require_src3(), 1);
-function exchangeSupports(broker, capability) {
-  return broker.has?.[capability] === true;
+function getBinanceSpotWsApiUrl(exchange) {
+  const urls = exchange.urls;
+  return urls?.api?.ws?.["ws-api"]?.spot ?? BINANCE_SPOT_WS_API_URL;
 }
-function extractPerpConfigs(positions) {
-  return positions.map((position) => ({
-    symbol: typeof position.symbol === "string" ? position.symbol : undefined,
-    leverage: typeof position.leverage === "number" ? position.leverage : undefined,
-    marginMode: typeof position.marginMode === "string" ? position.marginMode : undefined
-  }));
+function getRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
 }
-async function handleGetPerpConfigState(ctx) {
-  const { wrappedCallback, cex: cex3, normalizedCex, broker } = ctx;
-  const payload = parsePayloadForAction(ctx, GetPerpConfigStatePayloadSchema);
-  if (payload === null) {
-    return;
-  }
-  if (!broker) {
-    return wrappedCallback({
-      code: grpc8.status.INVALID_ARGUMENT,
-      message: `Invalid CEX key: ${cex3}`
-    }, null);
-  }
-  const exchange = broker;
-  if (!exchangeSupports(exchange, "fetchPositions")) {
-    return wrappedCallback({
-      code: grpc8.status.UNIMPLEMENTED,
-      message: `${normalizedCex} does not support fetchPositions`
-    }, null);
+function getMessage(value) {
+  if (value instanceof Error) {
+    return value.message;
   }
-  try {
-    const symbols = payload.symbol ? [payload.symbol] : undefined;
-    const positions = await exchange.fetchPositions?.(symbols, payload.params);
-    ctx.wrappedCallback(null, {
-      result: JSON.stringify({
-        exchange: normalizedCex,
-        configs: extractPerpConfigs(positions ?? []),
-        positions: positions ?? []
-      })
-    });
-  } catch (error48) {
-    safeLogError(`GetPerpConfigState failed for ${cex3}`, error48);
-    ctx.wrappedCallback({
-      code: grpc8.status.INTERNAL,
-      message: getErrorMessage(error48)
-    }, null);
+  if (typeof value === "string" && value.length > 0) {
+    return value;
   }
+  const record2 = getRecord(value);
+  const message = record2?.message;
+  return typeof message === "string" && message.length > 0 ? message : null;
 }
-async function handleSetPerpConfigState(ctx) {
-  const { wrappedCallback, cex: cex3, normalizedCex, broker } = ctx;
-  const payload = parsePayloadForAction(ctx, SetPerpConfigStatePayloadSchema);
-  if (payload === null) {
-    return;
-  }
-  if (!broker) {
-    return wrappedCallback({
-      code: grpc8.status.INVALID_ARGUMENT,
-      message: `Invalid CEX key: ${cex3}`
-    }, null);
-  }
-  const exchange = broker;
-  if (!exchangeSupports(exchange, "setLeverage")) {
-    return wrappedCallback({
-      code: grpc8.status.UNIMPLEMENTED,
-      message: `${normalizedCex} does not support setLeverage`
-    }, null);
-  }
-  try {
-    const response = await exchange.setLeverage?.(payload.leverage, payload.symbol, {
-      marginMode: payload.marginMode ?? "cross",
-      ...payload.params
-    });
-    ctx.wrappedCallback(null, {
-      result: JSON.stringify({
-        exchange: normalizedCex,
-        symbol: payload.symbol,
-        leverage: payload.leverage,
-        marginMode: payload.marginMode ?? "cross",
-        response
-      })
-    });
-  } catch (error48) {
-    safeLogError(`SetPerpConfigState failed for ${cex3}`, error48);
-    ctx.wrappedCallback({
-      code: grpc8.status.INTERNAL,
-      message: getErrorMessage(error48)
-    }, null);
+function getOptionalExchangeString(exchange, key) {
+  const value = exchange[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function redactDiagnosticMessage(message, secretValues) {
+  let redacted = message;
+  for (const value of secretValues) {
+    if (value.length > 0) {
+      redacted = redacted.split(value).join("[redacted]");
+    }
   }
+  return redacted.replace(/(\b(?:apiKey|secret|signature)\b\s*=\s*)[^\s&,;)]+/gi, "$1[redacted]").replace(/("(?:apiKey|secret|signature)"\s*:\s*")[^"]*(")/gi, "$1[redacted]$2");
 }
-async function handlePerpConfig(ctx) {
-  if (ctx.action === Action.GetPerpConfigState) {
-    return handleGetPerpConfigState(ctx);
+function formatBinanceUserDataWebSocketError(event, secretValues) {
+  const record2 = getRecord(event);
+  const message = getMessage(record2?.error) ?? getMessage(record2?.message) ?? getMessage(event);
+  const safeMessage = message === null ? null : redactDiagnosticMessage(message, secretValues);
+  return new Error(safeMessage ? `Binance user-data WebSocket error: ${safeMessage}` : "Binance user-data WebSocket error");
+}
+function getCloseReason(value) {
+  if (typeof value === "string") {
+    return value.length > 0 ? value : null;
   }
-  if (ctx.action === Action.SetPerpConfigState) {
-    return handleSetPerpConfigState(ctx);
+  if (Buffer2.isBuffer(value)) {
+    const reason = value.toString("utf8");
+    return reason.length > 0 ? reason : null;
   }
-}
-
-// src/handlers/execute-action/treasury-call.ts
-var grpc9 = __toESM(require_src3(), 1);
-async function handleTreasuryCall(ctx) {
-  const { broker } = ctx;
-  const callValue = parsePayloadForAction(ctx, CallPayloadSchema);
-  if (callValue === null)
-    return;
-  try {
-    if (callValue.functionName.startsWith("_") || callValue.functionName.includes("constructor") || callValue.functionName.includes("prototype")) {
-      return ctx.wrappedCallback({
-        code: grpc9.status.PERMISSION_DENIED,
-        message: "Access to the requested function is denied"
-      }, null);
-    }
-    const argsArray = callArgs(callValue.args, callValue.params ?? {});
-    const treasuryDiscovery = await handleTreasuryDiscoveryCall(broker, callValue.functionName, callValue.args, callValue.params ?? {});
-    if (treasuryDiscovery.handled) {
-      return ctx.wrappedCallback(null, {
-        proof: ctx.verity.proof,
-        result: JSON.stringify(treasuryDiscovery.result)
-      });
-    }
-    const fn = broker[callValue.functionName];
-    if (typeof fn !== "function" || broker.has?.[callValue.functionName] === false) {
-      return ctx.wrappedCallback({
-        code: grpc9.status.INVALID_ARGUMENT,
-        message: `Function not found on broker: ${callValue.functionName}`
-      }, null);
-    }
-    const result = await fn.apply(broker, argsArray);
-    ctx.wrappedCallback(null, {
-      proof: ctx.verity.proof,
-      result: JSON.stringify(result)
-    });
-  } catch (error48) {
-    safeLogError("Call failed", error48);
-    rejectWithGrpcError(ctx, error48, {
-      message: getErrorMessage(error48),
-      preferStableMessageOnly: true
-    });
+  if (value instanceof Uint8Array) {
+    const reason = Buffer2.from(value).toString("utf8");
+    return reason.length > 0 ? reason : null;
   }
+  return null;
 }
-
-// src/handlers/execute-action/withdraw.ts
-var grpc10 = __toESM(require_src3(), 1);
-async function handleWithdraw(ctx) {
-  const {
-    call,
-    wrappedCallback,
-    policy,
-    brokers,
-    metadata,
-    normalizedCex,
-    cex: cex3,
-    symbol: symbol2,
-    selectedBrokerAccount,
-    broker,
-    verity,
-    applyVerityToBroker,
-    useVerity,
-    verityProverUrl,
-    otelMetrics
-  } = ctx;
-  const verityProof = verity.proof;
-  if (!symbol2) {
-    return ctx.wrappedCallback({
-      code: grpc10.status.INVALID_ARGUMENT,
-      message: `ValidationError: Symbol required`
-    }, null);
+function formatBinanceUserDataWebSocketClose(codeOrEvent, reasonOrUndefined, secretValues) {
+  const record2 = getRecord(codeOrEvent);
+  const code = record2 ? record2.code : codeOrEvent;
+  const reason = getCloseReason(record2 ? record2.reason : reasonOrUndefined);
+  const safeReason = reason === null ? null : redactDiagnosticMessage(reason, secretValues);
+  const details = [
+    typeof code === "number" || typeof code === "string" ? `code=${code}` : null,
+    safeReason ? `reason=${safeReason}` : null
+  ].filter((detail) => detail !== null);
+  return new Error(details.length > 0 ? `Binance user-data WebSocket closed unexpectedly (${details.join(", ")})` : "Binance user-data WebSocket closed unexpectedly");
+}
+function decodeMessageData(data) {
+  if (typeof data === "string") {
+    return data;
   }
-  const transferValue = parsePayloadForAction(ctx, WithdrawPayloadSchema);
-  if (transferValue === null)
-    return;
-  let withdrawNetwork;
-  try {
-    withdrawNetwork = await resolveTransferNetwork(broker, symbol2, transferValue.chain);
-  } catch (error48) {
-    const message = getErrorMessage(error48);
-    return ctx.wrappedCallback({
-      code: stableGrpcErrorCode(message) ?? grpc10.status.INVALID_ARGUMENT,
-      message
-    }, null);
+  if (Buffer2.isBuffer(data)) {
+    return data.toString("utf8");
   }
-  const transferValidation = validateWithdraw(policy, cex3, withdrawNetwork.brokerNetworkId, transferValue.recipientAddress, transferValue.amount, symbol2);
-  if (!transferValidation.valid) {
-    return ctx.wrappedCallback({
-      code: grpc10.status.PERMISSION_DENIED,
-      message: `policy_withdrawal_denied: ${transferValidation.error}`
-    }, null);
+  if (data instanceof ArrayBuffer) {
+    return Buffer2.from(data).toString("utf8");
   }
-  const travelRule = resolveTravelRuleDecision(policy, cex3, transferValue.recipientAddress);
-  if (travelRule.mode === "denied") {
-    return ctx.wrappedCallback({
-      code: grpc10.status.FAILED_PRECONDITION,
-      message: `travel_rule_denied: ${travelRule.error}`
-    }, null);
+  if (ArrayBuffer.isView(data)) {
+    return Buffer2.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
   }
-  try {
-    const transaction = travelRule.mode === "localentity" ? await withdrawViaLocalEntity(broker, {
-      code: symbol2,
-      amount: transferValue.amount,
-      address: transferValue.recipientAddress,
-      network: withdrawNetwork.exchangeNetworkId,
-      questionnaire: travelRule.questionnaire,
-      params: transferValue.params
-    }) : await broker.withdraw(symbol2, transferValue.amount, transferValue.recipientAddress, undefined, {
-      ...transferValue.params ?? {},
-      network: withdrawNetwork.exchangeNetworkId
-    });
-    log.info(`Withdraw Result: ${JSON.stringify(transaction)}`);
-    ctx.wrappedCallback(null, {
-      proof: ctx.verity.proof,
-      result: JSON.stringify({
-        ...transaction,
-        operatorAlias: withdrawNetwork.operatorAlias,
-        brokerNetworkId: withdrawNetwork.brokerNetworkId,
-        exchangeNetworkId: withdrawNetwork.exchangeNetworkId
-      })
-    });
-  } catch (error48) {
-    safeLogError("Withdraw failed", error48);
-    const code = mapCcxtErrorToGrpcStatus(error48) ?? grpc10.status.INTERNAL;
-    ctx.wrappedCallback({
-      code,
-      message: `Withdraw failed: ${getErrorMessage(error48)}`
-    }, null);
+  if (Array.isArray(data) && data.every((item) => Buffer2.isBuffer(item))) {
+    return Buffer2.concat(data).toString("utf8");
   }
+  return data;
 }
 
-// src/handlers/execute-action/registry.ts
-var ACTION_HANDLERS = {
-  [Action.Deposit]: handleDeposit,
-  [Action.Withdraw]: handleWithdraw,
-  [Action.Call]: handleTreasuryCall,
-  [Action.InternalTransfer]: handleInternalTransfer,
-  [Action.CreateOrder]: handleOrders,
-  [Action.GetOrderDetails]: handleOrders,
-  [Action.CancelOrder]: handleOrders,
-  [Action.FetchCurrency]: handlePassThrough,
-  [Action.FetchAccountId]: handlePassThrough,
-  [Action.FetchFees]: handlePassThrough,
-  [Action.FetchDepositAddresses]: handlePassThrough,
-  [Action.FetchBalances]: handlePassThrough,
-  [Action.FetchTicker]: handlePassThrough,
-  [Action.GetPerpConfigState]: handlePerpConfig,
-  [Action.SetPerpConfigState]: handlePerpConfig
-};
-async function dispatchExecuteAction(ctx) {
-  const handler = ACTION_HANDLERS[ctx.action];
-  if (!handler) {
-    ctx.wrappedCallback({
-      code: grpc11.status.INVALID_ARGUMENT,
-      message: "Invalid Action"
-    }, null);
-    return;
+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));
   }
-  await handler(ctx);
-}
-
-// src/handlers/execute-action/handler.ts
-function createExecuteActionHandler(deps) {
-  const {
-    policy,
-    brokers,
-    whitelistIps,
-    useVerity,
-    verityProverUrl,
-    otelMetrics
-  } = deps;
-  return async (call, callback) => {
-    const startTime = Date.now();
-    const { action: rawAction, cex: cex3, symbol: symbol2 } = call.request;
-    const action = resolveAction(rawAction);
-    let actionCompleted = false;
-    const wrappedCallback = (error48, value) => {
-      if (!actionCompleted) {
-        actionCompleted = true;
-        const latency = Date.now() - startTime;
-        const actionName = getActionName(action);
-        otelMetrics?.recordHistogram("execute_action_duration_ms", latency, {
-          action: actionName,
-          cex: cex3 || "unknown"
-        });
-        if (error48) {
-          otelMetrics?.recordCounter("execute_action_errors_total", 1, {
-            action: actionName,
-            cex: cex3 || "unknown",
-            error_type: error48.code ? grpc12.status[error48.code] || "unknown" : "unknown"
-          });
-        } else {
-          otelMetrics?.recordCounter("execute_action_success_total", 1, {
-            action: actionName,
-            cex: cex3 || "unknown"
-          });
-        }
+  async* [Symbol.asyncIterator]() {
+    while (true) {
+      const event = await this.nextEvent();
+      if (!event) {
+        break;
       }
-      callback(error48, value);
-    };
+      yield event;
+    }
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.queue.length = 0;
     try {
-      log.info(`Request - ExecuteAction:`, { action, cex: cex3, symbol: symbol2 });
-      otelMetrics?.recordCounter("execute_action_requests_total", 1, {
-        action: getActionName(action),
-        cex: cex3 || "unknown"
-      });
-      if (!authenticateRequest(call, whitelistIps)) {
-        return wrappedCallback({
-          code: grpc12.status.PERMISSION_DENIED,
-          message: "Access denied: Unauthorized IP"
-        }, null);
+      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;
       }
-      if (!action || !cex3) {
-        return wrappedCallback({
-          code: grpc12.status.INVALID_ARGUMENT,
-          message: "`action` AND `cex` fields are required"
-        }, null);
+      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);
       }
-      const normalizedCex = cex3.trim().toLowerCase();
-      const metadata = call.metadata;
-      const selectedBrokerAccount = selectBrokerAccountForCex(normalizedCex, brokers, metadata);
-      const verity = { proof: "" };
-      const applyVerityToBroker = (targetBroker) => {
-        if (!useVerity)
-          return;
-        const override = buildHttpClientOverrideFromMetadata(metadata, verityProverUrl, (proof, notaryPubKey) => {
-          verity.proof = proof;
-          log.debug(`Verity proof:`, { proof, notaryPubKey });
+    }
+  }
+}
+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
         });
-        targetBroker.setHttpClientOverride(override, verityHttpClientOverridePredicate);
-      };
-      const preludeCtx = {
-        call,
-        wrappedCallback,
-        action,
-        policy,
-        brokers,
-        metadata,
-        normalizedCex,
-        cex: cex3,
-        symbol: symbol2,
-        selectedBrokerAccount,
-        broker: selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, metadata),
-        verity,
-        applyVerityToBroker,
-        useVerity,
-        verityProverUrl,
-        otelMetrics
-      };
-      if (action === Action.Call) {
-        const handled = await handleOrderBookCall(preludeCtx);
-        if (handled)
-          return;
-      }
-      const broker = selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, metadata);
-      if (!broker) {
-        return wrappedCallback({
-          code: grpc12.status.UNAUTHENTICATED,
-          message: `This Exchange is not registered and No API metadata was found`
-        }, null);
       }
-      applyVerityToBroker(broker);
-      const ctx = { ...preludeCtx, broker };
-      await dispatchExecuteAction(ctx);
-    } catch (error48) {
-      safeLogError("ExecuteAction unhandled error", error48);
-      return wrappedCallback({
-        code: grpc12.status.INTERNAL,
-        message: "ExecuteAction failed unexpectedly"
-      }, null);
     }
-  };
+    candidates.push({
+      bar: lastBar,
+      isClosed: false,
+      brokerVersion
+    });
+    this.lastOpenTimeMs = lastBar.openTimeMs;
+    this.lastBar = lastBar;
+    return candidates;
+  }
 }
-// src/handlers/subscribe/handler.ts
-var grpc13 = __toESM(require_src3(), 1);
 
-// src/helpers/binance-user-data-stream.ts
-import { Buffer as Buffer2 } from "node:buffer";
-import { createHmac } from "node:crypto";
-var BINANCE_SPOT_WS_API_URL = "wss://ws-api.binance.com:443/ws-api/v3";
-var DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS = 16;
-var createWebSocket = (url3) => new wrapper_default(url3);
-function getExchangeString(exchange, key) {
-  const value = exchange[key];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`Binance user-data stream requires exchange.${key}`);
+// 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;
   }
-  return value;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ORDERBOOK_INTERVAL_MS;
 }
-function sortedQuery(params) {
-  return Object.entries(params).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
+function isMarketArchiveEnabled() {
+  return process.env.CEX_BROKER_MARKET_ARCHIVE_ENABLED !== "false";
 }
-function signUserDataStreamParams(exchange, params) {
-  const signParams = exchange.signParams;
-  if (typeof signParams === "function") {
-    return signParams.call(exchange, params);
+
+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;
   }
-  const secret = getExchangeString(exchange, "secret");
-  return {
-    ...params,
-    signature: createHmac("sha256", secret).update(sortedQuery(params)).digest("hex")
-  };
 }
-function getBinanceSpotWsApiUrl(exchange) {
-  const urls = exchange.urls;
-  return urls?.api?.ws?.["ws-api"]?.spot ?? BINANCE_SPOT_WS_API_URL;
+
+// src/helpers/market-data-archive/parse-stream.ts
+function isFiniteNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value);
 }
-function getRecord(value) {
-  return typeof value === "object" && value !== null ? value : null;
+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 getMessage(value) {
-  if (value instanceof Error) {
-    return value.message;
+function toStringId(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
   }
-  if (typeof value === "string" && value.length > 0) {
-    return value;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
   }
-  const record2 = getRecord(value);
-  const message = record2?.message;
-  return typeof message === "string" && message.length > 0 ? message : null;
+  return;
 }
-function getOptionalExchangeString(exchange, key) {
-  const value = exchange[key];
-  return typeof value === "string" && value.length > 0 ? value : null;
+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 redactDiagnosticMessage(message, secretValues) {
-  let redacted = message;
-  for (const value of secretValues) {
-    if (value.length > 0) {
-      redacted = redacted.split(value).join("[redacted]");
+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 redacted.replace(/(\b(?:apiKey|secret|signature)\b\s*=\s*)[^\s&,;)]+/gi, "$1[redacted]").replace(/("(?:apiKey|secret|signature)"\s*:\s*")[^"]*(")/gi, "$1[redacted]$2");
+  return parsed;
 }
-function formatBinanceUserDataWebSocketError(event, secretValues) {
-  const record2 = getRecord(event);
-  const message = getMessage(record2?.error) ?? getMessage(record2?.message) ?? getMessage(event);
-  const safeMessage = message === null ? null : redactDiagnosticMessage(message, secretValues);
-  return new Error(safeMessage ? `Binance user-data WebSocket error: ${safeMessage}` : "Binance user-data WebSocket error");
+
+// 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 getCloseReason(value) {
-  if (typeof value === "string") {
-    return value.length > 0 ? value : null;
+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);
   }
-  if (Buffer2.isBuffer(value)) {
-    const reason = value.toString("utf8");
-    return reason.length > 0 ? reason : null;
+  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 (value instanceof Uint8Array) {
-    const reason = Buffer2.from(value).toString("utf8");
-    return reason.length > 0 ? reason : null;
+  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 null;
+  return Date.now();
 }
-function formatBinanceUserDataWebSocketClose(codeOrEvent, reasonOrUndefined, secretValues) {
-  const record2 = getRecord(codeOrEvent);
-  const code = record2 ? record2.code : codeOrEvent;
-  const reason = getCloseReason(record2 ? record2.reason : reasonOrUndefined);
-  const safeReason = reason === null ? null : redactDiagnosticMessage(reason, secretValues);
-  const details = [
-    typeof code === "number" || typeof code === "string" ? `code=${code}` : null,
-    safeReason ? `reason=${safeReason}` : null
-  ].filter((detail) => detail !== null);
-  return new Error(details.length > 0 ? `Binance user-data WebSocket closed unexpectedly (${details.join(", ")})` : "Binance user-data WebSocket closed unexpectedly");
+function 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 decodeMessageData(data) {
-  if (typeof data === "string") {
-    return data;
+function topOfBookLevel(levels) {
+  const level = levels[0];
+  if (!level || level.length < 2) {
+    return null;
   }
-  if (Buffer2.isBuffer(data)) {
-    return data.toString("utf8");
+  const price = level[0];
+  const size = level[1];
+  if (price === undefined || size === undefined || !Number.isFinite(price) || !Number.isFinite(size)) {
+    return null;
   }
-  if (data instanceof ArrayBuffer) {
-    return Buffer2.from(data).toString("utf8");
+  return { price, size };
+}
+function computeSpreadBps(bestBid, bestAsk) {
+  if (bestBid <= 0 || bestAsk <= 0 || bestAsk < bestBid) {
+    return 0;
   }
-  if (ArrayBuffer.isView(data)) {
-    return Buffer2.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
+  const mid = (bestBid + bestAsk) / 2;
+  if (mid <= 0) {
+    return 0;
   }
-  if (Array.isArray(data) && data.every((item) => Buffer2.isBuffer(item))) {
-    return Buffer2.concat(data).toString("utf8");
+  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;
   }
-  return data;
+  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
+    })
+  };
 }
 
-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));
+// 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 +332520,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 +332545,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 +332682,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 +332698,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 +332721,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 +332773,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 +332809,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 +332846,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 +332908,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 +332927,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 +333111,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 +333120,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 +333264,7 @@ class CEXBroker {
   useVerity = false;
   otelMetrics;
   otelLogs;
+  brokerArchiver;
   depositReconciler;
   loadEnvConfig() {
     log.info("\uD83D\uDD27 Loading CEX_BROKER_ environment variables:");
@@ -331951,6 +333376,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 +333409,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 +333431,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);