@usherlabs/cex-broker 0.2.26 → 0.2.28

package/dist/index.js

@@ -274246,6 +274246,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);
@@ -274266,7 +274325,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);
@@ -274758,7 +274816,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)
     })
   };
@@ -274890,386 +274948,126 @@ 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
+import { closeSync, fsyncSync, openSync, writeSync } from "fs";
+import { request as httpRequest2 } from "http";
+import { request as httpsRequest2 } from "https";
+
+// node_modules/@opentelemetry/api-logs/build/esm/types/LogRecord.js
+var SeverityNumber2;
+(function(SeverityNumber3) {
+  SeverityNumber3[SeverityNumber3["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  SeverityNumber3[SeverityNumber3["TRACE"] = 1] = "TRACE";
+  SeverityNumber3[SeverityNumber3["TRACE2"] = 2] = "TRACE2";
+  SeverityNumber3[SeverityNumber3["TRACE3"] = 3] = "TRACE3";
+  SeverityNumber3[SeverityNumber3["TRACE4"] = 4] = "TRACE4";
+  SeverityNumber3[SeverityNumber3["DEBUG"] = 5] = "DEBUG";
+  SeverityNumber3[SeverityNumber3["DEBUG2"] = 6] = "DEBUG2";
+  SeverityNumber3[SeverityNumber3["DEBUG3"] = 7] = "DEBUG3";
+  SeverityNumber3[SeverityNumber3["DEBUG4"] = 8] = "DEBUG4";
+  SeverityNumber3[SeverityNumber3["INFO"] = 9] = "INFO";
+  SeverityNumber3[SeverityNumber3["INFO2"] = 10] = "INFO2";
+  SeverityNumber3[SeverityNumber3["INFO3"] = 11] = "INFO3";
+  SeverityNumber3[SeverityNumber3["INFO4"] = 12] = "INFO4";
+  SeverityNumber3[SeverityNumber3["WARN"] = 13] = "WARN";
+  SeverityNumber3[SeverityNumber3["WARN2"] = 14] = "WARN2";
+  SeverityNumber3[SeverityNumber3["WARN3"] = 15] = "WARN3";
+  SeverityNumber3[SeverityNumber3["WARN4"] = 16] = "WARN4";
+  SeverityNumber3[SeverityNumber3["ERROR"] = 17] = "ERROR";
+  SeverityNumber3[SeverityNumber3["ERROR2"] = 18] = "ERROR2";
+  SeverityNumber3[SeverityNumber3["ERROR3"] = 19] = "ERROR3";
+  SeverityNumber3[SeverityNumber3["ERROR4"] = 20] = "ERROR4";
+  SeverityNumber3[SeverityNumber3["FATAL"] = 21] = "FATAL";
+  SeverityNumber3[SeverityNumber3["FATAL2"] = 22] = "FATAL2";
+  SeverityNumber3[SeverityNumber3["FATAL3"] = 23] = "FATAL3";
+  SeverityNumber3[SeverityNumber3["FATAL4"] = 24] = "FATAL4";
+})(SeverityNumber2 || (SeverityNumber2 = {}));
+// node_modules/@opentelemetry/api-logs/build/esm/NoopLogger.js
+class NoopLogger2 {
+  emit(_logRecord) {}
+}
+var NOOP_LOGGER2 = new NoopLogger2;
+// node_modules/@opentelemetry/api-logs/build/esm/internal/global-utils.js
+var GLOBAL_LOGS_API_KEY2 = Symbol.for("io.opentelemetry.js.api.logs");
+var _global3 = globalThis;
+function makeGetter2(requiredVersion, instance, fallback) {
+  return (version3) => version3 === requiredVersion ? instance : fallback;
+}
+var API_BACKWARDS_COMPATIBILITY_VERSION2 = 1;
+
+// node_modules/@opentelemetry/api-logs/build/esm/NoopLoggerProvider.js
+class NoopLoggerProvider2 {
+  getLogger(_name, _version, _options) {
+    return new NoopLogger2;
   }
-  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;
+var NOOP_LOGGER_PROVIDER2 = new NoopLoggerProvider2;
+
+// node_modules/@opentelemetry/api-logs/build/esm/ProxyLogger.js
+class ProxyLogger2 {
+  constructor(provider, name, version3, options) {
+    this._provider = provider;
+    this.name = name;
+    this.version = version3;
+    this.options = options;
   }
-  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) {
-      log.warn("Failed to archive subscribe stream event", {
-        error: archiveError
-      });
+  emit(logRecord) {
+    this._getLogger().emit(logRecord);
+  }
+  _getLogger() {
+    if (this._delegate) {
+      return this._delegate;
     }
-  });
+    const logger = this._provider._getDelegateLogger(this.name, this.version, this.options);
+    if (!logger) {
+      return NOOP_LOGGER2;
+    }
+    this._delegate = logger;
+    return this._delegate;
+  }
 }
-function archiveTransferEventInBackground(archiver, input) {
-  if (!archiver?.isEnabled()) {
-    return;
+
+// node_modules/@opentelemetry/api-logs/build/esm/ProxyLoggerProvider.js
+class ProxyLoggerProvider2 {
+  getLogger(name, version3, options) {
+    var _a3;
+    return (_a3 = this._getDelegateLogger(name, version3, options)) !== null && _a3 !== undefined ? _a3 : new ProxyLogger2(this, name, version3, options);
+  }
+  _getDelegate() {
+    var _a3;
+    return (_a3 = this._delegate) !== null && _a3 !== undefined ? _a3 : NOOP_LOGGER_PROVIDER2;
+  }
+  _setDelegate(delegate) {
+    this._delegate = delegate;
+  }
+  _getDelegateLogger(name, version3, options) {
+    var _a3;
+    return (_a3 = this._delegate) === null || _a3 === undefined ? undefined : _a3.getLogger(name, version3, options);
   }
-  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) {
-      log.warn("Failed to archive transfer event", { error: archiveError });
-    }
-  });
 }
-function archiveWithdrawalObservationsInBackground(archiver, tracker, input) {
-  try {
-    if (!archiver?.isEnabled() || !Array.isArray(input.transactions)) {
-      return;
+
+// node_modules/@opentelemetry/api-logs/build/esm/api/logs.js
+class LogsAPI2 {
+  constructor() {
+    this._proxyLoggerProvider = new ProxyLoggerProvider2;
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new LogsAPI2;
     }
-    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
-        }
-      });
+    return this._instance;
+  }
+  setGlobalLoggerProvider(provider) {
+    if (_global3[GLOBAL_LOGS_API_KEY2]) {
+      return this.getLoggerProvider();
     }
-  } catch (archiveError) {
-    log.warn("Failed to archive withdrawal observations", {
-      error: archiveError
-    });
+    _global3[GLOBAL_LOGS_API_KEY2] = makeGetter2(API_BACKWARDS_COMPATIBILITY_VERSION2, provider, NOOP_LOGGER_PROVIDER2);
+    this._proxyLoggerProvider._setDelegate(provider);
+    return provider;
   }
-}
-async function captureMarketMetadataSnapshot(archiver, broker, input) {
-  if (!archiver?.canPersistMarketMetadataSnapshot()) {
-    return;
-  }
-  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
-import { request as httpRequest2 } from "http";
-import { request as httpsRequest2 } from "https";
-
-// node_modules/@opentelemetry/api-logs/build/esm/types/LogRecord.js
-var SeverityNumber2;
-(function(SeverityNumber3) {
-  SeverityNumber3[SeverityNumber3["UNSPECIFIED"] = 0] = "UNSPECIFIED";
-  SeverityNumber3[SeverityNumber3["TRACE"] = 1] = "TRACE";
-  SeverityNumber3[SeverityNumber3["TRACE2"] = 2] = "TRACE2";
-  SeverityNumber3[SeverityNumber3["TRACE3"] = 3] = "TRACE3";
-  SeverityNumber3[SeverityNumber3["TRACE4"] = 4] = "TRACE4";
-  SeverityNumber3[SeverityNumber3["DEBUG"] = 5] = "DEBUG";
-  SeverityNumber3[SeverityNumber3["DEBUG2"] = 6] = "DEBUG2";
-  SeverityNumber3[SeverityNumber3["DEBUG3"] = 7] = "DEBUG3";
-  SeverityNumber3[SeverityNumber3["DEBUG4"] = 8] = "DEBUG4";
-  SeverityNumber3[SeverityNumber3["INFO"] = 9] = "INFO";
-  SeverityNumber3[SeverityNumber3["INFO2"] = 10] = "INFO2";
-  SeverityNumber3[SeverityNumber3["INFO3"] = 11] = "INFO3";
-  SeverityNumber3[SeverityNumber3["INFO4"] = 12] = "INFO4";
-  SeverityNumber3[SeverityNumber3["WARN"] = 13] = "WARN";
-  SeverityNumber3[SeverityNumber3["WARN2"] = 14] = "WARN2";
-  SeverityNumber3[SeverityNumber3["WARN3"] = 15] = "WARN3";
-  SeverityNumber3[SeverityNumber3["WARN4"] = 16] = "WARN4";
-  SeverityNumber3[SeverityNumber3["ERROR"] = 17] = "ERROR";
-  SeverityNumber3[SeverityNumber3["ERROR2"] = 18] = "ERROR2";
-  SeverityNumber3[SeverityNumber3["ERROR3"] = 19] = "ERROR3";
-  SeverityNumber3[SeverityNumber3["ERROR4"] = 20] = "ERROR4";
-  SeverityNumber3[SeverityNumber3["FATAL"] = 21] = "FATAL";
-  SeverityNumber3[SeverityNumber3["FATAL2"] = 22] = "FATAL2";
-  SeverityNumber3[SeverityNumber3["FATAL3"] = 23] = "FATAL3";
-  SeverityNumber3[SeverityNumber3["FATAL4"] = 24] = "FATAL4";
-})(SeverityNumber2 || (SeverityNumber2 = {}));
-// node_modules/@opentelemetry/api-logs/build/esm/NoopLogger.js
-class NoopLogger2 {
-  emit(_logRecord) {}
-}
-var NOOP_LOGGER2 = new NoopLogger2;
-// node_modules/@opentelemetry/api-logs/build/esm/internal/global-utils.js
-var GLOBAL_LOGS_API_KEY2 = Symbol.for("io.opentelemetry.js.api.logs");
-var _global3 = globalThis;
-function makeGetter2(requiredVersion, instance, fallback) {
-  return (version3) => version3 === requiredVersion ? instance : fallback;
-}
-var API_BACKWARDS_COMPATIBILITY_VERSION2 = 1;
-
-// node_modules/@opentelemetry/api-logs/build/esm/NoopLoggerProvider.js
-class NoopLoggerProvider2 {
-  getLogger(_name, _version, _options) {
-    return new NoopLogger2;
-  }
-}
-var NOOP_LOGGER_PROVIDER2 = new NoopLoggerProvider2;
-
-// node_modules/@opentelemetry/api-logs/build/esm/ProxyLogger.js
-class ProxyLogger2 {
-  constructor(provider, name, version3, options) {
-    this._provider = provider;
-    this.name = name;
-    this.version = version3;
-    this.options = options;
-  }
-  emit(logRecord) {
-    this._getLogger().emit(logRecord);
-  }
-  _getLogger() {
-    if (this._delegate) {
-      return this._delegate;
-    }
-    const logger = this._provider._getDelegateLogger(this.name, this.version, this.options);
-    if (!logger) {
-      return NOOP_LOGGER2;
-    }
-    this._delegate = logger;
-    return this._delegate;
-  }
-}
-
-// node_modules/@opentelemetry/api-logs/build/esm/ProxyLoggerProvider.js
-class ProxyLoggerProvider2 {
-  getLogger(name, version3, options) {
-    var _a3;
-    return (_a3 = this._getDelegateLogger(name, version3, options)) !== null && _a3 !== undefined ? _a3 : new ProxyLogger2(this, name, version3, options);
-  }
-  _getDelegate() {
-    var _a3;
-    return (_a3 = this._delegate) !== null && _a3 !== undefined ? _a3 : NOOP_LOGGER_PROVIDER2;
-  }
-  _setDelegate(delegate) {
-    this._delegate = delegate;
-  }
-  _getDelegateLogger(name, version3, options) {
-    var _a3;
-    return (_a3 = this._delegate) === null || _a3 === undefined ? undefined : _a3.getLogger(name, version3, options);
-  }
-}
-
-// node_modules/@opentelemetry/api-logs/build/esm/api/logs.js
-class LogsAPI2 {
-  constructor() {
-    this._proxyLoggerProvider = new ProxyLoggerProvider2;
-  }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new LogsAPI2;
-    }
-    return this._instance;
-  }
-  setGlobalLoggerProvider(provider) {
-    if (_global3[GLOBAL_LOGS_API_KEY2]) {
-      return this.getLoggerProvider();
-    }
-    _global3[GLOBAL_LOGS_API_KEY2] = makeGetter2(API_BACKWARDS_COMPATIBILITY_VERSION2, provider, NOOP_LOGGER_PROVIDER2);
-    this._proxyLoggerProvider._setDelegate(provider);
-    return provider;
-  }
-  getLoggerProvider() {
-    var _a3, _b2;
-    return (_b2 = (_a3 = _global3[GLOBAL_LOGS_API_KEY2]) === null || _a3 === undefined ? undefined : _a3.call(_global3, API_BACKWARDS_COMPATIBILITY_VERSION2)) !== null && _b2 !== undefined ? _b2 : this._proxyLoggerProvider;
+  getLoggerProvider() {
+    var _a3, _b2;
+    return (_b2 = (_a3 = _global3[GLOBAL_LOGS_API_KEY2]) === null || _a3 === undefined ? undefined : _a3.call(_global3, API_BACKWARDS_COMPATIBILITY_VERSION2)) !== null && _b2 !== undefined ? _b2 : this._proxyLoggerProvider;
   }
   getLogger(name, version3, options) {
     return this.getLoggerProvider().getLogger(name, version3, options);
@@ -275283,18 +275081,6 @@ class LogsAPI2 {
 // node_modules/@opentelemetry/api-logs/build/esm/index.js
 var logs2 = LogsAPI2.getInstance();
 
-// 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",
@@ -275305,29 +275091,28 @@ var BROKER_EXECUTION_ARCHIVE_TABLES = new Set([
 function isBrokerExecutionArchiveTable(table) {
   return BROKER_EXECUTION_ARCHIVE_TABLES.has(table);
 }
+
+class BrokerExecutionArchiveDurabilityError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BrokerExecutionArchiveDurabilityError";
+  }
+}
+function rethrowArchiveDurabilityError(error) {
+  if (error instanceof BrokerExecutionArchiveDurabilityError) {
+    throw error;
+  }
+}
 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;
+var SHED_WARN_INTERVAL_MS = 60000;
 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}`;
+  return process.env.CEX_BROKER_ARCHIVE_FORWARDER_URL?.trim() || undefined;
 }
 
 class BrokerExecutionArchiver {
@@ -275335,6 +275120,8 @@ class BrokerExecutionArchiver {
   otelLogs;
   otelMetrics;
   forwarderUrl;
+  deadLetterPath;
+  deadLetterFd;
   maxQueueSize;
   batchSize;
   flushIntervalMs;
@@ -275348,8 +275135,8 @@ class BrokerExecutionArchiver {
   };
   flushTimer = null;
   flushInFlight = null;
+  lastShedWarnAtMs = 0;
   closed = false;
-  loggedMissingMarketForwarder = false;
   enabled;
   forwarderAuthToken;
   constructor(options) {
@@ -275357,61 +275144,81 @@ class BrokerExecutionArchiver {
     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) {
+    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 {
+      this.deadLetterFd = openSync(this.deadLetterPath, "a", 384);
+    } catch {
+      throw new Error("Broker execution archive cannot open CEX_BROKER_ARCHIVE_DEAD_LETTER_PATH for append");
+    }
+    try {
       this.flushTimer = setInterval(() => {
-        this.flush().catch((error) => {
-          log.warn("Broker execution archive flush failed", { error });
-        });
+        this.flush();
       }, this.flushIntervalMs);
       this.flushTimer.unref?.();
+      log.info("Broker execution archive enabled", {
+        enabled: true,
+        otel_mirror_enabled: Boolean(this.otelLogs?.isOtelEnabled())
+      });
+    } catch (error) {
+      this.closeLossJournal();
+      throw error;
     }
   }
   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 });
+    return new BrokerExecutionArchiver({ ...options, enabled: true });
   }
   getDeploymentId() {
     return this.deploymentId;
   }
   isEnabled() {
-    return this.enabled && !this.closed && (Boolean(this.otelLogs) || Boolean(this.forwarderUrl));
+    return this.enabled && !this.closed;
   }
   canPersistMarketMetadataSnapshot() {
-    return this.isEnabled() && (Boolean(this.otelLogs?.isOtelEnabled()) || Boolean(this.forwarderUrl));
+    return this.isEnabled();
   }
   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) {
+    if (!this.enabled || this.closed) {
       return;
     }
     if (this.queue.length >= this.maxQueueSize) {
-      this.queue.shift();
+      const shedRow = this.queue[0];
+      if (shedRow) {
+        this.appendLossRecords([shedRow], "queue_shed");
+        this.queue.shift();
+      }
       this.stats.shed += 1;
       this.recordArchiveMetric("cex_archive_rows_shed_total", {
-        table: row.table
+        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;
+      }
     }
     this.queue.push(row);
     this.stats.enqueued += 1;
@@ -275419,9 +275226,7 @@ class BrokerExecutionArchiver {
       table: row.table
     });
     if (this.queue.length >= this.batchSize) {
-      this.flush().catch((error) => {
-        log.warn("Broker execution archive flush failed", { error });
-      });
+      this.flush();
     }
   }
   enqueueInBackground(row) {
@@ -275446,22 +275251,37 @@ class BrokerExecutionArchiver {
     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;
+    }
+    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 };
@@ -275469,15 +275289,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) {
@@ -275514,111 +275379,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: SeverityNumber2.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: SeverityNumber2.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 = {
@@ -275712,6 +275873,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));
@@ -275741,6 +275903,7 @@ class AccountBalanceArchivePoller {
     try {
       await this.pollAllOnce();
     } catch (error) {
+      rethrowArchiveDurabilityError(error);
       log.error("Account balance archive poller tick failed", error);
     } finally {
       if (!this.#stopped) {
@@ -275804,6 +275967,7 @@ class FillArchivePoller {
     try {
       await this.pollTrackedOnce();
     } catch (error) {
+      rethrowArchiveDurabilityError(error);
       log.error("Fill archive poller tick failed", error);
     } finally {
       this.#running = false;
@@ -279795,32 +279959,6 @@ import * as grpc14 from "@grpc/grpc-js";
 // src/handlers/execute-action/deposit.ts
 import * as grpc3 from "@grpc/grpc-js";
 
-// 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(context3, error) {
-  try {
-    log.error(context3, { error });
-  } catch {
-    console.error(context3, error);
-  }
-}
-
 // src/helpers/treasury-discovery.ts
 function callArgs(args, params) {
   const argsArray = Array.isArray(args) ? [...args] : [];
@@ -294347,7 +294485,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,
@@ -295622,8 +295761,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) {
@@ -295775,19 +295914,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,
@@ -295797,12 +295943,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;
   }
 }
@@ -296214,6 +296360,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 });
     }
   });
@@ -296241,6 +296388,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 });
     }
   });
@@ -296267,6 +296415,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 });
     }
   });
@@ -296302,7 +296451,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;
@@ -296787,7 +296935,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),
@@ -297412,4 +297560,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=1D08CFF8FA968C4064756E2164756E21
+//# debugId=9DC3823C033EB0C864756E2164756E21