@usherlabs/cex-broker 0.2.20 → 0.2.21

package/dist/commands/cli.js

@@ -315278,6 +315278,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) {
@@ -315291,6 +315293,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));
 }
@@ -315355,6 +315377,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);
@@ -315423,6 +315538,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;
@@ -315678,11 +315812,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, value, labels);
+    } catch {}
+  }
+  async recordArchiveGauge(metricName, value) {
     try {
-      await this.otelMetrics?.recordCounter(metricName, 1, labels);
+      await this.otelMetrics?.recordGauge(metricName, value, {});
     } catch {}
   }
   emitOtelLog(entry) {
@@ -315779,6 +315929,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_api2 = __toESM(require_src5(), 1);
 var import_api_logs3 = __toESM(require_src7(), 1);
@@ -329955,7 +330258,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,
@@ -330018,6 +330327,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,
@@ -330431,7 +330766,8 @@ async function handleInternalTransfer(ctx) {
     symbol: symbol2,
     verity,
     useVerity,
-    verityProverUrl
+    verityProverUrl,
+    brokerArchiver
   } = ctx;
   if (!symbol2) {
     return ctx.wrappedCallback({
@@ -330479,6 +330815,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)
@@ -330526,7 +330877,8 @@ async function handleCreateOrder(ctx) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = ctx;
   const verityProof = verity.proof;
   const orderValue = parsePayloadForAction(ctx, CreateOrderPayloadSchema);
@@ -330552,6 +330904,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, {
@@ -330616,7 +330971,8 @@ async function handleGetOrderDetails(ctx) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = ctx;
   const verityProof = verity.proof;
   const getOrderValue = parsePayloadForAction(ctx, GetOrderDetailsPayloadSchema);
@@ -330630,6 +330986,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,
@@ -330685,7 +331044,8 @@ async function handleCancelOrder(ctx) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = ctx;
   const verityProof = verity.proof;
   const cancelOrderValue = parsePayloadForAction(ctx, CancelOrderPayloadSchema);
@@ -330706,6 +331066,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, {
@@ -331336,7 +331699,8 @@ async function handleWithdraw(ctx) {
     applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    otelMetrics,
+    brokerArchiver
   } = ctx;
   const verityProof = verity.proof;
   if (!symbol2) {
@@ -331385,6 +331749,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({
@@ -331396,6 +331780,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,
@@ -331443,7 +331842,8 @@ function createExecuteActionHandler(deps) {
     useVerity,
     verityProverUrl,
     otelMetrics,
-    brokerArchiver
+    brokerArchiver,
+    orderActivityTracker
   } = deps;
   return async (call, callback) => {
     const startTime = Date.now();
@@ -331522,7 +331922,8 @@ function createExecuteActionHandler(deps) {
         useVerity,
         verityProverUrl,
         otelMetrics,
-        brokerArchiver
+        brokerArchiver,
+        orderActivityTracker
       };
       if (action === Action.Call) {
         const handled = await handleOrderBookCall(preludeCtx);
@@ -333111,7 +333512,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({
@@ -333121,7 +333522,8 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
       useVerity,
       verityProverUrl,
       otelMetrics,
-      brokerArchiver
+      brokerArchiver,
+      orderActivityTracker
     }),
     Subscribe: createSubscribeHandler({
       brokers,
@@ -333266,6 +333668,8 @@ class CEXBroker {
   otelLogs;
   brokerArchiver;
   depositReconciler;
+  orderActivityTracker = new OrderActivityTracker;
+  fillArchivePoller;
   loadEnvConfig() {
     log.info("\uD83D\uDD27 Loading CEX_BROKER_ environment variables:");
     const configMap = {};
@@ -333406,6 +333810,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();
     }
@@ -333427,11 +333835,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);
@@ -333446,6 +333858,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;
   }
 }

package/dist/handlers/execute-action/context.d.ts

@@ -5,6 +5,7 @@ import type { z } from "zod";
 import type { BrokerAccount, BrokerPoolEntry } from "../../helpers";
 import type { BrokerExecutionArchiver } from "../../helpers/broker-execution-archive";
 import type { Action as ActionType } from "../../helpers/constants";
+import type { OrderActivityTracker } from "../../helpers/order-activity-tracker";
 import type { OtelMetrics } from "../../helpers/otel";
 import type { PolicyConfig } from "../../types";
 import type { ActionRequest, ActionResponse } from "../types";
@@ -29,6 +30,7 @@ export type ExecuteActionContext = {
     verityProverUrl: string;
     otelMetrics?: OtelMetrics;
     brokerArchiver?: BrokerExecutionArchiver;
+    orderActivityTracker?: OrderActivityTracker;
 };
 export declare function requireSymbol(ctx: ExecuteActionContext, message?: string): ctx is ExecuteActionContext & {
     symbol: string;

package/dist/handlers/execute-action/handler.d.ts

@@ -1,6 +1,7 @@
 import * as grpc from "@grpc/grpc-js";
 import { type BrokerPoolEntry } from "../../helpers/broker";
 import type { BrokerExecutionArchiver } from "../../helpers/broker-execution-archive";
+import type { OrderActivityTracker } from "../../helpers/order-activity-tracker";
 import type { OtelMetrics } from "../../helpers/otel";
 import type { PolicyConfig } from "../../types";
 import type { ActionRequest, ActionResponse } from "../types";
@@ -12,5 +13,6 @@ export type ExecuteActionDeps = {
     verityProverUrl: string;
     otelMetrics?: OtelMetrics;
     brokerArchiver?: BrokerExecutionArchiver;
+    orderActivityTracker?: OrderActivityTracker;
 };
 export declare function createExecuteActionHandler(deps: ExecuteActionDeps): (call: grpc.ServerUnaryCall<ActionRequest, ActionResponse>, callback: grpc.sendUnaryData<ActionResponse>) => Promise<void>;

package/dist/helpers/broker-execution-archive/capture.d.ts

@@ -1,5 +1,6 @@
 import type { Exchange } from "@usherlabs/ccxt";
 import { type OrderTelemetryAction, type OrderTelemetryContext } from "../order-telemetry";
+import { type TransferArchiveFields } from "./rows";
 import type { SubscribeArchiveType } from "./types";
 import type { BrokerExecutionArchiver } from "./writer";
 export declare function archiveOrderExecutionInBackground(archiver: BrokerExecutionArchiver | undefined, context: OrderTelemetryContext, order: unknown, error?: unknown, options?: {
@@ -13,6 +14,13 @@ export declare function archiveSubscribeStreamInBackground(archiver: BrokerExecu
     streamPayload: unknown;
     secretLiterals?: readonly string[];
 }): void;
+export declare function archiveTransferEventInBackground(archiver: BrokerExecutionArchiver | undefined, input: {
+    exchange: string;
+    accountSelector?: string;
+    assetSymbol?: string;
+    brokerObservedTimestamp?: string;
+    transfer: TransferArchiveFields;
+}): void;
 export declare function captureMarketMetadataSnapshot(archiver: BrokerExecutionArchiver | undefined, broker: Exchange, input: {
     exchange: string;
     accountSelector?: string;