@usherlabs/cex-broker 0.2.20 → 0.2.22

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;
@@ -275058,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) {
@@ -275159,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);
 
@@ -279052,9 +279355,23 @@ import * as grpc14 from "@grpc/grpc-js";
 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 });
@@ -292902,12 +293219,24 @@ function rejectWithGrpcError(ctx, error48, options) {
   } else {
     finalMessage = message;
   }
+  if (options?.appendClassName) {
+    const className = errorClassName(error48);
+    if (className && !finalMessage.includes(className)) {
+      finalMessage = `${finalMessage} (${className})`;
+    }
+  }
   ctx.wrappedCallback({ code, message: finalMessage }, null);
 }
 
 // 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,
@@ -292970,6 +293299,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,
@@ -293042,7 +293397,8 @@ async function handleDeposit(ctx) {
     }
     rejectWithGrpcError(ctx, error48, {
       message,
-      prefix: "deposit_observation_unavailable: "
+      prefix: "deposit_observation_unavailable: ",
+      appendClassName: true
     });
   }
 }
@@ -293361,10 +293717,9 @@ async function handleOrderBookCall(ctx) {
     });
   } catch (error48) {
     safeLogError("Order-book Call failed", error48);
-    const message = getErrorMessage(error48);
     ctx.wrappedCallback({
       code: mapCcxtErrorToGrpcStatus(error48) ?? grpc4.status.INTERNAL,
-      message: `Order-book Call failed: ${message}`
+      message: `Order-book Call failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
   return true;
@@ -293383,7 +293738,8 @@ async function handleInternalTransfer(ctx) {
     symbol: symbol2,
     verity,
     useVerity,
-    verityProverUrl
+    verityProverUrl,
+    brokerArchiver
   } = ctx;
   if (!symbol2) {
     return ctx.wrappedCallback({
@@ -293431,6 +293787,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)
@@ -293454,7 +293825,7 @@ async function handleInternalTransfer(ctx) {
     }
     ctx.wrappedCallback({
       code,
-      message: `InternalTransfer failed: ${msg}`
+      message: `InternalTransfer failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
 }
@@ -293478,7 +293849,8 @@ async function handleCreateOrder(ctx) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = ctx;
   const verityProof = verity.proof;
   const orderValue = parsePayloadForAction(ctx, CreateOrderPayloadSchema);
@@ -293504,6 +293876,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, {
@@ -293547,7 +293922,7 @@ async function handleCreateOrder(ctx) {
     archiveOrderExecutionInBackground(brokerArchiver, failedCreateContext, undefined, error48);
     ctx.wrappedCallback({
       code: grpc6.status.INTERNAL,
-      message: "Order Creation failed"
+      message: `Order Creation failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
 }
@@ -293568,7 +293943,8 @@ async function handleGetOrderDetails(ctx) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = ctx;
   const verityProof = verity.proof;
   const getOrderValue = parsePayloadForAction(ctx, GetOrderDetailsPayloadSchema);
@@ -293582,6 +293958,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,
@@ -293616,7 +293995,7 @@ async function handleGetOrderDetails(ctx) {
     archiveOrderExecutionInBackground(brokerArchiver, failedGetOrderContext, undefined, error48);
     ctx.wrappedCallback({
       code: grpc6.status.INTERNAL,
-      message: `Failed to fetch order details from ${cex3}`
+      message: `Failed to fetch order details from ${cex3}: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
 }
@@ -293637,7 +294016,8 @@ async function handleCancelOrder(ctx) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = ctx;
   const verityProof = verity.proof;
   const cancelOrderValue = parsePayloadForAction(ctx, CancelOrderPayloadSchema);
@@ -293658,6 +294038,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, {
@@ -293676,7 +294059,7 @@ async function handleCancelOrder(ctx) {
     archiveOrderExecutionInBackground(brokerArchiver, failedCancelContext, undefined, error48);
     ctx.wrappedCallback({
       code: grpc6.status.INTERNAL,
-      message: `Failed to cancel order from ${cex3}`
+      message: `Failed to cancel order from ${cex3}: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
 }
@@ -294173,7 +294556,7 @@ async function handleGetPerpConfigState(ctx) {
     safeLogError(`GetPerpConfigState failed for ${cex3}`, error48);
     ctx.wrappedCallback({
       code: grpc8.status.INTERNAL,
-      message: getErrorMessage(error48)
+      message: `GetPerpConfigState failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
 }
@@ -294214,7 +294597,7 @@ async function handleSetPerpConfigState(ctx) {
     safeLogError(`SetPerpConfigState failed for ${cex3}`, error48);
     ctx.wrappedCallback({
       code: grpc8.status.INTERNAL,
-      message: getErrorMessage(error48)
+      message: `SetPerpConfigState failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
 }
@@ -294265,7 +294648,8 @@ async function handleTreasuryCall(ctx) {
     safeLogError("Call failed", error48);
     rejectWithGrpcError(ctx, error48, {
       message: getErrorMessage(error48),
-      preferStableMessageOnly: true
+      preferStableMessageOnly: true,
+      appendClassName: true
     });
   }
 }
@@ -294288,7 +294672,8 @@ async function handleWithdraw(ctx) {
     applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    otelMetrics,
+    brokerArchiver
   } = ctx;
   const verityProof = verity.proof;
   if (!symbol2) {
@@ -294337,6 +294722,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({
@@ -294348,10 +294753,25 @@ 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,
-      message: `Withdraw failed: ${getErrorMessage(error48)}`
+      message: `Withdraw failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
 }
@@ -294395,7 +294815,8 @@ function createExecuteActionHandler(deps) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = deps;
   return async (call, callback) => {
     const startTime = Date.now();
@@ -294474,7 +294895,8 @@ function createExecuteActionHandler(deps) {
         useVerity,
         verityProverUrl,
         otelMetrics,
-        brokerArchiver
+        brokerArchiver,
+        orderActivityTracker
       };
       if (action === Action.Call) {
         const handled = await handleOrderBookCall(preludeCtx);
@@ -296064,7 +296486,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({
@@ -296074,7 +296496,8 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
       useVerity,
       verityProverUrl,
       otelMetrics,
-      brokerArchiver
+      brokerArchiver,
+      orderActivityTracker
     }),
     Subscribe: createSubscribeHandler({
       brokers,
@@ -296219,6 +296642,8 @@ class CEXBroker {
   otelLogs;
   brokerArchiver;
   depositReconciler;
+  orderActivityTracker = new OrderActivityTracker;
+  fillArchivePoller;
   loadEnvConfig() {
     log.info("\uD83D\uDD27 Loading CEX_BROKER_ environment variables:");
     const configMap = {};
@@ -296359,6 +296784,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();
     }
@@ -296380,11 +296809,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);
@@ -296399,6 +296832,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;
   }
 }
@@ -296406,4 +296848,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=2BAA8D1C40735DFB64756E2164756E21
+//# debugId=6EFE98438C50664564756E2164756E21