@usherlabs/cex-broker 0.2.19 → 0.2.21

package/dist/index.js

@@ -274531,6 +274531,8 @@ function hashMarketMetadata(payload) {
 
 // src/helpers/broker-execution-archive/types.ts
 var BROKER_WRITE_SOURCE = "broker_write";
+var ARCHIVE_SCHEMA_VERSION = "1";
+var FILL_EVENT_KIND = "trade_history_fill";
 
 // src/helpers/broker-execution-archive/rows.ts
 function firstString2(...values2) {
@@ -274544,6 +274546,26 @@ function firstString2(...values2) {
   }
   return;
 }
+function firstNumber2(...values2) {
+  for (const value of values2) {
+    const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+    if (Number.isFinite(numeric)) {
+      return numeric;
+    }
+  }
+  return;
+}
+function normalizeTimestamp2(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  const ms = firstNumber2(value);
+  if (ms === undefined) {
+    return;
+  }
+  const date = new Date(ms);
+  return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
 function compactUndefined2(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
 }
@@ -274608,6 +274630,99 @@ function buildSubscribeStreamArchiveRow(input) {
     })
   };
 }
+function quantityString(...values2) {
+  return firstString2(...values2);
+}
+function buildTransferEventArchiveRow(input) {
+  const { tags, transfer } = input;
+  return {
+    table: "broker_execution.transfer_events",
+    row: compactUndefined2({
+      ...tags,
+      schema_version: ARCHIVE_SCHEMA_VERSION,
+      event_kind: transfer.eventKind,
+      lifecycle_action: transfer.lifecycleAction,
+      status: transfer.status ?? "",
+      asset_symbol: tags.symbol,
+      amount: transfer.amount,
+      address: transfer.address,
+      network: transfer.network,
+      external_id: transfer.externalId ?? "",
+      txid: transfer.txid,
+      result_index: transfer.resultIndex ?? 0,
+      fee_amount: transfer.feeAmount,
+      fee_currency: transfer.feeCurrency,
+      exchange_timestamp: transfer.exchangeTimestamp,
+      error_summary: transfer.errorSummary,
+      payload_json: JSON.stringify(transfer.payload)
+    })
+  };
+}
+function normalizeCcxtTransactionForArchive(transaction) {
+  const record = asRecord(transaction);
+  const info = asRecord(record?.info);
+  const fee = asRecord(record?.fee);
+  return compactUndefined2({
+    externalId: firstString2(record?.id, info?.id, record?.txid, info?.txId),
+    txid: firstString2(record?.txid, info?.txId, info?.txid, info?.tx_hash),
+    address: firstString2(record?.address, record?.addressTo, info?.address),
+    network: firstString2(record?.network, info?.network),
+    amount: quantityString(info?.amount, record?.amount),
+    assetSymbol: firstString2(record?.currency, info?.coin, info?.asset),
+    status: firstString2(record?.status, info?.status)?.toLowerCase(),
+    feeAmount: quantityString(fee?.cost, record?.feeCost),
+    feeCurrency: firstString2(fee?.currency, record?.feeCurrency),
+    exchangeTimestamp: normalizeTimestamp2(firstValueForTransfer(record?.timestamp, record?.datetime, info?.applyTime))
+  });
+}
+function firstValueForTransfer(...values2) {
+  return values2.find((value) => value !== undefined && value !== null);
+}
+function buildFillEventArchiveRow(input) {
+  const { tags, fill } = input;
+  return {
+    table: "broker_execution.fill_events",
+    row: compactUndefined2({
+      ...tags,
+      schema_version: ARCHIVE_SCHEMA_VERSION,
+      event_kind: FILL_EVENT_KIND,
+      order_id: fill.orderId ?? "",
+      client_order_id: fill.clientOrderId,
+      fill_id: fill.fillId,
+      fill_index: fill.fillIndex ?? 0,
+      side: fill.side,
+      order_type: fill.orderType,
+      price: fill.price,
+      base_quantity: fill.baseQuantity,
+      quote_quantity: fill.quoteQuantity,
+      fee_amount: fill.feeAmount,
+      fee_currency: fill.feeCurrency,
+      fee_rate: fill.feeRate,
+      exchange_timestamp: fill.exchangeTimestamp,
+      payload_json: JSON.stringify(fill.payload)
+    })
+  };
+}
+function normalizeCcxtTradeForArchive(trade) {
+  const record = asRecord(trade);
+  const info = asRecord(record?.info);
+  const fee = asRecord(record?.fee);
+  return {
+    orderId: firstString2(record?.order, info?.orderId, info?.orderID),
+    clientOrderId: firstString2(record?.clientOrderId, info?.clientOrderId, info?.origClientOrderId),
+    fillId: firstString2(record?.id, info?.id, info?.tradeId),
+    side: firstString2(record?.side, info?.side)?.toLowerCase(),
+    orderType: firstString2(record?.type, info?.type)?.toLowerCase(),
+    price: quantityString(info?.price, record?.price),
+    baseQuantity: quantityString(info?.qty, record?.amount),
+    quoteQuantity: quantityString(info?.quoteQty, record?.cost),
+    feeAmount: quantityString(fee?.cost, info?.commission),
+    feeCurrency: firstString2(fee?.currency, info?.commissionAsset),
+    feeRate: quantityString(fee?.rate),
+    exchangeTimestamp: normalizeTimestamp2(firstValueForTransfer(record?.timestamp, record?.datetime, info?.time)),
+    payload: trade
+  };
+}
 function buildMarketMetadataSnapshotRow(input) {
   const redactedSnapshot = redactStreamPayload(input.marketSnapshot);
   const metadataHash = hashMarketMetadata(redactedSnapshot);
@@ -274676,6 +274791,25 @@ function archiveSubscribeStreamInBackground(archiver, input) {
     }
   });
 }
+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) {
+      log.warn("Failed to archive transfer event", { error: archiveError });
+    }
+  });
+}
 async function captureMarketMetadataSnapshot(archiver, broker, input) {
   if (!archiver?.canPersistMarketMetadataSnapshot()) {
     return;
@@ -274721,6 +274855,10 @@ async function captureMarketMetadataSnapshot(archiver, broker, input) {
     return;
   }
 }
+// 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) {
@@ -275054,11 +275192,27 @@ class BrokerExecutionArchiver {
       }
     }
     this.stats.flushed += batch.length;
+    this.recordFlushHealth(batch);
     return true;
   }
-  async recordArchiveMetric(metricName, labels) {
+  recordFlushHealth(batch) {
+    const countByTable = new Map;
+    for (const entry of batch) {
+      countByTable.set(entry.table, (countByTable.get(entry.table) ?? 0) + 1);
+    }
+    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, 1, labels);
+      await this.otelMetrics?.recordCounter(metricName, value, labels);
+    } catch {}
+  }
+  async recordArchiveGauge(metricName, value) {
+    try {
+      await this.otelMetrics?.recordGauge(metricName, value, {});
     } catch {}
   }
   emitOtelLog(entry) {
@@ -275076,35 +275230,47 @@ class BrokerExecutionArchiver {
       log.warn("Broker execution archive OTLP emit failed", { error });
     }
   }
-  async postToForwarder(batch) {
+  postToForwarder(batch) {
     if (!this.forwarderUrl || batch.length === 0) {
-      return;
+      return Promise.resolve();
     }
-    const controller = new AbortController;
-    const timeout2 = setTimeout(() => controller.abort(), this.forwarderTimeoutMs);
+    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-type": "application/json",
+      "content-length": Buffer.byteLength(body)
     };
     if (this.forwarderAuthToken) {
       headers.authorization = `Bearer ${this.forwarderAuthToken}`;
     }
-    try {
-      const response = await fetch(this.forwarderUrl, {
+    return new Promise((resolve, reject) => {
+      const req = doRequest(url2, {
         method: "POST",
         headers,
-        body: JSON.stringify({
-          source: "broker_write",
-          deployment_id: this.deploymentId,
-          rows: batch
-        }),
-        signal: controller.signal
+        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();
+        });
       });
-      if (!response.ok) {
-        throw new Error(`Archive forwarder returned ${response.status} ${response.statusText}`);
-      }
-    } finally {
-      clearTimeout(timeout2);
-    }
+      req.on("error", reject);
+      req.on("timeout", () => {
+        req.destroy(new Error("Archive forwarder request timed out"));
+      });
+      req.write(body);
+      req.end();
+    });
   }
 }
 function flattenArchiveAttributes(entry) {
@@ -275143,6 +275309,159 @@ function parsePositiveInt(value, fallback) {
   const parsed = Number.parseInt(value, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
+// src/helpers/fill-archive-poller.ts
+var DEFAULT_CONFIG = {
+  pollIntervalMs: 60000,
+  lookbackMs: 24 * 60 * 60 * 1000,
+  tradesLimit: 500
+};
+function nextFillCursor(trades, currentSince) {
+  let next = currentSince;
+  for (const trade of trades) {
+    const ts = asRecord(trade)?.timestamp;
+    if (typeof ts === "number" && Number.isFinite(ts) && ts + 1 > next) {
+      next = ts + 1;
+    }
+  }
+  return next;
+}
+
+class FillArchivePoller {
+  params;
+  #timer = null;
+  #stopped = false;
+  #running = false;
+  #cursors = new Map;
+  #config;
+  constructor(params) {
+    this.params = params;
+    this.#config = { ...DEFAULT_CONFIG, ...params.config };
+  }
+  start() {
+    if (this.#timer || this.#stopped) {
+      return;
+    }
+    if (!this.params.archiver.isEnabled()) {
+      return;
+    }
+    log.info("\uD83E\uDDFE Fill archive poller started");
+    this.#timer = setTimeout(() => void this.#tick(), 0);
+    this.#timer.unref?.();
+  }
+  stop() {
+    this.#stopped = true;
+    if (this.#timer) {
+      clearTimeout(this.#timer);
+      this.#timer = null;
+    }
+  }
+  async#tick() {
+    if (this.#stopped || this.#running) {
+      return;
+    }
+    this.#running = true;
+    try {
+      await this.pollTrackedOnce();
+    } catch (error) {
+      log.error("Fill archive poller tick failed", error);
+    } finally {
+      this.#running = false;
+      if (!this.#stopped) {
+        this.#timer = setTimeout(() => void this.#tick(), this.#config.pollIntervalMs);
+        this.#timer.unref?.();
+      }
+    }
+  }
+  async pollTrackedOnce() {
+    for (const entry of this.params.tracker.list()) {
+      if (this.#stopped) {
+        break;
+      }
+      await this.#pollOne(entry.exchangeId, entry.accountLabel, entry.symbol);
+    }
+  }
+  async#pollOne(exchangeId, accountLabel, symbol) {
+    const account = resolveBrokerAccount(this.params.brokers[exchangeId], accountLabel);
+    if (!account) {
+      return;
+    }
+    const exchange = account.exchange;
+    if (typeof exchange.fetchMyTrades !== "function" || exchange.has?.fetchMyTrades === false) {
+      return;
+    }
+    const key = `${exchangeId}|${accountLabel}|${symbol}`;
+    const since = this.#cursors.get(key) ?? Date.now() - this.#config.lookbackMs;
+    let trades;
+    try {
+      trades = await exchange.fetchMyTrades(symbol, since, this.#config.tradesLimit);
+    } catch (error) {
+      this.params.metrics?.recordCounter("cex_fill_poller_errors_total", 1, {
+        exchange: exchangeId
+      });
+      log.warn("Fill archive poll failed", {
+        exchange: exchangeId,
+        account: accountLabel,
+        symbol,
+        error
+      });
+      return;
+    }
+    if (!Array.isArray(trades) || trades.length === 0) {
+      return;
+    }
+    trades.forEach((trade, fillIndex) => {
+      const tags = buildCommonArchiveTags({
+        deploymentId: this.params.archiver.getDeploymentId(),
+        accountSelector: accountLabel,
+        exchange: exchangeId,
+        symbol
+      });
+      this.params.archiver.enqueue(buildFillEventArchiveRow({
+        tags,
+        fill: { ...normalizeCcxtTradeForArchive(trade), fillIndex }
+      }));
+    });
+    this.params.metrics?.recordCounter("cex_fill_poller_trades_archived_total", trades.length, { exchange: exchangeId });
+    this.#cursors.set(key, nextFillCursor(trades, since));
+  }
+}
+
+// src/helpers/order-activity-tracker.ts
+var DEFAULT_MAX_AGE_MS = 6 * 60 * 60 * 1000;
+
+class OrderActivityTracker {
+  #entries = new Map;
+  #maxAgeMs;
+  constructor(options) {
+    this.#maxAgeMs = options?.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+  }
+  record(exchangeId, accountLabel, symbol, now3 = Date.now()) {
+    const exchange = exchangeId.trim().toLowerCase();
+    const trimmedSymbol = symbol.trim();
+    if (!exchange || !accountLabel.trim() || !trimmedSymbol) {
+      return;
+    }
+    const key = `${exchange}|${accountLabel}|${trimmedSymbol}`;
+    this.#entries.set(key, {
+      exchangeId: exchange,
+      accountLabel,
+      symbol: trimmedSymbol,
+      lastActivityAt: now3
+    });
+  }
+  list(now3 = Date.now()) {
+    const active = [];
+    for (const [key, entry] of this.#entries) {
+      if (now3 - entry.lastActivityAt > this.#maxAgeMs) {
+        this.#entries.delete(key);
+        continue;
+      }
+      active.push(entry);
+    }
+    return active;
+  }
+}
+
 // src/helpers/otel.ts
 var import_api14 = __toESM(require_src2(), 1);
 
@@ -278110,11 +278429,11 @@ var JsonMetricsSerializer = {
   }
 };
 // node_modules/@opentelemetry/exporter-logs-otlp-http/build/esm/platform/node/OTLPLogExporter.js
-var import_node_http2 = __toESM(require_index_node_http(), 1);
+var import_node_http3 = __toESM(require_index_node_http(), 1);
 
 class OTLPLogExporter extends import_otlp_exporter_base.OTLPExporterBase {
   constructor(config = {}) {
-    super(import_node_http2.createOtlpHttpExportDelegate(import_node_http2.convertLegacyHttpOptions(config, "LOGS", "v1/logs", {
+    super(import_node_http3.createOtlpHttpExportDelegate(import_node_http3.convertLegacyHttpOptions(config, "LOGS", "v1/logs", {
       "Content-Type": "application/json"
     }), JsonLogsSerializer));
   }
@@ -278209,11 +278528,11 @@ class OTLPMetricExporterBase extends import_otlp_exporter_base2.OTLPExporterBase
 }
 
 // node_modules/@opentelemetry/exporter-metrics-otlp-http/build/esm/platform/node/OTLPMetricExporter.js
-var import_node_http3 = __toESM(require_index_node_http(), 1);
+var import_node_http4 = __toESM(require_index_node_http(), 1);
 
 class OTLPMetricExporter extends OTLPMetricExporterBase {
   constructor(config) {
-    super(import_node_http3.createOtlpHttpExportDelegate(import_node_http3.convertLegacyHttpOptions(config ?? {}, "METRICS", "v1/metrics", {
+    super(import_node_http4.createOtlpHttpExportDelegate(import_node_http4.convertLegacyHttpOptions(config ?? {}, "METRICS", "v1/metrics", {
       "Content-Type": "application/json"
     }), JsonMetricsSerializer), config);
   }
@@ -292891,7 +293210,13 @@ function rejectWithGrpcError(ctx, error48, options) {
 
 // src/handlers/execute-action/deposit.ts
 async function handleDeposit(ctx) {
-  const { normalizedCex, symbol: symbol2, selectedBrokerAccount, broker } = ctx;
+  const {
+    normalizedCex,
+    symbol: symbol2,
+    selectedBrokerAccount,
+    broker,
+    brokerArchiver
+  } = ctx;
   if (!symbol2) {
     return ctx.wrappedCallback({
       code: grpc3.status.INVALID_ARGUMENT,
@@ -292954,6 +293279,32 @@ async function handleDeposit(ctx) {
         }, null);
       }
       const status4 = normalizeDepositStatus(depositField(deposit, ["status", "state"]));
+      const depositTxid = String(depositField(deposit, ["txid", "txId", "tx_hash", "txHash"]) ?? value.transactionHash);
+      const creditedAt = depositField(deposit, [
+        "creditedAt",
+        "credited_at",
+        "updated",
+        "updatedAt",
+        "timestamp",
+        "datetime"
+      ]);
+      archiveTransferEventInBackground(brokerArchiver, {
+        exchange: normalizedCex,
+        accountSelector: selectedBrokerAccount?.label,
+        assetSymbol: symbol2,
+        transfer: {
+          eventKind: "deposit",
+          lifecycleAction: "observe_deposit",
+          status: status4,
+          amount: observedAmount !== undefined ? String(observedAmount) : undefined,
+          address: String(observedAddress ?? value.recipientAddress),
+          network: depositNetwork?.exchangeNetworkId,
+          externalId: depositTxid,
+          txid: depositTxid,
+          exchangeTimestamp: typeof creditedAt === "string" ? creditedAt : undefined,
+          payload: deposit
+        }
+      });
       log.info(`Amount ${value.amount} at ${value.transactionHash} . Paid to ${value.recipientAddress}`);
       return ctx.wrappedCallback(null, {
         proof: ctx.verity.proof,
@@ -293367,7 +293718,8 @@ async function handleInternalTransfer(ctx) {
     symbol: symbol2,
     verity,
     useVerity,
-    verityProverUrl
+    verityProverUrl,
+    brokerArchiver
   } = ctx;
   if (!symbol2) {
     return ctx.wrappedCallback({
@@ -293415,6 +293767,21 @@ async function handleInternalTransfer(ctx) {
       }), verityHttpClientOverridePredicate);
     }
     const result = await transferBinanceInternal(sourceAccount, destAccount, symbol2, transferPayload.amount);
+    const normalized = normalizeCcxtTransactionForArchive(result);
+    archiveTransferEventInBackground(brokerArchiver, {
+      exchange: normalizedCex,
+      accountSelector: fromSelector,
+      assetSymbol: symbol2,
+      transfer: {
+        eventKind: "internal_transfer",
+        lifecycleAction: "submit_internal_transfer",
+        status: normalized.status ?? "ok",
+        amount: normalized.amount ?? String(transferPayload.amount),
+        network: "internal",
+        externalId: normalized.externalId,
+        payload: { from: fromSelector, to: toSelector, result }
+      }
+    });
     ctx.wrappedCallback(null, {
       proof: verity.proof,
       result: JSON.stringify(result)
@@ -293462,7 +293829,8 @@ async function handleCreateOrder(ctx) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = ctx;
   const verityProof = verity.proof;
   const orderValue = parsePayloadForAction(ctx, CreateOrderPayloadSchema);
@@ -293488,6 +293856,9 @@ async function handleCreateOrder(ctx) {
       side: resolution.side,
       requestedQuantity: resolution.amountBase ?? orderValue.amount
     };
+    if (selectedBrokerAccount?.label) {
+      orderActivityTracker?.record(cex3, selectedBrokerAccount.label, resolution.symbol);
+    }
     const telemetryIds = extractOrderTelemetryIds(orderValue.params);
     const submissionTimestamp = new Date().toISOString();
     const marketMetadataHash = await captureMarketMetadataSnapshot(brokerArchiver, broker, {
@@ -293552,7 +293923,8 @@ async function handleGetOrderDetails(ctx) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = ctx;
   const verityProof = verity.proof;
   const getOrderValue = parsePayloadForAction(ctx, GetOrderDetailsPayloadSchema);
@@ -293566,6 +293938,9 @@ async function handleGetOrderDetails(ctx) {
       }, null);
     }
     const orderDetails = await broker.fetchOrder(getOrderValue.orderId, symbol2, { ...getOrderValue.params });
+    if (selectedBrokerAccount?.label && symbol2) {
+      orderActivityTracker?.record(cex3, selectedBrokerAccount.label, symbol2);
+    }
     const getOrderContext = {
       action: "GetOrderDetails",
       cex: cex3,
@@ -293621,7 +293996,8 @@ async function handleCancelOrder(ctx) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = ctx;
   const verityProof = verity.proof;
   const cancelOrderValue = parsePayloadForAction(ctx, CancelOrderPayloadSchema);
@@ -293642,6 +294018,9 @@ async function handleCancelOrder(ctx) {
       ...extractOrderTelemetryIds(cancelOrderValue.params)
     };
     const cancelledOrder = await broker.cancelOrder(cancelOrderValue.orderId, symbol2, cancelOrderValue.params ?? {});
+    if (selectedBrokerAccount?.label && symbol2) {
+      orderActivityTracker?.record(cex3, selectedBrokerAccount.label, symbol2);
+    }
     emitOrderExecutionTelemetryInBackground(otelMetrics, cancelOrderContext, cancelledOrder);
     archiveOrderExecutionInBackground(brokerArchiver, cancelOrderContext, cancelledOrder);
     ctx.wrappedCallback(null, {
@@ -294272,7 +294651,8 @@ async function handleWithdraw(ctx) {
     applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    otelMetrics,
+    brokerArchiver
   } = ctx;
   const verityProof = verity.proof;
   if (!symbol2) {
@@ -294321,6 +294701,26 @@ async function handleWithdraw(ctx) {
       network: withdrawNetwork.exchangeNetworkId
     });
     log.info(`Withdraw Result: ${JSON.stringify(transaction)}`);
+    const normalized = normalizeCcxtTransactionForArchive(transaction);
+    archiveTransferEventInBackground(brokerArchiver, {
+      exchange: cex3,
+      accountSelector: selectedBrokerAccount?.label,
+      assetSymbol: normalized.assetSymbol ?? symbol2,
+      transfer: {
+        eventKind: "withdrawal",
+        lifecycleAction: "submit_withdrawal",
+        status: normalized.status,
+        amount: normalized.amount ?? String(transferValue.amount),
+        address: normalized.address ?? transferValue.recipientAddress,
+        network: normalized.network ?? withdrawNetwork.exchangeNetworkId,
+        externalId: normalized.externalId,
+        txid: normalized.txid,
+        feeAmount: normalized.feeAmount,
+        feeCurrency: normalized.feeCurrency,
+        exchangeTimestamp: normalized.exchangeTimestamp,
+        payload: transaction
+      }
+    });
     ctx.wrappedCallback(null, {
       proof: ctx.verity.proof,
       result: JSON.stringify({
@@ -294332,6 +294732,21 @@ async function handleWithdraw(ctx) {
     });
   } catch (error48) {
     safeLogError("Withdraw failed", error48);
+    archiveTransferEventInBackground(brokerArchiver, {
+      exchange: cex3,
+      accountSelector: selectedBrokerAccount?.label,
+      assetSymbol: symbol2,
+      transfer: {
+        eventKind: "withdrawal",
+        lifecycleAction: "submit_withdrawal",
+        status: "failed",
+        amount: String(transferValue.amount),
+        address: transferValue.recipientAddress,
+        network: withdrawNetwork.exchangeNetworkId,
+        errorSummary: getErrorMessage(error48),
+        payload: { recipientAddress: transferValue.recipientAddress }
+      }
+    });
     const code = mapCcxtErrorToGrpcStatus(error48) ?? grpc10.status.INTERNAL;
     ctx.wrappedCallback({
       code,
@@ -294379,7 +294794,8 @@ function createExecuteActionHandler(deps) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = deps;
   return async (call, callback) => {
     const startTime = Date.now();
@@ -294458,7 +294874,8 @@ function createExecuteActionHandler(deps) {
         useVerity,
         verityProverUrl,
         otelMetrics,
-        brokerArchiver
+        brokerArchiver,
+        orderActivityTracker
       };
       if (action === Action.Call) {
         const handled = await handleOrderBookCall(preludeCtx);
@@ -296048,7 +296465,7 @@ var CEX_BROKER_PACKAGE_DEFINITION = protoLoader.fromJSON(node_descriptor_default
 // src/server.ts
 var grpcObj = grpc14.loadPackageDefinition(CEX_BROKER_PACKAGE_DEFINITION);
 var cexNode = grpcObj.cex_broker;
-function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, otelMetrics, brokerArchiver) {
+function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, otelMetrics, brokerArchiver, orderActivityTracker) {
   const server = new grpc14.Server;
   server.addService(cexNode.cex_service.service, {
     ExecuteAction: createExecuteActionHandler({
@@ -296058,7 +296475,8 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
       useVerity,
       verityProverUrl,
       otelMetrics,
-      brokerArchiver
+      brokerArchiver,
+      orderActivityTracker
     }),
     Subscribe: createSubscribeHandler({
       brokers,
@@ -296203,6 +296621,8 @@ class CEXBroker {
   otelLogs;
   brokerArchiver;
   depositReconciler;
+  orderActivityTracker = new OrderActivityTracker;
+  fillArchivePoller;
   loadEnvConfig() {
     log.info("\uD83D\uDD27 Loading CEX_BROKER_ environment variables:");
     const configMap = {};
@@ -296343,6 +296763,10 @@ class CEXBroker {
       this.depositReconciler.stop();
       this.depositReconciler = undefined;
     }
+    if (this.fillArchivePoller) {
+      this.fillArchivePoller.stop();
+      this.fillArchivePoller = undefined;
+    }
     if (this.server) {
       await this.server.forceShutdown();
     }
@@ -296364,11 +296788,15 @@ class CEXBroker {
       this.depositReconciler.stop();
       this.depositReconciler = undefined;
     }
+    if (this.fillArchivePoller) {
+      this.fillArchivePoller.stop();
+      this.fillArchivePoller = undefined;
+    }
     log.info(`Running CEXBroker at ${new Date().toISOString()}`);
     if (this.otelMetrics?.isOtelEnabled()) {
       await this.otelMetrics.initialize();
     }
-    this.server = getServer(this.policy, this.brokers, this.whitelistIps, this.useVerity, this.#verityProverUrl, this.otelMetrics, this.brokerArchiver);
+    this.server = getServer(this.policy, this.brokers, this.whitelistIps, this.useVerity, this.#verityProverUrl, this.otelMetrics, this.brokerArchiver, this.orderActivityTracker);
     this.server.bindAsync(`0.0.0.0:${this.port}`, grpc15.ServerCredentials.createInsecure(), (err2, port) => {
       if (err2) {
         log.error(err2);
@@ -296383,6 +296811,15 @@ class CEXBroker {
       metrics: this.otelMetrics
     });
     this.depositReconciler.start();
+    if (this.brokerArchiver?.isEnabled()) {
+      this.fillArchivePoller = new FillArchivePoller({
+        brokers: this.brokers,
+        archiver: this.brokerArchiver,
+        tracker: this.orderActivityTracker,
+        metrics: this.otelMetrics
+      });
+      this.fillArchivePoller.start();
+    }
     return this;
   }
 }
@@ -296390,4 +296827,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=FD2894A2A920C90B64756E2164756E21
+//# debugId=72B06323144A22CC64756E2164756E21