@usherlabs/cex-broker 0.2.26 → 0.2.28

package/dist/commands/cli.js

@@ -314993,6 +314993,65 @@ function validateDeposit(policy, exchange, network, ticker) {
   return { valid: true };
 }
 
+// src/helpers/shared/errors.ts
+var MAX_ERROR_DETAIL_LENGTH = 512;
+var REDACTED_ERROR_MESSAGE = "redacted_error";
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
+}
+function errorClassName(error) {
+  if (!(error instanceof Error)) {
+    return;
+  }
+  const name = error.constructor?.name || error.name;
+  return name && name !== "Error" ? name : undefined;
+}
+function errorCode(error) {
+  if (error === null || typeof error !== "object") {
+    return;
+  }
+  const code = error.code;
+  if (typeof code === "string") {
+    return code.trim() || undefined;
+  }
+  if (typeof code === "number" && Number.isFinite(code)) {
+    return String(code);
+  }
+  if (typeof code === "bigint") {
+    return String(code);
+  }
+  return;
+}
+function sanitizeErrorDetail(error, options = {}) {
+  const className = errorClassName(error);
+  const message = getErrorMessage(error);
+  const code = options.includeCode ? errorCode(error) : undefined;
+  const prefix = [className, code ? `[code=${code}]` : undefined].filter((part) => Boolean(part)).join(" ");
+  const detail = prefix ? `${prefix}: ${message}` : message;
+  return detail.replace(/\s+/g, " ").trim().slice(0, MAX_ERROR_DETAIL_LENGTH);
+}
+function safeLogError(context2, error) {
+  try {
+    log.error(context2, { error });
+  } catch {
+    console.error(context2, error);
+  }
+}
+function safeLogRedactedError(context2, error) {
+  const errorType = errorClassName(error) ?? (error instanceof Error ? error.name : typeof error);
+  try {
+    log.error(context2, {
+      error_type: errorType,
+      error_message: REDACTED_ERROR_MESSAGE
+    });
+  } catch {
+    console.error(context2, {
+      error_type: errorType,
+      error_message: REDACTED_ERROR_MESSAGE
+    });
+  }
+}
+
 // src/helpers/shared/guards.ts
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -315013,7 +315072,6 @@ var NUMERIC_METRICS = [
   ["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);
@@ -315505,7 +315563,7 @@ function buildOrderEventArchiveRow(input) {
       fee_rate: telemetry.feeRate,
       exchange_timestamp: telemetry.exchangeTimestamp,
       error_type: telemetry.errorType,
-      error_message: telemetry.errorMessage,
+      error_message: input.errorDetail ?? telemetry.errorMessage,
       payload_json: JSON.stringify(telemetry)
     })
   };
@@ -315637,418 +315695,163 @@ function buildMarketMetadataSnapshotRow(input) {
   };
 }
 
-// src/helpers/broker-execution-archive/capture.ts
-function archiveOrderExecutionInBackground(archiver, context2, order, error, options) {
-  if (!archiver?.isEnabled()) {
-    return;
+// src/helpers/broker-execution-archive/writer.ts
+var import_api_logs2 = __toESM(require_src7(), 1);
+import { closeSync, fsyncSync, openSync, writeSync } from "node:fs";
+import { request as httpRequest2 } from "node:http";
+import { request as httpsRequest2 } from "node:https";
+var BROKER_EXECUTION_ARCHIVE_TABLES = new Set([
+  "broker_execution.order_events",
+  "broker_execution.market_metadata_snapshots",
+  "broker_execution.transfer_events",
+  "broker_execution.fill_events"
+]);
+function isBrokerExecutionArchiveTable(table) {
+  return BROKER_EXECUTION_ARCHIVE_TABLES.has(table);
+}
+
+class BrokerExecutionArchiveDurabilityError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BrokerExecutionArchiveDurabilityError";
   }
-  queueMicrotask(() => {
-    try {
-      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;
+function rethrowArchiveDurabilityError(error) {
+  if (error instanceof BrokerExecutionArchiveDurabilityError) {
+    throw error;
   }
-  queueMicrotask(() => {
+}
+var DEFAULT_MAX_QUEUE_SIZE = 1e4;
+var DEFAULT_BATCH_SIZE = 10;
+var DEFAULT_FLUSH_INTERVAL_MS = 1000;
+var DEFAULT_FORWARDER_TIMEOUT_MS = 3000;
+var SHED_WARN_INTERVAL_MS = 60000;
+function isArchiveOtelLogsEnabled() {
+  return process.env.CEX_BROKER_ARCHIVE_OTEL_LOGS_ENABLED === "true";
+}
+function resolveArchiveForwarderUrlFromEnv() {
+  return process.env.CEX_BROKER_ARCHIVE_FORWARDER_URL?.trim() || undefined;
+}
+
+class BrokerExecutionArchiver {
+  deploymentId;
+  otelLogs;
+  otelMetrics;
+  forwarderUrl;
+  deadLetterPath;
+  deadLetterFd;
+  maxQueueSize;
+  batchSize;
+  flushIntervalMs;
+  forwarderTimeoutMs;
+  queue = [];
+  stats = {
+    enqueued: 0,
+    shed: 0,
+    flushed: 0,
+    forwarderFailures: 0
+  };
+  flushTimer = null;
+  flushInFlight = null;
+  lastShedWarnAtMs = 0;
+  closed = 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.deadLetterPath = options.deadLetterPath?.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) {
+      log.info("Broker execution archive disabled", { enabled: false });
+      return;
+    }
+    validateForwarderUrl(this.forwarderUrl);
+    if (!this.deadLetterPath) {
+      throw new Error("Broker execution archive is enabled but CEX_BROKER_ARCHIVE_DEAD_LETTER_PATH is missing");
+    }
     try {
-      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
-      });
+      this.deadLetterFd = openSync(this.deadLetterPath, "a", 384);
+    } catch {
+      throw new Error("Broker execution archive cannot open CEX_BROKER_ARCHIVE_DEAD_LETTER_PATH for append");
     }
-  });
-}
-function archiveTransferEventInBackground(archiver, input) {
-  if (!archiver?.isEnabled()) {
-    return;
-  }
-  queueMicrotask(() => {
     try {
-      const tags = buildCommonArchiveTags({
-        deploymentId: archiver.getDeploymentId(),
-        accountSelector: input.accountSelector,
-        exchange: input.exchange,
-        symbol: input.assetSymbol,
-        brokerObservedTimestamp: input.brokerObservedTimestamp
+      this.flushTimer = setInterval(() => {
+        this.flush();
+      }, this.flushIntervalMs);
+      this.flushTimer.unref?.();
+      log.info("Broker execution archive enabled", {
+        enabled: true,
+        otel_mirror_enabled: Boolean(this.otelLogs?.isOtelEnabled())
       });
-      archiver.enqueue(buildTransferEventArchiveRow({ tags, transfer: input.transfer }));
-    } catch (archiveError) {
-      log.warn("Failed to archive transfer event", { error: archiveError });
+    } catch (error) {
+      this.closeLossJournal();
+      throw error;
     }
-  });
-}
-function archiveWithdrawalObservationsInBackground(archiver, tracker, input) {
-  try {
-    if (!archiver?.isEnabled() || !Array.isArray(input.transactions)) {
+  }
+  static disabled() {
+    return new BrokerExecutionArchiver({ enabled: false });
+  }
+  static create(options) {
+    return new BrokerExecutionArchiver({ ...options, enabled: true });
+  }
+  getDeploymentId() {
+    return this.deploymentId;
+  }
+  isEnabled() {
+    return this.enabled && !this.closed;
+  }
+  canPersistMarketMetadataSnapshot() {
+    return this.isEnabled();
+  }
+  canPersistAccountBalanceSnapshots() {
+    return this.isEnabled() && Boolean(this.forwarderUrl);
+  }
+  enqueue(row) {
+    if (!this.enabled || this.closed) {
       return;
     }
-    const brokerObservedTimestamp = new Date().toISOString();
-    for (const [resultIndex, transaction] of input.transactions.entries()) {
-      const normalized = normalizeCcxtTransactionForArchive(transaction);
-      const assetSymbol = normalized.assetSymbol;
-      if (!tracker.shouldArchive({
-        exchange: input.exchange,
-        accountSelector: input.accountSelector,
-        assetSymbol,
-        transaction,
-        normalized
-      })) {
-        continue;
+    if (this.queue.length >= this.maxQueueSize) {
+      const shedRow = this.queue[0];
+      if (shedRow) {
+        this.appendLossRecords([shedRow], "queue_shed");
+        this.queue.shift();
       }
-      archiveTransferEventInBackground(archiver, {
-        exchange: input.exchange,
-        accountSelector: input.accountSelector,
-        assetSymbol,
-        brokerObservedTimestamp,
-        transfer: {
-          eventKind: "withdrawal",
-          lifecycleAction: "observe_withdrawal",
-          status: normalized.status,
-          amount: normalized.amount,
-          address: normalized.address,
-          network: normalized.network,
-          externalId: normalized.externalId,
-          txid: normalized.txid,
-          resultIndex,
-          feeAmount: normalized.feeAmount,
-          feeCurrency: normalized.feeCurrency,
-          exchangeTimestamp: normalized.exchangeTimestamp,
-          payload: transaction
-        }
+      this.stats.shed += 1;
+      this.recordArchiveMetric("cex_archive_rows_shed_total", {
+        table: shedRow?.table ?? "unknown"
       });
+      const now3 = Date.now();
+      if (now3 - this.lastShedWarnAtMs >= SHED_WARN_INTERVAL_MS) {
+        log.warn("Archive queue full: shedding oldest rows", {
+          shed_total: this.stats.shed,
+          queue_max: this.maxQueueSize,
+          table: shedRow?.table ?? "unknown"
+        });
+        this.lastShedWarnAtMs = now3;
+      }
     }
-  } catch (archiveError) {
-    log.warn("Failed to archive withdrawal observations", {
-      error: archiveError
+    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();
+    }
   }
-}
-async function captureMarketMetadataSnapshot(archiver, broker, input) {
-  if (!archiver?.canPersistMarketMetadataSnapshot()) {
-    return;
+  enqueueInBackground(row) {
+    queueMicrotask(() => this.enqueue(row));
   }
-  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 row = buildMarketMetadataSnapshotRow({
-      tags,
-      clientOrderId: input.clientOrderId,
-      orderId: input.orderId,
-      makerActionId: input.makerActionId,
-      idempotencyId: input.idempotencyId,
-      marketSnapshot: snapshot
-    });
-    archiver.enqueue(row);
-    const hash4 = row.row.market_metadata_hash;
-    return typeof hash4 === "string" ? hash4 : undefined;
-  } catch (archiveError) {
-    log.warn("Failed to capture market metadata snapshot", {
-      error: archiveError
-    });
-    return;
-  }
-}
-// src/helpers/broker-execution-archive/withdrawal-observation-tracker.ts
-var DEFAULT_WITHDRAWAL_OBSERVATION_TRACKER_MAX_ENTRIES = 1e4;
-var VENUE_LIFECYCLE_EVIDENCE_FIELDS = [
-  "updated",
-  "updatedAt",
-  "updated_at",
-  "updateTime",
-  "update_time",
-  "updateTimestamp",
-  "lastUpdateTimestamp",
-  "completed",
-  "completedAt",
-  "completed_at",
-  "completeTime",
-  "complete_time",
-  "completionTime",
-  "successTime"
-];
-function fingerprintEvidenceValue(value) {
-  if (value === undefined || value === null) {
-    return value;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-function venueLifecycleEvidence(transaction) {
-  const record = asRecord(transaction);
-  const info = asRecord(record?.info);
-  const evidence = [];
-  for (const [scope, source] of [
-    ["transaction", record],
-    ["info", info]
-  ]) {
-    for (const field of VENUE_LIFECYCLE_EVIDENCE_FIELDS) {
-      const value = source?.[field];
-      if (value !== undefined && value !== null) {
-        evidence.push([scope, field, fingerprintEvidenceValue(value)]);
-      }
-    }
-  }
-  return evidence;
-}
-function observationFingerprint(observation) {
-  const { normalized, transaction } = observation;
-  return JSON.stringify({
-    status: normalized.status ?? null,
-    txid: normalized.txid ?? null,
-    amount: normalized.amount ?? null,
-    feeAmount: normalized.feeAmount ?? null,
-    feeCurrency: normalized.feeCurrency ?? null,
-    address: normalized.address ?? null,
-    network: normalized.network ?? null,
-    exchangeTimestamp: normalized.exchangeTimestamp ?? null,
-    venueLifecycleEvidence: venueLifecycleEvidence(transaction)
-  });
-}
-
-class WithdrawalObservationTracker {
-  #fingerprints = new Map;
-  #maxEntries;
-  #missingIdSequence = 0n;
-  constructor(options) {
-    const maxEntries = options?.maxEntries ?? DEFAULT_WITHDRAWAL_OBSERVATION_TRACKER_MAX_ENTRIES;
-    this.#maxEntries = Number.isFinite(maxEntries) ? Math.max(1, Math.floor(maxEntries)) : DEFAULT_WITHDRAWAL_OBSERVATION_TRACKER_MAX_ENTRIES;
-  }
-  shouldArchive(observation) {
-    const externalId = observation.normalized.externalId?.trim();
-    const identity = JSON.stringify([
-      observation.exchange.trim().toLowerCase() || "unknown",
-      observation.accountSelector?.trim() || "unknown",
-      observation.assetSymbol?.trim().toUpperCase() || "unknown",
-      externalId || `missing:${++this.#missingIdSequence}`
-    ]);
-    const fingerprint = observationFingerprint(observation);
-    if (this.#fingerprints.get(identity) === fingerprint) {
-      return false;
-    }
-    this.#fingerprints.delete(identity);
-    this.#fingerprints.set(identity, fingerprint);
-    while (this.#fingerprints.size > this.#maxEntries) {
-      const oldest = this.#fingerprints.keys().next().value;
-      if (oldest === undefined)
-        break;
-      this.#fingerprints.delete(oldest);
-    }
-    return true;
-  }
-  getSize() {
-    return this.#fingerprints.size;
-  }
-}
-// 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 BROKER_EXECUTION_ARCHIVE_TABLES = new Set([
-  "broker_execution.order_events",
-  "broker_execution.market_metadata_snapshots",
-  "broker_execution.transfer_events",
-  "broker_execution.fill_events"
-]);
-function isBrokerExecutionArchiveTable(table) {
-  return BROKER_EXECUTION_ARCHIVE_TABLES.has(table);
-}
-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;
-  }
-  const protocol = process.env.CEX_BROKER_CLICKHOUSE_PROTOCOL || "http";
-  const port = parsePositiveInt(process.env.CEX_BROKER_ARCHIVE_FORWARDER_PORT, DEFAULT_ARCHIVE_FORWARDER_PORT);
-  const path = process.env.CEX_BROKER_ARCHIVE_FORWARDER_PATH?.trim() || DEFAULT_ARCHIVE_FORWARDER_PATH;
-  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-  return `${protocol}://${host}:${port}${normalizedPath}`;
-}
-
-class BrokerExecutionArchiver {
-  deploymentId;
-  otelLogs;
-  otelMetrics;
-  forwarderUrl;
-  maxQueueSize;
-  batchSize;
-  flushIntervalMs;
-  forwarderTimeoutMs;
-  queue = [];
-  stats = {
-    enqueued: 0,
-    shed: 0,
-    flushed: 0,
-    forwarderFailures: 0
-  };
-  flushTimer = null;
-  flushInFlight = null;
-  closed = false;
-  loggedMissingMarketForwarder = false;
-  enabled;
-  forwarderAuthToken;
-  constructor(options) {
-    this.deploymentId = options.deploymentId?.trim() || process.env.CEX_BROKER_DEPLOYMENT_ID?.trim() || "unknown";
-    this.otelLogs = options.otelLogs;
-    this.otelMetrics = options.otelMetrics;
-    this.forwarderUrl = options.forwarderUrl?.trim();
-    this.maxQueueSize = options.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
-    this.batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
-    this.flushIntervalMs = options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
-    this.forwarderTimeoutMs = options.forwarderTimeoutMs ?? DEFAULT_FORWARDER_TIMEOUT_MS;
-    this.enabled = options.enabled;
-    this.forwarderAuthToken = process.env.CEX_BROKER_ARCHIVE_FORWARDER_TOKEN?.trim() || undefined;
-    if (this.enabled) {
-      this.flushTimer = setInterval(() => {
-        this.flush().catch((error) => {
-          log.warn("Broker execution archive flush failed", { error });
-        });
-      }, this.flushIntervalMs);
-      this.flushTimer.unref?.();
-    }
-  }
-  static disabled() {
-    return new BrokerExecutionArchiver({ enabled: false });
-  }
-  static create(options) {
-    const hasSink = Boolean(options.otelLogs?.isOtelEnabled()) || Boolean(options.forwarderUrl);
-    const enabled = process.env.CEX_BROKER_ARCHIVE_ENABLED !== "false" && hasSink;
-    return new BrokerExecutionArchiver({ ...options, enabled });
-  }
-  getDeploymentId() {
-    return this.deploymentId;
-  }
-  isEnabled() {
-    return this.enabled && !this.closed && (Boolean(this.otelLogs) || Boolean(this.forwarderUrl));
-  }
-  canPersistMarketMetadataSnapshot() {
-    return this.isEnabled() && (Boolean(this.otelLogs?.isOtelEnabled()) || Boolean(this.forwarderUrl));
-  }
-  canPersistAccountBalanceSnapshots() {
-    return this.isEnabled() && Boolean(this.forwarderUrl);
-  }
-  enqueue(row) {
-    if (!this.enabled || this.closed || !this.otelLogs && !this.forwarderUrl) {
-      return;
-    }
-    if (isMarketArchiveTable(row.table) && !this.forwarderUrl) {
-      if (!this.loggedMissingMarketForwarder) {
-        this.loggedMissingMarketForwarder = true;
-        log.warn("Market data archive row dropped: configure CEX_BROKER_ARCHIVE_FORWARDER_URL or CEX_BROKER_CLICKHOUSE_HOST", { table: row.table });
-      }
-      return;
-    }
-    if (row.table === "broker_account.balance_snapshots" && !this.forwarderUrl) {
-      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 });
-      });
-    }
-  }
-  enqueueInBackground(row) {
-    queueMicrotask(() => this.enqueue(row));
-  }
-  async flush() {
-    if (!this.enabled || this.closed || this.queue.length === 0) {
+  async flush() {
+    if (!this.enabled || this.closed || this.queue.length === 0) {
       return;
     }
     if (this.flushInFlight) {
@@ -316067,21 +315870,36 @@ class BrokerExecutionArchiver {
       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;
+    let closeError;
+    try {
+      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 undelivered = [...this.queue];
+          this.appendLossRecords(undelivered, "shutdown_forwarder_failure");
+          this.queue.length = 0;
+          break;
+        }
       }
+    } catch (error) {
+      closeError = error;
     }
     this.closed = true;
+    if (this.deadLetterFd !== undefined) {
+      try {
+        this.closeLossJournal();
+      } catch (error) {
+        closeError ??= error;
+      }
+    }
+    if (closeError) {
+      throw closeError;
+    }
   }
   getStats() {
     return { ...this.stats };
@@ -316089,15 +315907,60 @@ class BrokerExecutionArchiver {
   getQueueDepth() {
     return this.queue.length;
   }
+  closeLossJournal() {
+    if (this.deadLetterFd === undefined) {
+      return;
+    }
+    const fd2 = this.deadLetterFd;
+    try {
+      closeSync(fd2);
+    } catch (error) {
+      throw new BrokerExecutionArchiveDurabilityError("Broker execution archive failed to close the configured CEX_BROKER_ARCHIVE_DEAD_LETTER_PATH loss journal", { cause: error });
+    } finally {
+      this.deadLetterFd = undefined;
+    }
+  }
   enforceQueueBound() {
     while (this.queue.length > this.maxQueueSize) {
-      const dropped = this.queue.shift();
+      const dropped = this.queue[0];
+      if (!dropped) {
+        return;
+      }
+      this.appendLossRecords([dropped], "queue_shed");
+      this.queue.shift();
       this.stats.shed += 1;
       this.recordArchiveMetric("cex_archive_rows_shed_total", {
         table: dropped?.table ?? "unknown"
       });
     }
   }
+  appendLossRecords(rows, reason) {
+    if (rows.length === 0) {
+      return;
+    }
+    if (this.deadLetterFd === undefined) {
+      throw new BrokerExecutionArchiveDurabilityError(`Broker execution archive cannot record ${reason}: dead-letter file is not open`);
+    }
+    const timestamp = new Date().toISOString();
+    const records = rows.map((payload) => ({
+      timestamp,
+      deployment_id: this.deploymentId,
+      reason,
+      payload
+    }));
+    try {
+      const bytes2 = Buffer.from(records.map((record) => JSON.stringify(record)).join(`
+`) + `
+`);
+      const written = writeSync(this.deadLetterFd, bytes2);
+      if (written !== bytes2.length) {
+        throw new Error(`wrote ${written} of ${bytes2.length} bytes`);
+      }
+      fsyncSync(this.deadLetterFd);
+    } catch (error) {
+      throw new BrokerExecutionArchiveDurabilityError(`Broker execution archive failed to durably record ${reason}; affected row(s) were retained`, { cause: error });
+    }
+  }
   async flushBatch() {
     const batch = this.queue.splice(0, this.batchSize);
     if (batch.length === 0) {
@@ -316134,111 +315997,407 @@ class BrokerExecutionArchiver {
     for (const [table, count2] of countByTable) {
       this.recordArchiveMetric("cex_archive_rows_flushed_total", { table }, count2);
     }
-    this.recordArchiveGauge("cex_archive_last_flush_success", Math.floor(Date.now() / 1000));
-  }
-  async recordArchiveMetric(metricName, labels, value = 1) {
-    try {
-      await this.otelMetrics?.recordCounter(metricName, value, labels);
-    } catch {}
+    this.recordArchiveGauge("cex_archive_last_flush_success", Math.floor(Date.now() / 1000));
+  }
+  async recordArchiveMetric(metricName, labels, value = 1) {
+    try {
+      await this.otelMetrics?.recordCounter(metricName, value, labels);
+    } catch {}
+  }
+  async recordArchiveGauge(metricName, value) {
+    try {
+      await this.otelMetrics?.recordGauge(metricName, value, {});
+    } catch {}
+  }
+  emitOtelLog(entry) {
+    if (!this.otelLogs?.isOtelEnabled()) {
+      return;
+    }
+    try {
+      this.otelLogs.emit({
+        body: entry.table,
+        severityNumber: import_api_logs2.SeverityNumber.INFO,
+        severityText: "INFO",
+        attributes: flattenArchiveAttributes(redactArchiveErrorForOtel(entry))
+      });
+    } catch (error) {
+      log.warn("Broker execution archive OTLP emit failed", { error });
+    }
+  }
+  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();
+    });
+  }
+}
+function redactArchiveErrorForOtel(entry) {
+  if (entry.table !== "broker_execution.order_events" || typeof entry.row.error_message !== "string" || entry.row.error_message.length === 0) {
+    return entry;
+  }
+  return {
+    ...entry,
+    row: { ...entry.row, error_message: REDACTED_ERROR_MESSAGE }
+  };
+}
+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 attributes;
+}
+function createBrokerExecutionArchiverFromEnv(otelLogs, otelMetrics) {
+  if (process.env.CEX_BROKER_ARCHIVE_ENABLED !== "true") {
+    return BrokerExecutionArchiver.disabled();
+  }
+  const forwarderUrl = resolveArchiveForwarderUrlFromEnv();
+  const archiveOtelLogs = isArchiveOtelLogsEnabled() ? otelLogs : undefined;
+  return BrokerExecutionArchiver.create({
+    otelLogs: archiveOtelLogs,
+    otelMetrics,
+    forwarderUrl: forwarderUrl ?? "",
+    deadLetterPath: process.env.CEX_BROKER_ARCHIVE_DEAD_LETTER_PATH?.trim() ?? "",
+    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 validateForwarderUrl(value) {
+  if (!value) {
+    throw new Error("Broker execution archive is enabled but CEX_BROKER_ARCHIVE_FORWARDER_URL is missing");
+  }
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch (error) {
+    throw new Error("Broker execution archive requires a valid CEX_BROKER_ARCHIVE_FORWARDER_URL", { cause: error });
+  }
+  if (url2.protocol !== "http:" && url2.protocol !== "https:") {
+    throw new Error("Broker execution archive forwarder URL must use http or https");
+  }
+  return url2;
+}
+function parsePositiveInt(value, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+// src/helpers/broker-execution-archive/capture.ts
+function archiveOrderExecutionInBackground(archiver, context2, order, error, options) {
+  if (!archiver?.isEnabled()) {
+    return;
+  }
+  queueMicrotask(() => {
+    try {
+      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,
+        errorDetail: context2.action === "CreateOrder" && error !== undefined ? sanitizeErrorDetail(error, { includeCode: true }) : undefined,
+        marketMetadataHash: options?.marketMetadataHash
+      }));
+    } catch (archiveError) {
+      rethrowArchiveDurabilityError(archiveError);
+      log.warn("Failed to archive order execution", { error: archiveError });
+    }
+  });
+}
+function archiveSubscribeStreamInBackground(archiver, input) {
+  if (!archiver?.isEnabled()) {
+    return;
+  }
+  queueMicrotask(() => {
+    try {
+      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) {
+      rethrowArchiveDurabilityError(archiveError);
+      log.warn("Failed to archive subscribe stream event", {
+        error: archiveError
+      });
+    }
+  });
+}
+function archiveTransferEventInBackground(archiver, input) {
+  if (!archiver?.isEnabled()) {
+    return;
+  }
+  queueMicrotask(() => {
+    try {
+      const tags = buildCommonArchiveTags({
+        deploymentId: archiver.getDeploymentId(),
+        accountSelector: input.accountSelector,
+        exchange: input.exchange,
+        symbol: input.assetSymbol,
+        brokerObservedTimestamp: input.brokerObservedTimestamp
+      });
+      archiver.enqueue(buildTransferEventArchiveRow({ tags, transfer: input.transfer }));
+    } catch (archiveError) {
+      rethrowArchiveDurabilityError(archiveError);
+      log.warn("Failed to archive transfer event", { error: archiveError });
+    }
+  });
+}
+function archiveWithdrawalObservationsInBackground(archiver, tracker, input) {
+  try {
+    if (!archiver?.isEnabled() || !Array.isArray(input.transactions)) {
+      return;
+    }
+    const brokerObservedTimestamp = new Date().toISOString();
+    for (const [resultIndex, transaction] of input.transactions.entries()) {
+      const normalized = normalizeCcxtTransactionForArchive(transaction);
+      const assetSymbol = normalized.assetSymbol;
+      if (!tracker.shouldArchive({
+        exchange: input.exchange,
+        accountSelector: input.accountSelector,
+        assetSymbol,
+        transaction,
+        normalized
+      })) {
+        continue;
+      }
+      archiveTransferEventInBackground(archiver, {
+        exchange: input.exchange,
+        accountSelector: input.accountSelector,
+        assetSymbol,
+        brokerObservedTimestamp,
+        transfer: {
+          eventKind: "withdrawal",
+          lifecycleAction: "observe_withdrawal",
+          status: normalized.status,
+          amount: normalized.amount,
+          address: normalized.address,
+          network: normalized.network,
+          externalId: normalized.externalId,
+          txid: normalized.txid,
+          resultIndex,
+          feeAmount: normalized.feeAmount,
+          feeCurrency: normalized.feeCurrency,
+          exchangeTimestamp: normalized.exchangeTimestamp,
+          payload: transaction
+        }
+      });
+    }
+  } catch (archiveError) {
+    rethrowArchiveDurabilityError(archiveError);
+    log.warn("Failed to archive withdrawal observations", {
+      error: archiveError
+    });
   }
-  async recordArchiveGauge(metricName, value) {
-    try {
-      await this.otelMetrics?.recordGauge(metricName, value, {});
-    } catch {}
+}
+async function captureMarketMetadataSnapshot(archiver, broker, input) {
+  if (!archiver?.canPersistMarketMetadataSnapshot()) {
+    return;
   }
-  emitOtelLog(entry) {
-    if (!this.otelLogs?.isOtelEnabled()) {
+  try {
+    const fetchOrderBook = broker.fetchOrderBook;
+    if (typeof fetchOrderBook !== "function") {
       return;
     }
-    try {
-      this.otelLogs.emit({
-        body: entry.table,
-        severityNumber: import_api_logs2.SeverityNumber.INFO,
-        severityText: "INFO",
-        attributes: flattenArchiveAttributes(entry)
-      });
-    } catch (error) {
-      log.warn("Broker execution archive OTLP emit failed", { error });
-    }
-  }
-  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)
+    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
     };
-    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();
+    const tags = buildCommonArchiveTags({
+      deploymentId: archiver.getDeploymentId(),
+      accountSelector: input.accountSelector,
+      exchange: input.exchange,
+      symbol: input.symbol,
+      brokerObservedTimestamp: input.brokerObservedTimestamp
+    });
+    const row = buildMarketMetadataSnapshotRow({
+      tags,
+      clientOrderId: input.clientOrderId,
+      orderId: input.orderId,
+      makerActionId: input.makerActionId,
+      idempotencyId: input.idempotencyId,
+      marketSnapshot: snapshot
+    });
+    archiver.enqueue(row);
+    const hash4 = row.row.market_metadata_hash;
+    return typeof hash4 === "string" ? hash4 : undefined;
+  } catch (archiveError) {
+    rethrowArchiveDurabilityError(archiveError);
+    log.warn("Failed to capture market metadata snapshot", {
+      error: archiveError
     });
+    return;
   }
 }
-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);
+// src/helpers/broker-execution-archive/withdrawal-observation-tracker.ts
+var DEFAULT_WITHDRAWAL_OBSERVATION_TRACKER_MAX_ENTRIES = 1e4;
+var VENUE_LIFECYCLE_EVIDENCE_FIELDS = [
+  "updated",
+  "updatedAt",
+  "updated_at",
+  "updateTime",
+  "update_time",
+  "updateTimestamp",
+  "lastUpdateTimestamp",
+  "completed",
+  "completedAt",
+  "completed_at",
+  "completeTime",
+  "complete_time",
+  "completionTime",
+  "successTime"
+];
+function fingerprintEvidenceValue(value) {
+  if (value === undefined || value === null) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function venueLifecycleEvidence(transaction) {
+  const record = asRecord(transaction);
+  const info = asRecord(record?.info);
+  const evidence = [];
+  for (const [scope, source] of [
+    ["transaction", record],
+    ["info", info]
+  ]) {
+    for (const field of VENUE_LIFECYCLE_EVIDENCE_FIELDS) {
+      const value = source?.[field];
+      if (value !== undefined && value !== null) {
+        evidence.push([scope, field, fingerprintEvidenceValue(value)]);
+      }
     }
   }
-  return attributes;
+  return evidence;
 }
-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 observationFingerprint(observation) {
+  const { normalized, transaction } = observation;
+  return JSON.stringify({
+    status: normalized.status ?? null,
+    txid: normalized.txid ?? null,
+    amount: normalized.amount ?? null,
+    feeAmount: normalized.feeAmount ?? null,
+    feeCurrency: normalized.feeCurrency ?? null,
+    address: normalized.address ?? null,
+    network: normalized.network ?? null,
+    exchangeTimestamp: normalized.exchangeTimestamp ?? null,
+    venueLifecycleEvidence: venueLifecycleEvidence(transaction)
   });
 }
-function parsePositiveInt(value, fallback) {
-  if (!value) {
-    return fallback;
+
+class WithdrawalObservationTracker {
+  #fingerprints = new Map;
+  #maxEntries;
+  #missingIdSequence = 0n;
+  constructor(options) {
+    const maxEntries = options?.maxEntries ?? DEFAULT_WITHDRAWAL_OBSERVATION_TRACKER_MAX_ENTRIES;
+    this.#maxEntries = Number.isFinite(maxEntries) ? Math.max(1, Math.floor(maxEntries)) : DEFAULT_WITHDRAWAL_OBSERVATION_TRACKER_MAX_ENTRIES;
+  }
+  shouldArchive(observation) {
+    const externalId = observation.normalized.externalId?.trim();
+    const identity = JSON.stringify([
+      observation.exchange.trim().toLowerCase() || "unknown",
+      observation.accountSelector?.trim() || "unknown",
+      observation.assetSymbol?.trim().toUpperCase() || "unknown",
+      externalId || `missing:${++this.#missingIdSequence}`
+    ]);
+    const fingerprint = observationFingerprint(observation);
+    if (this.#fingerprints.get(identity) === fingerprint) {
+      return false;
+    }
+    this.#fingerprints.delete(identity);
+    this.#fingerprints.set(identity, fingerprint);
+    while (this.#fingerprints.size > this.#maxEntries) {
+      const oldest = this.#fingerprints.keys().next().value;
+      if (oldest === undefined)
+        break;
+      this.#fingerprints.delete(oldest);
+    }
+    return true;
+  }
+  getSize() {
+    return this.#fingerprints.size;
   }
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 // src/helpers/account-balance-archive-poller.ts
 var DEFAULT_CONFIG = {
@@ -316332,6 +316491,7 @@ class AccountBalanceArchivePoller {
       this.params.metrics?.recordGauge("cex_account_balance_poll_last_success_timestamp_seconds", Math.floor(successMs / 1000), labels);
       this.#recordFreshness(labels, successMs, successMs);
     } catch (error) {
+      rethrowArchiveDurabilityError(error);
       this.params.metrics?.recordCounter("cex_account_balance_poll_failures_total", 1, labels);
       const now3 = Date.now();
       const lastSuccess = this.#lastSuccessMs.get(this.#targetKey(target));
@@ -316361,6 +316521,7 @@ class AccountBalanceArchivePoller {
     try {
       await this.pollAllOnce();
     } catch (error) {
+      rethrowArchiveDurabilityError(error);
       log.error("Account balance archive poller tick failed", error);
     } finally {
       if (!this.#stopped) {
@@ -316424,6 +316585,7 @@ class FillArchivePoller {
     try {
       await this.pollTrackedOnce();
     } catch (error) {
+      rethrowArchiveDurabilityError(error);
       log.error("Fill archive poller tick failed", error);
     } finally {
       this.#running = false;
@@ -316843,32 +317005,6 @@ var grpc14 = __toESM(require_src3(), 1);
 // src/handlers/execute-action/deposit.ts
 var grpc3 = __toESM(require_src3(), 1);
 
-// src/helpers/shared/errors.ts
-var MAX_ERROR_DETAIL_LENGTH = 512;
-function getErrorMessage(error) {
-  return error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
-}
-function errorClassName(error) {
-  if (!(error instanceof Error)) {
-    return;
-  }
-  const name = error.constructor?.name || error.name;
-  return name && name !== "Error" ? name : undefined;
-}
-function sanitizeErrorDetail(error) {
-  const className = errorClassName(error);
-  const message = getErrorMessage(error);
-  const detail = className ? `${className}: ${message}` : message;
-  return detail.replace(/\s+/g, " ").trim().slice(0, MAX_ERROR_DETAIL_LENGTH);
-}
-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] : [];
@@ -331395,7 +331531,8 @@ async function handleCreateOrder(ctx) {
     archiveOrderExecutionInBackground(brokerArchiver, createOrderContext, order, undefined, { marketMetadataHash });
     ctx.wrappedCallback(null, { result: JSON.stringify({ ...order }) });
   } catch (error48) {
-    safeLogError("Order Creation failed", error48);
+    rethrowArchiveDurabilityError(error48);
+    safeLogRedactedError("Order Creation failed", error48);
     const failedCreateContext = {
       action: "CreateOrder",
       cex: cex3,
@@ -332669,8 +332806,8 @@ class BinanceSpotUserDataStream {
     }
     if ("status" in message && typeof message.status === "number" && message.status !== 200) {
       const errorMessage = message.error?.msg ?? message.error?.message ?? `Binance user-data request failed with status ${message.status}`;
-      const errorCode = message.error?.code;
-      this.fail(new Error(typeof errorCode === "number" ? `${errorMessage} (code ${errorCode})` : errorMessage));
+      const errorCode2 = message.error?.code;
+      this.fail(new Error(typeof errorCode2 === "number" ? `${errorMessage} (code ${errorCode2})` : errorMessage));
       return;
     }
     if (!("event" in message) || !message.event) {
@@ -332822,19 +332959,26 @@ class OhlcvBarTracker {
     if (!firstBar || !lastBar) {
       return [];
     }
-    if (this.lastOpenTimeMs !== null && lastBar.openTimeMs < this.lastOpenTimeMs) {
+    const lastOpenTimeMs = this.lastOpenTimeMs;
+    if (lastOpenTimeMs !== null && lastBar.openTimeMs < lastOpenTimeMs) {
+      return [];
+    }
+    const barsToProcess = lastOpenTimeMs === null ? bars : bars.filter((bar) => bar.openTimeMs >= lastOpenTimeMs);
+    const firstBarToProcess = barsToProcess[0];
+    const lastBarToProcess = barsToProcess[barsToProcess.length - 1];
+    if (!firstBarToProcess || !lastBarToProcess) {
       return [];
     }
     const candidates = [];
-    if (this.lastBar !== null && this.lastOpenTimeMs !== null && !bars.some((bar) => bar.openTimeMs === this.lastOpenTimeMs) && this.lastOpenTimeMs < firstBar.openTimeMs) {
+    if (this.lastBar !== null && lastOpenTimeMs !== null && lastOpenTimeMs < firstBarToProcess.openTimeMs) {
       candidates.push({
         bar: this.lastBar,
         isClosed: true,
         brokerVersion
       });
     }
-    for (let index2 = 0;index2 < bars.length - 1; index2 += 1) {
-      const bar = bars[index2];
+    for (let index2 = 0;index2 < barsToProcess.length - 1; index2 += 1) {
+      const bar = barsToProcess[index2];
       if (bar) {
         candidates.push({
           bar,
@@ -332844,12 +332988,12 @@ class OhlcvBarTracker {
       }
     }
     candidates.push({
-      bar: lastBar,
+      bar: lastBarToProcess,
       isClosed: false,
       brokerVersion
     });
-    this.lastOpenTimeMs = lastBar.openTimeMs;
-    this.lastBar = lastBar;
+    this.lastOpenTimeMs = lastBarToProcess.openTimeMs;
+    this.lastBar = lastBarToProcess;
     return candidates;
   }
 }
@@ -333261,6 +333405,7 @@ function archiveOrderbookInBackground(archiver, otelMetrics, input, options) {
         recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
       }
     } catch (error48) {
+      rethrowArchiveDurabilityError(error48);
       log.warn("Failed to archive orderbook snapshot", { error: error48 });
     }
   });
@@ -333288,6 +333433,7 @@ function archiveOhlcvInBackground(archiver, otelMetrics, tracker, input) {
         recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
       }
     } catch (error48) {
+      rethrowArchiveDurabilityError(error48);
       log.warn("Failed to archive OHLCV candle", { error: error48 });
     }
   });
@@ -333314,6 +333460,7 @@ function archiveMarketRowsInBackground(archiver, otelMetrics, stream4, input, en
         recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
       }
     } catch (error48) {
+      rethrowArchiveDurabilityError(error48);
       log.warn(`Failed to archive ${stream4} market data`, { error: error48 });
     }
   });
@@ -333349,7 +333496,6 @@ function resolveOhlcvBootstrapLimit(optionValue) {
   }
   return Math.min(parsed, MAX_OHLCV_BOOTSTRAP_LIMIT);
 }
-
 // src/helpers/market-data-archive/ohlcv-history.ts
 function supportsFetchOhlcv(broker) {
   const fetchOHLCV = broker.fetchOHLCV;
@@ -333834,7 +333980,7 @@ function createSubscribeHandler(deps) {
               }
             }
             while (ohlcvStreamActive && !isStreamClosed()) {
-              const data = await broker.fetchOHLCVWs(resolvedSymbol, timeframe);
+              const data = await broker.watchOHLCV(resolvedSymbol, timeframe);
               const receivedTimestamp = Date.now();
               if (!await writeSubscribeFrame(call, isStreamClosed, {
                 data: JSON.stringify(data),