@usherlabs/cex-broker 0.2.36 → 0.2.37

package/dist/index.js

@@ -291041,7 +291041,7 @@ function compactUndefined2(record) {
 }
 function buildCommonArchiveTags(input) {
   return {
-    source: BROKER_WRITE_SOURCE,
+    source: input.source ?? BROKER_WRITE_SOURCE,
     deployment_id: input.deploymentId,
     account_selector: input.accountSelector ?? "unknown",
     exchange: input.exchange.trim().toLowerCase() || "unknown",
@@ -291104,6 +291104,10 @@ function buildSubscribeStreamArchiveRow(input) {
 function quantityString(...values2) {
   return firstString2(...values2);
 }
+function extractBinanceInternalTransferId(response) {
+  const record = asRecord(response);
+  return firstString2(record?.txnId, record?.tranId);
+}
 function buildTransferEventArchiveRow(input) {
   const { tags, transfer } = input;
   return {
@@ -291136,6 +291140,7 @@ function normalizeCcxtTransactionForArchive(transaction) {
   const fee = asRecord(record?.fee);
   return compactUndefined2({
     externalId: firstString2(record?.id, info?.id, record?.txid, info?.txId),
+    clientWithdrawalId: firstString2(info?.withdrawOrderId),
     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),
@@ -291243,14 +291248,40 @@ var DEFAULT_BATCH_SIZE = 10;
 var DEFAULT_FLUSH_INTERVAL_MS = 1000;
 var DEFAULT_FORWARDER_TIMEOUT_MS = 3000;
 var SHED_WARN_INTERVAL_MS = 60000;
+var MARKET_FEEDS = new Set(["ORDERBOOK", "TICKER", "TRADES", "OHLCV"]);
+function archiveFeed(row) {
+  const declared = row.row.feed ?? row.row.stream_type;
+  if (typeof declared === "string" && MARKET_FEEDS.has(declared)) {
+    return declared;
+  }
+  if (row.table === "market_data.orderbook_snapshots" || row.table.startsWith("market_data.cex_order_book_")) {
+    return "ORDERBOOK";
+  }
+  if (row.table === "market_data.candles" || row.table === "market_data.cex_ohlcv") {
+    return "OHLCV";
+  }
+  if (row.table === "market_data.cex_ticker_events")
+    return "TICKER";
+  if (row.table === "market_data.cex_trades")
+    return "TRADES";
+  return "NON_MARKET";
+}
 function isArchiveOtelLogsEnabled() {
   return process.env.CEX_BROKER_ARCHIVE_OTEL_LOGS_ENABLED === "true";
 }
 function resolveArchiveForwarderUrlFromEnv() {
   return process.env.CEX_BROKER_ARCHIVE_FORWARDER_URL?.trim() || undefined;
 }
+function resolveArchiveSourceFromEnv(value = process.env.CEX_BROKER_ARCHIVE_SOURCE) {
+  const source = value?.trim() || BROKER_WRITE_SOURCE;
+  if (source !== "broker_read" && source !== "broker_write") {
+    throw new Error("CEX_BROKER_ARCHIVE_SOURCE must be broker_read or broker_write");
+  }
+  return source;
+}
 
 class BrokerExecutionArchiver {
+  source;
   deploymentId;
   otelLogs;
   otelMetrics;
@@ -291271,10 +291302,12 @@ class BrokerExecutionArchiver {
   flushTimer = null;
   flushInFlight = null;
   lastShedWarnAtMs = 0;
+  closing = false;
   closed = false;
   enabled;
   forwarderAuthToken;
   constructor(options) {
+    this.source = options.source ?? BROKER_WRITE_SOURCE;
     this.deploymentId = options.deploymentId?.trim() || process.env.CEX_BROKER_DEPLOYMENT_ID?.trim() || "unknown";
     this.otelLogs = options.otelLogs;
     this.otelMetrics = options.otelMetrics;
@@ -291306,6 +291339,7 @@ class BrokerExecutionArchiver {
       this.flushTimer.unref?.();
       log.info("Broker execution archive enabled", {
         enabled: true,
+        source: this.source,
         otel_mirror_enabled: Boolean(this.otelLogs?.isOtelEnabled())
       });
     } catch (error) {
@@ -291322,8 +291356,11 @@ class BrokerExecutionArchiver {
   getDeploymentId() {
     return this.deploymentId;
   }
+  getSource() {
+    return this.source;
+  }
   isEnabled() {
-    return this.enabled && !this.closed;
+    return this.enabled && !this.closing && !this.closed;
   }
   canPersistMarketMetadataSnapshot() {
     return this.isEnabled();
@@ -291335,6 +291372,10 @@ class BrokerExecutionArchiver {
     if (!this.enabled || this.closed) {
       return;
     }
+    const archiveRow = {
+      table: row.table,
+      row: { ...row.row, source: this.source }
+    };
     if (this.queue.length >= this.maxQueueSize) {
       const shedRow = this.queue[0];
       if (shedRow) {
@@ -291343,7 +291384,14 @@ class BrokerExecutionArchiver {
       }
       this.stats.shed += 1;
       this.recordArchiveMetric("cex_archive_rows_shed_total", {
-        table: shedRow?.table ?? "unknown"
+        table: shedRow?.table ?? "unknown",
+        source: this.source,
+        feed: shedRow ? archiveFeed(shedRow) : "NON_MARKET"
+      });
+      this.recordArchiveMetric("cex_archive_queue_saturated_rows_total", {
+        table: shedRow?.table ?? "unknown",
+        source: this.source,
+        feed: shedRow ? archiveFeed(shedRow) : "NON_MARKET"
       });
       const now3 = Date.now();
       if (now3 - this.lastShedWarnAtMs >= SHED_WARN_INTERVAL_MS) {
@@ -291355,10 +291403,12 @@ class BrokerExecutionArchiver {
         this.lastShedWarnAtMs = now3;
       }
     }
-    this.queue.push(row);
+    this.queue.push(archiveRow);
     this.stats.enqueued += 1;
     this.recordArchiveMetric("cex_archive_rows_enqueued_total", {
-      table: row.table
+      table: archiveRow.table,
+      source: this.source,
+      feed: archiveFeed(archiveRow)
     });
     if (this.queue.length >= this.batchSize) {
       this.flush();
@@ -291378,11 +291428,15 @@ class BrokerExecutionArchiver {
       return;
     }).finally(() => {
       this.flushInFlight = null;
+      if (!this.closed && !this.closing && this.enabled && this.queue.length >= this.batchSize) {
+        queueMicrotask(() => void this.flush());
+      }
     });
     this.flushInFlight = inFlight;
     return inFlight;
   }
   async close() {
+    this.closing = true;
     if (this.flushTimer) {
       clearInterval(this.flushTimer);
       this.flushTimer = null;
@@ -291447,7 +291501,14 @@ class BrokerExecutionArchiver {
       this.queue.shift();
       this.stats.shed += 1;
       this.recordArchiveMetric("cex_archive_rows_shed_total", {
-        table: dropped?.table ?? "unknown"
+        table: dropped?.table ?? "unknown",
+        source: this.source,
+        feed: archiveFeed(dropped)
+      });
+      this.recordArchiveMetric("cex_archive_queue_saturated_rows_total", {
+        table: dropped.table,
+        source: this.source,
+        feed: archiveFeed(dropped)
       });
     }
   }
@@ -291461,6 +291522,7 @@ class BrokerExecutionArchiver {
     const timestamp = new Date().toISOString();
     const records = rows.map((payload) => ({
       timestamp,
+      source: this.source,
       deployment_id: this.deploymentId,
       reason,
       payload
@@ -291474,6 +291536,21 @@ class BrokerExecutionArchiver {
         throw new Error(`wrote ${written} of ${bytes2.length} bytes`);
       }
       fsyncSync(this.deadLetterFd);
+      const byFeedAndTable = new Map;
+      for (const row of rows) {
+        const key = `${row.table}\x00${archiveFeed(row)}`;
+        const grouped = byFeedAndTable.get(key) ?? { row, count: 0 };
+        grouped.count += 1;
+        byFeedAndTable.set(key, grouped);
+      }
+      for (const { row, count: count2 } of byFeedAndTable.values()) {
+        this.recordArchiveMetric("cex_archive_rows_journaled_total", {
+          table: row.table,
+          source: this.source,
+          feed: archiveFeed(row),
+          reason
+        }, count2);
+      }
     } catch (error) {
       throw new BrokerExecutionArchiveDurabilityError(`Broker execution archive failed to durably record ${reason}; affected row(s) were retained`, { cause: error });
     }
@@ -291509,10 +291586,17 @@ class BrokerExecutionArchiver {
   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);
+      const key = `${entry.table}\x00${archiveFeed(entry)}`;
+      const grouped = countByTable.get(key) ?? { row: entry, count: 0 };
+      grouped.count += 1;
+      countByTable.set(key, grouped);
+    }
+    for (const { row, count: count2 } of countByTable.values()) {
+      this.recordArchiveMetric("cex_archive_rows_flushed_total", {
+        table: row.table,
+        source: this.source,
+        feed: archiveFeed(row)
+      }, count2);
     }
     this.recordArchiveGauge("cex_archive_last_flush_success", Math.floor(Date.now() / 1000));
   }
@@ -291546,7 +291630,7 @@ class BrokerExecutionArchiver {
       return Promise.resolve();
     }
     const body = JSON.stringify({
-      source: "broker_write",
+      source: this.source,
       deployment_id: this.deploymentId,
       rows: batch
     });
@@ -291616,6 +291700,7 @@ function createBrokerExecutionArchiverFromEnv(otelLogs, otelMetrics) {
   const forwarderUrl = resolveArchiveForwarderUrlFromEnv();
   const archiveOtelLogs = isArchiveOtelLogsEnabled() ? otelLogs : undefined;
   return BrokerExecutionArchiver.create({
+    source: resolveArchiveSourceFromEnv(),
     otelLogs: archiveOtelLogs,
     otelMetrics,
     forwarderUrl: forwarderUrl ?? "",
@@ -291754,6 +291839,7 @@ function archiveWithdrawalObservationsInBackground(archiver, tracker, input) {
           address: normalized.address,
           network: normalized.network,
           externalId: normalized.externalId,
+          clientWithdrawalId: normalized.clientWithdrawalId,
           txid: normalized.txid,
           resultIndex,
           feeAmount: normalized.feeAmount,
@@ -306850,9 +306936,6 @@ function selectBrokerAccountForCex(normalizedCex, brokers, metadata) {
   return selectBrokerAccount(brokers[normalizedCex], metadata) ?? undefined;
 }
 
-// src/handlers/execute-action/order-book-call.ts
-import * as grpc4 from "@grpc/grpc-js";
-
 // src/helpers/order-book.ts
 var ORDER_BOOK_CALL_METHODS = {
   FETCH_CAPABILITY: "fetch_order_book_capability",
@@ -307095,726 +307178,1200 @@ function buildHistoricalOrderBookUnsupported(payload) {
 }
 
 // src/handlers/execute-action/order-book-call.ts
-async function handleOrderBookCall(ctx) {
-  const parsedOrderBookCall = parseOrderBookCallPayload(ctx.call.request.payload, {
-    exchange: ctx.normalizedCex,
-    symbol: ctx.symbol
-  });
-  if (parsedOrderBookCall.kind === "error") {
-    ctx.wrappedCallback({
-      code: grpc4.status.INVALID_ARGUMENT,
-      message: parsedOrderBookCall.message
-    }, null);
-    return true;
+import * as grpc4 from "@grpc/grpc-js";
+
+// src/helpers/market-data-archive/capture-contract.ts
+import { createHash as createHash3 } from "node:crypto";
+var MARKET_CAPTURE_SCHEMA_VERSION = "1.0.0";
+var CHECKSUM_ALGORITHM = "sha256-canonical-json-v1";
+var ARCHIVE_SOURCES = ["broker_read", "broker_write"];
+var CAPTURE_FEEDS = [
+  "ORDERBOOK",
+  "TICKER",
+  "TRADES",
+  "OHLCV"
+];
+var SOURCE_MODES = [
+  "broker_live_stream_v1",
+  "broker_live_sampling_v1",
+  "broker_current_snapshot_v1",
+  "broker_bootstrap_fetch_v1",
+  "external_ccxt_fallback_v1",
+  "external_hummingbot_fallback_v1",
+  "legacy_migration_v1"
+];
+var RAW_CAPTURE_SCOPES = [
+  "ccxt_normalized_object",
+  "broker_visible_payload",
+  "exchange_wire_frame"
+];
+var CHECKSUM_FIELDS = new Set([
+  "normalized_row_checksum",
+  "raw_checksum",
+  "checksum"
+]);
+function canonicalDecimal(value) {
+  if (!Number.isFinite(value)) {
+    throw new Error("Canonical numbers must be finite");
   }
-  if (parsedOrderBookCall.kind !== "order_book") {
-    return false;
+  if (Object.is(value, -0)) {
+    return "0";
   }
-  const orderBookBroker = ctx.selectedBrokerAccount?.exchange ?? createBroker(ctx.normalizedCex, ctx.metadata) ?? createPublicBroker(ctx.normalizedCex);
-  if (!orderBookBroker) {
-    ctx.wrappedCallback({
-      code: grpc4.status.INVALID_ARGUMENT,
-      message: `Unsupported exchange for order-book market data: ${ctx.normalizedCex}`
-    }, null);
-    return true;
+  const rendered = String(value).toLowerCase();
+  if (!rendered.includes("e")) {
+    return rendered;
   }
-  ctx.applyVerityToBroker(orderBookBroker);
-  try {
-    const orderBookPayload = parsedOrderBookCall.payload;
-    if (orderBookPayload.method === ORDER_BOOK_CALL_METHODS.FETCH_CAPABILITY) {
-      ctx.wrappedCallback(null, {
-        proof: ctx.verity.proof,
-        result: JSON.stringify(buildOrderBookCapability(orderBookBroker, orderBookPayload))
-      });
-      return true;
-    }
-    if (orderBookPayload.method === ORDER_BOOK_CALL_METHODS.FETCH_HISTORICAL_SNAPSHOTS) {
-      ctx.wrappedCallback(null, {
-        proof: ctx.verity.proof,
-        result: JSON.stringify(buildHistoricalOrderBookUnsupported(orderBookPayload))
-      });
-      return true;
-    }
-    const fetchOrderBook = orderBookBroker.fetchOrderBook;
-    const canFetchOrderBook = typeof fetchOrderBook === "function" && orderBookBroker.has?.fetchOrderBook !== false;
-    if (!canFetchOrderBook) {
-      ctx.wrappedCallback({
-        code: grpc4.status.UNIMPLEMENTED,
-        message: `Order-book snapshot unsupported for ${ctx.normalizedCex}`
-      }, null);
-      return true;
+  const [coefficient = "0", exponentText = "0"] = rendered.split("e");
+  const exponent = Number.parseInt(exponentText, 10);
+  const negative = coefficient.startsWith("-");
+  const unsigned = negative ? coefficient.slice(1) : coefficient;
+  const [integer2 = "0", fraction = ""] = unsigned.split(".");
+  const digits = `${integer2}${fraction}`;
+  const decimalIndex = integer2.length + exponent;
+  let result;
+  if (decimalIndex <= 0) {
+    result = `0.${"0".repeat(-decimalIndex)}${digits}`;
+  } else if (decimalIndex >= digits.length) {
+    result = `${digits}${"0".repeat(decimalIndex - digits.length)}`;
+  } else {
+    result = `${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
+  }
+  return negative ? `-${result}` : result;
+}
+function serializeCanonical(value, stack) {
+  if (value === null)
+    return "null";
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (typeof value === "number")
+    return canonicalDecimal(value);
+  if (typeof value === "bigint")
+    return value.toString(10);
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw new Error("Canonical timestamps must be valid");
     }
-    const receivedTimestamp = Date.now();
-    const rawOrderBook = await fetchOrderBook.call(orderBookBroker, orderBookPayload.symbol, orderBookPayload.depthLimit);
-    ctx.wrappedCallback(null, {
-      proof: ctx.verity.proof,
-      result: JSON.stringify(normalizeOrderBookSnapshot(rawOrderBook, {
-        exchange: orderBookPayload.exchange,
-        symbol: orderBookPayload.symbol,
-        depthLimit: orderBookPayload.depthLimit,
-        receivedTimestamp
-      }))
-    });
-  } catch (error48) {
-    safeLogError("Order-book Call failed", error48);
-    ctx.wrappedCallback({
-      code: mapCcxtErrorToGrpcStatus(error48) ?? grpc4.status.INTERNAL,
-      message: `Order-book Call failed: ${sanitizeErrorDetail(error48)}`
-    }, null);
+    return value.getTime().toString(10);
   }
-  return true;
+  if (Array.isArray(value)) {
+    if (stack.has(value))
+      throw new Error("Canonical values must be acyclic");
+    stack.add(value);
+    const result = `[${value.map((entry) => entry === undefined ? "null" : serializeCanonical(entry, stack)).join(",")}]`;
+    stack.delete(value);
+    return result;
+  }
+  if (typeof value === "object") {
+    if (stack.has(value))
+      throw new Error("Canonical values must be acyclic");
+    stack.add(value);
+    const entries = Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([left], [right]) => left.localeCompare(right));
+    const result = `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${serializeCanonical(entry, stack)}`).join(",")}}`;
+    stack.delete(value);
+    return result;
+  }
+  throw new Error(`Unsupported canonical value type: ${typeof value}`);
 }
-
-// src/handlers/execute-action/registry.ts
-import * as grpc11 from "@grpc/grpc-js";
-
-// src/handlers/execute-action/internal-transfer.ts
-import * as grpc5 from "@grpc/grpc-js";
-async function handleInternalTransfer(ctx) {
-  const {
-    brokers,
-    metadata,
-    normalizedCex,
-    symbol: symbol2,
-    verity,
-    useVerity,
-    verityProverUrl,
-    brokerArchiver
-  } = ctx;
-  if (!symbol2) {
-    return ctx.wrappedCallback({
-      code: grpc5.status.INVALID_ARGUMENT,
-      message: `ValidationError: Symbol required`
-    }, null);
+function canonicalSerialize(value) {
+  return serializeCanonical(value, new Set);
+}
+function omitChecksumFields(value) {
+  if (Array.isArray(value))
+    return value.map(omitChecksumFields);
+  if (value && typeof value === "object" && !(value instanceof Date)) {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !CHECKSUM_FIELDS.has(key)).map(([key, entry]) => [key, omitChecksumFields(entry)]));
   }
-  const transferPayload = parsePayloadForAction(ctx, InternalTransferPayloadSchema);
-  if (transferPayload === null)
-    return;
-  if (normalizedCex !== "binance") {
-    return ctx.wrappedCallback({
-      code: grpc5.status.UNIMPLEMENTED,
-      message: `InternalTransfer is only supported for Binance`
-    }, null);
+  return value;
+}
+function sha256Canonical(value) {
+  return createHash3("sha256").update(canonicalSerialize(omitChecksumFields(value))).digest("hex");
+}
+function normalizeTimestampMs(value, field) {
+  let timestamp;
+  if (value instanceof Date) {
+    timestamp = value.getTime();
+  } else if (typeof value === "number") {
+    timestamp = value;
+  } else if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    timestamp = Number(value.trim());
+  } else if (typeof value === "string") {
+    timestamp = Date.parse(value);
+  } else {
+    timestamp = Number.NaN;
   }
-  const pool = brokers[normalizedCex];
-  if (!pool) {
-    return ctx.wrappedCallback({
-      code: grpc5.status.FAILED_PRECONDITION,
-      message: `No broker accounts configured for ${normalizedCex}`
-    }, null);
+  if (!Number.isSafeInteger(timestamp) || timestamp < 0) {
+    throw new Error(`${field} must be a non-negative millisecond timestamp`);
   }
-  const fromSelector = transferPayload.fromAccount ?? getCurrentBrokerSelector(metadata);
-  const toSelector = transferPayload.toAccount ?? "primary";
-  const sourceAccount = resolveBrokerAccount(pool, fromSelector);
-  if (!sourceAccount) {
-    return ctx.wrappedCallback({
-      code: grpc5.status.INVALID_ARGUMENT,
-      message: `Source account "${fromSelector}" is not configured`
-    }, null);
+  return timestamp;
+}
+function assertCaptureContext(context2) {
+  if (!ARCHIVE_SOURCES.includes(context2.source)) {
+    throw new Error(`Unsupported archive source: ${context2.source}`);
   }
-  const destAccount = resolveBrokerAccount(pool, toSelector);
-  if (!destAccount) {
-    return ctx.wrappedCallback({
-      code: grpc5.status.INVALID_ARGUMENT,
-      message: `Destination account "${toSelector}" is not configured`
-    }, null);
+  if (!CAPTURE_FEEDS.includes(context2.feed)) {
+    throw new Error(`Unsupported capture feed: ${context2.feed}`);
   }
-  try {
-    if (useVerity) {
-      sourceAccount.exchange.setHttpClientOverride(buildHttpClientOverrideFromMetadata(metadata, verityProverUrl, (proof, notaryPubKey) => {
-        verity.proof = proof;
-        log.debug(`Verity proof:`, { proof, notaryPubKey });
-      }), verityHttpClientOverridePredicate);
+  if (!SOURCE_MODES.includes(context2.sourceMode)) {
+    throw new Error(`Unsupported source mode: ${context2.sourceMode}`);
+  }
+  for (const [field, value] of [
+    ["deployment_id", context2.deploymentId],
+    ["capture_bundle_id", context2.captureBundleId],
+    ["exchange", context2.exchange],
+    ["symbol", context2.symbol],
+    ["provider", context2.provider]
+  ]) {
+    if (!value.trim())
+      throw new Error(`${field} must not be empty`);
+  }
+}
+function createRawCapture(context2, input) {
+  assertCaptureContext(context2);
+  if (!RAW_CAPTURE_SCOPES.includes(input.scope)) {
+    throw new Error(`Unsupported raw capture scope: ${input.scope}`);
+  }
+  const eventTimeMs = normalizeTimestampMs(input.eventTimeMs, "event_time_ms");
+  const receivedTimeMs = normalizeTimestampMs(input.receivedTimeMs, "received_time_ms");
+  const redactedPayload = redactStreamPayload(input.payload);
+  const rawChecksum = sha256Canonical(redactedPayload);
+  const rawCaptureId = sha256Canonical({
+    capture_bundle_id: context2.captureBundleId,
+    exchange: context2.exchange.trim().toLowerCase(),
+    feed: context2.feed,
+    raw_capture_scope: input.scope,
+    raw_payload_sha256: rawChecksum,
+    schema_version: context2.schemaVersion,
+    source_mode: context2.sourceMode,
+    source_symbol: context2.symbol.trim(),
+    source_time_ms: eventTimeMs
+  });
+  return {
+    rawCaptureId,
+    rawCaptureScope: input.scope,
+    rawChecksum,
+    redactedPayload,
+    eventTimeMs,
+    receivedTimeMs,
+    checksumAlgorithm: context2.checksumAlgorithm
+  };
+}
+function captureCoreFields(context2, rawCapture) {
+  assertCaptureContext(context2);
+  return {
+    source: context2.source,
+    deployment_id: context2.deploymentId,
+    capture_bundle_id: context2.captureBundleId,
+    exchange: context2.exchange.trim().toLowerCase(),
+    symbol: context2.symbol.trim(),
+    trading_pair: context2.symbol.trim().replace("/", "-"),
+    source_symbol: context2.symbol.trim(),
+    asset_type: context2.assetType,
+    feed: context2.feed,
+    provider: context2.provider,
+    source_mode: context2.sourceMode,
+    source_time_ms: rawCapture.eventTimeMs,
+    received_time_ms: rawCapture.receivedTimeMs,
+    raw_capture_id: rawCapture.rawCaptureId,
+    raw_capture_scope: rawCapture.rawCaptureScope,
+    schema_version: context2.schemaVersion,
+    checksum_algorithm: context2.checksumAlgorithm,
+    raw_checksum: rawCapture.rawChecksum,
+    provenance_complete: context2.provenanceComplete ? 1 : 0
+  };
+}
+
+// src/helpers/market-data-archive/canonical-orderbook.ts
+class OrderBookValidationError extends Error {
+  reason;
+  constructor(reason) {
+    super(`Invalid order-book evidence: ${reason}`);
+    this.name = "OrderBookValidationError";
+    this.reason = reason;
+  }
+}
+function parseSequence(value) {
+  if (value === undefined)
+    return;
+  const parsed = typeof value === "number" ? value : typeof value === "string" && /^\d+$/.test(value) ? Number(value) : Number.NaN;
+  if (!Number.isSafeInteger(parsed) || parsed < 0) {
+    throw new OrderBookValidationError("sequence must be a non-negative integer");
+  }
+  return parsed;
+}
+function validateSide(side, levels, depthLimit) {
+  if (levels.length === 0) {
+    throw new OrderBookValidationError(`${side} side is missing`);
+  }
+  const retained = levels.slice(0, depthLimit);
+  for (let index2 = 0;index2 < retained.length; index2 += 1) {
+    const entry = retained[index2];
+    const price = entry?.[0];
+    const amount = entry?.[1];
+    if (!Array.isArray(entry) || entry.length < 2 || price === undefined || amount === undefined || !Number.isFinite(price) || !Number.isFinite(amount) || price <= 0 || amount <= 0) {
+      throw new OrderBookValidationError(`${side} level ${index2} has a non-positive or non-finite price/amount`);
     }
-    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 }
+    if (index2 > 0) {
+      const previous = retained[index2 - 1]?.[0];
+      if (previous === undefined || (side === "bid" ? price >= previous : price <= previous)) {
+        throw new OrderBookValidationError(`${side} levels are not strictly ${side === "bid" ? "descending" : "ascending"}`);
       }
-    });
-    ctx.wrappedCallback(null, {
-      proof: verity.proof,
-      result: JSON.stringify(result)
-    });
-  } catch (error48) {
-    safeLogError("InternalTransfer failed", error48);
-    if (error48 instanceof BrokerAccountPreconditionError) {
-      return ctx.wrappedCallback({
-        code: grpc5.status.FAILED_PRECONDITION,
-        message: getErrorMessage(error48)
-      }, null);
     }
-    const msg = getErrorMessage(error48);
-    let code;
-    if (msg.includes("Unsupported transfer direction")) {
-      code = grpc5.status.INVALID_ARGUMENT;
-    } else if (msg.includes("unavailable in this CCXT build")) {
-      code = grpc5.status.UNIMPLEMENTED;
-    } else {
-      code = mapCcxtErrorToGrpcStatus(error48) ?? grpc5.status.INTERNAL;
+  }
+  return retained.map(([price, amount]) => ({
+    price,
+    amount
+  }));
+}
+function normalizedBands(input) {
+  const bands = input ?? [10, 25, 50, 100];
+  for (const band of bands) {
+    if (!Number.isFinite(band) || band <= 0 || !Number.isInteger(band)) {
+      throw new OrderBookValidationError("measurement bands must be positive integer basis points");
     }
-    ctx.wrappedCallback({
-      code,
-      message: `InternalTransfer failed: ${sanitizeErrorDetail(error48)}`
-    }, null);
   }
+  return [...new Set(bands)].sort((left, right) => left - right);
 }
-
-// src/handlers/execute-action/orders.ts
-import * as grpc6 from "@grpc/grpc-js";
-
-// src/helpers/passive-order.ts
-var PASSIVE_ORDER_ERROR_CODES = {
-  unsupported: "passive_order_unsupported",
-  rejected: "passive_order_rejected",
-  wouldCross: "passive_order_would_cross"
-};
-function identifiesWouldCross(message) {
-  const normalized = message.toLowerCase();
-  return normalized.includes("would immediately match and take") || /post[\s-]?only\b.*\bwould\b.*\bimmediately\b.*\b(?:execute|fill|match)/.test(normalized) || /post[\s-]?only\b.*\bwould\b.*\b(?:execute|fill|match)\w*\b.*\bimmediately/.test(normalized);
+function checksumRow(row) {
+  return { ...row, normalized_row_checksum: sha256Canonical(row) };
 }
-function identifiesUnsupported(message) {
-  const normalized = message.toLowerCase();
-  return /post[\s-]?only\b.*\b(?:not supported|unsupported|does not support)\b/.test(normalized) || /\b(?:not supported|unsupported|does not support)\b.*\bpost[\s-]?only\b/.test(normalized);
+function commonEvidenceFields(context2, rawCapture, input) {
+  return {
+    ...captureCoreFields(context2, rawCapture),
+    source_time_ms: input.eventTimeMs,
+    received_time_ms: input.receivedTimeMs,
+    snapshot_id: input.snapshotId,
+    construction_mode: "sampled_top_n_snapshot",
+    gap_policy: "record_gap",
+    depth_limit: input.depthLimit,
+    sequence: input.sequence,
+    exact_l2_reconstruction_complete: 0
+  };
 }
-function classifyPassiveOrderError(error48) {
-  if (error48 instanceof ccxt_default.InsufficientFunds) {
-    return "InsufficientFunds";
+function buildCanonicalOrderBookRows(input) {
+  if (!Number.isSafeInteger(input.depthLimit) || input.depthLimit <= 0 || input.depthLimit > 500) {
+    throw new OrderBookValidationError("depth limit must be an integer between 1 and 500");
   }
-  if (error48 instanceof ccxt_default.AuthenticationError) {
-    return "AuthenticationError";
+  if (input.context.feed !== "ORDERBOOK") {
+    throw new OrderBookValidationError("capture context feed is not ORDERBOOK");
   }
-  const message = getErrorMessage(error48);
-  if (error48 instanceof ccxt_default.OrderImmediatelyFillable || identifiesWouldCross(message)) {
-    return PASSIVE_ORDER_ERROR_CODES.wouldCross;
+  if (input.constructionMode === "exact_l2_reconstruction") {
+    throw new OrderBookValidationError("exact L2 requires a complete continuity proof and is unsupported");
   }
-  if (error48 instanceof ccxt_default.NotSupported || identifiesUnsupported(message)) {
-    return PASSIVE_ORDER_ERROR_CODES.unsupported;
+  let eventTimeMs;
+  let receivedTimeMs;
+  try {
+    eventTimeMs = normalizeTimestampMs(input.snapshot.timestamp, "source_time_ms");
+    receivedTimeMs = normalizeTimestampMs(input.snapshot.receivedTimestamp, "received_time_ms");
+  } catch (error48) {
+    throw new OrderBookValidationError(error48 instanceof Error ? error48.message : "invalid timestamp");
   }
-  return PASSIVE_ORDER_ERROR_CODES.rejected;
+  if (receivedTimeMs < eventTimeMs) {
+    throw new OrderBookValidationError("received timestamp precedes source timestamp");
+  }
+  const bids = validateSide("bid", input.snapshot.bids, input.depthLimit);
+  const asks = validateSide("ask", input.snapshot.asks, input.depthLimit);
+  const bestBid = bids[0];
+  const bestAsk = asks[0];
+  if (bestBid.price >= bestAsk.price) {
+    throw new OrderBookValidationError("book is crossed or locked");
+  }
+  const sequence = parseSequence(input.snapshot.sequence);
+  const midPrice = (bestBid.price + bestAsk.price) / 2;
+  const spread2 = bestAsk.price - bestBid.price;
+  const spreadBps = spread2 / midPrice * 1e4;
+  const snapshotId = sha256Canonical({
+    exchange: input.context.exchange.trim().toLowerCase(),
+    trading_pair: input.context.symbol.trim().replace("/", "-"),
+    source_time_ms: eventTimeMs,
+    sequence,
+    depth_limit: input.depthLimit,
+    bids,
+    asks,
+    schema_version: input.context.schemaVersion
+  });
+  const common = commonEvidenceFields(input.context, input.rawCapture, {
+    snapshotId,
+    sequence,
+    depthLimit: input.depthLimit,
+    eventTimeMs,
+    receivedTimeMs
+  });
+  const levels = [
+    ["bid", bids],
+    ["ask", asks]
+  ].flatMap(([side, sideLevels]) => sideLevels.map(({ price, amount }, levelIndex) => {
+    const row = checksumRow({
+      ...common,
+      side,
+      level_index: levelIndex,
+      price,
+      amount,
+      notional: price * amount,
+      mid_price: midPrice,
+      spread_from_mid_bps: Math.abs((price - midPrice) / midPrice) * 1e4
+    });
+    return { table: "market_data.cex_order_book_levels", row };
+  }));
+  const bands = normalizedBands(input.measurementBandsBps);
+  const bidDepth = bands.map((band) => {
+    const minimumPrice = bestBid.price * (1 - band / 1e4);
+    return bids.filter(({ price }) => price >= minimumPrice).reduce((sum3, { amount }) => sum3 + amount, 0);
+  });
+  const askDepth = bands.map((band) => {
+    const maximumPrice = bestAsk.price * (1 + band / 1e4);
+    return asks.filter(({ price }) => price <= maximumPrice).reduce((sum3, { amount }) => sum3 + amount, 0);
+  });
+  const summaryRow = checksumRow({
+    ...common,
+    best_bid: bestBid.price,
+    best_ask: bestAsk.price,
+    best_bid_amount: bestBid.amount,
+    best_ask_amount: bestAsk.amount,
+    mid_price: midPrice,
+    spread: spread2,
+    spread_bps: spreadBps,
+    staleness_ms: receivedTimeMs - eventTimeMs,
+    bid_level_count: bids.length,
+    ask_level_count: asks.length,
+    measurement_bands_bps: bands,
+    bid_depth_by_band: bidDepth,
+    ask_depth_by_band: askDepth
+  });
+  return {
+    snapshotId,
+    levels,
+    summary: {
+      table: "market_data.cex_order_book_depth_summary",
+      row: summaryRow
+    }
+  };
 }
 
-// src/handlers/execute-action/orders.ts
-async function handleCreateOrder(ctx) {
-  const {
-    call,
-    wrappedCallback,
-    policy,
-    brokers,
-    metadata,
-    normalizedCex,
-    cex: cex3,
+// src/helpers/market-data-archive/capture-context.ts
+function createMarketCaptureContext(input) {
+  const environment = input.environment ?? "development";
+  const deploymentId = input.deploymentId.trim();
+  if (!deploymentId)
+    throw new Error("deployment_id must not be empty");
+  const configuredBundle = input.captureBundleId?.trim();
+  if (environment === "production" && !configuredBundle) {
+    throw new Error("capture_bundle_id is required for production market capture");
+  }
+  const exchange = input.exchange.trim().toLowerCase();
+  const symbol2 = input.symbol.trim();
+  if (!exchange || !symbol2) {
+    throw new Error("exchange and symbol are required for market capture");
+  }
+  return {
+    source: input.source,
+    deploymentId,
+    captureBundleId: configuredBundle ?? `development:${deploymentId}`,
+    exchange,
     symbol: symbol2,
-    selectedBrokerAccount,
-    broker,
-    verity,
-    applyVerityToBroker,
-    useVerity,
-    verityProverUrl,
-    otelMetrics,
-    brokerArchiver,
-    orderActivityTracker
-  } = ctx;
-  const verityProof = verity.proof;
-  const orderValue = parsePayloadForAction(ctx, CreateOrderPayloadSchema);
-  if (orderValue === null)
-    return;
-  const isPassiveOrder = orderValue.orderIntent === "passive_only";
-  if (isPassiveOrder && orderValue.orderType !== "limit") {
-    return ctx.wrappedCallback({
-      code: grpc6.status.INVALID_ARGUMENT,
-      message: "ValidationError: passive_only order intent requires a limit order"
-    }, null);
+    assetType: input.assetType,
+    feed: input.feed,
+    provider: input.provider?.trim() || `ccxt:${exchange}`,
+    sourceMode: input.sourceMode,
+    schemaVersion: MARKET_CAPTURE_SCHEMA_VERSION,
+    checksumAlgorithm: CHECKSUM_ALGORITHM,
+    provenanceComplete: true,
+    timeframe: input.timeframe,
+    accountSelector: input.accountSelector
+  };
+}
+function captureEnvironmentFromEnv(value = process.env.CEX_BROKER_MARKET_CAPTURE_ENVIRONMENT) {
+  const environment = value?.trim() || "development";
+  if (environment !== "development" && environment !== "production") {
+    throw new Error("CEX_BROKER_MARKET_CAPTURE_ENVIRONMENT must be development or production");
   }
-  const createOrderParams = {
-    ...orderValue.params,
-    ...orderValue.clientOrderId !== undefined && {
-      clientOrderId: orderValue.clientOrderId
-    },
-    ...isPassiveOrder && { postOnly: true }
+  return environment;
+}
+
+// src/helpers/market-data-archive/ohlcv-bar-tracker.ts
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function parseOhlcvBar(value) {
+  if (!Array.isArray(value) || value.length < 6) {
+    return null;
+  }
+  const [openTimeMs, open, high, low, close, volume, quoteVolume] = value;
+  if (!isFiniteNumber(openTimeMs) || !isFiniteNumber(open) || !isFiniteNumber(high) || !isFiniteNumber(low) || !isFiniteNumber(close) || !isFiniteNumber(volume)) {
+    return null;
+  }
+  const bar = {
+    openTimeMs,
+    open,
+    high,
+    low,
+    close,
+    volume
   };
-  let resolvedOrderTelemetry = {};
-  let marketMetadataHash;
-  let submission = "not_attempted";
-  try {
-    if (!broker) {
-      return ctx.wrappedCallback({
-        code: grpc6.status.INVALID_ARGUMENT,
-        message: `Invalid CEX key: ${cex3}. Supported keys: ${Object.keys(brokers).join(", ")}`
-      }, null);
+  if (isFiniteNumber(quoteVolume)) {
+    bar.quoteVolume = quoteVolume;
+  }
+  return bar;
+}
+function extractOhlcvBars(payload) {
+  if (!Array.isArray(payload) || payload.length === 0) {
+    return [];
+  }
+  const rawBars = Array.isArray(payload[0]) ? payload : [payload];
+  const byOpenTime = new Map;
+  for (const entry of rawBars) {
+    const bar = parseOhlcvBar(entry);
+    if (bar) {
+      byOpenTime.set(bar.openTimeMs, bar);
     }
-    const resolution = await resolveOrderExecution(policy, broker, cex3, orderValue.fromToken, orderValue.toToken, orderValue.amount, orderValue.price, orderValue.marketType);
-    if (!resolution.valid || !resolution.symbol || !resolution.side) {
-      return ctx.wrappedCallback({
-        code: grpc6.status.INVALID_ARGUMENT,
-        message: resolution.error ?? "Order rejected by policy: market or limits not satisfied"
-      }, null);
+  }
+  return [...byOpenTime.values()].sort((a, b2) => a.openTimeMs - b2.openTimeMs);
+}
+class OhlcvBarTracker {
+  lastOpenTimeMs = null;
+  lastBar = null;
+  process(payload, brokerVersion) {
+    const bars = extractOhlcvBars(payload);
+    if (bars.length === 0) {
+      return [];
     }
-    resolvedOrderTelemetry = {
-      symbol: resolution.symbol,
-      side: resolution.side,
-      requestedQuantity: resolution.amountBase ?? orderValue.amount
-    };
-    if (selectedBrokerAccount?.label) {
-      orderActivityTracker?.record(cex3, selectedBrokerAccount.label, resolution.symbol);
+    if (bars.length === 1) {
+      const [bar] = bars;
+      return bar ? this.processSingleBar(bar, brokerVersion) : [];
     }
-    const telemetryIds = extractOrderTelemetryIds(createOrderParams);
-    const submissionTimestamp = new Date().toISOString();
-    marketMetadataHash = await captureMarketMetadataSnapshot(brokerArchiver, broker, {
-      exchange: cex3,
-      accountSelector: selectedBrokerAccount?.label,
-      symbol: resolution.symbol,
-      action: "CreateOrder",
-      brokerObservedTimestamp: submissionTimestamp,
-      ...telemetryIds
-    });
-    submission = "in_flight";
-    const order = await broker.createOrder(resolution.symbol, orderValue.orderType, resolution.side, resolution.amountBase ?? orderValue.amount, orderValue.price, createOrderParams);
-    submission = "placed";
-    const createOrderContext = {
-      action: "CreateOrder",
-      cex: cex3,
-      accountLabel: selectedBrokerAccount?.label,
-      symbol: resolvedOrderTelemetry.symbol,
-      side: resolvedOrderTelemetry.side,
-      orderType: orderValue.orderType,
-      requestedQuantity: resolvedOrderTelemetry.requestedQuantity,
-      requestedNotional: orderValue.amount * orderValue.price,
-      orderAuthor: orderValue.orderAuthor,
-      brokerObservedTimestamp: submissionTimestamp,
-      ...telemetryIds
-    };
-    emitOrderExecutionTelemetryInBackground(otelMetrics, createOrderContext, order);
-    archiveOrderExecutionInBackground(brokerArchiver, createOrderContext, order, undefined, { marketMetadataHash });
-    ctx.wrappedCallback(null, {
-      result: JSON.stringify({
-        ...order,
-        ...isPassiveOrder && {
-          passivePlacementOutcome: "accepted_passive"
-        }
-      })
+    return this.processBatch(bars, brokerVersion);
+  }
+  processSingleBar(currentBar, brokerVersion) {
+    if (this.lastOpenTimeMs !== null && currentBar.openTimeMs < this.lastOpenTimeMs) {
+      return [];
+    }
+    const candidates = [];
+    if (this.lastOpenTimeMs !== null && this.lastBar !== null && currentBar.openTimeMs !== this.lastOpenTimeMs) {
+      candidates.push({
+        bar: this.lastBar,
+        isClosed: true,
+        brokerVersion
+      });
+    }
+    candidates.push({
+      bar: currentBar,
+      isClosed: false,
+      brokerVersion
     });
-  } catch (error48) {
-    rethrowArchiveDurabilityError(error48);
-    safeLogRedactedError("Order Creation failed", error48);
-    const failedCreateContext = {
-      action: "CreateOrder",
-      cex: cex3,
-      accountLabel: selectedBrokerAccount?.label,
-      symbol: resolvedOrderTelemetry.symbol ?? symbol2,
-      side: resolvedOrderTelemetry.side,
-      orderType: orderValue.orderType,
-      requestedQuantity: resolvedOrderTelemetry.requestedQuantity ?? orderValue.amount,
-      requestedNotional: orderValue.amount * orderValue.price,
-      orderAuthor: orderValue.orderAuthor,
-      ...extractOrderTelemetryIds(createOrderParams)
-    };
-    emitOrderExecutionTelemetryInBackground(otelMetrics, failedCreateContext, undefined, error48);
-    archiveOrderExecutionInBackground(brokerArchiver, failedCreateContext, undefined, error48, { marketMetadataHash });
-    if (isPassiveOrder && submission === "in_flight") {
-      const stableErrorCode = classifyPassiveOrderError(error48);
-      return rejectWithGrpcError(ctx, error48, {
-        message: `${stableErrorCode}: ${sanitizeErrorDetail(error48)}`,
-        preferStableMessageOnly: true
+    this.lastOpenTimeMs = currentBar.openTimeMs;
+    this.lastBar = currentBar;
+    return candidates;
+  }
+  processBatch(bars, brokerVersion) {
+    const firstBar = bars[0];
+    const lastBar = bars[bars.length - 1];
+    if (!firstBar || !lastBar) {
+      return [];
+    }
+    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 && lastOpenTimeMs !== null && lastOpenTimeMs < firstBarToProcess.openTimeMs) {
+      candidates.push({
+        bar: this.lastBar,
+        isClosed: true,
+        brokerVersion
       });
     }
-    ctx.wrappedCallback({
-      code: grpc6.status.INTERNAL,
-      message: `Order Creation failed: ${sanitizeErrorDetail(error48)}`
-    }, null);
+    for (let index2 = 0;index2 < barsToProcess.length - 1; index2 += 1) {
+      const bar = barsToProcess[index2];
+      if (bar) {
+        candidates.push({
+          bar,
+          isClosed: true,
+          brokerVersion
+        });
+      }
+    }
+    candidates.push({
+      bar: lastBarToProcess,
+      isClosed: false,
+      brokerVersion
+    });
+    this.lastOpenTimeMs = lastBarToProcess.openTimeMs;
+    this.lastBar = lastBarToProcess;
+    return candidates;
   }
 }
-async function handleGetOrderDetails(ctx) {
-  const {
-    call,
-    wrappedCallback,
-    policy,
-    brokers,
-    metadata,
-    normalizedCex,
-    cex: cex3,
-    symbol: symbol2,
-    selectedBrokerAccount,
-    broker,
-    verity,
-    applyVerityToBroker,
-    useVerity,
-    verityProverUrl,
-    otelMetrics,
-    brokerArchiver,
-    orderActivityTracker
-  } = ctx;
-  const verityProof = verity.proof;
-  const getOrderValue = parsePayloadForAction(ctx, GetOrderDetailsPayloadSchema);
-  if (getOrderValue === null)
-    return;
-  try {
-    if (!broker) {
-      return ctx.wrappedCallback({
-        code: grpc6.status.INVALID_ARGUMENT,
-        message: `Invalid CEX key: ${cex3}. Supported keys: ${Object.keys(brokers).join(", ")}`
-      }, 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,
-      accountLabel: selectedBrokerAccount?.label,
-      symbol: symbol2,
-      ...extractOrderTelemetryIds(getOrderValue.params)
-    };
-    emitOrderExecutionTelemetryInBackground(otelMetrics, getOrderContext, orderDetails);
-    archiveOrderExecutionInBackground(brokerArchiver, getOrderContext, orderDetails);
-    ctx.wrappedCallback(null, {
-      result: JSON.stringify({
-        orderId: orderDetails.id,
-        status: orderDetails.status,
-        amount: orderDetails.amount,
-        filled: orderDetails.filled,
-        remaining: orderDetails.remaining,
-        symbol: orderDetails.symbol,
-        side: orderDetails.side,
-        price: orderDetails.price
-      })
-    });
-  } catch (error48) {
-    safeLogError(`Error fetching order details from ${cex3}`, error48);
-    const failedGetOrderContext = {
-      action: "GetOrderDetails",
-      cex: cex3,
-      accountLabel: selectedBrokerAccount?.label,
-      symbol: symbol2,
-      ...extractOrderTelemetryIds(getOrderValue.params)
-    };
-    emitOrderExecutionTelemetryInBackground(otelMetrics, failedGetOrderContext, undefined, error48);
-    archiveOrderExecutionInBackground(brokerArchiver, failedGetOrderContext, undefined, error48);
-    ctx.wrappedCallback({
-      code: grpc6.status.INTERNAL,
-      message: `Failed to fetch order details from ${cex3}: ${sanitizeErrorDetail(error48)}`
-    }, null);
+
+// src/helpers/market-data-archive/orderbook-depth.ts
+var DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT = 25;
+var MAX_ORDERBOOK_ARCHIVE_DEPTH_LIMIT = 500;
+function getOrderbookArchiveDepthLimit() {
+  const raw = process.env.CEX_BROKER_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
+  if (!raw) {
+    return DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
   }
+  return Math.min(parsed, MAX_ORDERBOOK_ARCHIVE_DEPTH_LIMIT);
 }
-async function handleCancelOrder(ctx) {
-  const {
-    call,
-    wrappedCallback,
-    policy,
-    brokers,
-    metadata,
-    normalizedCex,
-    cex: cex3,
-    symbol: symbol2,
-    selectedBrokerAccount,
-    broker,
-    verity,
-    applyVerityToBroker,
-    useVerity,
-    verityProverUrl,
-    otelMetrics,
-    brokerArchiver,
-    orderActivityTracker
-  } = ctx;
-  const verityProof = verity.proof;
-  const cancelOrderValue = parsePayloadForAction(ctx, CancelOrderPayloadSchema);
-  if (cancelOrderValue === null)
-    return;
-  try {
-    if (!broker) {
-      return ctx.wrappedCallback({
-        code: grpc6.status.INVALID_ARGUMENT,
-        message: `Invalid CEX key: ${cex3}. Supported keys: ${Object.keys(brokers).join(", ")}`
-      }, null);
+
+// src/helpers/market-data-archive/orderbook-sampler.ts
+var DEFAULT_ORDERBOOK_INTERVAL_MS = 1000;
+function getOrderbookIntervalMs() {
+  const raw = process.env.CEX_BROKER_ORDERBOOK_INTERVAL_MS ?? process.env.CEX_BROKER_ORDERBOOK_TOB_INTERVAL_MS;
+  if (!raw) {
+    return DEFAULT_ORDERBOOK_INTERVAL_MS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ORDERBOOK_INTERVAL_MS;
+}
+function isMarketArchiveEnabled() {
+  return process.env.CEX_BROKER_MARKET_ARCHIVE_ENABLED !== "false";
+}
+
+class OrderbookSampler {
+  intervalMs;
+  lastEmitMs = null;
+  constructor(intervalMs = getOrderbookIntervalMs()) {
+    this.intervalMs = intervalMs;
+  }
+  shouldEmit(nowMs = Date.now()) {
+    if (this.lastEmitMs !== null && nowMs < this.lastEmitMs) {
+      this.lastEmitMs = nowMs;
+      return true;
     }
-    const cancelOrderContext = {
-      action: "CancelOrder",
-      cex: cex3,
-      accountLabel: selectedBrokerAccount?.label,
-      symbol: symbol2,
-      ...extractOrderTelemetryIds(cancelOrderValue.params)
-    };
-    const cancelledOrder = await broker.cancelOrder(cancelOrderValue.orderId, symbol2, cancelOrderValue.params ?? {});
-    if (selectedBrokerAccount?.label && symbol2) {
-      orderActivityTracker?.record(cex3, selectedBrokerAccount.label, symbol2);
+    if (this.lastEmitMs !== null && nowMs - this.lastEmitMs < this.intervalMs) {
+      return false;
     }
-    emitOrderExecutionTelemetryInBackground(otelMetrics, cancelOrderContext, cancelledOrder);
-    archiveOrderExecutionInBackground(brokerArchiver, cancelOrderContext, cancelledOrder);
-    ctx.wrappedCallback(null, {
-      result: JSON.stringify({ ...cancelledOrder })
-    });
-  } catch (error48) {
-    safeLogError(`Error cancelling order from ${cex3}`, error48);
-    const failedCancelContext = {
-      action: "CancelOrder",
-      cex: cex3,
-      accountLabel: selectedBrokerAccount?.label,
-      symbol: symbol2,
-      ...extractOrderTelemetryIds(cancelOrderValue.params)
-    };
-    emitOrderExecutionTelemetryInBackground(otelMetrics, failedCancelContext, undefined, error48);
-    archiveOrderExecutionInBackground(brokerArchiver, failedCancelContext, undefined, error48);
-    ctx.wrappedCallback({
-      code: grpc6.status.INTERNAL,
-      message: `Failed to cancel order from ${cex3}: ${sanitizeErrorDetail(error48)}`
-    }, null);
+    this.lastEmitMs = nowMs;
+    return true;
   }
 }
-async function handleOrders(ctx) {
-  if (ctx.action === Action.CreateOrder)
-    return handleCreateOrder(ctx);
-  if (ctx.action === Action.GetOrderDetails)
-    return handleGetOrderDetails(ctx);
-  if (ctx.action === Action.CancelOrder)
-    return handleCancelOrder(ctx);
-}
 
-// src/handlers/execute-action/pass-through.ts
-import * as grpc7 from "@grpc/grpc-js";
-async function handleFetchCurrency(ctx) {
-  const {
-    call,
-    wrappedCallback,
-    policy,
-    brokers,
-    metadata,
-    normalizedCex,
-    cex: cex3,
-    symbol: symbol2,
-    selectedBrokerAccount,
-    broker,
-    verity,
-    applyVerityToBroker,
-    useVerity,
-    verityProverUrl,
-    otelMetrics
-  } = ctx;
-  const verityProof = verity.proof;
-  if (!symbol2) {
-    return ctx.wrappedCallback({
-      code: grpc7.status.INVALID_ARGUMENT,
-      message: `ValidationError: Symbol required`
-    }, null);
+// src/helpers/market-data-archive/parse-stream.ts
+function isFiniteNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function toNumber2(value) {
+  if (isFiniteNumber2(value)) {
+    return value;
   }
-  try {
-    const assetCode = symbol2.trim().toUpperCase();
-    const currencyInfo = await fetchCurrencyMetadata(broker, assetCode);
-    if (!currencyInfo) {
-      return ctx.wrappedCallback({
-        code: grpc7.status.NOT_FOUND,
-        message: `venue_discovery_unavailable: currency not found for ${assetCode}`
-      }, null);
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
     }
-    const networkEvidence = buildTransferNetworkEvidence(currencyInfo);
-    ctx.wrappedCallback(null, {
-      proof: ctx.verity.proof,
-      result: JSON.stringify({
-        ...currencyInfo,
-        exchange: normalizedCex,
-        asset: assetCode,
-        code: currencyInfo.code ?? assetCode,
-        id: currencyInfo.id ?? null,
-        networks: networkEvidence.networks,
-        networkAliases: networkEvidence.aliases,
-        raw: currencyInfo
-      })
-    });
-  } catch (error48) {
-    safeLogError(`Error fetching currency ${symbol2} from ${cex3}`, error48);
-    const message = getErrorMessage(error48);
-    ctx.wrappedCallback({
-      code: stableGrpcErrorCode(message) ?? mapCcxtErrorToGrpcStatus(error48) ?? grpc7.status.INTERNAL,
-      message: message.startsWith("venue_discovery_unavailable:") ? message : `venue_discovery_unavailable: ${message}`
-    }, null);
   }
+  return;
 }
-async function handleFetchAccountId(ctx) {
-  const {
-    call,
-    wrappedCallback,
-    policy,
-    brokers,
-    metadata,
-    normalizedCex,
-    cex: cex3,
-    symbol: symbol2,
-    selectedBrokerAccount,
-    broker,
-    verity,
-    applyVerityToBroker,
-    useVerity,
-    verityProverUrl,
-    otelMetrics
-  } = ctx;
-  const verityProof = verity.proof;
+function toStringId(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return;
+}
+function scalarTimestampMs(value, fallbackMs) {
+  const numeric = toNumber2(value);
+  if (numeric !== undefined) {
+    return numeric < 1000000000000 ? numeric * 1000 : numeric;
+  }
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return fallbackMs;
+}
+function parseTrade(value, fallbackMs = Date.now()) {
+  const record2 = asRecord(value);
+  if (!record2) {
+    return null;
+  }
+  const tradeId = toStringId(record2.id);
+  const price = toNumber2(record2.price);
+  const amount = toNumber2(record2.amount);
+  const side = typeof record2.side === "string" ? record2.side.toLowerCase() : undefined;
+  if (!tradeId || price === undefined || amount === undefined || !side) {
+    return null;
+  }
+  const parsed = {
+    tradeId,
+    eventTimeMs: scalarTimestampMs(record2.timestamp, fallbackMs),
+    side,
+    price,
+    amount
+  };
+  const cost = toNumber2(record2.cost);
+  if (cost !== undefined) {
+    parsed.cost = cost;
+  }
+  if (typeof record2.takerOrMaker === "string") {
+    parsed.takerOrMaker = record2.takerOrMaker;
+  }
+  return parsed;
+}
+function extractTrades(payload, fallbackMs = Date.now()) {
+  if (Array.isArray(payload)) {
+    return payload.map((entry) => parseTrade(entry, fallbackMs)).filter((entry) => entry !== null);
+  }
+  const single = parseTrade(payload, fallbackMs);
+  return single ? [single] : [];
+}
+function parseTicker(value, fallbackMs) {
+  const record2 = asRecord(value);
+  if (!record2) {
+    return null;
+  }
+  const parsed = {
+    eventTimeMs: scalarTimestampMs(record2.timestamp, fallbackMs)
+  };
+  const fields = [
+    ["last", record2.last],
+    ["bid", record2.bid],
+    ["ask", record2.ask],
+    ["high", record2.high],
+    ["low", record2.low],
+    ["open", record2.open],
+    ["close", record2.close],
+    ["baseVolume", record2.baseVolume],
+    ["quoteVolume", record2.quoteVolume],
+    ["change", record2.change],
+    ["percentage", record2.percentage]
+  ];
+  for (const [key, rawValue] of fields) {
+    const numeric = toNumber2(rawValue);
+    if (numeric !== undefined) {
+      parsed[key] = numeric;
+    }
+  }
+  return parsed;
+}
+
+// src/helpers/market-data-archive/rows.ts
+function compactUndefined3(record2) {
+  return Object.fromEntries(Object.entries(record2).filter(([, value]) => value !== undefined));
+}
+function withNormalizedChecksum(record2) {
+  const compact = compactUndefined3(record2);
+  return {
+    ...compact,
+    normalized_row_checksum: sha256Canonical(compact)
+  };
+}
+function buildCanonicalCexStreamEventRow(context2, rawCapture) {
+  const row = withNormalizedChecksum({
+    ...captureCoreFields(context2, rawCapture),
+    stream_type: context2.feed,
+    event_time_ms: rawCapture.eventTimeMs,
+    payload_encoding: "canonical_json_v1",
+    payload_json: canonicalSerialize(rawCapture.redactedPayload)
+  });
+  return { table: "market_data.cex_stream_events", row };
+}
+function buildCanonicalTickerEventRow(context2, rawCapture, ticker) {
+  if (context2.feed !== "TICKER") {
+    throw new Error("Ticker row requires a TICKER capture context");
+  }
+  const row = withNormalizedChecksum({
+    ...captureCoreFields(context2, rawCapture),
+    source_time_ms: ticker.eventTimeMs,
+    event_time_ms: ticker.eventTimeMs,
+    last: ticker.last,
+    bid: ticker.bid,
+    ask: ticker.ask,
+    high: ticker.high,
+    low: ticker.low,
+    open: ticker.open,
+    close: ticker.close,
+    base_volume: ticker.baseVolume,
+    quote_volume: ticker.quoteVolume,
+    change: ticker.change,
+    percentage: ticker.percentage
+  });
+  return { table: "market_data.cex_ticker_events", row };
+}
+function buildCanonicalTradeRow(context2, rawCapture, trade) {
+  if (context2.feed !== "TRADES") {
+    throw new Error("Trade row requires a TRADES capture context");
+  }
+  const row = withNormalizedChecksum({
+    ...captureCoreFields(context2, rawCapture),
+    source_time_ms: trade.eventTimeMs,
+    trade_id: trade.tradeId,
+    event_time_ms: trade.eventTimeMs,
+    side: trade.side,
+    price: trade.price,
+    amount: trade.amount,
+    cost: trade.cost,
+    taker_or_maker: trade.takerOrMaker
+  });
+  return { table: "market_data.cex_trades", row };
+}
+function buildCanonicalOhlcvRow(input) {
+  if (input.context.feed !== "OHLCV") {
+    throw new Error("OHLCV row requires an OHLCV capture context");
+  }
+  const row = withNormalizedChecksum({
+    ...captureCoreFields(input.context, input.rawCapture),
+    source_time_ms: input.bar.openTimeMs,
+    timeframe: input.context.timeframe ?? "1m",
+    open_time_ms: input.bar.openTimeMs,
+    open: input.bar.open,
+    high: input.bar.high,
+    low: input.bar.low,
+    close: input.bar.close,
+    volume: input.bar.volume,
+    quote_volume: input.bar.quoteVolume,
+    is_closed: input.isClosed ? 1 : 0,
+    broker_version: input.brokerVersion
+  });
+  return { table: "market_data.cex_ohlcv", row };
+}
+function buildCexStreamEventRow(input) {
+  const receivedTimeMs = input.receivedTimestamp;
+  const redactedPayload = redactStreamPayload(input.payload);
+  const tags = buildCommonArchiveTags({
+    source: input.source,
+    deploymentId: input.deploymentId,
+    accountSelector: input.accountSelector,
+    exchange: input.exchange,
+    symbol: input.symbol,
+    brokerObservedTimestamp: new Date(receivedTimeMs).toISOString()
+  });
+  return {
+    table: "market_data.cex_stream_events",
+    row: compactUndefined3({
+      ...tags,
+      asset_type: input.assetType,
+      stream_type: input.streamType,
+      event_time_ms: input.eventTimeMs ?? receivedTimeMs,
+      received_time_ms: receivedTimeMs,
+      payload_json: JSON.stringify(redactedPayload)
+    })
+  };
+}
+
+// src/helpers/market-data-archive/capture.ts
+async function recordWatchMetric(otelMetrics, metricName, labels) {
   try {
-    const accountId = await broker.fetchAccountId();
-    return ctx.wrappedCallback(null, {
+    await otelMetrics?.recordCounter(metricName, 1, labels);
+  } catch {}
+}
+function watchLabels(stream4, input, archiver, feed) {
+  return {
+    stream: stream4,
+    feed,
+    source: archiver?.getSource() ?? "disabled",
+    exchange: input.exchange,
+    symbol: input.symbol
+  };
+}
+function resolveCaptureContext(archiver, input, feed, sourceMode) {
+  return createMarketCaptureContext({
+    source: archiver.getSource(),
+    deploymentId: archiver.getDeploymentId(),
+    captureBundleId: process.env.CEX_BROKER_CAPTURE_BUNDLE_ID,
+    exchange: input.exchange,
+    symbol: input.symbol,
+    assetType: input.assetType,
+    feed,
+    provider: `ccxt:${input.exchange.trim().toLowerCase()}`,
+    sourceMode,
+    timeframe: input.timeframe,
+    accountSelector: input.accountSelector,
+    environment: captureEnvironmentFromEnv()
+  });
+}
+function archiveOrderbookInBackground(archiver, otelMetrics, input, options) {
+  const labels = watchLabels("orderbook", input, archiver, "ORDERBOOK");
+  recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
+  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
+    return;
+  }
+  if (options?.sampledOut) {
+    recordWatchMetric(otelMetrics, "cex_watch_frames_sampled_out_total", labels);
+    return;
+  }
+  queueMicrotask(() => {
+    try {
+      const context2 = resolveCaptureContext(archiver, input, "ORDERBOOK", options?.sourceMode ?? "broker_live_sampling_v1");
+      const rawCapture = createRawCapture(context2, {
+        payload: input.snapshot,
+        eventTimeMs: input.snapshot.timestamp,
+        receivedTimeMs: input.snapshot.receivedTimestamp,
+        scope: "ccxt_normalized_object"
+      });
+      const canonical = buildCanonicalOrderBookRows({
+        context: context2,
+        snapshot: input.snapshot,
+        rawCapture,
+        depthLimit: options?.depthLimit ?? getOrderbookArchiveDepthLimit()
+      });
+      archiver.enqueue(buildCanonicalCexStreamEventRow(context2, rawCapture));
+      for (const row of canonical.levels)
+        archiver.enqueue(row);
+      archiver.enqueue(canonical.summary);
+      recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
+    } catch (error48) {
+      rethrowArchiveDurabilityError(error48);
+      if (error48 instanceof OrderBookValidationError) {
+        recordWatchMetric(otelMetrics, "cex_watch_frames_invalid_total", {
+          ...labels,
+          reason: error48.reason
+        });
+      }
+      log.warn("Failed to archive orderbook snapshot", { error: error48 });
+    }
+  });
+}
+function archiveOhlcvInBackground(archiver, otelMetrics, tracker, input) {
+  const labels = watchLabels("ohlcv", input, archiver, "OHLCV");
+  recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
+  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
+    return;
+  }
+  queueMicrotask(() => {
+    try {
+      const candidates = tracker.process(input.payload, input.receivedTimestamp);
+      const context2 = resolveCaptureContext(archiver, input, "OHLCV", input.sourceMode ?? "broker_live_stream_v1");
+      const rawCapture = candidates.length > 0 ? createRawCapture(context2, {
+        payload: input.payload,
+        eventTimeMs: candidates[0]?.bar.openTimeMs ?? input.receivedTimestamp,
+        receivedTimeMs: input.receivedTimestamp,
+        scope: "ccxt_normalized_object"
+      }) : undefined;
+      if (rawCapture) {
+        archiver.enqueue(buildCanonicalCexStreamEventRow(context2, rawCapture));
+      }
+      for (const candidate of candidates) {
+        if (rawCapture) {
+          archiver.enqueue(buildCanonicalOhlcvRow({
+            context: context2,
+            rawCapture,
+            bar: candidate.bar,
+            isClosed: candidate.isClosed,
+            brokerVersion: candidate.brokerVersion
+          }));
+        }
+      }
+      if (candidates.length > 0) {
+        recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
+      }
+    } catch (error48) {
+      rethrowArchiveDurabilityError(error48);
+      log.warn("Failed to archive OHLCV candle", { error: error48 });
+    }
+  });
+}
+function createOrderbookSampler() {
+  return new OrderbookSampler;
+}
+function createOhlcvBarTracker() {
+  return new OhlcvBarTracker;
+}
+function archiveMarketRowsInBackground(archiver, otelMetrics, stream4, input, feed, enqueueRows) {
+  const labels = watchLabels(stream4, input, archiver, feed);
+  recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
+  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
+    return;
+  }
+  queueMicrotask(() => {
+    try {
+      const rows = enqueueRows();
+      for (const row of rows) {
+        archiver.enqueue(row);
+      }
+      if (rows.length > 0) {
+        recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
+      }
+    } catch (error48) {
+      rethrowArchiveDurabilityError(error48);
+      log.warn(`Failed to archive ${stream4} market data`, { error: error48 });
+    }
+  });
+}
+function archiveTradesInBackground(archiver, otelMetrics, input) {
+  archiveMarketRowsInBackground(archiver, otelMetrics, "trades", input, "TRADES", () => {
+    if (!archiver)
+      return [];
+    const trades = extractTrades(input.payload, input.receivedTimestamp);
+    if (trades.length === 0)
+      return [];
+    const context2 = resolveCaptureContext(archiver, input, "TRADES", "broker_live_stream_v1");
+    const raw = createRawCapture(context2, {
+      payload: input.payload,
+      eventTimeMs: trades[0]?.eventTimeMs ?? input.receivedTimestamp,
+      receivedTimeMs: input.receivedTimestamp,
+      scope: "ccxt_normalized_object"
+    });
+    return [
+      buildCanonicalCexStreamEventRow(context2, raw),
+      ...trades.map((trade) => buildCanonicalTradeRow(context2, raw, trade))
+    ];
+  });
+}
+function archiveTickerInBackground(archiver, otelMetrics, input) {
+  archiveMarketRowsInBackground(archiver, otelMetrics, "ticker", input, "TICKER", () => {
+    const ticker = parseTicker(input.payload, input.receivedTimestamp);
+    if (!ticker || !archiver)
+      return [];
+    const context2 = resolveCaptureContext(archiver, input, "TICKER", "broker_live_stream_v1");
+    const raw = createRawCapture(context2, {
+      payload: input.payload,
+      eventTimeMs: ticker.eventTimeMs,
+      receivedTimeMs: input.receivedTimestamp,
+      scope: "ccxt_normalized_object"
+    });
+    return [
+      buildCanonicalCexStreamEventRow(context2, raw),
+      buildCanonicalTickerEventRow(context2, raw, ticker)
+    ];
+  });
+}
+function archiveCexStreamEventInBackground(archiver, otelMetrics, input) {
+  archiveMarketRowsInBackground(archiver, otelMetrics, "stream", input, input.streamType, () => [
+    buildCexStreamEventRow({
+      ...input,
+      source: archiver?.getSource()
+    })
+  ]);
+}
+
+// src/handlers/execute-action/order-book-call.ts
+async function handleOrderBookCall(ctx) {
+  const parsedOrderBookCall = parseOrderBookCallPayload(ctx.call.request.payload, {
+    exchange: ctx.normalizedCex,
+    symbol: ctx.symbol
+  });
+  if (parsedOrderBookCall.kind === "error") {
+    ctx.wrappedCallback({
+      code: grpc4.status.INVALID_ARGUMENT,
+      message: parsedOrderBookCall.message
+    }, null);
+    return true;
+  }
+  if (parsedOrderBookCall.kind !== "order_book") {
+    return false;
+  }
+  const orderBookBroker = ctx.broker;
+  if (!orderBookBroker) {
+    ctx.wrappedCallback({
+      code: grpc4.status.INVALID_ARGUMENT,
+      message: `Unsupported exchange for order-book market data: ${ctx.normalizedCex}`
+    }, null);
+    return true;
+  }
+  ctx.applyVerityToBroker(orderBookBroker);
+  try {
+    const orderBookPayload = parsedOrderBookCall.payload;
+    if (orderBookPayload.method === ORDER_BOOK_CALL_METHODS.FETCH_CAPABILITY) {
+      ctx.wrappedCallback(null, {
+        proof: ctx.verity.proof,
+        result: JSON.stringify(buildOrderBookCapability(orderBookBroker, orderBookPayload))
+      });
+      return true;
+    }
+    if (orderBookPayload.method === ORDER_BOOK_CALL_METHODS.FETCH_HISTORICAL_SNAPSHOTS) {
+      ctx.wrappedCallback(null, {
+        proof: ctx.verity.proof,
+        result: JSON.stringify(buildHistoricalOrderBookUnsupported(orderBookPayload))
+      });
+      return true;
+    }
+    const fetchOrderBook = orderBookBroker.fetchOrderBook;
+    const canFetchOrderBook = typeof fetchOrderBook === "function" && orderBookBroker.has?.fetchOrderBook !== false;
+    if (!canFetchOrderBook) {
+      ctx.wrappedCallback({
+        code: grpc4.status.UNIMPLEMENTED,
+        message: `Order-book snapshot unsupported for ${ctx.normalizedCex}`
+      }, null);
+      return true;
+    }
+    const receivedTimestamp = Date.now();
+    const rawOrderBook = await fetchOrderBook.call(orderBookBroker, orderBookPayload.symbol, orderBookPayload.depthLimit);
+    const snapshot = normalizeOrderBookSnapshot(rawOrderBook, {
+      exchange: orderBookPayload.exchange,
+      symbol: orderBookPayload.symbol,
+      depthLimit: orderBookPayload.depthLimit,
+      receivedTimestamp
+    });
+    ctx.wrappedCallback(null, {
       proof: ctx.verity.proof,
-      result: JSON.stringify({ accountId })
+      result: JSON.stringify(snapshot)
+    });
+    archiveOrderbookInBackground(ctx.brokerArchiver, ctx.otelMetrics, {
+      exchange: orderBookPayload.exchange,
+      symbol: orderBookPayload.symbol,
+      assetType: "spot",
+      accountSelector: ctx.selectedBrokerAccount?.label,
+      deploymentId: ctx.brokerArchiver?.getDeploymentId() ?? "unarchived",
+      snapshot
+    }, {
+      sourceMode: "broker_current_snapshot_v1",
+      depthLimit: orderBookPayload.depthLimit
     });
   } catch (error48) {
-    safeLogError(`Error fetching account ID ${cex3}`, error48);
+    safeLogError("Order-book Call failed", error48);
     ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
-      message: `Error fetching account ID from ${cex3}`
+      code: mapCcxtErrorToGrpcStatus(error48) ?? grpc4.status.INTERNAL,
+      message: `Order-book Call failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
+  return true;
 }
-async function handleFetchFees(ctx) {
+
+// src/handlers/execute-action/registry.ts
+import * as grpc11 from "@grpc/grpc-js";
+
+// src/handlers/execute-action/internal-transfer.ts
+import * as grpc5 from "@grpc/grpc-js";
+async function handleInternalTransfer(ctx) {
   const {
-    call,
-    wrappedCallback,
-    policy,
     brokers,
     metadata,
     normalizedCex,
-    cex: cex3,
     symbol: symbol2,
-    selectedBrokerAccount,
-    broker,
     verity,
-    applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    brokerArchiver
   } = ctx;
-  const verityProof = verity.proof;
   if (!symbol2) {
     return ctx.wrappedCallback({
-      code: grpc7.status.INVALID_ARGUMENT,
+      code: grpc5.status.INVALID_ARGUMENT,
       message: `ValidationError: Symbol required`
     }, null);
   }
-  const feesPayload = parsePayloadForAction(ctx, FetchFeesPayloadSchema);
-  if (feesPayload === null)
+  const transferPayload = parsePayloadForAction(ctx, InternalTransferPayloadSchema);
+  if (transferPayload === null)
     return;
-  const includeAllFees = feesPayload.includeAllFees || feesPayload.includeFundingFees === true;
+  if (normalizedCex !== "binance") {
+    return ctx.wrappedCallback({
+      code: grpc5.status.UNIMPLEMENTED,
+      message: `InternalTransfer is only supported for Binance`
+    }, null);
+  }
+  const pool = brokers[normalizedCex];
+  if (!pool) {
+    return ctx.wrappedCallback({
+      code: grpc5.status.FAILED_PRECONDITION,
+      message: `No broker accounts configured for ${normalizedCex}`
+    }, null);
+  }
+  const fromSelector = transferPayload.fromAccount ?? getCurrentBrokerSelector(metadata);
+  const toSelector = transferPayload.toAccount ?? "primary";
+  const sourceAccount = resolveBrokerAccount(pool, fromSelector);
+  if (!sourceAccount) {
+    return ctx.wrappedCallback({
+      code: grpc5.status.INVALID_ARGUMENT,
+      message: `Source account "${fromSelector}" is not configured`
+    }, null);
+  }
+  const destAccount = resolveBrokerAccount(pool, toSelector);
+  if (!destAccount) {
+    return ctx.wrappedCallback({
+      code: grpc5.status.INVALID_ARGUMENT,
+      message: `Destination account "${toSelector}" is not configured`
+    }, null);
+  }
   try {
-    await broker.loadMarkets();
-    const fetchFundingFees = async (currencyCodes) => {
-      let fundingFeeSource2 = "unavailable";
-      const fundingFeesByCurrency2 = {};
-      if (broker.has.fetchDepositWithdrawFees) {
-        try {
-          const feeMap = await broker.fetchDepositWithdrawFees(currencyCodes);
-          for (const code of currencyCodes) {
-            const feeInfo = feeMap[code];
-            if (!feeInfo) {
-              continue;
-            }
-            const fallbackFee = feeInfo.fee !== undefined || feeInfo.percentage !== undefined ? {
-              fee: feeInfo.fee ?? null,
-              percentage: feeInfo.percentage ?? null
-            } : null;
-            fundingFeesByCurrency2[code] = {
-              deposit: feeInfo.deposit ?? fallbackFee,
-              withdraw: feeInfo.withdraw ?? fallbackFee,
-              networks: feeInfo.networks ?? {}
-            };
-          }
-          if (Object.keys(fundingFeesByCurrency2).length > 0) {
-            fundingFeeSource2 = "fetchDepositWithdrawFees";
-          }
-        } catch (error48) {
-          safeLogError(`Error fetching deposit/withdraw fee map for ${symbol2} from ${cex3}`, error48);
-        }
-      }
-      if (fundingFeeSource2 === "unavailable") {
-        try {
-          const currencies = await broker.fetchCurrencies();
-          for (const code of currencyCodes) {
-            const currency = currencies[code];
-            if (!currency) {
-              continue;
-            }
-            fundingFeesByCurrency2[code] = {
-              deposit: {
-                enabled: currency.deposit ?? null
-              },
-              withdraw: {
-                enabled: currency.withdraw ?? null,
-                fee: currency.fee ?? null,
-                limits: currency.limits?.withdraw ?? null
-              },
-              networks: currency.networks ?? {}
-            };
-          }
-          if (Object.keys(fundingFeesByCurrency2).length > 0) {
-            fundingFeeSource2 = "currencies";
-          }
-        } catch (error48) {
-          safeLogError(`Error fetching currency metadata for fees for ${symbol2} from ${cex3}`, error48);
-        }
-      }
-      return { fundingFeeSource: fundingFeeSource2, fundingFeesByCurrency: fundingFeesByCurrency2 };
-    };
-    const isMarketSymbol = symbol2.includes("/");
-    if (isMarketSymbol) {
-      const market = await broker.market(symbol2);
-      const generalFee = broker.fees ?? null;
-      const feeStatus = broker.fees ? "available" : "unknown";
-      if (!broker.fees) {
-        log.warn(`Fee metadata unavailable for ${cex3}`, { symbol: symbol2 });
-      }
-      if (!includeAllFees) {
-        return ctx.wrappedCallback(null, {
-          proof: ctx.verity.proof,
-          result: JSON.stringify({
-            feeScope: "market",
-            generalFee,
-            feeStatus,
-            market
-          })
-        });
-      }
-      const currencyCodes = Array.from(new Set([market.base, market.quote]));
-      const { fundingFeeSource: fundingFeeSource2, fundingFeesByCurrency: fundingFeesByCurrency2 } = await fetchFundingFees(currencyCodes);
-      return ctx.wrappedCallback(null, {
-        proof: ctx.verity.proof,
-        result: JSON.stringify({
-          feeScope: "market+funding",
-          generalFee,
-          feeStatus,
-          market,
-          fundingFeeSource: fundingFeeSource2,
-          fundingFeesByCurrency: fundingFeesByCurrency2
-        })
-      });
+    if (useVerity) {
+      sourceAccount.exchange.setHttpClientOverride(buildHttpClientOverrideFromMetadata(metadata, verityProverUrl, (proof, notaryPubKey) => {
+        verity.proof = proof;
+        log.debug(`Verity proof:`, { proof, notaryPubKey });
+      }), verityHttpClientOverridePredicate);
     }
-    const tokenCode = symbol2.toUpperCase();
-    const { fundingFeeSource, fundingFeesByCurrency } = await fetchFundingFees([
-      tokenCode
-    ]);
-    return ctx.wrappedCallback(null, {
-      proof: ctx.verity.proof,
-      result: JSON.stringify({
-        feeScope: "token",
-        symbol: tokenCode,
-        fundingFeeSource,
-        fundingFeesByCurrency
-      })
+    const result = await transferBinanceInternal(sourceAccount, destAccount, symbol2, transferPayload.amount);
+    archiveTransferEventInBackground(brokerArchiver, {
+      exchange: normalizedCex,
+      accountSelector: fromSelector,
+      assetSymbol: symbol2,
+      transfer: {
+        eventKind: "internal_transfer",
+        lifecycleAction: "submit_internal_transfer",
+        status: "ok",
+        amount: String(transferPayload.amount),
+        network: "internal",
+        externalId: extractBinanceInternalTransferId(result),
+        payload: { from: fromSelector, to: toSelector, result }
+      }
+    });
+    ctx.wrappedCallback(null, {
+      proof: verity.proof,
+      result: JSON.stringify(result)
     });
   } catch (error48) {
-    safeLogError(`Error fetching fees for ${symbol2} from ${cex3}`, error48);
+    safeLogError("InternalTransfer failed", error48);
+    if (error48 instanceof BrokerAccountPreconditionError) {
+      return ctx.wrappedCallback({
+        code: grpc5.status.FAILED_PRECONDITION,
+        message: getErrorMessage(error48)
+      }, null);
+    }
+    const msg = getErrorMessage(error48);
+    let code;
+    if (msg.includes("Unsupported transfer direction")) {
+      code = grpc5.status.INVALID_ARGUMENT;
+    } else if (msg.includes("unavailable in this CCXT build")) {
+      code = grpc5.status.UNIMPLEMENTED;
+    } else {
+      code = mapCcxtErrorToGrpcStatus(error48) ?? grpc5.status.INTERNAL;
+    }
     ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
-      message: `Error fetching fees from ${cex3}`
+      code,
+      message: `InternalTransfer failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
 }
-async function handleFetchDepositAddresses(ctx) {
+
+// src/handlers/execute-action/orders.ts
+import * as grpc6 from "@grpc/grpc-js";
+
+// src/helpers/passive-order.ts
+var PASSIVE_ORDER_ERROR_CODES = {
+  unsupported: "passive_order_unsupported",
+  rejected: "passive_order_rejected",
+  wouldCross: "passive_order_would_cross"
+};
+function identifiesWouldCross(message) {
+  const normalized = message.toLowerCase();
+  return normalized.includes("would immediately match and take") || /post[\s-]?only\b.*\bwould\b.*\bimmediately\b.*\b(?:execute|fill|match)/.test(normalized) || /post[\s-]?only\b.*\bwould\b.*\b(?:execute|fill|match)\w*\b.*\bimmediately/.test(normalized);
+}
+function identifiesUnsupported(message) {
+  const normalized = message.toLowerCase();
+  return /post[\s-]?only\b.*\b(?:not supported|unsupported|does not support)\b/.test(normalized) || /\b(?:not supported|unsupported|does not support)\b.*\bpost[\s-]?only\b/.test(normalized);
+}
+function classifyPassiveOrderError(error48) {
+  if (error48 instanceof ccxt_default.InsufficientFunds) {
+    return "InsufficientFunds";
+  }
+  if (error48 instanceof ccxt_default.AuthenticationError) {
+    return "AuthenticationError";
+  }
+  const message = getErrorMessage(error48);
+  if (error48 instanceof ccxt_default.OrderImmediatelyFillable || identifiesWouldCross(message)) {
+    return PASSIVE_ORDER_ERROR_CODES.wouldCross;
+  }
+  if (error48 instanceof ccxt_default.NotSupported || identifiesUnsupported(message)) {
+    return PASSIVE_ORDER_ERROR_CODES.unsupported;
+  }
+  return PASSIVE_ORDER_ERROR_CODES.rejected;
+}
+
+// src/handlers/execute-action/orders.ts
+async function handleCreateOrder(ctx) {
   const {
     call,
     wrappedCallback,
@@ -307830,70 +308387,193 @@ async function handleFetchDepositAddresses(ctx) {
     applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    otelMetrics,
+    brokerArchiver,
+    orderActivityTracker
   } = ctx;
   const verityProof = verity.proof;
-  if (!symbol2) {
-    return ctx.wrappedCallback({
-      code: grpc7.status.INVALID_ARGUMENT,
-      message: `ValidationError: Symbol required`
-    }, null);
-  }
-  const fetchDepositAddresses = parsePayloadForAction(ctx, FetchDepositAddressesPayloadSchema);
-  if (fetchDepositAddresses === null)
+  const orderValue = parsePayloadForAction(ctx, CreateOrderPayloadSchema);
+  if (orderValue === null)
     return;
-  let depositNetwork;
-  try {
-    depositNetwork = await resolveTransferNetwork(broker, symbol2, fetchDepositAddresses.chain);
-  } catch (error48) {
-    const message = getErrorMessage(error48);
-    return ctx.wrappedCallback({
-      code: stableGrpcErrorCode(message) ?? grpc7.status.INVALID_ARGUMENT,
-      message
-    }, null);
-  }
-  const depositValidation = validateDeposit(policy, cex3, depositNetwork.brokerNetworkId, symbol2);
-  if (!depositValidation.valid) {
+  const isPassiveOrder = orderValue.orderIntent === "passive_only";
+  if (isPassiveOrder && orderValue.orderType !== "limit") {
     return ctx.wrappedCallback({
-      code: grpc7.status.PERMISSION_DENIED,
-      message: `policy_deposit_denied: ${depositValidation.error}`
+      code: grpc6.status.INVALID_ARGUMENT,
+      message: "ValidationError: passive_only order intent requires a limit order"
     }, null);
   }
+  const createOrderParams = {
+    ...orderValue.params,
+    ...orderValue.clientOrderId !== undefined && {
+      clientOrderId: orderValue.clientOrderId
+    },
+    ...isPassiveOrder && { postOnly: true }
+  };
+  let resolvedOrderTelemetry = {};
+  let marketMetadataHash;
+  let submission = "not_attempted";
   try {
-    const depositAddresses = broker.has.fetchDepositAddress === true ? [
-      await broker.fetchDepositAddress(symbol2, {
-        network: depositNetwork.exchangeNetworkId,
-        ...fetchDepositAddresses.params ?? {}
+    if (!broker) {
+      return ctx.wrappedCallback({
+        code: grpc6.status.INVALID_ARGUMENT,
+        message: `Invalid CEX key: ${cex3}. Supported keys: ${Object.keys(brokers).join(", ")}`
+      }, null);
+    }
+    const resolution = await resolveOrderExecution(policy, broker, cex3, orderValue.fromToken, orderValue.toToken, orderValue.amount, orderValue.price, orderValue.marketType);
+    if (!resolution.valid || !resolution.symbol || !resolution.side) {
+      return ctx.wrappedCallback({
+        code: grpc6.status.INVALID_ARGUMENT,
+        message: resolution.error ?? "Order rejected by policy: market or limits not satisfied"
+      }, null);
+    }
+    resolvedOrderTelemetry = {
+      symbol: resolution.symbol,
+      side: resolution.side,
+      requestedQuantity: resolution.amountBase ?? orderValue.amount
+    };
+    if (selectedBrokerAccount?.label) {
+      orderActivityTracker?.record(cex3, selectedBrokerAccount.label, resolution.symbol);
+    }
+    const telemetryIds = extractOrderTelemetryIds(createOrderParams);
+    const submissionTimestamp = new Date().toISOString();
+    marketMetadataHash = await captureMarketMetadataSnapshot(brokerArchiver, broker, {
+      exchange: cex3,
+      accountSelector: selectedBrokerAccount?.label,
+      symbol: resolution.symbol,
+      action: "CreateOrder",
+      brokerObservedTimestamp: submissionTimestamp,
+      ...telemetryIds
+    });
+    submission = "in_flight";
+    const order = await broker.createOrder(resolution.symbol, orderValue.orderType, resolution.side, resolution.amountBase ?? orderValue.amount, orderValue.price, createOrderParams);
+    submission = "placed";
+    const createOrderContext = {
+      action: "CreateOrder",
+      cex: cex3,
+      accountLabel: selectedBrokerAccount?.label,
+      symbol: resolvedOrderTelemetry.symbol,
+      side: resolvedOrderTelemetry.side,
+      orderType: orderValue.orderType,
+      requestedQuantity: resolvedOrderTelemetry.requestedQuantity,
+      requestedNotional: orderValue.amount * orderValue.price,
+      orderAuthor: orderValue.orderAuthor,
+      brokerObservedTimestamp: submissionTimestamp,
+      ...telemetryIds
+    };
+    emitOrderExecutionTelemetryInBackground(otelMetrics, createOrderContext, order);
+    archiveOrderExecutionInBackground(brokerArchiver, createOrderContext, order, undefined, { marketMetadataHash });
+    ctx.wrappedCallback(null, {
+      result: JSON.stringify({
+        ...order,
+        ...isPassiveOrder && {
+          passivePlacementOutcome: "accepted_passive"
+        }
       })
-    ] : await broker.fetchDepositAddressesByNetwork(symbol2, {
-      network: depositNetwork.exchangeNetworkId,
-      ...fetchDepositAddresses.params ?? {}
     });
-    if (depositAddresses.length > 0) {
-      return ctx.wrappedCallback(null, {
-        proof: ctx.verity.proof,
-        result: JSON.stringify(depositAddresses.map((depositAddress) => ({
-          ...depositAddress,
-          operatorAlias: depositNetwork.operatorAlias,
-          brokerNetworkId: depositNetwork.brokerNetworkId,
-          exchangeNetworkId: depositNetwork.exchangeNetworkId
-        })))
+  } catch (error48) {
+    rethrowArchiveDurabilityError(error48);
+    safeLogRedactedError("Order Creation failed", error48);
+    const failedCreateContext = {
+      action: "CreateOrder",
+      cex: cex3,
+      accountLabel: selectedBrokerAccount?.label,
+      symbol: resolvedOrderTelemetry.symbol ?? symbol2,
+      side: resolvedOrderTelemetry.side,
+      orderType: orderValue.orderType,
+      requestedQuantity: resolvedOrderTelemetry.requestedQuantity ?? orderValue.amount,
+      requestedNotional: orderValue.amount * orderValue.price,
+      orderAuthor: orderValue.orderAuthor,
+      ...extractOrderTelemetryIds(createOrderParams)
+    };
+    emitOrderExecutionTelemetryInBackground(otelMetrics, failedCreateContext, undefined, error48);
+    archiveOrderExecutionInBackground(brokerArchiver, failedCreateContext, undefined, error48, { marketMetadataHash });
+    if (isPassiveOrder && submission === "in_flight") {
+      const stableErrorCode = classifyPassiveOrderError(error48);
+      return rejectWithGrpcError(ctx, error48, {
+        message: `${stableErrorCode}: ${sanitizeErrorDetail(error48)}`,
+        preferStableMessageOnly: true
       });
     }
     ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
-      message: "Deposit confirmation failed"
+      code: grpc6.status.INTERNAL,
+      message: `Order Creation failed: ${sanitizeErrorDetail(error48)}`
     }, null);
+  }
+}
+async function handleGetOrderDetails(ctx) {
+  const {
+    call,
+    wrappedCallback,
+    policy,
+    brokers,
+    metadata,
+    normalizedCex,
+    cex: cex3,
+    symbol: symbol2,
+    selectedBrokerAccount,
+    broker,
+    verity,
+    applyVerityToBroker,
+    useVerity,
+    verityProverUrl,
+    otelMetrics,
+    brokerArchiver,
+    orderActivityTracker
+  } = ctx;
+  const verityProof = verity.proof;
+  const getOrderValue = parsePayloadForAction(ctx, GetOrderDetailsPayloadSchema);
+  if (getOrderValue === null)
+    return;
+  try {
+    if (!broker) {
+      return ctx.wrappedCallback({
+        code: grpc6.status.INVALID_ARGUMENT,
+        message: `Invalid CEX key: ${cex3}. Supported keys: ${Object.keys(brokers).join(", ")}`
+      }, 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,
+      accountLabel: selectedBrokerAccount?.label,
+      symbol: symbol2,
+      ...extractOrderTelemetryIds(getOrderValue.params)
+    };
+    emitOrderExecutionTelemetryInBackground(otelMetrics, getOrderContext, orderDetails);
+    archiveOrderExecutionInBackground(brokerArchiver, getOrderContext, orderDetails);
+    ctx.wrappedCallback(null, {
+      result: JSON.stringify({
+        orderId: orderDetails.id,
+        status: orderDetails.status,
+        amount: orderDetails.amount,
+        filled: orderDetails.filled,
+        remaining: orderDetails.remaining,
+        symbol: orderDetails.symbol,
+        side: orderDetails.side,
+        price: orderDetails.price
+      })
+    });
   } catch (error48) {
-    safeLogError("Fetch Deposit Addresses confirmation failed", error48);
-    const message = getErrorMessage(error48);
+    safeLogError(`Error fetching order details from ${cex3}`, error48);
+    const failedGetOrderContext = {
+      action: "GetOrderDetails",
+      cex: cex3,
+      accountLabel: selectedBrokerAccount?.label,
+      symbol: symbol2,
+      ...extractOrderTelemetryIds(getOrderValue.params)
+    };
+    emitOrderExecutionTelemetryInBackground(otelMetrics, failedGetOrderContext, undefined, error48);
+    archiveOrderExecutionInBackground(brokerArchiver, failedGetOrderContext, undefined, error48);
     ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
-      message: "Fetch Deposit Addresses confirmation failed: " + message
+      code: grpc6.status.INTERNAL,
+      message: `Failed to fetch order details from ${cex3}: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
 }
-async function handleFetchBalances(ctx) {
+async function handleCancelOrder(ctx) {
   const {
     call,
     wrappedCallback,
@@ -307909,63 +308589,66 @@ async function handleFetchBalances(ctx) {
     applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics
+    otelMetrics,
+    brokerArchiver,
+    orderActivityTracker
   } = ctx;
   const verityProof = verity.proof;
+  const cancelOrderValue = parsePayloadForAction(ctx, CancelOrderPayloadSchema);
+  if (cancelOrderValue === null)
+    return;
   try {
-    const payload = call.request.payload || {};
-    const providedBalanceType = payload.balanceType;
-    const balanceType = (providedBalanceType ?? "total").toString();
-    const validBalanceTypes = new Set(["free", "used", "total"]);
-    if (!validBalanceTypes.has(balanceType)) {
+    if (!broker) {
       return ctx.wrappedCallback({
-        code: grpc7.status.INVALID_ARGUMENT,
-        message: `ValidationError: invalid balanceType '${providedBalanceType}'. Expected one of: free | used | total`
+        code: grpc6.status.INVALID_ARGUMENT,
+        message: `Invalid CEX key: ${cex3}. Supported keys: ${Object.keys(brokers).join(", ")}`
       }, null);
     }
-    const params = { ...payload };
-    delete params.balanceType;
-    const marketType = parseMarketType(params.marketType);
-    delete params.marketType;
-    if (params.type === undefined) {
-      params.type = marketTypeToCcxtType(marketType);
-    }
-    let responseBalances = {};
-    if (balanceType === "free") {
-      const partial2 = await broker.fetchFreeBalance(params);
-      responseBalances = partial2 ?? {};
-    } else if (balanceType === "used") {
-      const partial2 = await broker.fetchUsedBalance(params);
-      responseBalances = partial2 ?? {};
-    } else if (balanceType === "total") {
-      const partial2 = await broker.fetchTotalBalance(params);
-      responseBalances = partial2 ?? {};
-    }
-    if (symbol2) {
-      if (typeof responseBalances[symbol2] === "number") {
-        responseBalances = {
-          [symbol2]: responseBalances[symbol2] ?? 0
-        };
-      } else {
-        responseBalances = {};
-      }
+    const cancelOrderContext = {
+      action: "CancelOrder",
+      cex: cex3,
+      accountLabel: selectedBrokerAccount?.label,
+      symbol: symbol2,
+      ...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, {
-      proof: ctx.verity.proof,
-      result: JSON.stringify({
-        balances: responseBalances,
-        balanceType
-      })
+      result: JSON.stringify({ ...cancelledOrder })
     });
   } catch (error48) {
-    safeLogError(`Error fetching balance from ${cex3}`, error48);
+    safeLogError(`Error cancelling order from ${cex3}`, error48);
+    const failedCancelContext = {
+      action: "CancelOrder",
+      cex: cex3,
+      accountLabel: selectedBrokerAccount?.label,
+      symbol: symbol2,
+      ...extractOrderTelemetryIds(cancelOrderValue.params)
+    };
+    emitOrderExecutionTelemetryInBackground(otelMetrics, failedCancelContext, undefined, error48);
+    archiveOrderExecutionInBackground(brokerArchiver, failedCancelContext, undefined, error48);
     ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
-      message: `Failed to fetch balance from ${cex3}`
+      code: grpc6.status.INTERNAL,
+      message: `Failed to cancel order from ${cex3}: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
 }
-async function handleFetchTicker(ctx) {
+async function handleOrders(ctx) {
+  if (ctx.action === Action.CreateOrder)
+    return handleCreateOrder(ctx);
+  if (ctx.action === Action.GetOrderDetails)
+    return handleGetOrderDetails(ctx);
+  if (ctx.action === Action.CancelOrder)
+    return handleCancelOrder(ctx);
+}
+
+// src/handlers/execute-action/pass-through.ts
+import * as grpc7 from "@grpc/grpc-js";
+async function handleFetchCurrency(ctx) {
   const {
     call,
     wrappedCallback,
@@ -307991,241 +308674,213 @@ async function handleFetchTicker(ctx) {
     }, null);
   }
   try {
-    const ticker = await broker.fetchTicker(symbol2);
+    const assetCode = symbol2.trim().toUpperCase();
+    const currencyInfo = await fetchCurrencyMetadata(broker, assetCode);
+    if (!currencyInfo) {
+      return ctx.wrappedCallback({
+        code: grpc7.status.NOT_FOUND,
+        message: `venue_discovery_unavailable: currency not found for ${assetCode}`
+      }, null);
+    }
+    const networkEvidence = buildTransferNetworkEvidence(currencyInfo);
     ctx.wrappedCallback(null, {
       proof: ctx.verity.proof,
-      result: JSON.stringify(ticker)
-    });
-  } catch (error48) {
-    safeLogError(`Error fetching ticker from ${cex3}`, error48);
-    ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
-      message: `Failed to fetch ticker from ${cex3}`
-    }, null);
-  }
-}
-async function handlePassThrough(ctx) {
-  if (ctx.action === Action.FetchCurrency)
-    return handleFetchCurrency(ctx);
-  if (ctx.action === Action.FetchAccountId)
-    return handleFetchAccountId(ctx);
-  if (ctx.action === Action.FetchFees)
-    return handleFetchFees(ctx);
-  if (ctx.action === Action.FetchDepositAddresses)
-    return handleFetchDepositAddresses(ctx);
-  if (ctx.action === Action.FetchBalances)
-    return handleFetchBalances(ctx);
-  if (ctx.action === Action.FetchTicker)
-    return handleFetchTicker(ctx);
-}
-
-// src/handlers/execute-action/perp-config.ts
-import * as grpc8 from "@grpc/grpc-js";
-function exchangeSupports(broker, capability) {
-  return broker.has?.[capability] === true;
-}
-function extractPerpConfigs(positions) {
-  return positions.map((position) => ({
-    symbol: typeof position.symbol === "string" ? position.symbol : undefined,
-    leverage: typeof position.leverage === "number" ? position.leverage : undefined,
-    marginMode: typeof position.marginMode === "string" ? position.marginMode : undefined
-  }));
-}
-async function handleGetPerpConfigState(ctx) {
-  const { wrappedCallback, cex: cex3, normalizedCex, broker } = ctx;
-  const payload = parsePayloadForAction(ctx, GetPerpConfigStatePayloadSchema);
-  if (payload === null) {
-    return;
-  }
-  if (!broker) {
-    return wrappedCallback({
-      code: grpc8.status.INVALID_ARGUMENT,
-      message: `Invalid CEX key: ${cex3}`
-    }, null);
-  }
-  const exchange = broker;
-  if (!exchangeSupports(exchange, "fetchPositions")) {
-    return wrappedCallback({
-      code: grpc8.status.UNIMPLEMENTED,
-      message: `${normalizedCex} does not support fetchPositions`
-    }, null);
-  }
-  try {
-    const symbols = payload.symbol ? [payload.symbol] : undefined;
-    const positions = await exchange.fetchPositions?.(symbols, payload.params);
-    ctx.wrappedCallback(null, {
       result: JSON.stringify({
+        ...currencyInfo,
         exchange: normalizedCex,
-        configs: extractPerpConfigs(positions ?? []),
-        positions: positions ?? []
+        asset: assetCode,
+        code: currencyInfo.code ?? assetCode,
+        id: currencyInfo.id ?? null,
+        networks: networkEvidence.networks,
+        networkAliases: networkEvidence.aliases,
+        raw: currencyInfo
       })
     });
   } catch (error48) {
-    safeLogError(`GetPerpConfigState failed for ${cex3}`, error48);
+    safeLogError(`Error fetching currency ${symbol2} from ${cex3}`, error48);
+    const message = getErrorMessage(error48);
     ctx.wrappedCallback({
-      code: grpc8.status.INTERNAL,
-      message: `GetPerpConfigState failed: ${sanitizeErrorDetail(error48)}`
+      code: stableGrpcErrorCode(message) ?? mapCcxtErrorToGrpcStatus(error48) ?? grpc7.status.INTERNAL,
+      message: message.startsWith("venue_discovery_unavailable:") ? message : `venue_discovery_unavailable: ${message}`
     }, null);
   }
 }
-async function handleSetPerpConfigState(ctx) {
-  const { wrappedCallback, cex: cex3, normalizedCex, broker } = ctx;
-  const payload = parsePayloadForAction(ctx, SetPerpConfigStatePayloadSchema);
-  if (payload === null) {
-    return;
-  }
-  if (!broker) {
-    return wrappedCallback({
-      code: grpc8.status.INVALID_ARGUMENT,
-      message: `Invalid CEX key: ${cex3}`
-    }, null);
-  }
-  const exchange = broker;
-  if (!exchangeSupports(exchange, "setLeverage")) {
-    return wrappedCallback({
-      code: grpc8.status.UNIMPLEMENTED,
-      message: `${normalizedCex} does not support setLeverage`
-    }, null);
-  }
+async function handleFetchAccountId(ctx) {
+  const {
+    call,
+    wrappedCallback,
+    policy,
+    brokers,
+    metadata,
+    normalizedCex,
+    cex: cex3,
+    symbol: symbol2,
+    selectedBrokerAccount,
+    broker,
+    verity,
+    applyVerityToBroker,
+    useVerity,
+    verityProverUrl,
+    otelMetrics
+  } = ctx;
+  const verityProof = verity.proof;
   try {
-    const response = await exchange.setLeverage?.(payload.leverage, payload.symbol, {
-      marginMode: payload.marginMode ?? "cross",
-      ...payload.params
-    });
-    ctx.wrappedCallback(null, {
-      result: JSON.stringify({
-        exchange: normalizedCex,
-        symbol: payload.symbol,
-        leverage: payload.leverage,
-        marginMode: payload.marginMode ?? "cross",
-        response
-      })
+    const accountId = await broker.fetchAccountId();
+    return ctx.wrappedCallback(null, {
+      proof: ctx.verity.proof,
+      result: JSON.stringify({ accountId })
     });
   } catch (error48) {
-    safeLogError(`SetPerpConfigState failed for ${cex3}`, error48);
+    safeLogError(`Error fetching account ID ${cex3}`, error48);
     ctx.wrappedCallback({
-      code: grpc8.status.INTERNAL,
-      message: `SetPerpConfigState failed: ${sanitizeErrorDetail(error48)}`
+      code: grpc7.status.INTERNAL,
+      message: `Error fetching account ID from ${cex3}`
     }, null);
   }
 }
-async function handlePerpConfig(ctx) {
-  if (ctx.action === Action.GetPerpConfigState) {
-    return handleGetPerpConfigState(ctx);
-  }
-  if (ctx.action === Action.SetPerpConfigState) {
-    return handleSetPerpConfigState(ctx);
+async function handleFetchFees(ctx) {
+  const {
+    call,
+    wrappedCallback,
+    policy,
+    brokers,
+    metadata,
+    normalizedCex,
+    cex: cex3,
+    symbol: symbol2,
+    selectedBrokerAccount,
+    broker,
+    verity,
+    applyVerityToBroker,
+    useVerity,
+    verityProverUrl,
+    otelMetrics
+  } = ctx;
+  const verityProof = verity.proof;
+  if (!symbol2) {
+    return ctx.wrappedCallback({
+      code: grpc7.status.INVALID_ARGUMENT,
+      message: `ValidationError: Symbol required`
+    }, null);
   }
-}
-
-// src/handlers/execute-action/treasury-call.ts
-import * as grpc9 from "@grpc/grpc-js";
-async function handleTreasuryCall(ctx) {
-  const { broker } = ctx;
-  const callValue = parsePayloadForAction(ctx, CallPayloadSchema);
-  if (callValue === null)
+  const feesPayload = parsePayloadForAction(ctx, FetchFeesPayloadSchema);
+  if (feesPayload === null)
     return;
-  let createOrderContext;
-  let marketMetadataHash;
+  const includeAllFees = feesPayload.includeAllFees || feesPayload.includeFundingFees === true;
   try {
-    if (callValue.functionName.startsWith("_") || callValue.functionName.includes("constructor") || callValue.functionName.includes("prototype")) {
-      return ctx.wrappedCallback({
-        code: grpc9.status.PERMISSION_DENIED,
-        message: "Access to the requested function is denied"
-      }, null);
-    }
-    const argsArray = callArgs(callValue.args, callValue.params ?? {});
-    const treasuryDiscovery = await handleTreasuryDiscoveryCall(broker, callValue.functionName, callValue.args, callValue.params ?? {});
-    if (treasuryDiscovery.handled) {
-      return ctx.wrappedCallback(null, {
-        proof: ctx.verity.proof,
-        result: JSON.stringify(treasuryDiscovery.result)
-      });
-    }
-    const fn = broker[callValue.functionName];
-    if (typeof fn !== "function" || broker.has?.[callValue.functionName] === false) {
-      return ctx.wrappedCallback({
-        code: grpc9.status.INVALID_ARGUMENT,
-        message: `Function not found on broker: ${callValue.functionName}`
-      }, null);
-    }
-    if (callValue.functionName === "createOrder") {
-      const [symbol2, orderType, side, quantity, price] = callValue.args;
-      const requestedQuantity = asFiniteNumber(quantity);
-      const requestedPrice = asFiniteNumber(price);
-      const requestedNotional = requestedQuantity !== undefined && requestedPrice !== undefined ? asFiniteNumber(requestedQuantity * requestedPrice) : undefined;
-      const telemetryIds = extractOrderTelemetryIds(callValue.params);
-      const submissionTimestamp = new Date().toISOString();
-      createOrderContext = {
-        action: "CreateOrder",
-        cex: ctx.cex,
-        accountLabel: ctx.selectedBrokerAccount?.label,
-        symbol: asNonEmptyString(symbol2),
-        orderType: asNonEmptyString(orderType),
-        side: asNonEmptyString(side),
-        requestedQuantity,
-        requestedNotional,
-        orderAuthor: callValue.orderAuthor,
-        brokerObservedTimestamp: submissionTimestamp,
-        ...telemetryIds
-      };
-      if (createOrderContext.symbol !== undefined) {
-        marketMetadataHash = await captureMarketMetadataSnapshot(ctx.brokerArchiver, broker, {
-          exchange: ctx.cex,
-          accountSelector: ctx.selectedBrokerAccount?.label,
-          symbol: createOrderContext.symbol,
-          action: "CreateOrder",
-          brokerObservedTimestamp: submissionTimestamp,
-          ...telemetryIds
+    await broker.loadMarkets();
+    const fetchFundingFees = async (currencyCodes) => {
+      let fundingFeeSource2 = "unavailable";
+      const fundingFeesByCurrency2 = {};
+      if (broker.has.fetchDepositWithdrawFees) {
+        try {
+          const feeMap = await broker.fetchDepositWithdrawFees(currencyCodes);
+          for (const code of currencyCodes) {
+            const feeInfo = feeMap[code];
+            if (!feeInfo) {
+              continue;
+            }
+            const fallbackFee = feeInfo.fee !== undefined || feeInfo.percentage !== undefined ? {
+              fee: feeInfo.fee ?? null,
+              percentage: feeInfo.percentage ?? null
+            } : null;
+            fundingFeesByCurrency2[code] = {
+              deposit: feeInfo.deposit ?? fallbackFee,
+              withdraw: feeInfo.withdraw ?? fallbackFee,
+              networks: feeInfo.networks ?? {}
+            };
+          }
+          if (Object.keys(fundingFeesByCurrency2).length > 0) {
+            fundingFeeSource2 = "fetchDepositWithdrawFees";
+          }
+        } catch (error48) {
+          safeLogError(`Error fetching deposit/withdraw fee map for ${symbol2} from ${cex3}`, error48);
+        }
+      }
+      if (fundingFeeSource2 === "unavailable") {
+        try {
+          const currencies = await broker.fetchCurrencies();
+          for (const code of currencyCodes) {
+            const currency = currencies[code];
+            if (!currency) {
+              continue;
+            }
+            fundingFeesByCurrency2[code] = {
+              deposit: {
+                enabled: currency.deposit ?? null
+              },
+              withdraw: {
+                enabled: currency.withdraw ?? null,
+                fee: currency.fee ?? null,
+                limits: currency.limits?.withdraw ?? null
+              },
+              networks: currency.networks ?? {}
+            };
+          }
+          if (Object.keys(fundingFeesByCurrency2).length > 0) {
+            fundingFeeSource2 = "currencies";
+          }
+        } catch (error48) {
+          safeLogError(`Error fetching currency metadata for fees for ${symbol2} from ${cex3}`, error48);
+        }
+      }
+      return { fundingFeeSource: fundingFeeSource2, fundingFeesByCurrency: fundingFeesByCurrency2 };
+    };
+    const isMarketSymbol = symbol2.includes("/");
+    if (isMarketSymbol) {
+      const market = await broker.market(symbol2);
+      const generalFee = broker.fees ?? null;
+      const feeStatus = broker.fees ? "available" : "unknown";
+      if (!broker.fees) {
+        log.warn(`Fee metadata unavailable for ${cex3}`, { symbol: symbol2 });
+      }
+      if (!includeAllFees) {
+        return ctx.wrappedCallback(null, {
+          proof: ctx.verity.proof,
+          result: JSON.stringify({
+            feeScope: "market",
+            generalFee,
+            feeStatus,
+            market
+          })
         });
       }
-    }
-    const result = await fn.apply(broker, argsArray);
-    if (createOrderContext !== undefined) {
-      emitOrderExecutionTelemetryInBackground(ctx.otelMetrics, createOrderContext, result);
-      archiveOrderExecutionInBackground(ctx.brokerArchiver, createOrderContext, result, undefined, { marketMetadataHash });
-    } else if (callValue.functionName === "fetchWithdrawals") {
-      archiveWithdrawalObservationsInBackground(ctx.brokerArchiver, ctx.withdrawalObservationTracker, {
-        exchange: ctx.normalizedCex,
-        accountSelector: ctx.selectedBrokerAccount?.label,
-        transactions: result
+      const currencyCodes = Array.from(new Set([market.base, market.quote]));
+      const { fundingFeeSource: fundingFeeSource2, fundingFeesByCurrency: fundingFeesByCurrency2 } = await fetchFundingFees(currencyCodes);
+      return ctx.wrappedCallback(null, {
+        proof: ctx.verity.proof,
+        result: JSON.stringify({
+          feeScope: "market+funding",
+          generalFee,
+          feeStatus,
+          market,
+          fundingFeeSource: fundingFeeSource2,
+          fundingFeesByCurrency: fundingFeesByCurrency2
+        })
       });
     }
-    ctx.wrappedCallback(null, {
+    const tokenCode = symbol2.toUpperCase();
+    const { fundingFeeSource, fundingFeesByCurrency } = await fetchFundingFees([
+      tokenCode
+    ]);
+    return ctx.wrappedCallback(null, {
       proof: ctx.verity.proof,
-      result: JSON.stringify(result)
+      result: JSON.stringify({
+        feeScope: "token",
+        symbol: tokenCode,
+        fundingFeeSource,
+        fundingFeesByCurrency
+      })
     });
   } catch (error48) {
-    if (createOrderContext !== undefined) {
-      rethrowArchiveDurabilityError(error48);
-      emitOrderExecutionTelemetryInBackground(ctx.otelMetrics, createOrderContext, undefined, error48);
-      archiveOrderExecutionInBackground(ctx.brokerArchiver, createOrderContext, undefined, error48, { marketMetadataHash });
-    }
-    safeLogError("Call failed", error48);
-    rejectWithGrpcError(ctx, error48, {
-      message: getErrorMessage(error48),
-      preferStableMessageOnly: true,
-      appendClassName: true
-    });
-  }
-}
-function asNonEmptyString(value) {
-  return typeof value === "string" && value.trim() ? value : undefined;
-}
-function asFiniteNumber(value) {
-  if (typeof value === "number") {
-    return Number.isFinite(value) ? value : undefined;
-  }
-  if (typeof value !== "string" || !value.trim()) {
-    return;
+    safeLogError(`Error fetching fees for ${symbol2} from ${cex3}`, error48);
+    ctx.wrappedCallback({
+      code: grpc7.status.INTERNAL,
+      message: `Error fetching fees from ${cex3}`
+    }, null);
   }
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : undefined;
 }
-
-// src/handlers/execute-action/withdraw.ts
-import * as grpc10 from "@grpc/grpc-js";
-async function handleWithdraw(ctx) {
+async function handleFetchDepositAddresses(ctx) {
   const {
     call,
     wrappedCallback,
@@ -308241,1183 +308896,998 @@ async function handleWithdraw(ctx) {
     applyVerityToBroker,
     useVerity,
     verityProverUrl,
-    otelMetrics,
-    brokerArchiver
+    otelMetrics
   } = ctx;
   const verityProof = verity.proof;
   if (!symbol2) {
     return ctx.wrappedCallback({
-      code: grpc10.status.INVALID_ARGUMENT,
+      code: grpc7.status.INVALID_ARGUMENT,
       message: `ValidationError: Symbol required`
     }, null);
   }
-  const transferValue = parsePayloadForAction(ctx, WithdrawPayloadSchema);
-  if (transferValue === null)
+  const fetchDepositAddresses = parsePayloadForAction(ctx, FetchDepositAddressesPayloadSchema);
+  if (fetchDepositAddresses === null)
     return;
-  let withdrawNetwork;
+  let depositNetwork;
   try {
-    withdrawNetwork = await resolveTransferNetwork(broker, symbol2, transferValue.chain);
+    depositNetwork = await resolveTransferNetwork(broker, symbol2, fetchDepositAddresses.chain);
   } catch (error48) {
     const message = getErrorMessage(error48);
     return ctx.wrappedCallback({
-      code: stableGrpcErrorCode(message) ?? grpc10.status.INVALID_ARGUMENT,
+      code: stableGrpcErrorCode(message) ?? grpc7.status.INVALID_ARGUMENT,
       message
     }, null);
   }
-  const transferValidation = validateWithdraw(policy, cex3, withdrawNetwork.brokerNetworkId, transferValue.recipientAddress, transferValue.amount, symbol2);
-  if (!transferValidation.valid) {
-    return ctx.wrappedCallback({
-      code: grpc10.status.PERMISSION_DENIED,
-      message: `policy_withdrawal_denied: ${transferValidation.error}`
-    }, null);
-  }
-  const travelRule = resolveTravelRuleDecision(policy, cex3, transferValue.recipientAddress);
-  if (travelRule.mode === "denied") {
+  const depositValidation = validateDeposit(policy, cex3, depositNetwork.brokerNetworkId, symbol2);
+  if (!depositValidation.valid) {
     return ctx.wrappedCallback({
-      code: grpc10.status.FAILED_PRECONDITION,
-      message: `travel_rule_denied: ${travelRule.error}`
+      code: grpc7.status.PERMISSION_DENIED,
+      message: `policy_deposit_denied: ${depositValidation.error}`
     }, null);
   }
-  const withdrawOrderId = transferValue.params.withdrawOrderId;
-  const clientWithdrawalId = typeof withdrawOrderId === "string" && withdrawOrderId.length > 0 ? withdrawOrderId : undefined;
   try {
-    const transaction = travelRule.mode === "localentity" ? await withdrawViaLocalEntity(broker, {
-      code: symbol2,
-      amount: transferValue.amount,
-      address: transferValue.recipientAddress,
-      network: withdrawNetwork.exchangeNetworkId,
-      questionnaire: travelRule.questionnaire,
-      params: transferValue.params
-    }) : await broker.withdraw(symbol2, transferValue.amount, transferValue.recipientAddress, undefined, {
-      ...transferValue.params ?? {},
-      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,
-        clientWithdrawalId,
-        txid: normalized.txid,
-        feeAmount: normalized.feeAmount,
-        feeCurrency: normalized.feeCurrency,
-        exchangeTimestamp: normalized.exchangeTimestamp,
-        payload: transaction
-      }
-    });
-    ctx.wrappedCallback(null, {
-      proof: ctx.verity.proof,
-      result: JSON.stringify({
-        ...transaction,
-        operatorAlias: withdrawNetwork.operatorAlias,
-        brokerNetworkId: withdrawNetwork.brokerNetworkId,
-        exchangeNetworkId: withdrawNetwork.exchangeNetworkId
+    const depositAddresses = broker.has.fetchDepositAddress === true ? [
+      await broker.fetchDepositAddress(symbol2, {
+        network: depositNetwork.exchangeNetworkId,
+        ...fetchDepositAddresses.params ?? {}
       })
+    ] : await broker.fetchDepositAddressesByNetwork(symbol2, {
+      network: depositNetwork.exchangeNetworkId,
+      ...fetchDepositAddresses.params ?? {}
     });
-  } 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,
-        clientWithdrawalId,
-        errorSummary: getErrorMessage(error48),
-        payload: { recipientAddress: transferValue.recipientAddress }
-      }
-    });
-    const code = mapCcxtErrorToGrpcStatus(error48) ?? grpc10.status.INTERNAL;
+    if (depositAddresses.length > 0) {
+      return ctx.wrappedCallback(null, {
+        proof: ctx.verity.proof,
+        result: JSON.stringify(depositAddresses.map((depositAddress) => ({
+          ...depositAddress,
+          operatorAlias: depositNetwork.operatorAlias,
+          brokerNetworkId: depositNetwork.brokerNetworkId,
+          exchangeNetworkId: depositNetwork.exchangeNetworkId
+        })))
+      });
+    }
     ctx.wrappedCallback({
-      code,
-      message: `Withdraw failed: ${sanitizeErrorDetail(error48)}`
+      code: grpc7.status.INTERNAL,
+      message: "Deposit confirmation failed"
     }, null);
-  }
-}
-
-// src/handlers/execute-action/registry.ts
-var ACTION_HANDLERS = {
-  [Action.Deposit]: handleDeposit,
-  [Action.Withdraw]: handleWithdraw,
-  [Action.Call]: handleTreasuryCall,
-  [Action.InternalTransfer]: handleInternalTransfer,
-  [Action.CreateOrder]: handleOrders,
-  [Action.GetOrderDetails]: handleOrders,
-  [Action.CancelOrder]: handleOrders,
-  [Action.FetchCurrency]: handlePassThrough,
-  [Action.FetchAccountId]: handlePassThrough,
-  [Action.FetchFees]: handlePassThrough,
-  [Action.FetchDepositAddresses]: handlePassThrough,
-  [Action.FetchBalances]: handlePassThrough,
-  [Action.FetchTicker]: handlePassThrough,
-  [Action.GetPerpConfigState]: handlePerpConfig,
-  [Action.SetPerpConfigState]: handlePerpConfig
-};
-async function dispatchExecuteAction(ctx) {
-  const handler = ACTION_HANDLERS[ctx.action];
-  if (!handler) {
+  } catch (error48) {
+    safeLogError("Fetch Deposit Addresses confirmation failed", error48);
+    const message = getErrorMessage(error48);
     ctx.wrappedCallback({
-      code: grpc11.status.INVALID_ARGUMENT,
-      message: "Invalid Action"
+      code: grpc7.status.INTERNAL,
+      message: "Fetch Deposit Addresses confirmation failed: " + message
     }, null);
-    return;
   }
-  await handler(ctx);
 }
-
-// src/handlers/execute-action/handler.ts
-function createExecuteActionHandler(deps) {
+async function handleFetchBalances(ctx) {
   const {
+    call,
+    wrappedCallback,
     policy,
     brokers,
-    whitelistIps,
-    useVerity,
-    verityProverUrl,
-    otelMetrics,
-    brokerArchiver,
-    orderActivityTracker
-  } = deps;
-  const withdrawalObservationTracker = deps.withdrawalObservationTracker ?? new WithdrawalObservationTracker;
-  return async (call, callback) => {
-    const startTime = Date.now();
-    const { action: rawAction, cex: cex3, symbol: symbol2 } = call.request;
-    const action = resolveAction(rawAction);
-    let actionCompleted = false;
-    const wrappedCallback = (error48, value) => {
-      if (!actionCompleted) {
-        actionCompleted = true;
-        const latency = Date.now() - startTime;
-        const actionName = getActionName(action);
-        otelMetrics?.recordHistogram("execute_action_duration_ms", latency, {
-          action: actionName,
-          cex: cex3 || "unknown"
-        });
-        if (error48) {
-          otelMetrics?.recordCounter("execute_action_errors_total", 1, {
-            action: actionName,
-            cex: cex3 || "unknown",
-            error_type: error48.code ? grpc12.status[error48.code] || "unknown" : "unknown"
-          });
-        } else {
-          otelMetrics?.recordCounter("execute_action_success_total", 1, {
-            action: actionName,
-            cex: cex3 || "unknown"
-          });
-        }
-      }
-      callback(error48, value);
-    };
-    try {
-      log.info(`Request - ExecuteAction:`, { action, cex: cex3, symbol: symbol2 });
-      otelMetrics?.recordCounter("execute_action_requests_total", 1, {
-        action: getActionName(action),
-        cex: cex3 || "unknown"
-      });
-      if (!authenticateRequest(call, whitelistIps)) {
-        return wrappedCallback({
-          code: grpc12.status.PERMISSION_DENIED,
-          message: "Access denied: Unauthorized IP"
-        }, null);
-      }
-      if (!action || !cex3) {
-        return wrappedCallback({
-          code: grpc12.status.INVALID_ARGUMENT,
-          message: "`action` AND `cex` fields are required"
-        }, null);
-      }
-      const normalizedCex = cex3.trim().toLowerCase();
-      const metadata = call.metadata;
-      const selectedBrokerAccount = selectBrokerAccountForCex(normalizedCex, brokers, metadata);
-      const verity = { proof: "" };
-      const applyVerityToBroker = (targetBroker) => {
-        if (!useVerity)
-          return;
-        const override = buildHttpClientOverrideFromMetadata(metadata, verityProverUrl, (proof, notaryPubKey) => {
-          verity.proof = proof;
-          log.debug(`Verity proof:`, { proof, notaryPubKey });
-        });
-        targetBroker.setHttpClientOverride(override, verityHttpClientOverridePredicate);
-      };
-      const preludeCtx = {
-        call,
-        wrappedCallback,
-        action,
-        policy,
-        brokers,
-        metadata,
-        normalizedCex,
-        cex: cex3,
-        symbol: symbol2,
-        selectedBrokerAccount,
-        broker: selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, metadata),
-        verity,
-        applyVerityToBroker,
-        useVerity,
-        verityProverUrl,
-        otelMetrics,
-        brokerArchiver,
-        orderActivityTracker,
-        withdrawalObservationTracker
-      };
-      if (action === Action.Call) {
-        const handled = await handleOrderBookCall(preludeCtx);
-        if (handled)
-          return;
-      }
-      const broker = selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, metadata);
-      if (!broker) {
-        return wrappedCallback({
-          code: grpc12.status.UNAUTHENTICATED,
-          message: `This Exchange is not registered and No API metadata was found`
-        }, null);
-      }
-      applyVerityToBroker(broker);
-      const ctx = { ...preludeCtx, broker };
-      await dispatchExecuteAction(ctx);
-    } catch (error48) {
-      safeLogError("ExecuteAction unhandled error", error48);
-      return wrappedCallback({
-        code: grpc12.status.INTERNAL,
-        message: "ExecuteAction failed unexpectedly"
+    metadata,
+    normalizedCex,
+    cex: cex3,
+    symbol: symbol2,
+    selectedBrokerAccount,
+    broker,
+    verity,
+    applyVerityToBroker,
+    useVerity,
+    verityProverUrl,
+    otelMetrics
+  } = ctx;
+  const verityProof = verity.proof;
+  try {
+    const payload = call.request.payload || {};
+    const providedBalanceType = payload.balanceType;
+    const balanceType = (providedBalanceType ?? "total").toString();
+    const validBalanceTypes = new Set(["free", "used", "total"]);
+    if (!validBalanceTypes.has(balanceType)) {
+      return ctx.wrappedCallback({
+        code: grpc7.status.INVALID_ARGUMENT,
+        message: `ValidationError: invalid balanceType '${providedBalanceType}'. Expected one of: free | used | total`
       }, null);
     }
-  };
-}
-// src/handlers/subscribe/broker-lifecycle.ts
-class SubscribeBrokerLifecycle {
-  #brokers = new Map;
-  #closing = new Map;
-  #shuttingDown = false;
-  register(broker, context2) {
-    this.#brokers.set(broker, context2);
-    if (this.#shuttingDown) {
-      this.close(broker);
+    const params = { ...payload };
+    delete params.balanceType;
+    const marketType = parseMarketType(params.marketType);
+    delete params.marketType;
+    if (params.type === undefined) {
+      params.type = marketTypeToCcxtType(marketType);
     }
-  }
-  close(broker) {
-    const existing = this.#closing.get(broker);
-    if (existing) {
-      return existing;
+    let responseBalances = {};
+    if (balanceType === "free") {
+      const partial2 = await broker.fetchFreeBalance(params);
+      responseBalances = partial2 ?? {};
+    } else if (balanceType === "used") {
+      const partial2 = await broker.fetchUsedBalance(params);
+      responseBalances = partial2 ?? {};
+    } else if (balanceType === "total") {
+      const partial2 = await broker.fetchTotalBalance(params);
+      responseBalances = partial2 ?? {};
     }
-    const context2 = this.#brokers.get(broker) ?? {
-      cex: "unknown",
-      symbol: "unknown"
-    };
-    this.#brokers.delete(broker);
-    const closing = (async () => {
-      try {
-        await broker.close();
-        log.debug("Request-scoped Subscribe broker closed", context2);
-        return "closed";
-      } catch (error48) {
-        log.warn("Failed to close request-scoped Subscribe broker", {
-          ...context2,
-          error: error48
-        });
-        return "failed";
-      } finally {
-        this.#closing.delete(broker);
+    if (symbol2) {
+      if (typeof responseBalances[symbol2] === "number") {
+        responseBalances = {
+          [symbol2]: responseBalances[symbol2] ?? 0
+        };
+      } else {
+        responseBalances = {};
       }
-    })();
-    this.#closing.set(broker, closing);
-    return closing;
-  }
-  async closeAll() {
-    this.#shuttingDown = true;
-    let failed = 0;
-    while (this.#brokers.size > 0 || this.#closing.size > 0) {
-      const inFlight = [...this.#closing.values()];
-      const fresh = [...this.#brokers.keys()].map((broker) => this.close(broker));
-      const outcomes = await Promise.all([...fresh, ...inFlight]);
-      failed += outcomes.filter((outcome) => outcome === "failed").length;
-    }
-    if (failed > 0) {
-      throw new Error(`${failed} request-scoped Subscribe broker(s) failed to close`);
     }
+    ctx.wrappedCallback(null, {
+      proof: ctx.verity.proof,
+      result: JSON.stringify({
+        balances: responseBalances,
+        balanceType
+      })
+    });
+  } catch (error48) {
+    safeLogError(`Error fetching balance from ${cex3}`, error48);
+    ctx.wrappedCallback({
+      code: grpc7.status.INTERNAL,
+      message: `Failed to fetch balance from ${cex3}`
+    }, null);
   }
 }
-// src/handlers/subscribe/handler.ts
-import * as grpc13 from "@grpc/grpc-js";
-
-// src/helpers/binance-user-data-stream.ts
-import { Buffer as Buffer2 } from "node:buffer";
-import { createHmac } from "node:crypto";
-var BINANCE_SPOT_WS_API_URL = "wss://ws-api.binance.com:443/ws-api/v3";
-var DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS = 16;
-var createWebSocket = (url3) => new wrapper_default(url3);
-var userDataRequestCounter = 0;
-function getExchangeString(exchange, key) {
-  const value = exchange[key];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`Binance user-data stream requires exchange.${key}`);
-  }
-  return value;
-}
-function sortedQuery(params) {
-  return Object.entries(params).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
-}
-function signUserDataStreamParams(exchange, params) {
-  const signParams = exchange.signParams;
-  if (typeof signParams === "function") {
-    return signParams.call(exchange, params);
-  }
-  const secret = getExchangeString(exchange, "secret");
-  return {
-    ...params,
-    signature: createHmac("sha256", secret).update(sortedQuery(params)).digest("hex")
-  };
-}
-function getBinanceSpotWsApiUrl(exchange) {
-  const urls = exchange.urls;
-  return urls?.api?.ws?.["ws-api"]?.spot ?? BINANCE_SPOT_WS_API_URL;
-}
-function getRecord(value) {
-  return typeof value === "object" && value !== null ? value : null;
-}
-function getMessage(value) {
-  if (value instanceof Error) {
-    return value.message;
-  }
-  if (typeof value === "string" && value.length > 0) {
-    return value;
+async function handleFetchTicker(ctx) {
+  const {
+    call,
+    wrappedCallback,
+    policy,
+    brokers,
+    metadata,
+    normalizedCex,
+    cex: cex3,
+    symbol: symbol2,
+    selectedBrokerAccount,
+    broker,
+    verity,
+    applyVerityToBroker,
+    useVerity,
+    verityProverUrl,
+    otelMetrics
+  } = ctx;
+  const verityProof = verity.proof;
+  if (!symbol2) {
+    return ctx.wrappedCallback({
+      code: grpc7.status.INVALID_ARGUMENT,
+      message: `ValidationError: Symbol required`
+    }, null);
   }
-  const record2 = getRecord(value);
-  const message = record2?.message;
-  return typeof message === "string" && message.length > 0 ? message : null;
-}
-function getOptionalExchangeString(exchange, key) {
-  const value = exchange[key];
-  return typeof value === "string" && value.length > 0 ? value : null;
-}
-function redactDiagnosticMessage(message, secretValues) {
-  let redacted = message;
-  for (const value of secretValues) {
-    if (value.length > 0) {
-      redacted = redacted.split(value).join("[redacted]");
-    }
+  try {
+    const ticker = await broker.fetchTicker(symbol2);
+    ctx.wrappedCallback(null, {
+      proof: ctx.verity.proof,
+      result: JSON.stringify(ticker)
+    });
+  } catch (error48) {
+    safeLogError(`Error fetching ticker from ${cex3}`, error48);
+    ctx.wrappedCallback({
+      code: grpc7.status.INTERNAL,
+      message: `Failed to fetch ticker from ${cex3}`
+    }, null);
   }
-  return redacted.replace(/(\b(?:apiKey|secret|signature)\b\s*=\s*)[^\s&,;)]+/gi, "$1[redacted]").replace(/("(?:apiKey|secret|signature)"\s*:\s*")[^"]*(")/gi, "$1[redacted]$2");
 }
-function formatBinanceUserDataWebSocketError(event, secretValues) {
-  const record2 = getRecord(event);
-  const message = getMessage(record2?.error) ?? getMessage(record2?.message) ?? getMessage(event);
-  const safeMessage = message === null ? null : redactDiagnosticMessage(message, secretValues);
-  return new Error(safeMessage ? `Binance user-data WebSocket error: ${safeMessage}` : "Binance user-data WebSocket error");
+async function handlePassThrough(ctx) {
+  if (ctx.action === Action.FetchCurrency)
+    return handleFetchCurrency(ctx);
+  if (ctx.action === Action.FetchAccountId)
+    return handleFetchAccountId(ctx);
+  if (ctx.action === Action.FetchFees)
+    return handleFetchFees(ctx);
+  if (ctx.action === Action.FetchDepositAddresses)
+    return handleFetchDepositAddresses(ctx);
+  if (ctx.action === Action.FetchBalances)
+    return handleFetchBalances(ctx);
+  if (ctx.action === Action.FetchTicker)
+    return handleFetchTicker(ctx);
 }
-function getCloseReason(value) {
-  if (typeof value === "string") {
-    return value.length > 0 ? value : null;
-  }
-  if (Buffer2.isBuffer(value)) {
-    const reason = value.toString("utf8");
-    return reason.length > 0 ? reason : null;
-  }
-  if (value instanceof Uint8Array) {
-    const reason = Buffer2.from(value).toString("utf8");
-    return reason.length > 0 ? reason : null;
-  }
-  return null;
+
+// src/handlers/execute-action/perp-config.ts
+import * as grpc8 from "@grpc/grpc-js";
+function exchangeSupports(broker, capability) {
+  return broker.has?.[capability] === true;
 }
-function formatBinanceUserDataWebSocketClose(codeOrEvent, reasonOrUndefined, secretValues) {
-  const record2 = getRecord(codeOrEvent);
-  const code = record2 ? record2.code : codeOrEvent;
-  const reason = getCloseReason(record2 ? record2.reason : reasonOrUndefined);
-  const safeReason = reason === null ? null : redactDiagnosticMessage(reason, secretValues);
-  const details = [
-    typeof code === "number" || typeof code === "string" ? `code=${code}` : null,
-    safeReason ? `reason=${safeReason}` : null
-  ].filter((detail) => detail !== null);
-  return new Error(details.length > 0 ? `Binance user-data WebSocket closed unexpectedly (${details.join(", ")})` : "Binance user-data WebSocket closed unexpectedly");
+function extractPerpConfigs(positions) {
+  return positions.map((position) => ({
+    symbol: typeof position.symbol === "string" ? position.symbol : undefined,
+    leverage: typeof position.leverage === "number" ? position.leverage : undefined,
+    marginMode: typeof position.marginMode === "string" ? position.marginMode : undefined
+  }));
 }
-function decodeMessageData(data) {
-  if (typeof data === "string") {
-    return data;
-  }
-  if (Buffer2.isBuffer(data)) {
-    return data.toString("utf8");
+async function handleGetPerpConfigState(ctx) {
+  const { wrappedCallback, cex: cex3, normalizedCex, broker } = ctx;
+  const payload = parsePayloadForAction(ctx, GetPerpConfigStatePayloadSchema);
+  if (payload === null) {
+    return;
   }
-  if (data instanceof ArrayBuffer) {
-    return Buffer2.from(data).toString("utf8");
+  if (!broker) {
+    return wrappedCallback({
+      code: grpc8.status.INVALID_ARGUMENT,
+      message: `Invalid CEX key: ${cex3}`
+    }, null);
   }
-  if (ArrayBuffer.isView(data)) {
-    return Buffer2.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
+  const exchange = broker;
+  if (!exchangeSupports(exchange, "fetchPositions")) {
+    return wrappedCallback({
+      code: grpc8.status.UNIMPLEMENTED,
+      message: `${normalizedCex} does not support fetchPositions`
+    }, null);
   }
-  if (Array.isArray(data) && data.every((item) => Buffer2.isBuffer(item))) {
-    return Buffer2.concat(data).toString("utf8");
+  try {
+    const symbols = payload.symbol ? [payload.symbol] : undefined;
+    const positions = await exchange.fetchPositions?.(symbols, payload.params);
+    ctx.wrappedCallback(null, {
+      result: JSON.stringify({
+        exchange: normalizedCex,
+        configs: extractPerpConfigs(positions ?? []),
+        positions: positions ?? []
+      })
+    });
+  } catch (error48) {
+    safeLogError(`GetPerpConfigState failed for ${cex3}`, error48);
+    ctx.wrappedCallback({
+      code: grpc8.status.INTERNAL,
+      message: `GetPerpConfigState failed: ${sanitizeErrorDetail(error48)}`
+    }, null);
   }
-  return data;
 }
-
-class BinanceSpotUserDataStream {
-  exchange;
-  ws;
-  secretValues;
-  requestId = `user-data-${Date.now()}-${userDataRequestCounter++}`;
-  maxBufferedEvents;
-  queue = [];
-  waiters = [];
-  closed = false;
-  closeError = null;
-  subscriptionId = null;
-  constructor(exchange, options = {}) {
-    this.exchange = exchange;
-    this.maxBufferedEvents = options.maxBufferedEvents ?? DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS;
-    this.secretValues = [
-      getOptionalExchangeString(exchange, "apiKey"),
-      getOptionalExchangeString(exchange, "secret")
-    ].filter((value) => value !== null);
-    this.ws = createWebSocket(getBinanceSpotWsApiUrl(exchange));
-    this.ws.on("open", () => this.subscribe());
-    this.ws.on("message", (data) => this.handleMessage(data));
-    this.ws.on("error", (error48) => this.fail(formatBinanceUserDataWebSocketError(error48, this.secretValues)));
-    this.ws.on("close", (code, reason) => this.handleClose(code, reason));
-  }
-  async* [Symbol.asyncIterator]() {
-    while (true) {
-      const event = await this.nextEvent();
-      if (!event) {
-        break;
-      }
-      yield event;
-    }
+async function handleSetPerpConfigState(ctx) {
+  const { wrappedCallback, cex: cex3, normalizedCex, broker } = ctx;
+  const payload = parsePayloadForAction(ctx, SetPerpConfigStatePayloadSchema);
+  if (payload === null) {
+    return;
   }
-  close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    this.queue.length = 0;
-    try {
-      this.ws.close();
-    } catch {}
-    this.flushWaiters();
+  if (!broker) {
+    return wrappedCallback({
+      code: grpc8.status.INVALID_ARGUMENT,
+      message: `Invalid CEX key: ${cex3}`
+    }, null);
   }
-  handleClose(code, reason) {
-    if (this.closed) {
-      return;
-    }
-    this.fail(formatBinanceUserDataWebSocketClose(code, reason, this.secretValues));
+  const exchange = broker;
+  if (!exchangeSupports(exchange, "setLeverage")) {
+    return wrappedCallback({
+      code: grpc8.status.UNIMPLEMENTED,
+      message: `${normalizedCex} does not support setLeverage`
+    }, null);
   }
-  subscribe() {
-    const apiKey = getExchangeString(this.exchange, "apiKey");
-    const signedParams = signUserDataStreamParams(this.exchange, {
-      apiKey,
-      timestamp: Date.now()
+  try {
+    const response = await exchange.setLeverage?.(payload.leverage, payload.symbol, {
+      marginMode: payload.marginMode ?? "cross",
+      ...payload.params
     });
-    this.ws.send(JSON.stringify({
-      id: this.requestId,
-      method: "userDataStream.subscribe.signature",
-      params: signedParams
-    }));
+    ctx.wrappedCallback(null, {
+      result: JSON.stringify({
+        exchange: normalizedCex,
+        symbol: payload.symbol,
+        leverage: payload.leverage,
+        marginMode: payload.marginMode ?? "cross",
+        response
+      })
+    });
+  } catch (error48) {
+    safeLogError(`SetPerpConfigState failed for ${cex3}`, error48);
+    ctx.wrappedCallback({
+      code: grpc8.status.INTERNAL,
+      message: `SetPerpConfigState failed: ${sanitizeErrorDetail(error48)}`
+    }, null);
   }
-  handleMessage(data) {
-    if (this.closed) {
-      return;
-    }
-    let message;
-    try {
-      const decodedData = decodeMessageData(data);
-      message = typeof decodedData === "string" ? JSON.parse(decodedData) : decodedData;
-    } catch (error48) {
-      this.fail(error48 instanceof Error ? error48 : new Error("Invalid Binance user-data message"));
-      return;
-    }
-    if ("id" in message && message.id === this.requestId) {
-      if (message.status !== 200) {
-        this.fail(new Error(message.error?.msg ?? message.error?.message ?? `Binance user-data subscription failed with status ${message.status}`));
-        return;
-      }
-      this.subscriptionId = message.result?.subscriptionId ?? null;
-      return;
-    }
-    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 errorCode2 = message.error?.code;
-      this.fail(new Error(typeof errorCode2 === "number" ? `${errorMessage} (code ${errorCode2})` : errorMessage));
-      return;
-    }
-    if (!("event" in message) || !message.event) {
-      return;
-    }
-    const subscriptionId = message.subscriptionId ?? this.subscriptionId;
-    if (subscriptionId === null || subscriptionId === undefined) {
-      return;
-    }
-    this.push({ subscriptionId, event: message.event });
+}
+async function handlePerpConfig(ctx) {
+  if (ctx.action === Action.GetPerpConfigState) {
+    return handleGetPerpConfigState(ctx);
   }
-  push(event) {
-    if (this.closed) {
-      return;
-    }
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      waiter.resolve(event);
-      return;
+  if (ctx.action === Action.SetPerpConfigState) {
+    return handleSetPerpConfigState(ctx);
+  }
+}
+
+// src/handlers/execute-action/treasury-call.ts
+import * as grpc9 from "@grpc/grpc-js";
+async function handleTreasuryCall(ctx) {
+  const { broker } = ctx;
+  const callValue = parsePayloadForAction(ctx, CallPayloadSchema);
+  if (callValue === null)
+    return;
+  let createOrderContext;
+  let marketMetadataHash;
+  try {
+    if (callValue.functionName.startsWith("_") || callValue.functionName.includes("constructor") || callValue.functionName.includes("prototype")) {
+      return ctx.wrappedCallback({
+        code: grpc9.status.PERMISSION_DENIED,
+        message: "Access to the requested function is denied"
+      }, null);
     }
-    if (this.queue.length >= this.maxBufferedEvents) {
-      this.fail(new Error(`Binance user-data stream buffered event limit exceeded (${this.maxBufferedEvents}); downstream consumer is not keeping up`));
-      return;
+    const argsArray = callArgs(callValue.args, callValue.params ?? {});
+    const treasuryDiscovery = await handleTreasuryDiscoveryCall(broker, callValue.functionName, callValue.args, callValue.params ?? {});
+    if (treasuryDiscovery.handled) {
+      return ctx.wrappedCallback(null, {
+        proof: ctx.verity.proof,
+        result: JSON.stringify(treasuryDiscovery.result)
+      });
     }
-    this.queue.push(event);
-  }
-  nextEvent() {
-    const event = this.queue.shift();
-    if (event) {
-      return Promise.resolve(event);
+    const fn = broker[callValue.functionName];
+    if (typeof fn !== "function" || broker.has?.[callValue.functionName] === false) {
+      return ctx.wrappedCallback({
+        code: grpc9.status.INVALID_ARGUMENT,
+        message: `Function not found on broker: ${callValue.functionName}`
+      }, null);
     }
-    if (this.closeError) {
-      return Promise.reject(this.closeError);
+    if (callValue.functionName === "createOrder") {
+      const [symbol2, orderType, side, quantity, price] = callValue.args;
+      const requestedQuantity = asFiniteNumber(quantity);
+      const requestedPrice = asFiniteNumber(price);
+      const requestedNotional = requestedQuantity !== undefined && requestedPrice !== undefined ? asFiniteNumber(requestedQuantity * requestedPrice) : undefined;
+      const telemetryIds = extractOrderTelemetryIds(callValue.params);
+      const submissionTimestamp = new Date().toISOString();
+      createOrderContext = {
+        action: "CreateOrder",
+        cex: ctx.cex,
+        accountLabel: ctx.selectedBrokerAccount?.label,
+        symbol: asNonEmptyString(symbol2),
+        orderType: asNonEmptyString(orderType),
+        side: asNonEmptyString(side),
+        requestedQuantity,
+        requestedNotional,
+        orderAuthor: callValue.orderAuthor,
+        brokerObservedTimestamp: submissionTimestamp,
+        ...telemetryIds
+      };
+      if (createOrderContext.symbol !== undefined) {
+        marketMetadataHash = await captureMarketMetadataSnapshot(ctx.brokerArchiver, broker, {
+          exchange: ctx.cex,
+          accountSelector: ctx.selectedBrokerAccount?.label,
+          symbol: createOrderContext.symbol,
+          action: "CreateOrder",
+          brokerObservedTimestamp: submissionTimestamp,
+          ...telemetryIds
+        });
+      }
     }
-    if (this.closed) {
-      return Promise.resolve(null);
+    const result = await fn.apply(broker, argsArray);
+    if (createOrderContext !== undefined) {
+      emitOrderExecutionTelemetryInBackground(ctx.otelMetrics, createOrderContext, result);
+      archiveOrderExecutionInBackground(ctx.brokerArchiver, createOrderContext, result, undefined, { marketMetadataHash });
+    } else if (callValue.functionName === "fetchWithdrawals") {
+      archiveWithdrawalObservationsInBackground(ctx.brokerArchiver, ctx.withdrawalObservationTracker, {
+        exchange: ctx.normalizedCex,
+        accountSelector: ctx.selectedBrokerAccount?.label,
+        transactions: result
+      });
     }
-    return new Promise((resolve, reject) => {
-      this.waiters.push({ resolve, reject });
+    ctx.wrappedCallback(null, {
+      proof: ctx.verity.proof,
+      result: JSON.stringify(result)
     });
-  }
-  fail(error48) {
-    if (this.closeError) {
-      return;
-    }
-    this.closeError = error48;
-    this.closed = true;
-    this.queue.length = 0;
-    this.flushWaiters();
-    try {
-      this.ws.close();
-    } catch {}
-  }
-  flushWaiters() {
-    const error48 = this.closeError;
-    for (const waiter of this.waiters.splice(0)) {
-      if (error48) {
-        waiter.reject(error48);
-      } else {
-        waiter.resolve(null);
-      }
+  } catch (error48) {
+    if (createOrderContext !== undefined) {
+      rethrowArchiveDurabilityError(error48);
+      emitOrderExecutionTelemetryInBackground(ctx.otelMetrics, createOrderContext, undefined, error48);
+      archiveOrderExecutionInBackground(ctx.brokerArchiver, createOrderContext, undefined, error48, { marketMetadataHash });
     }
+    safeLogError("Call failed", error48);
+    rejectWithGrpcError(ctx, error48, {
+      message: getErrorMessage(error48),
+      preferStableMessageOnly: true,
+      appendClassName: true
+    });
   }
 }
-function isBinanceBalanceUserDataEvent(event) {
-  return event.e === "outboundAccountPosition" || event.e === "balanceUpdate" || event.e === "externalLockUpdate";
-}
-function isBinanceOrderUserDataEvent(event) {
-  return event.e === "executionReport" || event.e === "listStatus";
-}
-
-// src/helpers/market-data-archive/ohlcv-bar-tracker.ts
-function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
+function asNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
 }
-function parseOhlcvBar(value) {
-  if (!Array.isArray(value) || value.length < 6) {
-    return null;
-  }
-  const [openTimeMs, open, high, low, close, volume, quoteVolume] = value;
-  if (!isFiniteNumber(openTimeMs) || !isFiniteNumber(open) || !isFiniteNumber(high) || !isFiniteNumber(low) || !isFiniteNumber(close) || !isFiniteNumber(volume)) {
-    return null;
+function asFiniteNumber(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : undefined;
   }
-  const bar = {
-    openTimeMs,
-    open,
-    high,
-    low,
-    close,
-    volume
-  };
-  if (isFiniteNumber(quoteVolume)) {
-    bar.quoteVolume = quoteVolume;
+  if (typeof value !== "string" || !value.trim()) {
+    return;
   }
-  return bar;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
 }
-function extractOhlcvBars(payload) {
-  if (!Array.isArray(payload) || payload.length === 0) {
-    return [];
+
+// src/handlers/execute-action/withdraw.ts
+import * as grpc10 from "@grpc/grpc-js";
+async function handleWithdraw(ctx) {
+  const {
+    call,
+    wrappedCallback,
+    policy,
+    brokers,
+    metadata,
+    normalizedCex,
+    cex: cex3,
+    symbol: symbol2,
+    selectedBrokerAccount,
+    broker,
+    verity,
+    applyVerityToBroker,
+    useVerity,
+    verityProverUrl,
+    otelMetrics,
+    brokerArchiver
+  } = ctx;
+  const verityProof = verity.proof;
+  if (!symbol2) {
+    return ctx.wrappedCallback({
+      code: grpc10.status.INVALID_ARGUMENT,
+      message: `ValidationError: Symbol required`
+    }, null);
   }
-  const rawBars = Array.isArray(payload[0]) ? payload : [payload];
-  const byOpenTime = new Map;
-  for (const entry of rawBars) {
-    const bar = parseOhlcvBar(entry);
-    if (bar) {
-      byOpenTime.set(bar.openTimeMs, bar);
-    }
+  const transferValue = parsePayloadForAction(ctx, WithdrawPayloadSchema);
+  if (transferValue === null)
+    return;
+  let withdrawNetwork;
+  try {
+    withdrawNetwork = await resolveTransferNetwork(broker, symbol2, transferValue.chain);
+  } catch (error48) {
+    const message = getErrorMessage(error48);
+    return ctx.wrappedCallback({
+      code: stableGrpcErrorCode(message) ?? grpc10.status.INVALID_ARGUMENT,
+      message
+    }, null);
   }
-  return [...byOpenTime.values()].sort((a, b2) => a.openTimeMs - b2.openTimeMs);
-}
-class OhlcvBarTracker {
-  lastOpenTimeMs = null;
-  lastBar = null;
-  process(payload, brokerVersion) {
-    const bars = extractOhlcvBars(payload);
-    if (bars.length === 0) {
-      return [];
-    }
-    if (bars.length === 1) {
-      const [bar] = bars;
-      return bar ? this.processSingleBar(bar, brokerVersion) : [];
-    }
-    return this.processBatch(bars, brokerVersion);
+  const transferValidation = validateWithdraw(policy, cex3, withdrawNetwork.brokerNetworkId, transferValue.recipientAddress, transferValue.amount, symbol2);
+  if (!transferValidation.valid) {
+    return ctx.wrappedCallback({
+      code: grpc10.status.PERMISSION_DENIED,
+      message: `policy_withdrawal_denied: ${transferValidation.error}`
+    }, null);
   }
-  processSingleBar(currentBar, brokerVersion) {
-    if (this.lastOpenTimeMs !== null && currentBar.openTimeMs < this.lastOpenTimeMs) {
-      return [];
-    }
-    const candidates = [];
-    if (this.lastOpenTimeMs !== null && this.lastBar !== null && currentBar.openTimeMs !== this.lastOpenTimeMs) {
-      candidates.push({
-        bar: this.lastBar,
-        isClosed: true,
-        brokerVersion
-      });
-    }
-    candidates.push({
-      bar: currentBar,
-      isClosed: false,
-      brokerVersion
-    });
-    this.lastOpenTimeMs = currentBar.openTimeMs;
-    this.lastBar = currentBar;
-    return candidates;
+  const travelRule = resolveTravelRuleDecision(policy, cex3, transferValue.recipientAddress);
+  if (travelRule.mode === "denied") {
+    return ctx.wrappedCallback({
+      code: grpc10.status.FAILED_PRECONDITION,
+      message: `travel_rule_denied: ${travelRule.error}`
+    }, null);
   }
-  processBatch(bars, brokerVersion) {
-    const firstBar = bars[0];
-    const lastBar = bars[bars.length - 1];
-    if (!firstBar || !lastBar) {
-      return [];
-    }
-    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 && lastOpenTimeMs !== null && lastOpenTimeMs < firstBarToProcess.openTimeMs) {
-      candidates.push({
-        bar: this.lastBar,
-        isClosed: true,
-        brokerVersion
-      });
-    }
-    for (let index2 = 0;index2 < barsToProcess.length - 1; index2 += 1) {
-      const bar = barsToProcess[index2];
-      if (bar) {
-        candidates.push({
-          bar,
-          isClosed: true,
-          brokerVersion
-        });
+  const withdrawOrderId = transferValue.params.withdrawOrderId;
+  const clientWithdrawalId = typeof withdrawOrderId === "string" && withdrawOrderId.length > 0 ? withdrawOrderId : undefined;
+  try {
+    const transaction = travelRule.mode === "localentity" ? await withdrawViaLocalEntity(broker, {
+      code: symbol2,
+      amount: transferValue.amount,
+      address: transferValue.recipientAddress,
+      network: withdrawNetwork.exchangeNetworkId,
+      questionnaire: travelRule.questionnaire,
+      params: transferValue.params
+    }) : await broker.withdraw(symbol2, transferValue.amount, transferValue.recipientAddress, undefined, {
+      ...transferValue.params ?? {},
+      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,
+        clientWithdrawalId,
+        txid: normalized.txid,
+        feeAmount: normalized.feeAmount,
+        feeCurrency: normalized.feeCurrency,
+        exchangeTimestamp: normalized.exchangeTimestamp,
+        payload: transaction
+      }
+    });
+    ctx.wrappedCallback(null, {
+      proof: ctx.verity.proof,
+      result: JSON.stringify({
+        ...transaction,
+        operatorAlias: withdrawNetwork.operatorAlias,
+        brokerNetworkId: withdrawNetwork.brokerNetworkId,
+        exchangeNetworkId: withdrawNetwork.exchangeNetworkId
+      })
+    });
+  } 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,
+        clientWithdrawalId,
+        errorSummary: getErrorMessage(error48),
+        payload: { recipientAddress: transferValue.recipientAddress }
       }
-    }
-    candidates.push({
-      bar: lastBarToProcess,
-      isClosed: false,
-      brokerVersion
     });
-    this.lastOpenTimeMs = lastBarToProcess.openTimeMs;
-    this.lastBar = lastBarToProcess;
-    return candidates;
-  }
-}
-
-// src/helpers/market-data-archive/orderbook-sampler.ts
-var DEFAULT_ORDERBOOK_INTERVAL_MS = 1000;
-function getOrderbookIntervalMs() {
-  const raw = process.env.CEX_BROKER_ORDERBOOK_INTERVAL_MS ?? process.env.CEX_BROKER_ORDERBOOK_TOB_INTERVAL_MS;
-  if (!raw) {
-    return DEFAULT_ORDERBOOK_INTERVAL_MS;
+    const code = mapCcxtErrorToGrpcStatus(error48) ?? grpc10.status.INTERNAL;
+    ctx.wrappedCallback({
+      code,
+      message: `Withdraw failed: ${sanitizeErrorDetail(error48)}`
+    }, null);
   }
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ORDERBOOK_INTERVAL_MS;
-}
-function isMarketArchiveEnabled() {
-  return process.env.CEX_BROKER_MARKET_ARCHIVE_ENABLED !== "false";
 }
 
-class OrderbookSampler {
-  intervalMs;
-  lastEmitMs = null;
-  constructor(intervalMs = getOrderbookIntervalMs()) {
-    this.intervalMs = intervalMs;
-  }
-  shouldEmit(nowMs = Date.now()) {
-    if (this.lastEmitMs !== null && nowMs < this.lastEmitMs) {
-      this.lastEmitMs = nowMs;
-      return true;
-    }
-    if (this.lastEmitMs !== null && nowMs - this.lastEmitMs < this.intervalMs) {
-      return false;
-    }
-    this.lastEmitMs = nowMs;
-    return true;
+// src/handlers/execute-action/registry.ts
+var ACTION_HANDLERS = {
+  [Action.Deposit]: handleDeposit,
+  [Action.Withdraw]: handleWithdraw,
+  [Action.Call]: handleTreasuryCall,
+  [Action.InternalTransfer]: handleInternalTransfer,
+  [Action.CreateOrder]: handleOrders,
+  [Action.GetOrderDetails]: handleOrders,
+  [Action.CancelOrder]: handleOrders,
+  [Action.FetchCurrency]: handlePassThrough,
+  [Action.FetchAccountId]: handlePassThrough,
+  [Action.FetchFees]: handlePassThrough,
+  [Action.FetchDepositAddresses]: handlePassThrough,
+  [Action.FetchBalances]: handlePassThrough,
+  [Action.FetchTicker]: handlePassThrough,
+  [Action.GetPerpConfigState]: handlePerpConfig,
+  [Action.SetPerpConfigState]: handlePerpConfig
+};
+async function dispatchExecuteAction(ctx) {
+  const handler = ACTION_HANDLERS[ctx.action];
+  if (!handler) {
+    ctx.wrappedCallback({
+      code: grpc11.status.INVALID_ARGUMENT,
+      message: "Invalid Action"
+    }, null);
+    return;
   }
+  await handler(ctx);
 }
 
-// src/helpers/market-data-archive/parse-stream.ts
-function isFiniteNumber2(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function toNumber2(value) {
-  if (isFiniteNumber2(value)) {
-    return value;
-  }
-  if (typeof value === "string") {
-    const parsed = Number.parseFloat(value);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
-  }
-  return;
-}
-function toStringId(value) {
-  if (typeof value === "string" && value.trim()) {
-    return value.trim();
-  }
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return String(value);
-  }
-  return;
-}
-function scalarTimestampMs(value, fallbackMs) {
-  const numeric = toNumber2(value);
-  if (numeric !== undefined) {
-    return numeric < 1000000000000 ? numeric * 1000 : numeric;
-  }
-  if (typeof value === "string") {
-    const parsed = Date.parse(value);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
-  }
-  return fallbackMs;
-}
-function parseTrade(value, fallbackMs = Date.now()) {
-  const record2 = asRecord(value);
-  if (!record2) {
-    return null;
-  }
-  const tradeId = toStringId(record2.id);
-  const price = toNumber2(record2.price);
-  const amount = toNumber2(record2.amount);
-  const side = typeof record2.side === "string" ? record2.side.toLowerCase() : undefined;
-  if (!tradeId || price === undefined || amount === undefined || !side) {
-    return null;
-  }
-  const parsed = {
-    tradeId,
-    eventTimeMs: scalarTimestampMs(record2.timestamp, fallbackMs),
-    side,
-    price,
-    amount
-  };
-  const cost = toNumber2(record2.cost);
-  if (cost !== undefined) {
-    parsed.cost = cost;
-  }
-  if (typeof record2.takerOrMaker === "string") {
-    parsed.takerOrMaker = record2.takerOrMaker;
-  }
-  return parsed;
-}
-function extractTrades(payload, fallbackMs = Date.now()) {
-  if (Array.isArray(payload)) {
-    return payload.map((entry) => parseTrade(entry, fallbackMs)).filter((entry) => entry !== null);
-  }
-  const single = parseTrade(payload, fallbackMs);
-  return single ? [single] : [];
+// src/handlers/execute-action/handler.ts
+function isPublicMarketDataAction(action, payload) {
+  if (action !== Action.Call)
+    return false;
+  return isOrderBookCallMethod(payload?.method ?? payload?.functionName);
 }
-function parseTicker(value, fallbackMs) {
-  const record2 = asRecord(value);
-  if (!record2) {
-    return null;
-  }
-  const parsed = {
-    eventTimeMs: scalarTimestampMs(record2.timestamp, fallbackMs)
-  };
-  const fields = [
-    ["last", record2.last],
-    ["bid", record2.bid],
-    ["ask", record2.ask],
-    ["high", record2.high],
-    ["low", record2.low],
-    ["open", record2.open],
-    ["close", record2.close],
-    ["baseVolume", record2.baseVolume],
-    ["quoteVolume", record2.quoteVolume],
-    ["change", record2.change],
-    ["percentage", record2.percentage]
-  ];
-  for (const [key, rawValue] of fields) {
-    const numeric = toNumber2(rawValue);
-    if (numeric !== undefined) {
-      parsed[key] = numeric;
+function createExecuteActionHandler(deps) {
+  const {
+    policy,
+    brokers,
+    whitelistIps,
+    useVerity,
+    verityProverUrl,
+    otelMetrics,
+    brokerArchiver,
+    orderActivityTracker
+  } = deps;
+  const withdrawalObservationTracker = deps.withdrawalObservationTracker ?? new WithdrawalObservationTracker;
+  return async (call, callback) => {
+    const startTime = Date.now();
+    const { action: rawAction, cex: cex3, symbol: symbol2 } = call.request;
+    const action = resolveAction(rawAction);
+    let actionCompleted = false;
+    const wrappedCallback = (error48, value) => {
+      if (!actionCompleted) {
+        actionCompleted = true;
+        const latency = Date.now() - startTime;
+        const actionName = getActionName(action);
+        otelMetrics?.recordHistogram("execute_action_duration_ms", latency, {
+          action: actionName,
+          cex: cex3 || "unknown"
+        });
+        if (error48) {
+          otelMetrics?.recordCounter("execute_action_errors_total", 1, {
+            action: actionName,
+            cex: cex3 || "unknown",
+            error_type: error48.code ? grpc12.status[error48.code] || "unknown" : "unknown"
+          });
+        } else {
+          otelMetrics?.recordCounter("execute_action_success_total", 1, {
+            action: actionName,
+            cex: cex3 || "unknown"
+          });
+        }
+      }
+      callback(error48, value);
+    };
+    try {
+      log.info(`Request - ExecuteAction:`, { action, cex: cex3, symbol: symbol2 });
+      otelMetrics?.recordCounter("execute_action_requests_total", 1, {
+        action: getActionName(action),
+        cex: cex3 || "unknown"
+      });
+      if (!authenticateRequest(call, whitelistIps)) {
+        return wrappedCallback({
+          code: grpc12.status.PERMISSION_DENIED,
+          message: "Access denied: Unauthorized IP"
+        }, null);
+      }
+      if (!action || !cex3) {
+        return wrappedCallback({
+          code: grpc12.status.INVALID_ARGUMENT,
+          message: "`action` AND `cex` fields are required"
+        }, null);
+      }
+      const normalizedCex = cex3.trim().toLowerCase();
+      const metadata = call.metadata;
+      const selectedBrokerAccount = selectBrokerAccountForCex(normalizedCex, brokers, metadata);
+      const broker = selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, call.metadata) ?? (isPublicMarketDataAction(action, call.request.payload) ? createPublicBroker(normalizedCex) : null);
+      if (!broker) {
+        return wrappedCallback({
+          code: grpc12.status.UNAUTHENTICATED,
+          message: `This Exchange is not registered and No API metadata was found`
+        }, null);
+      }
+      const verity = { proof: "" };
+      const applyVerityToBroker = (targetBroker) => {
+        if (!useVerity)
+          return;
+        const override = buildHttpClientOverrideFromMetadata(metadata, verityProverUrl, (proof, notaryPubKey) => {
+          verity.proof = proof;
+          log.debug(`Verity proof:`, { proof, notaryPubKey });
+        });
+        targetBroker.setHttpClientOverride(override, verityHttpClientOverridePredicate);
+      };
+      const preludeCtx = {
+        call,
+        wrappedCallback,
+        action,
+        policy,
+        brokers,
+        metadata,
+        normalizedCex,
+        cex: cex3,
+        symbol: symbol2,
+        selectedBrokerAccount,
+        broker,
+        verity,
+        applyVerityToBroker,
+        useVerity,
+        verityProverUrl,
+        otelMetrics,
+        brokerArchiver,
+        orderActivityTracker,
+        withdrawalObservationTracker
+      };
+      if (action === Action.Call) {
+        const handled = await handleOrderBookCall(preludeCtx);
+        if (handled)
+          return;
+      }
+      applyVerityToBroker(broker);
+      const ctx = { ...preludeCtx, broker };
+      await dispatchExecuteAction(ctx);
+    } catch (error48) {
+      safeLogError("ExecuteAction unhandled error", error48);
+      return wrappedCallback({
+        code: grpc12.status.INTERNAL,
+        message: "ExecuteAction failed unexpectedly"
+      }, null);
     }
-  }
-  return parsed;
+  };
 }
-
-// src/helpers/market-data-archive/orderbook-depth.ts
-var DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT = 25;
-var MAX_ORDERBOOK_ARCHIVE_DEPTH_LIMIT = 500;
-function getOrderbookArchiveDepthLimit() {
-  const raw = process.env.CEX_BROKER_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
-  if (!raw) {
-    return DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
+// src/handlers/subscribe/broker-lifecycle.ts
+class SubscribeBrokerLifecycle {
+  #brokers = new Map;
+  #closing = new Map;
+  #shuttingDown = false;
+  register(broker, context2) {
+    this.#brokers.set(broker, context2);
+    if (this.#shuttingDown) {
+      this.close(broker);
+    }
   }
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    return DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
+  close(broker) {
+    const existing = this.#closing.get(broker);
+    if (existing) {
+      return existing;
+    }
+    const context2 = this.#brokers.get(broker) ?? {
+      cex: "unknown",
+      symbol: "unknown"
+    };
+    this.#brokers.delete(broker);
+    const closing = (async () => {
+      try {
+        await broker.close();
+        log.debug("Request-scoped Subscribe broker closed", context2);
+        return "closed";
+      } catch (error48) {
+        log.warn("Failed to close request-scoped Subscribe broker", {
+          ...context2,
+          error: error48
+        });
+        return "failed";
+      } finally {
+        this.#closing.delete(broker);
+      }
+    })();
+    this.#closing.set(broker, closing);
+    return closing;
   }
-  return Math.min(parsed, MAX_ORDERBOOK_ARCHIVE_DEPTH_LIMIT);
-}
-function splitOrderBookSide(levels, limit) {
-  const prices = [];
-  const sizes = [];
-  for (const level of levels.slice(0, limit)) {
-    if (!Array.isArray(level) || level.length < 2) {
-      continue;
+  async closeAll() {
+    this.#shuttingDown = true;
+    let failed = 0;
+    while (this.#brokers.size > 0 || this.#closing.size > 0) {
+      const inFlight = [...this.#closing.values()];
+      const fresh = [...this.#brokers.keys()].map((broker) => this.close(broker));
+      const outcomes = await Promise.all([...fresh, ...inFlight]);
+      failed += outcomes.filter((outcome) => outcome === "failed").length;
     }
-    const price = level[0];
-    const size = level[1];
-    if (price === undefined || size === undefined || !Number.isFinite(price) || !Number.isFinite(size)) {
-      continue;
+    if (failed > 0) {
+      throw new Error(`${failed} request-scoped Subscribe broker(s) failed to close`);
     }
-    prices.push(price);
-    sizes.push(size);
   }
-  return { prices, sizes };
 }
+// src/handlers/subscribe/handler.ts
+import * as grpc13 from "@grpc/grpc-js";
 
-// src/helpers/market-data-archive/rows.ts
-function compactUndefined3(record2) {
-  return Object.fromEntries(Object.entries(record2).filter(([, value]) => value !== undefined));
-}
-function scalarTimestampMs2(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string") {
-    if (/^\d+$/.test(value)) {
-      const numeric = Number.parseInt(value, 10);
-      if (Number.isFinite(numeric)) {
-        return numeric;
-      }
-    }
-    const parsed = Date.parse(value);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
+// src/helpers/binance-user-data-stream.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { createHmac } from "node:crypto";
+var BINANCE_SPOT_WS_API_URL = "wss://ws-api.binance.com:443/ws-api/v3";
+var DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS = 16;
+var createWebSocket = (url3) => new wrapper_default(url3);
+var userDataRequestCounter = 0;
+function getExchangeString(exchange, key) {
+  const value = exchange[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Binance user-data stream requires exchange.${key}`);
   }
-  return Date.now();
+  return value;
 }
-function parseSequence(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string" && /^\d+$/.test(value)) {
-    return Number.parseInt(value, 10);
-  }
-  return;
+function sortedQuery(params) {
+  return Object.entries(params).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
 }
-function topOfBookLevel(levels) {
-  const level = levels[0];
-  if (!level || level.length < 2) {
-    return null;
-  }
-  const price = level[0];
-  const size = level[1];
-  if (price === undefined || size === undefined || !Number.isFinite(price) || !Number.isFinite(size)) {
-    return null;
+function signUserDataStreamParams(exchange, params) {
+  const signParams = exchange.signParams;
+  if (typeof signParams === "function") {
+    return signParams.call(exchange, params);
   }
-  return { price, size };
+  const secret = getExchangeString(exchange, "secret");
+  return {
+    ...params,
+    signature: createHmac("sha256", secret).update(sortedQuery(params)).digest("hex")
+  };
 }
-function computeSpreadBps(bestBid, bestAsk) {
-  if (bestBid <= 0 || bestAsk <= 0 || bestAsk < bestBid) {
-    return 0;
-  }
-  const mid = (bestBid + bestAsk) / 2;
-  if (mid <= 0) {
-    return 0;
-  }
-  return (bestAsk - bestBid) / mid * 1e4;
+function getBinanceSpotWsApiUrl(exchange) {
+  const urls = exchange.urls;
+  return urls?.api?.ws?.["ws-api"]?.spot ?? BINANCE_SPOT_WS_API_URL;
 }
-function buildOrderbookArchiveTags(input, receivedTimeMs) {
-  return buildCommonArchiveTags({
-    deploymentId: input.deploymentId,
-    accountSelector: input.accountSelector,
-    exchange: input.exchange,
-    symbol: input.symbol,
-    brokerObservedTimestamp: new Date(receivedTimeMs).toISOString()
-  });
+function getRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
 }
-function buildOrderbookSnapshotRow(input) {
-  const bid = topOfBookLevel(input.snapshot.bids);
-  const ask = topOfBookLevel(input.snapshot.asks);
-  if (!bid || !ask) {
-    return null;
+function getMessage(value) {
+  if (value instanceof Error) {
+    return value.message;
   }
-  const archiveDepthLimit = getOrderbookArchiveDepthLimit();
-  const bids = splitOrderBookSide(input.snapshot.bids, archiveDepthLimit);
-  const asks = splitOrderBookSide(input.snapshot.asks, archiveDepthLimit);
-  if (bids.prices.length === 0 || asks.prices.length === 0) {
-    return null;
+  if (typeof value === "string" && value.length > 0) {
+    return value;
   }
-  const eventTimeMs = scalarTimestampMs2(input.snapshot.timestamp);
-  const receivedTimeMs = input.snapshot.receivedTimestamp;
-  const mid = (bid.price + ask.price) / 2;
-  const sequence = parseSequence(input.snapshot.sequence);
-  return {
-    table: "market_data.orderbook_snapshots",
-    row: compactUndefined3({
-      ...buildOrderbookArchiveTags(input, receivedTimeMs),
-      asset_type: input.assetType,
-      event_time_ms: eventTimeMs,
-      received_time_ms: receivedTimeMs,
-      best_bid: bid.price,
-      best_ask: ask.price,
-      bid_size: bid.size,
-      ask_size: ask.size,
-      mid,
-      spread_bps: computeSpreadBps(bid.price, ask.price),
-      depth_limit: archiveDepthLimit,
-      bid_levels: bids.prices.length,
-      ask_levels: asks.prices.length,
-      bids_price: bids.prices,
-      bids_size: bids.sizes,
-      asks_price: asks.prices,
-      asks_size: asks.sizes,
-      sequence
-    })
-  };
-}
-function buildCandleRow(input) {
-  const { context: context2, bar, isClosed, brokerVersion, receivedTimestamp } = input;
-  const tags = buildCommonArchiveTags({
-    deploymentId: context2.deploymentId,
-    accountSelector: context2.accountSelector,
-    exchange: context2.exchange,
-    symbol: context2.symbol,
-    brokerObservedTimestamp: new Date(receivedTimestamp).toISOString()
-  });
-  return {
-    table: "market_data.candles",
-    row: compactUndefined3({
-      ...tags,
-      asset_type: context2.assetType,
-      timeframe: context2.timeframe ?? "1m",
-      open_time_ms: bar.openTimeMs,
-      open: bar.open,
-      high: bar.high,
-      low: bar.low,
-      close: bar.close,
-      volume: bar.volume,
-      quote_volume: bar.quoteVolume,
-      is_closed: isClosed ? 1 : 0,
-      broker_version: brokerVersion
-    })
-  };
+  const record2 = getRecord(value);
+  const message = record2?.message;
+  return typeof message === "string" && message.length > 0 ? message : null;
 }
-function buildCexStreamEventRow(input) {
-  const receivedTimeMs = input.receivedTimestamp;
-  const redactedPayload = redactStreamPayload(input.payload);
-  const tags = buildCommonArchiveTags({
-    deploymentId: input.deploymentId,
-    accountSelector: input.accountSelector,
-    exchange: input.exchange,
-    symbol: input.symbol,
-    brokerObservedTimestamp: new Date(receivedTimeMs).toISOString()
-  });
-  return {
-    table: "market_data.cex_stream_events",
-    row: compactUndefined3({
-      ...tags,
-      asset_type: input.assetType,
-      stream_type: input.streamType,
-      event_time_ms: input.eventTimeMs ?? receivedTimeMs,
-      received_time_ms: receivedTimeMs,
-      payload_json: JSON.stringify(redactedPayload)
-    })
-  };
+function getOptionalExchangeString(exchange, key) {
+  const value = exchange[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
 }
-function buildCexTickerEventRow(input, ticker) {
-  const receivedTimeMs = input.receivedTimestamp;
-  const tags = buildCommonArchiveTags({
-    deploymentId: input.deploymentId,
-    accountSelector: input.accountSelector,
-    exchange: input.exchange,
-    symbol: input.symbol,
-    brokerObservedTimestamp: new Date(receivedTimeMs).toISOString()
-  });
-  return {
-    table: "market_data.cex_ticker_events",
-    row: compactUndefined3({
-      ...tags,
-      asset_type: input.assetType,
-      event_time_ms: ticker.eventTimeMs,
-      received_time_ms: receivedTimeMs,
-      last: ticker.last,
-      bid: ticker.bid,
-      ask: ticker.ask,
-      high: ticker.high,
-      low: ticker.low,
-      open: ticker.open,
-      close: ticker.close,
-      base_volume: ticker.baseVolume,
-      quote_volume: ticker.quoteVolume,
-      change: ticker.change,
-      percentage: ticker.percentage,
-      payload_json: JSON.stringify(redactStreamPayload(input.payload))
-    })
-  };
+function redactDiagnosticMessage(message, secretValues) {
+  let redacted = message;
+  for (const value of secretValues) {
+    if (value.length > 0) {
+      redacted = redacted.split(value).join("[redacted]");
+    }
+  }
+  return redacted.replace(/(\b(?:apiKey|secret|signature)\b\s*=\s*)[^\s&,;)]+/gi, "$1[redacted]").replace(/("(?:apiKey|secret|signature)"\s*:\s*")[^"]*(")/gi, "$1[redacted]$2");
 }
-function buildCexTradeRow(input, trade) {
-  const receivedTimeMs = input.receivedTimestamp;
-  const tags = buildCommonArchiveTags({
-    deploymentId: input.deploymentId,
-    accountSelector: input.accountSelector,
-    exchange: input.exchange,
-    symbol: input.symbol,
-    brokerObservedTimestamp: new Date(receivedTimeMs).toISOString()
-  });
-  return {
-    table: "market_data.cex_trades",
-    row: compactUndefined3({
-      ...tags,
-      asset_type: input.assetType,
-      trade_id: trade.tradeId,
-      event_time_ms: trade.eventTimeMs,
-      received_time_ms: receivedTimeMs,
-      side: trade.side,
-      price: trade.price,
-      amount: trade.amount,
-      cost: trade.cost,
-      taker_or_maker: trade.takerOrMaker
-    })
-  };
+function formatBinanceUserDataWebSocketError(event, secretValues) {
+  const record2 = getRecord(event);
+  const message = getMessage(record2?.error) ?? getMessage(record2?.message) ?? getMessage(event);
+  const safeMessage = message === null ? null : redactDiagnosticMessage(message, secretValues);
+  return new Error(safeMessage ? `Binance user-data WebSocket error: ${safeMessage}` : "Binance user-data WebSocket error");
 }
-
-// src/helpers/market-data-archive/capture.ts
-async function recordWatchMetric(otelMetrics, metricName, labels) {
-  try {
-    await otelMetrics?.recordCounter(metricName, 1, labels);
-  } catch {}
+function getCloseReason(value) {
+  if (typeof value === "string") {
+    return value.length > 0 ? value : null;
+  }
+  if (Buffer2.isBuffer(value)) {
+    const reason = value.toString("utf8");
+    return reason.length > 0 ? reason : null;
+  }
+  if (value instanceof Uint8Array) {
+    const reason = Buffer2.from(value).toString("utf8");
+    return reason.length > 0 ? reason : null;
+  }
+  return null;
 }
-function watchLabels(stream4, input) {
-  return {
-    stream: stream4,
-    exchange: input.exchange,
-    symbol: input.symbol
-  };
+function formatBinanceUserDataWebSocketClose(codeOrEvent, reasonOrUndefined, secretValues) {
+  const record2 = getRecord(codeOrEvent);
+  const code = record2 ? record2.code : codeOrEvent;
+  const reason = getCloseReason(record2 ? record2.reason : reasonOrUndefined);
+  const safeReason = reason === null ? null : redactDiagnosticMessage(reason, secretValues);
+  const details = [
+    typeof code === "number" || typeof code === "string" ? `code=${code}` : null,
+    safeReason ? `reason=${safeReason}` : null
+  ].filter((detail) => detail !== null);
+  return new Error(details.length > 0 ? `Binance user-data WebSocket closed unexpectedly (${details.join(", ")})` : "Binance user-data WebSocket closed unexpectedly");
 }
-function archiveOrderbookInBackground(archiver, otelMetrics, input, options) {
-  const labels = watchLabels("orderbook", input);
-  recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
-  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
-    return;
+function decodeMessageData(data) {
+  if (typeof data === "string") {
+    return data;
   }
-  if (options?.sampledOut) {
-    recordWatchMetric(otelMetrics, "cex_watch_frames_sampled_out_total", labels);
-    return;
+  if (Buffer2.isBuffer(data)) {
+    return data.toString("utf8");
   }
-  queueMicrotask(() => {
-    try {
-      const row = buildOrderbookSnapshotRow(input);
-      if (row) {
-        archiver.enqueue(row);
-        recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
+  if (data instanceof ArrayBuffer) {
+    return Buffer2.from(data).toString("utf8");
+  }
+  if (ArrayBuffer.isView(data)) {
+    return Buffer2.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
+  }
+  if (Array.isArray(data) && data.every((item) => Buffer2.isBuffer(item))) {
+    return Buffer2.concat(data).toString("utf8");
+  }
+  return data;
+}
+
+class BinanceSpotUserDataStream {
+  exchange;
+  ws;
+  secretValues;
+  requestId = `user-data-${Date.now()}-${userDataRequestCounter++}`;
+  maxBufferedEvents;
+  queue = [];
+  waiters = [];
+  closed = false;
+  closeError = null;
+  subscriptionId = null;
+  constructor(exchange, options = {}) {
+    this.exchange = exchange;
+    this.maxBufferedEvents = options.maxBufferedEvents ?? DEFAULT_BINANCE_USER_DATA_MAX_BUFFERED_EVENTS;
+    this.secretValues = [
+      getOptionalExchangeString(exchange, "apiKey"),
+      getOptionalExchangeString(exchange, "secret")
+    ].filter((value) => value !== null);
+    this.ws = createWebSocket(getBinanceSpotWsApiUrl(exchange));
+    this.ws.on("open", () => this.subscribe());
+    this.ws.on("message", (data) => this.handleMessage(data));
+    this.ws.on("error", (error48) => this.fail(formatBinanceUserDataWebSocketError(error48, this.secretValues)));
+    this.ws.on("close", (code, reason) => this.handleClose(code, reason));
+  }
+  async* [Symbol.asyncIterator]() {
+    while (true) {
+      const event = await this.nextEvent();
+      if (!event) {
+        break;
       }
-    } catch (error48) {
-      rethrowArchiveDurabilityError(error48);
-      log.warn("Failed to archive orderbook snapshot", { error: error48 });
+      yield event;
     }
-  });
-}
-function archiveOhlcvInBackground(archiver, otelMetrics, tracker, input) {
-  const labels = watchLabels("ohlcv", input);
-  recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
-  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
-    return;
   }
-  queueMicrotask(() => {
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.queue.length = 0;
     try {
-      const candidates = tracker.process(input.payload, input.receivedTimestamp);
-      for (const candidate of candidates) {
-        const row = buildCandleRow({
-          context: input,
-          bar: candidate.bar,
-          isClosed: candidate.isClosed,
-          brokerVersion: candidate.brokerVersion,
-          receivedTimestamp: input.receivedTimestamp
-        });
-        archiver.enqueue(row);
-      }
-      if (candidates.length > 0) {
-        recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
-      }
-    } catch (error48) {
-      rethrowArchiveDurabilityError(error48);
-      log.warn("Failed to archive OHLCV candle", { error: error48 });
+      this.ws.close();
+    } catch {}
+    this.flushWaiters();
+  }
+  handleClose(code, reason) {
+    if (this.closed) {
+      return;
     }
-  });
-}
-function createOrderbookSampler() {
-  return new OrderbookSampler;
-}
-function createOhlcvBarTracker() {
-  return new OhlcvBarTracker;
-}
-function archiveMarketRowsInBackground(archiver, otelMetrics, stream4, input, enqueueRows) {
-  const labels = watchLabels(stream4, input);
-  recordWatchMetric(otelMetrics, "cex_watch_frames_received_total", labels);
-  if (!isMarketArchiveEnabled() || !archiver?.isEnabled()) {
-    return;
+    this.fail(formatBinanceUserDataWebSocketClose(code, reason, this.secretValues));
   }
-  queueMicrotask(() => {
+  subscribe() {
+    const apiKey = getExchangeString(this.exchange, "apiKey");
+    const signedParams = signUserDataStreamParams(this.exchange, {
+      apiKey,
+      timestamp: Date.now()
+    });
+    this.ws.send(JSON.stringify({
+      id: this.requestId,
+      method: "userDataStream.subscribe.signature",
+      params: signedParams
+    }));
+  }
+  handleMessage(data) {
+    if (this.closed) {
+      return;
+    }
+    let message;
     try {
-      const rows = enqueueRows();
-      for (const row of rows) {
-        archiver.enqueue(row);
+      const decodedData = decodeMessageData(data);
+      message = typeof decodedData === "string" ? JSON.parse(decodedData) : decodedData;
+    } catch (error48) {
+      this.fail(error48 instanceof Error ? error48 : new Error("Invalid Binance user-data message"));
+      return;
+    }
+    if ("id" in message && message.id === this.requestId) {
+      if (message.status !== 200) {
+        this.fail(new Error(message.error?.msg ?? message.error?.message ?? `Binance user-data subscription failed with status ${message.status}`));
+        return;
       }
-      if (rows.length > 0) {
-        recordWatchMetric(otelMetrics, "cex_watch_frames_archived_total", labels);
+      this.subscriptionId = message.result?.subscriptionId ?? null;
+      return;
+    }
+    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 errorCode2 = message.error?.code;
+      this.fail(new Error(typeof errorCode2 === "number" ? `${errorMessage} (code ${errorCode2})` : errorMessage));
+      return;
+    }
+    if (!("event" in message) || !message.event) {
+      return;
+    }
+    const subscriptionId = message.subscriptionId ?? this.subscriptionId;
+    if (subscriptionId === null || subscriptionId === undefined) {
+      return;
+    }
+    this.push({ subscriptionId, event: message.event });
+  }
+  push(event) {
+    if (this.closed) {
+      return;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve(event);
+      return;
+    }
+    if (this.queue.length >= this.maxBufferedEvents) {
+      this.fail(new Error(`Binance user-data stream buffered event limit exceeded (${this.maxBufferedEvents}); downstream consumer is not keeping up`));
+      return;
+    }
+    this.queue.push(event);
+  }
+  nextEvent() {
+    const event = this.queue.shift();
+    if (event) {
+      return Promise.resolve(event);
+    }
+    if (this.closeError) {
+      return Promise.reject(this.closeError);
+    }
+    if (this.closed) {
+      return Promise.resolve(null);
+    }
+    return new Promise((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
+  }
+  fail(error48) {
+    if (this.closeError) {
+      return;
+    }
+    this.closeError = error48;
+    this.closed = true;
+    this.queue.length = 0;
+    this.flushWaiters();
+    try {
+      this.ws.close();
+    } catch {}
+  }
+  flushWaiters() {
+    const error48 = this.closeError;
+    for (const waiter of this.waiters.splice(0)) {
+      if (error48) {
+        waiter.reject(error48);
+      } else {
+        waiter.resolve(null);
       }
-    } catch (error48) {
-      rethrowArchiveDurabilityError(error48);
-      log.warn(`Failed to archive ${stream4} market data`, { error: error48 });
     }
-  });
-}
-function archiveTradesInBackground(archiver, otelMetrics, input) {
-  archiveMarketRowsInBackground(archiver, otelMetrics, "trades", input, () => extractTrades(input.payload, input.receivedTimestamp).map((trade) => buildCexTradeRow(input, trade)));
+  }
 }
-function archiveTickerInBackground(archiver, otelMetrics, input) {
-  archiveMarketRowsInBackground(archiver, otelMetrics, "ticker", input, () => {
-    const ticker = parseTicker(input.payload, input.receivedTimestamp);
-    return ticker ? [buildCexTickerEventRow(input, ticker)] : [];
-  });
+function isBinanceBalanceUserDataEvent(event) {
+  return event.e === "outboundAccountPosition" || event.e === "balanceUpdate" || event.e === "externalLockUpdate";
 }
-function archiveCexStreamEventInBackground(archiver, otelMetrics, input) {
-  archiveMarketRowsInBackground(archiver, otelMetrics, "stream", input, () => [
-    buildCexStreamEventRow(input)
-  ]);
+function isBinanceOrderUserDataEvent(event) {
+  return event.e === "executionReport" || event.e === "listStatus";
 }
 // src/helpers/market-data-archive/ohlcv-bootstrap.ts
 var DEFAULT_OHLCV_BOOTSTRAP_LIMIT = 100;
@@ -309456,6 +309926,7 @@ async function bootstrapOhlcvHistory(broker, archiver, otelMetrics, tracker, inp
     const receivedTimestamp = Date.now();
     archiveOhlcvInBackground(archiver, otelMetrics, tracker, {
       ...input,
+      sourceMode: "broker_bootstrap_fetch_v1",
       payload,
       receivedTimestamp
     });
@@ -310515,7 +310986,7 @@ class CEXBroker {
     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.orderActivityTracker, this.withdrawalObservationTracker);
+    this.server = getServer(this.policy, this.brokers, this.whitelistIps, this.useVerity, this.#verityProverUrl, this.otelMetrics, this.brokerArchiver, this.orderActivityTracker, this.withdrawalObservationTracker, undefined);
     this.server.bindAsync(`0.0.0.0:${this.port}`, grpc15.ServerCredentials.createInsecure(), (err2, port) => {
       if (err2) {
         log.error(err2);
@@ -310560,4 +311031,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=10F44147004B63EC64756E2164756E21
+//# debugId=89161A06846CFA7064756E2164756E21