@usherlabs/cex-broker 0.2.52 → 0.3.1

package/dist/index.js

@@ -50010,7 +50010,7 @@ var require_src13 = __commonJS((exports) => {
 });
 
 // src/index.ts
-import * as grpc15 from "@grpc/grpc-js";
+import * as grpc17 from "@grpc/grpc-js";
 
 // node_modules/@usherlabs/ccxt/js/src/base/functions.js
 var exports_functions = {};
@@ -290094,7 +290094,9 @@ var Action = {
   FetchFees: 12,
   InternalTransfer: 13,
   GetPerpConfigState: 14,
-  SetPerpConfigState: 15
+  SetPerpConfigState: 15,
+  FetchMarketRules: 16,
+  Batch: 17
 };
 var SubscriptionType = {
   NO_ACTION: 0,
@@ -290642,6 +290644,30 @@ function redactUnknownValue(value, secretLiterals) {
   }
   return String(value);
 }
+function removeSecretMaterial(value, secretLiterals = []) {
+  if (value === null || value === undefined) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return redactSecretLiterals(value, secretLiterals);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => removeSecretMaterial(entry, secretLiterals));
+  }
+  if (typeof value === "object") {
+    const clean = {};
+    for (const [key, entry] of Object.entries(value)) {
+      if (!SECRET_KEY_PATTERN.test(key)) {
+        clean[key] = removeSecretMaterial(entry, secretLiterals);
+      }
+    }
+    return clean;
+  }
+  return String(value);
+}
 function redactStreamPayload(payload, secretLiterals = []) {
   if (Array.isArray(payload)) {
     return {
@@ -291352,6 +291378,22 @@ import {
 import { basename, dirname } from "node:path";
 var EXPORT_CHUNK_BYTES = 8 * 1024 * 1024;
 var SHA256_RECEIPT_PATTERN = /^([0-9a-f]{64}) {2}(.+)\n$/;
+function sha256File(path) {
+  const hash4 = createHash3("sha256");
+  const fd2 = openSync(path, "r");
+  try {
+    const chunk = Buffer.alloc(EXPORT_CHUNK_BYTES);
+    for (;; ) {
+      const read = readSync(fd2, chunk, 0, chunk.length, null);
+      if (read === 0)
+        break;
+      hash4.update(chunk.subarray(0, read));
+    }
+  } finally {
+    closeSync(fd2);
+  }
+  return hash4.digest("hex");
+}
 
 class DeadLetterJournalExportError extends Error {
   constructor(message, options) {
@@ -291385,6 +291427,9 @@ function exportDeadLetterJournal(journalPath, exportPath) {
       if (match?.[1] === undefined || match[2] !== basename(exportPath)) {
         throw new Error("export receipt is malformed");
       }
+      if (sha256File(exportPath) !== match[1]) {
+        throw new Error("export digest does not match receipt");
+      }
     } catch (error) {
       throw new DeadLetterJournalExportError("Dead-letter journal export target is incomplete or unverifiable", { cause: error });
     }
@@ -292725,6 +292770,17 @@ function withTimeout(promise, timeoutMs, label) {
   return Promise.race([promise, expiry]).finally(() => clearTimeout(timer));
 }
 var ALL_CURRENCIES_CODE = "*";
+var MAX_FAILURE_REASON_CHARS = 256;
+var DEFAULT_FAILURE_REASON = "fetchDeposits failed";
+function decimal(value) {
+  return value === null || value === undefined ? null : String(value);
+}
+function failureReason(error, exchange) {
+  const text = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  const secrets = [exchange.apiKey, exchange.secret].filter((value) => typeof value === "string" && value.length > 0);
+  const trimmed = redactSecretLiterals(text, secrets).replace(/\s+/g, " ").trim().slice(0, MAX_FAILURE_REASON_CHARS);
+  return trimmed.length > 0 ? trimmed : DEFAULT_FAILURE_REASON;
+}
 var BINANCE_UNLOCK_PROGRESS_SOURCE = {
   venue: "binance",
   endpoint: "GET /sapi/v1/capital/deposit/hisrec",
@@ -292735,6 +292791,20 @@ var BINANCE_UNLOCK_PROGRESS_SOURCE = {
     completeTime: "info.completeTime"
   }
 };
+function observedProgress(progress) {
+  if (progress === undefined)
+    return null;
+  return {
+    state: progress.state,
+    progress_state: progress.progress_state,
+    reason: progress.reason,
+    native_status: decimal(progress.native_status),
+    current: decimal(progress.current),
+    credit_required: decimal(progress.credit_required),
+    unlock_required: decimal(progress.unlock_required),
+    complete_time: decimal(progress.complete_time)
+  };
+}
 function depositTimestamp(record) {
   const observedAt = depositField(record, [
     "timestamp",
@@ -292964,6 +293034,7 @@ class DepositArchivePoller {
   #cursors = new Map;
   #lastArchivedByTarget = new Map;
   #unsupportedLogged = new Set;
+  #coverage = new Map;
   #config;
   constructor(params) {
     this.params = params;
@@ -292974,6 +293045,7 @@ class DepositArchivePoller {
       return;
     }
     log.info("\uD83D\uDCE5 Deposit archive poller started");
+    this.params.coveragePublisher?.start();
     this.#schedule(0);
   }
   async stop() {
@@ -292983,6 +293055,7 @@ class DepositArchivePoller {
       this.#timer = null;
     }
     await this.#running;
+    await this.params.coveragePublisher?.close(this.#coverageSnapshots());
   }
   async pollAllOnce() {
     if (this.#stopped || this.#running || !this.params.archiver.isEnabled()) {
@@ -293018,14 +293091,90 @@ class DepositArchivePoller {
     return true;
   }
   async#pollOne(target) {
+    const attemptedAt = new Date().toISOString();
     let outcome = "error";
+    let observation;
     try {
-      outcome = await this.#pollTarget(target);
+      const result = await this.#pollTarget(target, attemptedAt);
+      outcome = result.outcome;
+      observation = result.observation;
+    } catch (error) {
+      observation = this.#observation("error", attemptedAt, {
+        errorReason: failureReason(error, target.account.exchange)
+      });
+      throw error;
     } finally {
       this.params.metrics?.recordCounter("cex_deposit_poller_polls_total", 1, { exchange: target.exchangeId, outcome });
+      this.#recordCoverage(target, outcome, observation ?? this.#observation("error", attemptedAt, {
+        errorReason: "poll aborted before completion"
+      }));
     }
   }
-  async#pollTarget(target) {
+  #observation(disposition, attemptedAt, detail = {}) {
+    if (disposition === "success" && detail.completedAt !== undefined && detail.completedAt < attemptedAt) {
+      return this.#observation("error", attemptedAt, {
+        requestSinceMs: detail.requestSinceMs,
+        errorReason: `source clock invalid: completed ${detail.completedAt} before attempted ${attemptedAt}`
+      });
+    }
+    return {
+      version: "1",
+      disposition,
+      attempted_at: attemptedAt,
+      completed_at: disposition === "success" ? detail.completedAt ?? null : null,
+      poll_interval_ms: String(this.#config.pollIntervalMs),
+      fetch_timeout_ms: String(this.#config.fetchTimeoutMs),
+      deposits_limit: String(this.#config.depositsLimit),
+      request_since_ms: decimal(detail.requestSinceMs),
+      next_cursor_ms: disposition === "success" ? decimal(detail.nextCursorMs) : null,
+      response_truncated: disposition === "success" ? detail.responseTruncated ?? null : null,
+      malformed_count: String(detail.malformedCount ?? 0),
+      error_reason: disposition === "error" ? detail.errorReason?.trim() || DEFAULT_FAILURE_REASON : "",
+      observed_deposits: disposition === "success" ? detail.observedDeposits ?? [] : []
+    };
+  }
+  #recordCoverage(target, outcome, observation) {
+    const publisher = this.params.coveragePublisher;
+    if (!publisher)
+      return;
+    const key = this.#targetKey(target);
+    const previous = this.#coverage.get(key);
+    const now3 = observation.completed_at ?? new Date().toISOString();
+    const state = outcome === "ok" ? "connected" : "error";
+    const base2 = previous?.snapshot;
+    const stateChangedAt = base2 && base2.state === state ? base2.stateChangedAt : now3;
+    const attempts = BigInt(base2?.connectAttemptCount ?? "0") + 1n;
+    const errors = BigInt(base2?.errorCount ?? "0") + (outcome === "error" ? 1n : 0n);
+    const reconnects = BigInt(base2?.reconnectCount ?? "0") + (outcome === "ok" && previous?.lastOutcome === "error" ? 1n : 0n);
+    const snapshot = {
+      exchange: target.exchangeId,
+      accountSelector: target.account.label,
+      accountRole: target.account.role,
+      streamKind: "deposit_poller",
+      accountScope: "spot",
+      registryStatus: "active",
+      retiredAt: null,
+      state,
+      stateChangedAt,
+      lastConnectedAt: outcome === "ok" ? observation.completed_at : base2?.lastConnectedAt ?? null,
+      lastAuthenticatedAt: null,
+      lastReceivedAt: outcome === "ok" ? observation.completed_at : base2?.lastReceivedAt ?? null,
+      connectAttemptCount: attempts.toString(),
+      reconnectCount: reconnects.toString(),
+      errorCount: errors.toString(),
+      lastFailureKind: outcome === "ok" ? "none" : outcome === "unsupported" ? "unsupported_connector" : "transport_error",
+      lastFailureReason: outcome === "ok" ? "" : outcome === "unsupported" ? "fetchDeposits unsupported" : observation.error_reason,
+      trafficMode: "continuous",
+      sourceWatermark: null,
+      pollObservation: observation
+    };
+    this.#coverage.set(key, { snapshot, lastOutcome: outcome });
+    publisher.publish(this.#coverageSnapshots());
+  }
+  #coverageSnapshots() {
+    return [...this.#coverage.values()].map((entry) => entry.snapshot);
+  }
+  async#pollTarget(target, attemptedAt) {
     const exchange = target.account.exchange;
     const key = this.#targetKey(target);
     if (typeof exchange.fetchDeposits !== "function" || exchange.has?.fetchDeposits === false) {
@@ -293036,7 +293185,10 @@ class DepositArchivePoller {
           account: target.account.label
         });
       }
-      return "unsupported";
+      return {
+        outcome: "unsupported",
+        observation: this.#observation("unsupported", attemptedAt)
+      };
     }
     const since = this.#cursors.get(key) ?? Date.now() - this.#config.lookbackMs;
     let deposits;
@@ -293049,15 +293201,48 @@ class DepositArchivePoller {
         account: target.account.label,
         error
       });
-      return "error";
+      return {
+        outcome: "error",
+        observation: this.#observation("error", attemptedAt, {
+          requestSinceMs: since,
+          errorReason: failureReason(error, exchange)
+        })
+      };
     }
-    if (!Array.isArray(deposits) || deposits.length === 0) {
-      return "ok";
+    if (!Array.isArray(deposits)) {
+      return {
+        outcome: "error",
+        observation: this.#observation("error", attemptedAt, {
+          requestSinceMs: since,
+          errorReason: "fetchDeposits returned a non-array response"
+        })
+      };
+    }
+    if (deposits.length > this.#config.depositsLimit) {
+      return {
+        outcome: "error",
+        observation: this.#observation("error", attemptedAt, {
+          requestSinceMs: since,
+          errorReason: `fetchDeposits returned ${deposits.length} rows for a limit of ${this.#config.depositsLimit}`
+        })
+      };
+    }
+    if (deposits.length === 0) {
+      return this.#completed(this.#observation("success", attemptedAt, {
+        completedAt: new Date().toISOString(),
+        requestSinceMs: since,
+        nextCursorMs: this.#cursors.get(key),
+        responseTruncated: false,
+        observedDeposits: []
+      }));
     }
     let archived = 0;
+    let malformed = 0;
+    const observed = [];
     for (const deposit of deposits) {
       const record = asRecord(deposit);
       if (!record) {
+        malformed += 1;
         continue;
       }
       const info = asRecord(record.info);
@@ -293082,6 +293267,16 @@ class DepositArchivePoller {
       });
       const lastArchived = identity === undefined ? undefined : this.#lastArchivedByTarget.get(key)?.get(identity);
       const classification = classifyDeposit(target.exchangeId, record, lastArchived);
+      const depositTimestampMs = depositTimestamp(record);
+      observed.push({
+        coin: assetSymbol === undefined ? "" : String(assetSymbol),
+        network: network === undefined ? "" : String(network),
+        external_id: depositTxid ?? "",
+        txid: depositTxid ?? "",
+        deposit_timestamp_ms: decimal(depositTimestampMs),
+        status: classification.archiveStatus,
+        progress: observedProgress(classification.unlockProgress)
+      });
       if (lastArchived && lastArchived.status === classification.archiveStatus && lastArchived.progressKey === classification.progressKey) {
         continue;
       }
@@ -293122,7 +293317,7 @@ class DepositArchivePoller {
         }
         targetDeposits2.set(identity, {
           status: classification.archiveStatus,
-          timestamp: depositTimestamp(record),
+          timestamp: depositTimestampMs,
           progressKey: classification.progressKey,
           highWatermark: classification.highWatermark
         });
@@ -293145,7 +293340,20 @@ class DepositArchivePoller {
         this.#lastArchivedByTarget.delete(key);
       }
     }
-    return "ok";
+    return this.#completed(this.#observation("success", attemptedAt, {
+      completedAt: new Date().toISOString(),
+      requestSinceMs: since,
+      nextCursorMs: nextCursor,
+      responseTruncated: deposits.length >= this.#config.depositsLimit,
+      malformedCount: malformed,
+      observedDeposits: observed
+    }));
+  }
+  #completed(observation) {
+    return {
+      outcome: observation.disposition === "success" ? "ok" : "error",
+      observation
+    };
   }
   #targetKey(target) {
     return `${target.exchangeId}|${target.account.label}|${target.code}`;
@@ -293292,10 +293500,7 @@ import { createHash as createHash4 } 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 MARKET_ARCHIVE_SOURCES = [
-  ...ARCHIVE_SOURCES,
-  "external_backfill"
-];
+var MARKET_ARCHIVE_SOURCES = ARCHIVE_SOURCES;
 var CAPTURE_FEEDS = [
   "ORDERBOOK",
   "TICKER",
@@ -293309,15 +293514,12 @@ var SOURCE_MODES = [
   "broker_bootstrap_fetch_v1",
   "external_ccxt_fallback_v1",
   "external_hummingbot_fallback_v1",
-  "legacy_migration_v1",
-  "historical_vendor_orderbook_v1",
-  "vendor_historical_backfill_v1"
+  "legacy_migration_v1"
 ];
 var RAW_CAPTURE_SCOPES = [
   "ccxt_normalized_object",
   "broker_visible_payload",
-  "exchange_wire_frame",
-  "vendor_normalized_dataset_file"
+  "exchange_wire_frame"
 ];
 var CHECKSUM_FIELDS = new Set([
   "normalized_row_checksum",
@@ -293506,6 +293708,9 @@ function createRawCapture(context2, input) {
     checksumAlgorithm: context2.checksumAlgorithm
   };
 }
+function projectRawCapturePayload(rawCapture, redactedPayload) {
+  return { ...rawCapture, redactedPayload };
+}
 function captureCoreFields(context2, rawCapture) {
   assertCaptureContext(context2);
   return {
@@ -294082,14 +294287,20 @@ function resolveConservativeOrderBookAcquisitionProfile(input) {
       id: `${exchange}:conservative:default`,
       upstreamLimit: undefined,
       guaranteedRetainedDepth: undefined,
-      coalescingSupported: false
+      coalescingSupported: false,
+      bidExhaustionEvidence: false,
+      askExhaustionEvidence: false,
+      exhaustionEvidenceValidated: true
     };
   }
   return {
     id: `${exchange}:conservative:limit:${input.requestedDepth}`,
     upstreamLimit: input.requestedDepth,
     guaranteedRetainedDepth: input.requestedDepth,
-    coalescingSupported: false
+    coalescingSupported: false,
+    bidExhaustionEvidence: false,
+    askExhaustionEvidence: false,
+    exhaustionEvidenceValidated: true
   };
 }
 function resolveOrderBookAcquisitionProfile(input) {
@@ -294101,7 +294312,10 @@ function resolveOrderBookAcquisitionProfile(input) {
       id: candidateProfileId,
       upstreamLimit: VERIFIED_PROFILE_DEPTH,
       guaranteedRetainedDepth: VERIFIED_PROFILE_DEPTH,
-      coalescingSupported: true
+      coalescingSupported: true,
+      bidExhaustionEvidence: false,
+      askExhaustionEvidence: false,
+      exhaustionEvidenceValidated: true
     };
   }
   return resolveConservativeOrderBookAcquisitionProfile(input);
@@ -294251,7 +294465,63 @@ class PublicFeedSubscriberBuffer {
     this.#bytes = 0;
   }
 }
+// src/helpers/market-data-archive/orderbook-depth.ts
+var DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT = 25;
+var MAX_ORDERBOOK_ARCHIVE_DEPTH_LIMIT = 500;
+var MAX_ORDERBOOK_MEASUREMENT_BANDS = 64;
+var MAX_ORDERBOOK_MEASUREMENT_BAND_BPS = 1e4;
+var DEFAULT_ORDERBOOK_MEASUREMENT_BANDS_BPS = [10, 25, 50, 100];
+function parseBoundedDepth(raw, field) {
+  if (!/^[1-9]\d*$/.test(raw)) {
+    throw new Error(`${field} must be an integer between 1 and 500`);
+  }
+  const parsed = Number(raw);
+  if (!Number.isSafeInteger(parsed) || parsed > MAX_ORDERBOOK_ARCHIVE_DEPTH_LIMIT) {
+    throw new Error(`${field} must be an integer between 1 and 500`);
+  }
+  return parsed;
+}
+function getOrderbookArchiveDepthLimit() {
+  const raw = process.env.CEX_BROKER_ORDERBOOK_ARCHIVE_DEPTH_LIMIT?.trim();
+  if (!raw) {
+    return DEFAULT_ORDERBOOK_ARCHIVE_DEPTH_LIMIT;
+  }
+  return parseBoundedDepth(raw, "CEX_BROKER_ORDERBOOK_ARCHIVE_DEPTH_LIMIT");
+}
+function normalizeOrderbookMeasurementBandsBps(input) {
+  const bands = input ?? DEFAULT_ORDERBOOK_MEASUREMENT_BANDS_BPS;
+  if (bands.length === 0) {
+    throw new Error("ORDERBOOK measurement bands must not be empty");
+  }
+  if (bands.length > MAX_ORDERBOOK_MEASUREMENT_BANDS) {
+    throw new Error(`ORDERBOOK measurement bands must contain at most ${MAX_ORDERBOOK_MEASUREMENT_BANDS} entries`);
+  }
+  for (const band of bands) {
+    if (!Number.isSafeInteger(band) || band <= 0 || band > MAX_ORDERBOOK_MEASUREMENT_BAND_BPS) {
+      throw new Error("ORDERBOOK measurement bands must be integer basis points in 1..10000");
+    }
+  }
+  const normalized = [...new Set(bands)].sort((left, right) => left - right);
+  if (normalized.length > MAX_ORDERBOOK_MEASUREMENT_BANDS) {
+    throw new Error(`ORDERBOOK measurement bands must contain at most ${MAX_ORDERBOOK_MEASUREMENT_BANDS} unique entries`);
+  }
+  return normalized;
+}
+function getOrderbookMeasurementBandsBps() {
+  const raw = process.env.CEX_BROKER_ORDERBOOK_MEASUREMENT_BANDS_BPS?.trim();
+  if (!raw) {
+    return [...DEFAULT_ORDERBOOK_MEASUREMENT_BANDS_BPS];
+  }
+  const parts = raw.split(",").map((entry) => entry.trim());
+  if (parts.some((entry) => !/^[1-9]\d*$/.test(entry))) {
+    throw new Error("CEX_BROKER_ORDERBOOK_MEASUREMENT_BANDS_BPS must be a comma-separated list of positive integers");
+  }
+  return normalizeOrderbookMeasurementBandsBps(parts.map(Number));
+}
+
 // src/helpers/market-data-archive/canonical-orderbook.ts
+var ORDERBOOK_SUMMARY_SCHEMA_VERSION = "2.0.0";
+
 class OrderBookValidationError extends Error {
   reason;
   constructor(reason) {
@@ -294277,38 +294547,70 @@ function parseSequence(value) {
   }
   return parsed.toString(10);
 }
-function validateSide(side, levels, depthLimit) {
+function validatePositiveInteger(value, field, maximum = Number.MAX_SAFE_INTEGER) {
+  if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) {
+    throw new OrderBookValidationError(`${field} must be a positive integer${maximum === 500 ? " between 1 and 500" : ""}`);
+  }
+}
+function validateSide(side, levels) {
   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 validated = [];
+  for (let index2 = 0;index2 < levels.length; index2 += 1) {
+    const entry = levels[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`);
     }
     if (index2 > 0) {
-      const previous = retained[index2 - 1]?.[0];
+      const previous = validated[index2 - 1]?.price;
       if (previous === undefined || (side === "bid" ? price >= previous : price <= previous)) {
         throw new OrderBookValidationError(`${side} levels are not strictly ${side === "bid" ? "descending" : "ascending"}`);
       }
     }
+    validated.push({ price, amount });
   }
-  return retained.map(([price, amount]) => ({
-    price,
-    amount
-  }));
+  return validated;
 }
-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");
+function validateMetadata(metadata, observedBids, observedAsks) {
+  if (!metadata.captureProfileId.trim()) {
+    throw new OrderBookValidationError("capture_profile_id must not be empty");
+  }
+  validatePositiveInteger(metadata.effectiveCadenceMs, "effective_cadence_ms");
+  if (metadata.requestedUpstreamDepth !== null) {
+    validatePositiveInteger(metadata.requestedUpstreamDepth, "requested_upstream_depth", 500);
+  }
+  validatePositiveInteger(metadata.observedBidCount, "observed_bid_count");
+  validatePositiveInteger(metadata.observedAskCount, "observed_ask_count");
+  if (metadata.observedBidCount !== observedBids.length) {
+    throw new OrderBookValidationError("observed_bid_count does not match the complete observation");
+  }
+  if (metadata.observedAskCount !== observedAsks.length) {
+    throw new OrderBookValidationError("observed_ask_count does not match the complete observation");
+  }
+  const farthestBid = observedBids.at(-1)?.price;
+  const farthestAsk = observedAsks.at(-1)?.price;
+  if (!Number.isFinite(metadata.observedFarthestBid) || metadata.observedFarthestBid <= 0 || metadata.observedFarthestBid !== farthestBid) {
+    throw new OrderBookValidationError("observed_farthest_bid does not match the complete observation");
+  }
+  if (!Number.isFinite(metadata.observedFarthestAsk) || metadata.observedFarthestAsk <= 0 || metadata.observedFarthestAsk !== farthestAsk) {
+    throw new OrderBookValidationError("observed_farthest_ask does not match the complete observation");
+  }
+  for (const [side, evidence] of [
+    ["bid", metadata.exhaustionEvidence.bid],
+    ["ask", metadata.exhaustionEvidence.ask]
+  ]) {
+    if (evidence.validated !== true || typeof evidence.exhausted !== "boolean" || !evidence.source.trim()) {
+      throw new OrderBookValidationError(`${side} exhaustion evidence must be validated and source-bound`);
     }
   }
-  return [...new Set(bands)].sort((left, right) => left - right);
+  try {
+    return normalizeOrderbookMeasurementBandsBps(metadata.measurementBandsBps);
+  } catch (error) {
+    throw new OrderBookValidationError(error instanceof Error ? error.message : "invalid measurement bands");
+  }
 }
 function checksumRow(row) {
   return { ...row, normalized_row_checksum: sha256Canonical(row) };
@@ -294319,20 +294621,33 @@ function commonEvidenceFields(context2, rawCapture, input) {
     source_time_ms: input.eventTimeMs,
     received_time_ms: input.receivedTimeMs,
     snapshot_id: input.snapshotId,
-    construction_mode: input.constructionMode,
+    construction_mode: "sampled_top_n_snapshot",
     gap_policy: "record_gap",
     depth_limit: input.depthLimit,
     sequence: input.sequence,
     exact_l2_reconstruction_complete: 0
   };
 }
+function sideBandEvidence(input) {
+  const farthest = input.levels.at(-1)?.price;
+  const depths = input.boundaries.map((boundary) => input.levels.filter(({ price }) => input.side === "bid" ? price >= boundary : price <= boundary).reduce((sum3, { amount }) => sum3 + amount, 0));
+  const statuses = input.boundaries.map((boundary) => {
+    const boundaryReached = input.side === "bid" ? farthest <= boundary : farthest >= boundary;
+    return boundaryReached || input.exhausted ? "exact" : "censored";
+  });
+  return { depths, statuses };
+}
 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");
-  }
+  validatePositiveInteger(input.depthLimit, "depth limit", 500);
   if (input.context.feed !== "ORDERBOOK") {
     throw new OrderBookValidationError("capture context feed is not ORDERBOOK");
   }
+  if (input.context.schemaVersion !== "1.0.0") {
+    throw new OrderBookValidationError("ORDERBOOK raw and level capture schema must be 1.0.0");
+  }
+  if (!input.context.provenanceComplete) {
+    throw new OrderBookValidationError("summary v2 requires complete live provenance");
+  }
   if (input.constructionMode === "exact_l2_reconstruction") {
     throw new OrderBookValidationError("exact L2 requires a complete continuity proof and is unsupported");
   }
@@ -294347,13 +294662,18 @@ function buildCanonicalOrderBookRows(input) {
   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];
+  const observedBids = validateSide("bid", input.snapshot.bids);
+  const observedAsks = validateSide("ask", input.snapshot.asks);
+  const bestBid = observedBids[0];
+  const bestAsk = observedAsks[0];
   if (bestBid.price >= bestAsk.price) {
     throw new OrderBookValidationError("book is crossed or locked");
   }
+  const bands = validateMetadata(input.archiveMetadata, observedBids, observedAsks);
+  const bids = observedBids.slice(0, input.depthLimit);
+  const asks = observedAsks.slice(0, input.depthLimit);
+  const retainedFarthestBid = bids.at(-1);
+  const retainedFarthestAsk = asks.at(-1);
   const sequence = parseSequence(input.snapshot.sequence);
   const midPrice = (bestBid.price + bestAsk.price) / 2;
   const spread2 = bestAsk.price - bestBid.price;
@@ -294373,8 +294693,7 @@ function buildCanonicalOrderBookRows(input) {
     sequence,
     depthLimit: input.depthLimit,
     eventTimeMs,
-    receivedTimeMs,
-    constructionMode: input.constructionMode ?? "sampled_top_n_snapshot"
+    receivedTimeMs
   });
   const levels = [
     ["bid", bids],
@@ -294392,17 +294711,34 @@ function buildCanonicalOrderBookRows(input) {
     });
     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 bidBoundaries = bands.map((band) => midPrice * (1 - band / 1e4));
+  const askBoundaries = bands.map((band) => midPrice * (1 + band / 1e4));
+  const bidEvidence = sideBandEvidence({
+    levels: observedBids,
+    boundaries: bidBoundaries,
+    side: "bid",
+    exhausted: input.archiveMetadata.exhaustionEvidence.bid.exhausted
   });
-  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 askEvidence = sideBandEvidence({
+    levels: observedAsks,
+    boundaries: askBoundaries,
+    side: "ask",
+    exhausted: input.archiveMetadata.exhaustionEvidence.ask.exhausted
   });
   const summaryRow = checksumRow({
     ...common,
+    schema_version: ORDERBOOK_SUMMARY_SCHEMA_VERSION,
+    capture_profile_id: input.archiveMetadata.captureProfileId,
+    effective_cadence_ms: input.archiveMetadata.effectiveCadenceMs,
+    requested_upstream_depth: input.archiveMetadata.requestedUpstreamDepth,
+    observed_bid_count: input.archiveMetadata.observedBidCount,
+    observed_ask_count: input.archiveMetadata.observedAskCount,
+    observed_farthest_bid: input.archiveMetadata.observedFarthestBid,
+    observed_farthest_ask: input.archiveMetadata.observedFarthestAsk,
+    retained_farthest_bid: retainedFarthestBid.price,
+    retained_farthest_ask: retainedFarthestAsk.price,
+    bid_exhausted: input.archiveMetadata.exhaustionEvidence.bid.exhausted ? 1 : 0,
+    ask_exhausted: input.archiveMetadata.exhaustionEvidence.ask.exhausted ? 1 : 0,
     best_bid: bestBid.price,
     best_ask: bestAsk.price,
     best_bid_amount: bestBid.amount,
@@ -294414,8 +294750,12 @@ function buildCanonicalOrderBookRows(input) {
     bid_level_count: bids.length,
     ask_level_count: asks.length,
     measurement_bands_bps: bands,
-    bid_depth_by_band: bidDepth,
-    ask_depth_by_band: askDepth
+    bid_boundary_price_by_band: bidBoundaries,
+    ask_boundary_price_by_band: askBoundaries,
+    bid_depth_by_band: bidEvidence.depths,
+    ask_depth_by_band: askEvidence.depths,
+    bid_status_by_band: bidEvidence.statuses,
+    ask_status_by_band: askEvidence.statuses
   });
   return {
     snapshotId,
@@ -294545,21 +294885,6 @@ class OhlcvBarTracker {
   }
 }
 
-// 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);
-}
-
 // src/helpers/market-data-archive/parse-stream.ts
 function isFiniteNumber2(value) {
   return typeof value === "number" && Number.isFinite(value);
@@ -294683,13 +295008,17 @@ function legacyMarketFields(context2, rawCapture) {
 function legacyDecimal8(value) {
   return value === undefined ? undefined : Number(value.toFixed(8));
 }
-function buildCanonicalCexStreamEventRow(context2, rawCapture) {
+function buildCanonicalCexStreamEventRow(context2, rawCapture, options) {
+  const payloadEncoding = options?.payloadEncoding ?? "canonical_json_v1";
+  if (payloadEncoding === "orderbook_metadata_only_v1" && context2.feed !== "ORDERBOOK") {
+    throw new Error("Metadata-only raw encoding requires an ORDERBOOK context");
+  }
   const row = withNormalizedChecksum({
     ...captureCoreFields(context2, rawCapture),
     ...legacyMarketFields(context2, rawCapture),
     stream_type: context2.feed,
     event_time_ms: rawCapture.eventTimeMs,
-    payload_encoding: "canonical_json_v1",
+    payload_encoding: payloadEncoding,
     payload_json: canonicalSerialize(rawCapture.redactedPayload)
   });
   return { table: "market_data.cex_stream_events", row };
@@ -294833,7 +295162,13 @@ function archiveOrderbookInBackground(archiver, otelMetrics, input, options) {
   queueMicrotask(() => {
     try {
       const context2 = resolveCaptureContext(archiver, input, "ORDERBOOK", options?.sourceMode ?? "broker_live_sampling_v1");
-      const rawCapture = createRawCapture(context2, {
+      const depthLimit = options?.depthLimit ?? getOrderbookArchiveDepthLimit();
+      const measurementBandsBps = normalizeOrderbookMeasurementBandsBps(input.archiveMetadata.measurementBandsBps);
+      const archiveMetadata = {
+        ...input.archiveMetadata,
+        measurementBandsBps
+      };
+      const completeRawCapture = createRawCapture(context2, {
         payload: input.snapshot,
         eventTimeMs: input.snapshot.timestamp,
         receivedTimeMs: input.snapshot.receivedTimestamp,
@@ -294842,10 +295177,29 @@ function archiveOrderbookInBackground(archiver, otelMetrics, input, options) {
       const canonical = buildCanonicalOrderBookRows({
         context: context2,
         snapshot: input.snapshot,
-        rawCapture,
-        depthLimit: options?.depthLimit ?? getOrderbookArchiveDepthLimit()
+        rawCapture: completeRawCapture,
+        depthLimit,
+        archiveMetadata
       });
-      archiver.enqueue(buildCanonicalCexStreamEventRow(context2, rawCapture));
+      const rawMetadata = {
+        capture_profile_id: archiveMetadata.captureProfileId,
+        effective_cadence_ms: archiveMetadata.effectiveCadenceMs,
+        requested_upstream_depth: archiveMetadata.requestedUpstreamDepth,
+        archive_depth_limit: depthLimit,
+        observed_bid_count: archiveMetadata.observedBidCount,
+        observed_ask_count: archiveMetadata.observedAskCount,
+        observed_farthest_bid: canonicalDecimal(archiveMetadata.observedFarthestBid),
+        observed_farthest_ask: canonicalDecimal(archiveMetadata.observedFarthestAsk),
+        bid_exhausted: archiveMetadata.exhaustionEvidence.bid.exhausted,
+        ask_exhausted: archiveMetadata.exhaustionEvidence.ask.exhausted,
+        retained_bid_count: canonical.levels.filter(({ row }) => row.side === "bid").length,
+        retained_ask_count: canonical.levels.filter(({ row }) => row.side === "ask").length,
+        measurement_bands_bps: measurementBandsBps
+      };
+      const storedRawCapture = projectRawCapturePayload(completeRawCapture, rawMetadata);
+      archiver.enqueue(buildCanonicalCexStreamEventRow(context2, storedRawCapture, {
+        payloadEncoding: "orderbook_metadata_only_v1"
+      }));
       for (const row of canonical.levels)
         archiver.enqueue(row);
       archiver.enqueue(canonical.summary);
@@ -294967,6 +295321,9 @@ function archiveTickerInBackground(archiver, otelMetrics, input) {
   });
 }
 function archiveCexStreamEventInBackground(archiver, otelMetrics, input) {
+  if (input.streamType === "ORDERBOOK") {
+    throw new Error("Generic ORDERBOOK archive events are unsupported; use archiveOrderbookInBackground");
+  }
   archiveMarketRowsInBackground(archiver, otelMetrics, "stream", input, input.streamType, () => [
     buildCexStreamEventRow({
       ...input,
@@ -294991,6 +295348,82 @@ function resolveOhlcvBootstrapLimit(optionValue) {
   }
   return Math.min(parsed, MAX_OHLCV_BOOTSTRAP_LIMIT);
 }
+// src/helpers/market-data-archive/summary-v2-conformance.ts
+var ORDERBOOK_SUMMARY_V2_SUPPORTED_VIEW_FIELDS = [
+  ["source", "String", false],
+  ["deployment_id", "String", false],
+  ["capture_bundle_id", "String", false],
+  ["exchange", "String", false],
+  ["symbol", "String", false],
+  ["trading_pair", "String", false],
+  ["source_symbol", "String", false],
+  ["asset_type", "String", false],
+  ["feed", "String", false],
+  ["provider", "String", false],
+  ["source_mode", "String", false],
+  ["source_time_ms", "UInt64", false],
+  ["received_time_ms", "UInt64", false],
+  ["raw_capture_id", "String", false],
+  ["raw_capture_scope", "String", false],
+  ["schema_version", "String", false],
+  ["checksum_algorithm", "String", false],
+  ["raw_checksum", "String", false],
+  ["provenance_complete", "UInt8", false],
+  ["snapshot_id", "String", false],
+  ["construction_mode", "String", false],
+  ["gap_policy", "String", false],
+  ["depth_limit", "UInt16", false],
+  ["sequence", "UInt64", true],
+  ["exact_l2_reconstruction_complete", "UInt8", false],
+  ["capture_profile_id", "String", false],
+  ["effective_cadence_ms", "UInt32", false],
+  ["requested_upstream_depth", "UInt16", true],
+  ["observed_bid_count", "UInt32", false],
+  ["observed_ask_count", "UInt32", false],
+  ["observed_farthest_bid", "Decimal(38,18)", false],
+  ["observed_farthest_ask", "Decimal(38,18)", false],
+  ["retained_farthest_bid", "Decimal(38,18)", false],
+  ["retained_farthest_ask", "Decimal(38,18)", false],
+  ["bid_exhausted", "UInt8", false],
+  ["ask_exhausted", "UInt8", false],
+  ["best_bid", "Decimal(38,18)", false],
+  ["best_ask", "Decimal(38,18)", false],
+  ["best_bid_amount", "Decimal(38,18)", false],
+  ["best_ask_amount", "Decimal(38,18)", false],
+  ["mid_price", "Decimal(38,18)", false],
+  ["spread", "Decimal(38,18)", false],
+  ["spread_bps", "Float64", false],
+  ["staleness_ms", "UInt64", false],
+  ["bid_level_count", "UInt16", false],
+  ["ask_level_count", "UInt16", false],
+  ["measurement_bands_bps", "Array(UInt32)", false],
+  ["bid_boundary_price_by_band", "Array(Decimal(38,18))", false],
+  ["ask_boundary_price_by_band", "Array(Decimal(38,18))", false],
+  ["bid_depth_by_band", "Array(Decimal(38,18))", false],
+  ["ask_depth_by_band", "Array(Decimal(38,18))", false],
+  ["bid_status_by_band", "Array(Enum8('exact'=1,'censored'=2))", false],
+  ["ask_status_by_band", "Array(Enum8('exact'=1,'censored'=2))", false],
+  ["normalized_row_checksum", "String", false]
+];
+var ORDERBOOK_SUMMARY_V2_SUPPORTED_VIEW_FIELD_NAMES = ORDERBOOK_SUMMARY_V2_SUPPORTED_VIEW_FIELDS.map(([name]) => name);
+var DECIMAL_38_18_FIELDS = new Set([
+  "observed_farthest_bid",
+  "observed_farthest_ask",
+  "retained_farthest_bid",
+  "retained_farthest_ask",
+  "best_bid",
+  "best_ask",
+  "best_bid_amount",
+  "best_ask_amount",
+  "mid_price",
+  "spread"
+]);
+var DECIMAL_38_18_ARRAY_FIELDS = new Set([
+  "bid_boundary_price_by_band",
+  "ask_boundary_price_by_band",
+  "bid_depth_by_band",
+  "ask_depth_by_band"
+]);
 // src/helpers/order-book.ts
 var ORDER_BOOK_CALL_METHODS = {
   FETCH_CAPABILITY: "fetch_order_book_capability",
@@ -295342,7 +295775,7 @@ class PublicFeedWorker {
     if (this.options.profile) {
       this.options.metrics?.recordCounter("public_feed_acquisition_profiles_total", 1, {
         ...this.#metricLabels(),
-        profile: this.options.profile.id
+        profile_class: this.options.profile.coalescingSupported ? "coalesced" : "conservative"
       });
     }
     this.#run = this.#watchLoop();
@@ -295410,7 +295843,34 @@ class PublicFeedWorker {
         depthLimit: retainedDepth,
         receivedTimestamp
       });
-      this.options.archiveSink.orderbook({ ...context2, snapshot }, { sampledOut: !this.#sampler.shouldEmit(receivedTimestamp) });
+      const observedBidCount = snapshot.bids.length;
+      const observedAskCount = snapshot.asks.length;
+      this.options.archiveSink.orderbook({
+        ...context2,
+        snapshot,
+        archiveMetadata: {
+          captureProfileId: this.options.profile?.id ?? `${this.options.exchangeName}:conservative:default`,
+          effectiveCadenceMs: getOrderbookIntervalMs(),
+          requestedUpstreamDepth: this.options.profile?.upstreamLimit ?? null,
+          observedBidCount,
+          observedAskCount,
+          observedFarthestBid: snapshot.bids.at(-1)?.[0] ?? Number.NaN,
+          observedFarthestAsk: snapshot.asks.at(-1)?.[0] ?? Number.NaN,
+          exhaustionEvidence: {
+            bid: {
+              exhausted: this.options.profile?.bidExhaustionEvidence ?? false,
+              validated: this.options.profile?.exhaustionEvidenceValidated ?? true,
+              source: this.options.profile?.id ?? "broker:conservative"
+            },
+            ask: {
+              exhausted: this.options.profile?.askExhaustionEvidence ?? false,
+              validated: this.options.profile?.exhaustionEvidenceValidated ?? true,
+              source: this.options.profile?.id ?? "broker:conservative"
+            }
+          },
+          measurementBandsBps: getOrderbookMeasurementBandsBps()
+        }
+      }, { sampledOut: !this.#sampler.shouldEmit(receivedTimestamp) });
       this.#recordCounter("public_feed_archive_decisions_total");
       this.options.observer?.archiveDecision?.(this.#observation());
       this.#fanout((subscriber) => this.#frame(projectOrderBookSnapshot(snapshot, subscriber.depthLimit), receivedTimestamp));
@@ -295583,7 +296043,7 @@ class PublicFeedWorker {
   }
   #metricLabels() {
     return {
-      exchange: this.options.exchangeName,
+      exchange_bucket: this.options.exchangeOwned ? "dynamic" : "configured",
       feed: this.options.feed,
       market_type: this.options.marketType
     };
@@ -295771,7 +296231,8 @@ import { request as httpsRequest3 } from "node:https";
 import { dirname as dirname2 } from "node:path";
 var SOURCE = "broker_write";
 var TABLE = "broker_stream_health.snapshots";
-var PRODUCER_ID = "cex-broker-user-data";
+var USER_DATA_STREAM_HEALTH_PRODUCER_ID = "cex-broker-user-data";
+var DEPOSIT_POLLER_STREAM_HEALTH_PRODUCER_ID = "cex-broker-deposit-poller";
 var STATE_VERSION = 1;
 var HEARTBEAT_MS = 30000;
 var FORWARDER_TIMEOUT_MS = 3000;
@@ -295806,11 +296267,11 @@ function registryRevision(snapshots) {
   })).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
   return createHash5("sha256").update(JSON.stringify(rows)).digest("hex");
 }
-function validState(value) {
+function validState(value, producerId) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return false;
   const state = value;
-  return state.version === STATE_VERSION && state.producerId === PRODUCER_ID && typeof state.producerEpoch === "string" && typeof state.runId === "string" && typeof state.nextBatchSequence === "string" && state.nextStreamSequences !== null && typeof state.nextStreamSequences === "object" && (state.pendingBody === undefined || typeof state.pendingBody === "string");
+  return state.version === STATE_VERSION && state.producerId === producerId && typeof state.producerEpoch === "string" && typeof state.runId === "string" && typeof state.nextBatchSequence === "string" && state.nextStreamSequences !== null && typeof state.nextStreamSequences === "object" && (state.pendingBody === undefined || typeof state.pendingBody === "string");
 }
 function forwarderPost(url2, body, authToken, timeoutMs) {
   const request = url2.protocol === "http:" ? httpRequest3 : httpsRequest3;
@@ -295840,6 +296301,7 @@ function forwarderPost(url2, body, authToken, timeoutMs) {
 }
 
 class StreamHealthPublisher {
+  #producerId;
   #deploymentId;
   #statePath;
   #heartbeatMs;
@@ -295854,6 +296316,7 @@ class StreamHealthPublisher {
   #retry = null;
   #retryAttempt = 0;
   constructor(options) {
+    this.#producerId = identifier(options.producerId, "producer_id");
     this.#deploymentId = identifier(options.deploymentId, "deployment_id");
     this.#statePath = options.statePath.trim();
     if (!this.#statePath) {
@@ -295878,7 +296341,7 @@ class StreamHealthPublisher {
     const loaded = this.#read();
     this.#state = loaded ?? {
       version: STATE_VERSION,
-      producerId: PRODUCER_ID,
+      producerId: this.#producerId,
       producerEpoch: "1",
       runId: randomUUID3(),
       nextBatchSequence: "1",
@@ -295991,7 +296454,7 @@ class StreamHealthPublisher {
       return {
         table: TABLE,
         row: {
-          producer_id: PRODUCER_ID,
+          producer_id: this.#producerId,
           producer_epoch: this.#state.producerEpoch,
           run_id: this.#state.runId,
           batch_sequence: batchSequence,
@@ -296018,7 +296481,8 @@ class StreamHealthPublisher {
           last_failure_kind: snapshot.lastFailureKind,
           last_failure_reason: snapshot.lastFailureReason,
           traffic_mode: snapshot.trafficMode,
-          source_watermark: snapshot.sourceWatermark
+          source_watermark: snapshot.sourceWatermark,
+          ...snapshot.streamKind === "deposit_poller" ? { poll_observation: snapshot.pollObservation } : {}
         }
       };
     });
@@ -296046,7 +296510,7 @@ class StreamHealthPublisher {
   #read() {
     try {
       const parsed = JSON.parse(readFileSync2(this.#statePath, "utf8"));
-      if (!validState(parsed))
+      if (!validState(parsed, this.#producerId))
         throw new Error("invalid state shape");
       return parsed;
     } catch (error) {
@@ -296109,6 +296573,14 @@ function streamHealthPublisherConfigFromEnv(env = process.env) {
     forwarderAuthToken: env.CEX_BROKER_ARCHIVE_FORWARDER_TOKEN?.trim() || undefined
   };
 }
+function depositPollerStreamHealthPublisherConfigFromEnv(env = process.env) {
+  const base2 = streamHealthPublisherConfigFromEnv(env);
+  return {
+    ...base2,
+    producerId: DEPOSIT_POLLER_STREAM_HEALTH_PRODUCER_ID,
+    statePath: `${base2.statePath}.deposit-poller`
+  };
+}
 
 // src/helpers/user-asset-archive-poller.ts
 var DEFAULT_CONFIG4 = {
@@ -296679,7 +297151,7 @@ class AccountWorker {
     for (const subscriber of [...this.#subscribers])
       subscriber.close();
   }
-  #transition(state, failureKind, failureReason) {
+  #transition(state, failureKind, failureReason2) {
     const timestamp = now3();
     if (this.#snapshot.state !== state) {
       this.#snapshot.state = state;
@@ -296687,7 +297159,7 @@ class AccountWorker {
     }
     if (failureKind) {
       this.#snapshot.lastFailureKind = failureKind;
-      this.#snapshot.lastFailureReason = failureReason ?? "";
+      this.#snapshot.lastFailureReason = failureReason2 ?? "";
     }
     this.onChange();
   }
@@ -296811,7 +297283,7 @@ class UserDataStreamSupervisor {
 }
 
 // src/server.ts
-import * as grpc14 from "@grpc/grpc-js";
+import * as grpc16 from "@grpc/grpc-js";
 
 // src/handlers/execute-action/deposit.ts
 import * as grpc3 from "@grpc/grpc-js";
@@ -310463,7 +310935,10 @@ config(en_default());
 // src/schemas/action-payloads.ts
 var parseJsonString = (value) => {
   if (typeof value !== "string") {
-    return value;
+    if (value === null || value === undefined || typeof value === "number" || typeof value === "boolean" || typeof value === "object") {
+      return value;
+    }
+    return String(value);
   }
   try {
     return JSON.parse(value);
@@ -310472,19 +310947,6 @@ var parseJsonString = (value) => {
   }
 };
 var stringNumberRecordSchema = exports_external.record(exports_external.string(), exports_external.union([exports_external.string(), exports_external.number()]));
-var booleanLikeSchema = exports_external.preprocess((value) => {
-  if (typeof value !== "string") {
-    return value;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (["true", "1", "yes"].includes(normalized)) {
-    return true;
-  }
-  if (["false", "0", "no"].includes(normalized)) {
-    return false;
-  }
-  return value;
-}, exports_external.boolean());
 var DepositPayloadSchema = exports_external.object({
   recipientAddress: exports_external.string().min(1),
   amount: exports_external.coerce.number().positive(),
@@ -310545,10 +311007,22 @@ var CancelOrderPayloadSchema = exports_external.object({
   orderId: exports_external.string().min(1),
   params: exports_external.preprocess(parseJsonString, stringNumberRecordSchema).default({})
 });
-var FetchFeesPayloadSchema = exports_external.object({
-  includeAllFees: booleanLikeSchema.optional().default(false),
-  includeFundingFees: booleanLikeSchema.optional()
-});
+var EmptyActionPayloadSchema = exports_external.object({}).strict();
+var FetchFeesPayloadSchema = EmptyActionPayloadSchema;
+var FetchCurrencyPayloadSchema = exports_external.object({
+  network: exports_external.string().trim().min(1)
+}).strict();
+var MAX_BATCH_CHILDREN = 32;
+var MAX_BATCH_REQUEST_BYTES = 256 * 1024;
+var BatchChildRequestSchema = exports_external.object({
+  id: exports_external.string().trim().min(1),
+  action: exports_external.number().int().nonnegative(),
+  symbol: exports_external.string(),
+  payload: exports_external.record(exports_external.string(), exports_external.string())
+}).strict();
+var BatchPayloadSchema = exports_external.object({
+  requests: exports_external.preprocess(parseJsonString, exports_external.array(BatchChildRequestSchema).min(1).max(MAX_BATCH_CHILDREN))
+}).strict();
 
 // src/helpers/grpc/callbacks.ts
 import * as grpc from "@grpc/grpc-js";
@@ -310597,7 +311071,7 @@ function stableGrpcErrorCode(message) {
   if (message.startsWith("AuthenticationError:")) {
     return grpc2.status.UNAUTHENTICATED;
   }
-  if (message.startsWith("InsufficientFunds:")) {
+  if (message.startsWith("InsufficientFunds:") || message.startsWith("fee_unavailable:")) {
     return grpc2.status.FAILED_PRECONDITION;
   }
   if (message.startsWith("venue_discovery_unavailable:")) {
@@ -310657,6 +311131,13 @@ function resolveGrpcError(error48, message) {
 }
 
 // src/handlers/execute-action/context.ts
+function requireSymbol(ctx, message = "ValidationError: Symbol required") {
+  if (!ctx.symbol) {
+    ctx.wrappedCallback(invalidArgumentError(message), null);
+    return false;
+  }
+  return true;
+}
 function parsePayloadForAction(ctx, schema) {
   return parseActionPayload(schema, ctx.call.request.payload, ctx.wrappedCallback);
 }
@@ -310679,6 +311160,12 @@ function rejectWithGrpcError(ctx, error48, options) {
   }
   ctx.wrappedCallback({ code, message: finalMessage }, null);
 }
+function successWithProof(ctx, result) {
+  ctx.wrappedCallback(null, {
+    proof: ctx.verity.proof,
+    result: JSON.stringify(result)
+  });
+}
 
 // src/handlers/execute-action/deposit.ts
 async function handleDeposit(ctx) {
@@ -310856,7 +311343,7 @@ async function handleDeposit(ctx) {
   }
 }
 // src/handlers/execute-action/handler.ts
-import * as grpc12 from "@grpc/grpc-js";
+import * as grpc14 from "@grpc/grpc-js";
 
 // src/helpers/grpc/broker.ts
 function selectBrokerAccountForCex(normalizedCex, brokers, metadata) {
@@ -310950,7 +311437,29 @@ async function handleOrderBookCall(ctx) {
       assetType: "spot",
       accountSelector: ctx.selectedBrokerAccount?.label,
       deploymentId: ctx.brokerArchiver?.getDeploymentId() ?? "unarchived",
-      snapshot
+      snapshot,
+      archiveMetadata: {
+        captureProfileId: `${orderBookPayload.exchange.trim().toLowerCase()}:current-snapshot:requested:${orderBookPayload.depthLimit}`,
+        effectiveCadenceMs: 1,
+        requestedUpstreamDepth: orderBookPayload.depthLimit,
+        observedBidCount: snapshot.bids.length,
+        observedAskCount: snapshot.asks.length,
+        observedFarthestBid: snapshot.bids.at(-1)?.[0] ?? Number.NaN,
+        observedFarthestAsk: snapshot.asks.at(-1)?.[0] ?? Number.NaN,
+        exhaustionEvidence: {
+          bid: {
+            exhausted: false,
+            validated: true,
+            source: "broker:current-snapshot"
+          },
+          ask: {
+            exhausted: false,
+            validated: true,
+            source: "broker:current-snapshot"
+          }
+        },
+        measurementBandsBps: getOrderbookMeasurementBandsBps()
+      }
     }, {
       sourceMode: "broker_current_snapshot_v1",
       depthLimit: orderBookPayload.depthLimit
@@ -310966,10 +311475,458 @@ async function handleOrderBookCall(ctx) {
 }
 
 // src/handlers/execute-action/registry.ts
-import * as grpc11 from "@grpc/grpc-js";
+import * as grpc13 from "@grpc/grpc-js";
 
-// src/handlers/execute-action/internal-transfer.ts
+// src/handlers/execute-action/batch.ts
 import * as grpc5 from "@grpc/grpc-js";
+
+// src/helpers/venue-evidence.ts
+var DECIMAL_PATTERN = /^\+?(\d+)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/;
+function exchangeSecretLiterals(broker) {
+  const record2 = broker;
+  return [
+    record2.apiKey,
+    record2.secret,
+    record2.password,
+    record2.privateKey
+  ].filter((value) => typeof value === "string" && value.length > 0);
+}
+function sanitizeVenueError(error48, broker) {
+  return redactSecretLiterals(sanitizeErrorDetail(error48), exchangeSecretLiterals(broker));
+}
+function resolveEvidenceAccountScope(selectedBrokerAccount, metadata) {
+  return {
+    accountSelector: selectedBrokerAccount?.label ?? getCurrentBrokerSelector(metadata),
+    credentialSource: selectedBrokerAccount ? "configured_pool" : "request_metadata"
+  };
+}
+function canonicalNonnegativeDecimal(value, field) {
+  const text = typeof value === "number" ? Number.isFinite(value) ? String(value) : "" : typeof value === "string" ? value.trim() : "";
+  const match = text.match(DECIMAL_PATTERN);
+  if (!match) {
+    throw new Error(`venue_discovery_unavailable: ${field} must be decimal`);
+  }
+  const integer2 = match[1] ?? "0";
+  const fraction = match[2] ?? "";
+  const exponent = Number.parseInt(match[3] ?? "0", 10);
+  if (!Number.isSafeInteger(exponent)) {
+    throw new Error(`venue_discovery_unavailable: ${field} exponent is invalid`);
+  }
+  const digits = `${integer2}${fraction}`;
+  const decimalIndex = integer2.length + exponent;
+  let rendered;
+  if (decimalIndex <= 0) {
+    rendered = `0.${"0".repeat(-decimalIndex)}${digits}`;
+  } else if (decimalIndex >= digits.length) {
+    rendered = `${digits}${"0".repeat(decimalIndex - digits.length)}`;
+  } else {
+    rendered = `${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
+  }
+  const [whole = "0", decimals = ""] = rendered.split(".");
+  const normalizedWhole = whole.replace(/^0+(?=\d)/, "") || "0";
+  const normalizedDecimals = decimals.replace(/0+$/, "");
+  return normalizedDecimals ? `${normalizedWhole}.${normalizedDecimals}` : normalizedWhole;
+}
+function decimalFractionToBasisPoints(value) {
+  const canonical = canonicalNonnegativeDecimal(value, "fee rate");
+  return canonicalNonnegativeDecimal(`${canonical}e4`, "fee basis points");
+}
+function canonicalOptionalDecimal(value, field) {
+  return value === undefined || value === null ? undefined : canonicalNonnegativeDecimal(value, field);
+}
+function precisionIncrement(value, precisionMode, field) {
+  if ((precisionMode === 2 || precisionMode === "DECIMAL_PLACES") && (typeof value === "number" || typeof value === "string")) {
+    const decimalPlaces = Number(value);
+    if (Number.isInteger(decimalPlaces) && decimalPlaces >= 0) {
+      return canonicalNonnegativeDecimal(`1e-${decimalPlaces}`, field);
+    }
+  }
+  return canonicalNonnegativeDecimal(value, field);
+}
+function evidenceSourceDigest(input) {
+  const source = removeSecretMaterial(input.source, exchangeSecretLiterals(input.broker));
+  return sha256Canonical({
+    action: input.action,
+    exchange: input.exchange,
+    requestedKey: input.requestedKey,
+    accountSelector: input.accountSelector,
+    sourceMethod: input.sourceMethod,
+    source
+  });
+}
+async function resolveSpotMarketIdentity(broker, symbol2) {
+  const requestedSymbol = symbol2.trim().toUpperCase();
+  if (!/^[^/\s]+\/[^/\s]+$/.test(requestedSymbol)) {
+    throw new Error("venue_discovery_unavailable: symbol must be a slash-delimited spot pair");
+  }
+  await broker.loadMarkets();
+  const market = broker.market(requestedSymbol);
+  if (!isRecord(market)) {
+    throw new Error(`venue_discovery_unavailable: market not found for ${requestedSymbol}`);
+  }
+  const unifiedSymbol = typeof market.symbol === "string" ? market.symbol.trim().toUpperCase() : requestedSymbol;
+  const baseAsset = typeof market.base === "string" ? market.base.trim().toUpperCase() : "";
+  const quoteAsset = typeof market.quote === "string" ? market.quote.trim().toUpperCase() : "";
+  const sourceSymbol = typeof market.id === "string" ? market.id.trim() : "";
+  const isSpot = market.spot === true || market.type === "spot";
+  if (unifiedSymbol !== requestedSymbol || !baseAsset || !quoteAsset || !sourceSymbol || !isSpot || market.active !== true) {
+    throw new Error(`venue_discovery_unavailable: active spot market identity unavailable for ${requestedSymbol}`);
+  }
+  return {
+    market,
+    canonicalPair: `${baseAsset}-${quoteAsset}`,
+    unifiedSymbol,
+    sourceSymbol,
+    baseAsset,
+    quoteAsset
+  };
+}
+function extractTradingFeeRates(response) {
+  if (!isRecord(response)) {
+    throw new Error("fee_unavailable: trading-fee response is not an object");
+  }
+  const info = isRecord(response.info) ? response.info : undefined;
+  const nestedData = isRecord(info?.data) ? info.data : isRecord(response.data) ? response.data : undefined;
+  const maker = [
+    response.maker,
+    response.makerCommission,
+    nestedData?.maker,
+    nestedData?.makerCommission
+  ].find((value) => value !== undefined && value !== null);
+  const taker = [
+    response.taker,
+    response.takerCommission,
+    nestedData?.taker,
+    nestedData?.takerCommission
+  ].find((value) => value !== undefined && value !== null);
+  try {
+    return {
+      makerRate: canonicalNonnegativeDecimal(maker, "maker commission"),
+      takerRate: canonicalNonnegativeDecimal(taker, "taker commission")
+    };
+  } catch (error48) {
+    throw new Error(`fee_unavailable: ${sanitizeErrorDetail(error48)}`, {
+      cause: error48
+    });
+  }
+}
+function evidenceExchange(broker) {
+  return broker;
+}
+
+// src/schemas/action-evidence.ts
+var EVIDENCE_DIGEST_ALGORITHM = "sha256-canonical-json-v1";
+var CanonicalDecimalStringSchema = exports_external.string().regex(/^(?:0|[1-9]\d*)(?:\.\d*[1-9])?$/);
+var accountScopeShape = {
+  accountSelector: exports_external.string().min(1),
+  credentialSource: exports_external.enum(["configured_pool", "request_metadata"])
+};
+var evidenceSourceShape = {
+  observedAt: exports_external.string().datetime({ offset: true }),
+  digestAlgorithm: exports_external.literal(EVIDENCE_DIGEST_ALGORITHM),
+  sourceDigest: exports_external.string().regex(/^[a-f0-9]{64}$/)
+};
+var TradingFeeEvidenceSchema = exports_external.object({
+  schemaVersion: exports_external.literal("cex-trading-fee-evidence/v1"),
+  exchange: exports_external.string().min(1),
+  marketType: exports_external.literal("spot"),
+  canonicalPair: exports_external.string().regex(/^[^-\s]+-[^-\s]+$/),
+  unifiedSymbol: exports_external.string().regex(/^[^/\s]+\/[^/\s]+$/),
+  sourceSymbol: exports_external.string().min(1),
+  ...accountScopeShape,
+  ...evidenceSourceShape,
+  sourceMethod: exports_external.literal("ccxt.fetchTradingFee"),
+  makerRate: CanonicalDecimalStringSchema,
+  takerRate: CanonicalDecimalStringSchema,
+  rateUnit: exports_external.literal("decimal_fraction"),
+  makerBasisPoints: CanonicalDecimalStringSchema,
+  takerBasisPoints: CanonicalDecimalStringSchema,
+  basisPointsUnit: exports_external.literal("basis_points")
+}).strict();
+var MarketRuleEvidenceSchema = exports_external.object({
+  schemaVersion: exports_external.literal("cex-market-rule-evidence/v1"),
+  exchange: exports_external.string().min(1),
+  marketType: exports_external.literal("spot"),
+  canonicalPair: exports_external.string().regex(/^[^-\s]+-[^-\s]+$/),
+  unifiedSymbol: exports_external.string().regex(/^[^/\s]+\/[^/\s]+$/),
+  sourceSymbol: exports_external.string().min(1),
+  baseAsset: exports_external.string().min(1),
+  quoteAsset: exports_external.string().min(1),
+  active: exports_external.literal(true),
+  precisionMode: exports_external.union([exports_external.string().min(1), exports_external.number().int()]),
+  priceIncrement: CanonicalDecimalStringSchema,
+  amountIncrement: CanonicalDecimalStringSchema,
+  minimumAmount: CanonicalDecimalStringSchema,
+  minimumNotional: CanonicalDecimalStringSchema,
+  maximumAmount: CanonicalDecimalStringSchema.optional(),
+  maximumPrice: CanonicalDecimalStringSchema.optional(),
+  maximumNotional: CanonicalDecimalStringSchema.optional(),
+  ...accountScopeShape,
+  ...evidenceSourceShape,
+  sourceMethod: exports_external.literal("ccxt.loadMarkets")
+}).strict();
+var TransferNetworkEvidenceSchema = exports_external.object({
+  schemaVersion: exports_external.literal("cex-transfer-network-evidence/v1"),
+  exchange: exports_external.string().min(1),
+  asset: exports_external.string().min(1),
+  operatorNetworkAlias: exports_external.string().min(1),
+  brokerNetworkId: exports_external.string().min(1),
+  exchangeNetworkId: exports_external.string().min(1),
+  depositAvailable: exports_external.boolean(),
+  withdrawalAvailable: exports_external.boolean(),
+  withdrawalFee: CanonicalDecimalStringSchema.nullable(),
+  withdrawalLimits: exports_external.object({
+    minimum: CanonicalDecimalStringSchema.nullable(),
+    maximum: CanonicalDecimalStringSchema.nullable()
+  }).strict(),
+  ...accountScopeShape,
+  ...evidenceSourceShape,
+  sourceMethod: exports_external.literal("ccxt.fetchCurrencies")
+}).strict();
+var BatchSuccessEntrySchema = exports_external.object({
+  id: exports_external.string().min(1),
+  action: exports_external.number().int().nonnegative(),
+  symbol: exports_external.string(),
+  response: exports_external.object({
+    result: exports_external.string(),
+    proof: exports_external.string()
+  }).strict(),
+  error: exports_external.null()
+}).strict();
+var BatchErrorEntrySchema = exports_external.object({
+  id: exports_external.string().min(1),
+  action: exports_external.number().int().nonnegative(),
+  symbol: exports_external.string(),
+  response: exports_external.null(),
+  error: exports_external.object({
+    code: exports_external.string().min(1),
+    grpcStatus: exports_external.number().int().nonnegative(),
+    message: exports_external.string()
+  }).strict()
+}).strict();
+var BatchResponseEntrySchema = exports_external.union([
+  BatchSuccessEntrySchema,
+  BatchErrorEntrySchema
+]);
+var BatchResponseEnvelopeSchema = exports_external.object({
+  schemaVersion: exports_external.literal("cex-broker-action-batch/v1"),
+  responses: exports_external.array(BatchResponseEntrySchema).max(32)
+}).strict();
+
+// src/handlers/execute-action/batch.ts
+var FORBIDDEN_ROUTING_KEYS = new Set([
+  "account",
+  "accountid",
+  "accountselector",
+  "apikey",
+  "apisecret",
+  "auth",
+  "authorization",
+  "cex",
+  "credential",
+  "credentials",
+  "exchange",
+  "metadata",
+  "password",
+  "secret",
+  "signature",
+  "usesecondarykey"
+]);
+function normalizeRoutingKey(key2) {
+  return key2.replace(/[-_]/g, "").toLowerCase();
+}
+function hasForbiddenRoutingKey(value) {
+  if (Array.isArray(value)) {
+    return value.some(hasForbiddenRoutingKey);
+  }
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  for (const [key2, entry] of Object.entries(value)) {
+    if (FORBIDDEN_ROUTING_KEYS.has(normalizeRoutingKey(key2))) {
+      return true;
+    }
+    if (hasForbiddenRoutingKey(entry)) {
+      return true;
+    }
+  }
+  return false;
+}
+function childContainsRoutingOverride(child) {
+  for (const [key2, value] of Object.entries(child.payload)) {
+    if (FORBIDDEN_ROUTING_KEYS.has(normalizeRoutingKey(key2))) {
+      return true;
+    }
+    try {
+      if (hasForbiddenRoutingKey(JSON.parse(value))) {
+        return true;
+      }
+    } catch {}
+  }
+  return false;
+}
+function stableBatchErrorCode(message, grpcStatus) {
+  const prefix = message.match(/^([A-Za-z][A-Za-z0-9_]*):/)?.[1];
+  if (prefix) {
+    return prefix;
+  }
+  return grpc5.status[grpcStatus] ?? "UNKNOWN";
+}
+function batchErrorEntry(child, error48, broker) {
+  const resolved = resolveGrpcError(error48);
+  const errorRecord = error48 !== null && typeof error48 === "object" ? error48 : undefined;
+  const grpcStatus = typeof errorRecord?.code === "number" ? errorRecord.code : resolved.code;
+  const rawMessage = typeof errorRecord?.message === "string" ? errorRecord.message : resolved.message;
+  const sanitizedMessage = redactSecretLiterals(sanitizeErrorDetail(rawMessage), exchangeSecretLiterals(broker));
+  return {
+    id: child.id,
+    action: child.action,
+    symbol: child.symbol,
+    response: null,
+    error: {
+      code: stableBatchErrorCode(rawMessage, grpcStatus),
+      grpcStatus,
+      message: sanitizedMessage
+    }
+  };
+}
+function childCall(ctx, request) {
+  return {
+    ...ctx.call,
+    request
+  };
+}
+async function executeChild(ctx, child, descriptor) {
+  const action = resolveAction(child.action);
+  if (action === undefined) {
+    return batchErrorEntry(child, new Error(`ValidationError: invalid action ${child.action}`), ctx.broker);
+  }
+  const proofState = { proof: "" };
+  let completion;
+  const localCallback = (error48, response) => {
+    if (completion === undefined) {
+      completion = { error: error48, response: response ?? null };
+    }
+  };
+  const request = {
+    action,
+    cex: ctx.cex,
+    symbol: child.symbol,
+    payload: child.payload
+  };
+  const childContext = {
+    ...ctx,
+    call: childCall(ctx, request),
+    wrappedCallback: localCallback,
+    action,
+    symbol: child.symbol,
+    verity: proofState,
+    applyVerityToBroker: (target) => ctx.applyVerityToBroker(target, proofState)
+  };
+  try {
+    childContext.applyVerityToBroker(ctx.broker);
+    await descriptor.handler(childContext);
+  } catch (error48) {
+    completion ??= {
+      error: resolveGrpcError(error48),
+      response: null
+    };
+  }
+  if (completion === undefined) {
+    return batchErrorEntry(child, new Error(`INTERNAL: ${getActionName(action)} completed without a callback`), ctx.broker);
+  }
+  if (completion.error || !completion.response) {
+    return batchErrorEntry(child, completion.error ?? new Error("INTERNAL: child returned no response"), ctx.broker);
+  }
+  return {
+    id: child.id,
+    action: child.action,
+    symbol: child.symbol,
+    response: {
+      result: completion.response.result,
+      proof: completion.response.proof ?? proofState.proof
+    },
+    error: null
+  };
+}
+async function handleBatch(ctx, lookupDescriptor) {
+  if (ctx.symbol?.trim()) {
+    return ctx.wrappedCallback({
+      code: grpc5.status.INVALID_ARGUMENT,
+      message: "ValidationError: Batch symbol must be empty"
+    }, null);
+  }
+  const encodedRequests = ctx.call.request.payload?.requests;
+  if (typeof encodedRequests === "string" && Buffer.byteLength(encodedRequests, "utf8") > MAX_BATCH_REQUEST_BYTES) {
+    return ctx.wrappedCallback({
+      code: grpc5.status.INVALID_ARGUMENT,
+      message: `ValidationError: Batch requests exceed ${MAX_BATCH_REQUEST_BYTES} bytes`
+    }, null);
+  }
+  const payload = parsePayloadForAction(ctx, BatchPayloadSchema);
+  if (payload === null) {
+    return;
+  }
+  const seenIds = new Set;
+  const prepared = [];
+  for (const child of payload.requests) {
+    if (seenIds.has(child.id)) {
+      return ctx.wrappedCallback({
+        code: grpc5.status.INVALID_ARGUMENT,
+        message: `ValidationError: duplicate batch child id '${child.id}'`
+      }, null);
+    }
+    seenIds.add(child.id);
+    if (childContainsRoutingOverride(child)) {
+      return ctx.wrappedCallback({
+        code: grpc5.status.INVALID_ARGUMENT,
+        message: `ValidationError: batch child '${child.id}' contains a routing override`
+      }, null);
+    }
+    const action = resolveAction(child.action);
+    const descriptor = action === undefined ? undefined : lookupDescriptor(action);
+    if (!descriptor || descriptor.access !== "read" || !descriptor.batchable) {
+      return ctx.wrappedCallback({
+        code: grpc5.status.INVALID_ARGUMENT,
+        message: `ValidationError: batch child '${child.id}' action ${child.action} is not batchable`
+      }, null);
+    }
+    const validation = descriptor.validateBatchRequest?.({
+      action,
+      cex: ctx.cex,
+      symbol: child.symbol,
+      payload: child.payload
+    });
+    if (validation && !validation.valid) {
+      return ctx.wrappedCallback({
+        code: grpc5.status.INVALID_ARGUMENT,
+        message: `ValidationError: batch child '${child.id}': ${validation.message}`
+      }, null);
+    }
+    prepared.push({ child, descriptor });
+  }
+  const responses = [];
+  for (const { child, descriptor } of prepared) {
+    const response = await executeChild(ctx, child, descriptor);
+    responses.push(response);
+    ctx.otelMetrics?.recordCounter("execute_action_batch_items_total", 1, {
+      action: getActionName(child.action),
+      cex: ctx.normalizedCex,
+      outcome: response.error ? "error" : "success"
+    });
+  }
+  const envelope = BatchResponseEnvelopeSchema.parse({
+    schemaVersion: "cex-broker-action-batch/v1",
+    responses
+  });
+  ctx.wrappedCallback(null, {
+    result: JSON.stringify(envelope),
+    proof: ""
+  });
+}
+
+// src/handlers/execute-action/internal-transfer.ts
+import * as grpc6 from "@grpc/grpc-js";
 async function handleInternalTransfer(ctx) {
   const {
     brokers,
@@ -310983,7 +311940,7 @@ async function handleInternalTransfer(ctx) {
   } = ctx;
   if (!symbol2) {
     return ctx.wrappedCallback({
-      code: grpc5.status.INVALID_ARGUMENT,
+      code: grpc6.status.INVALID_ARGUMENT,
       message: `ValidationError: Symbol required`
     }, null);
   }
@@ -310992,14 +311949,14 @@ async function handleInternalTransfer(ctx) {
     return;
   if (normalizedCex !== "binance") {
     return ctx.wrappedCallback({
-      code: grpc5.status.UNIMPLEMENTED,
+      code: grpc6.status.UNIMPLEMENTED,
       message: `InternalTransfer is only supported for Binance`
     }, null);
   }
   const pool = brokers[normalizedCex];
   if (!pool) {
     return ctx.wrappedCallback({
-      code: grpc5.status.FAILED_PRECONDITION,
+      code: grpc6.status.FAILED_PRECONDITION,
       message: `No broker accounts configured for ${normalizedCex}`
     }, null);
   }
@@ -311008,14 +311965,14 @@ async function handleInternalTransfer(ctx) {
   const sourceAccount = resolveBrokerAccount(pool, fromSelector);
   if (!sourceAccount) {
     return ctx.wrappedCallback({
-      code: grpc5.status.INVALID_ARGUMENT,
+      code: grpc6.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,
+      code: grpc6.status.INVALID_ARGUMENT,
       message: `Destination account "${toSelector}" is not configured`
     }, null);
   }
@@ -311049,18 +312006,18 @@ async function handleInternalTransfer(ctx) {
     safeLogError("InternalTransfer failed", error48);
     if (error48 instanceof BrokerAccountPreconditionError) {
       return ctx.wrappedCallback({
-        code: grpc5.status.FAILED_PRECONDITION,
+        code: grpc6.status.FAILED_PRECONDITION,
         message: getErrorMessage(error48)
       }, null);
     }
     const msg = getErrorMessage(error48);
     let code;
     if (msg.includes("Unsupported transfer direction")) {
-      code = grpc5.status.INVALID_ARGUMENT;
+      code = grpc6.status.INVALID_ARGUMENT;
     } else if (msg.includes("unavailable in this CCXT build")) {
-      code = grpc5.status.UNIMPLEMENTED;
+      code = grpc6.status.UNIMPLEMENTED;
     } else {
-      code = mapCcxtErrorToGrpcStatus(error48) ?? grpc5.status.INTERNAL;
+      code = mapCcxtErrorToGrpcStatus(error48) ?? grpc6.status.INTERNAL;
     }
     ctx.wrappedCallback({
       code,
@@ -311070,7 +312027,7 @@ async function handleInternalTransfer(ctx) {
 }
 
 // src/handlers/execute-action/orders.ts
-import * as grpc6 from "@grpc/grpc-js";
+import * as grpc7 from "@grpc/grpc-js";
 
 // src/helpers/passive-order.ts
 var PASSIVE_ORDER_ERROR_CODES = {
@@ -311131,7 +312088,7 @@ async function handleCreateOrder(ctx) {
   const isPassiveOrder = orderValue.orderIntent === "passive_only";
   if (isPassiveOrder && orderValue.orderType !== "limit") {
     return ctx.wrappedCallback({
-      code: grpc6.status.INVALID_ARGUMENT,
+      code: grpc7.status.INVALID_ARGUMENT,
       message: "ValidationError: passive_only order intent requires a limit order"
     }, null);
   }
@@ -311148,14 +312105,14 @@ async function handleCreateOrder(ctx) {
   try {
     if (!broker) {
       return ctx.wrappedCallback({
-        code: grpc6.status.INVALID_ARGUMENT,
+        code: grpc7.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,
+        code: grpc7.status.INVALID_ARGUMENT,
         message: resolution.error ?? "Order rejected by policy: market or limits not satisfied"
       }, null);
     }
@@ -311228,7 +312185,7 @@ async function handleCreateOrder(ctx) {
       });
     }
     ctx.wrappedCallback({
-      code: grpc6.status.INTERNAL,
+      code: grpc7.status.INTERNAL,
       message: `Order Creation failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
@@ -311260,7 +312217,7 @@ async function handleGetOrderDetails(ctx) {
   try {
     if (!broker) {
       return ctx.wrappedCallback({
-        code: grpc6.status.INVALID_ARGUMENT,
+        code: grpc7.status.INVALID_ARGUMENT,
         message: `Invalid CEX key: ${cex3}. Supported keys: ${Object.keys(brokers).join(", ")}`
       }, null);
     }
@@ -311301,7 +312258,7 @@ async function handleGetOrderDetails(ctx) {
     emitOrderExecutionTelemetryInBackground(otelMetrics, failedGetOrderContext, undefined, error48);
     archiveOrderExecutionInBackground(brokerArchiver, failedGetOrderContext, undefined, error48);
     ctx.wrappedCallback({
-      code: grpc6.status.INTERNAL,
+      code: grpc7.status.INTERNAL,
       message: `Failed to fetch order details from ${cex3}: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
@@ -311333,7 +312290,7 @@ async function handleCancelOrder(ctx) {
   try {
     if (!broker) {
       return ctx.wrappedCallback({
-        code: grpc6.status.INVALID_ARGUMENT,
+        code: grpc7.status.INVALID_ARGUMENT,
         message: `Invalid CEX key: ${cex3}. Supported keys: ${Object.keys(brokers).join(", ")}`
       }, null);
     }
@@ -311365,7 +312322,7 @@ async function handleCancelOrder(ctx) {
     emitOrderExecutionTelemetryInBackground(otelMetrics, failedCancelContext, undefined, error48);
     archiveOrderExecutionInBackground(brokerArchiver, failedCancelContext, undefined, error48);
     ctx.wrappedCallback({
-      code: grpc6.status.INTERNAL,
+      code: grpc7.status.INTERNAL,
       message: `Failed to cancel order from ${cex3}: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
@@ -311380,261 +312337,254 @@ async function handleOrders(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) {
+import * as grpc9 from "@grpc/grpc-js";
+
+// src/handlers/execute-action/venue-evidence.ts
+import * as grpc8 from "@grpc/grpc-js";
+function failVenueDiscovery(ctx, error48, operation) {
+  safeLogRedactedError(`${operation} failed`, error48);
+  const sanitized = sanitizeVenueError(error48, ctx.broker);
+  const message = sanitized.startsWith("venue_discovery_unavailable:") ? sanitized : `venue_discovery_unavailable: ${sanitized}`;
+  ctx.wrappedCallback({
+    code: stableGrpcErrorCode(message) ?? mapCcxtErrorToGrpcStatus(error48) ?? grpc8.status.UNIMPLEMENTED,
+    message
+  }, null);
+}
+function optionalDecimalFields(values2) {
+  const result = {};
+  for (const [key2, value, field] of values2) {
+    const normalized = canonicalOptionalDecimal(value, field);
+    if (normalized !== undefined) {
+      result[key2] = normalized;
+    }
+  }
+  return result;
+}
+async function handleFetchFeesEvidence(ctx) {
+  if (!requireSymbol(ctx, "ValidationError: symbol must be a slash-delimited spot pair")) {
+    return;
+  }
+  if (!/^[^/\s]+\/[^/\s]+$/.test(ctx.symbol.trim())) {
     return ctx.wrappedCallback({
-      code: grpc7.status.INVALID_ARGUMENT,
-      message: `ValidationError: Symbol required`
+      code: grpc8.status.INVALID_ARGUMENT,
+      message: "ValidationError: symbol must be a slash-delimited spot pair"
     }, null);
   }
+  if (parsePayloadForAction(ctx, FetchFeesPayloadSchema) === null) {
+    return;
+  }
   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);
-    }
-    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
+    const identity2 = await resolveSpotMarketIdentity(ctx.broker, ctx.symbol);
+    const exchange = evidenceExchange(ctx.broker);
+    if (exchange.has?.fetchTradingFee === false || typeof exchange.fetchTradingFee !== "function") {
+      throw new Error(`fee_unavailable: ${ctx.normalizedCex} does not support fetchTradingFee`);
+    }
+    const sourceResponse = await exchange.fetchTradingFee(identity2.unifiedSymbol);
+    if (isRecord(sourceResponse) && typeof sourceResponse.symbol === "string" && sourceResponse.symbol.trim().toUpperCase() !== identity2.unifiedSymbol) {
+      throw new Error(`fee_unavailable: trading-fee response symbol does not match ${identity2.unifiedSymbol}`);
+    }
+    const { makerRate, takerRate } = extractTradingFeeRates(sourceResponse);
+    const accountScope = resolveEvidenceAccountScope(ctx.selectedBrokerAccount, ctx.metadata);
+    const evidence = TradingFeeEvidenceSchema.parse({
+      schemaVersion: "cex-trading-fee-evidence/v1",
+      exchange: ctx.normalizedCex,
+      marketType: "spot",
+      canonicalPair: identity2.canonicalPair,
+      unifiedSymbol: identity2.unifiedSymbol,
+      sourceSymbol: identity2.sourceSymbol,
+      ...accountScope,
+      observedAt: new Date().toISOString(),
+      sourceMethod: "ccxt.fetchTradingFee",
+      makerRate,
+      takerRate,
+      rateUnit: "decimal_fraction",
+      makerBasisPoints: decimalFractionToBasisPoints(makerRate),
+      takerBasisPoints: decimalFractionToBasisPoints(takerRate),
+      basisPointsUnit: "basis_points",
+      digestAlgorithm: "sha256-canonical-json-v1",
+      sourceDigest: evidenceSourceDigest({
+        action: "FetchFees",
+        exchange: ctx.normalizedCex,
+        requestedKey: identity2.canonicalPair,
+        accountSelector: accountScope.accountSelector,
+        sourceMethod: "ccxt.fetchTradingFee",
+        source: sourceResponse,
+        broker: ctx.broker
       })
     });
+    successWithProof(ctx, evidence);
   } catch (error48) {
-    safeLogError(`Error fetching currency ${symbol2} from ${cex3}`, error48);
-    const message = getErrorMessage(error48);
+    safeLogRedactedError(`FetchFees failed for ${ctx.normalizedCex}/${ctx.symbol}`, error48);
+    const sanitized = sanitizeVenueError(error48, ctx.broker);
+    const message = sanitized.startsWith("fee_unavailable:") ? sanitized : `fee_unavailable: ${sanitized}`;
     ctx.wrappedCallback({
-      code: stableGrpcErrorCode(message) ?? mapCcxtErrorToGrpcStatus(error48) ?? grpc7.status.INTERNAL,
-      message: message.startsWith("venue_discovery_unavailable:") ? message : `venue_discovery_unavailable: ${message}`
+      code: grpc8.status.FAILED_PRECONDITION,
+      message
     }, 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;
+async function handleFetchMarketRulesEvidence(ctx) {
+  if (!requireSymbol(ctx, "ValidationError: symbol must be a slash-delimited spot pair")) {
+    return;
+  }
+  if (!/^[^/\s]+\/[^/\s]+$/.test(ctx.symbol.trim())) {
+    return ctx.wrappedCallback({
+      code: grpc8.status.INVALID_ARGUMENT,
+      message: "ValidationError: symbol must be a slash-delimited spot pair"
+    }, null);
+  }
+  if (parsePayloadForAction(ctx, EmptyActionPayloadSchema) === null) {
+    return;
+  }
   try {
-    const accountId = await broker.fetchAccountId();
-    return ctx.wrappedCallback(null, {
-      proof: ctx.verity.proof,
-      result: JSON.stringify({ accountId })
+    const identity2 = await resolveSpotMarketIdentity(ctx.broker, ctx.symbol);
+    const precision = isRecord(identity2.market.precision) ? identity2.market.precision : {};
+    const limits = isRecord(identity2.market.limits) ? identity2.market.limits : {};
+    const amountLimits = isRecord(limits.amount) ? limits.amount : {};
+    const priceLimits = isRecord(limits.price) ? limits.price : {};
+    const costLimits = isRecord(limits.cost) ? limits.cost : {};
+    const precisionMode = evidenceExchange(ctx.broker).precisionMode;
+    if (precisionMode === undefined || precisionMode === null) {
+      throw new Error("venue_discovery_unavailable: precision mode is unavailable");
+    }
+    const accountScope = resolveEvidenceAccountScope(ctx.selectedBrokerAccount, ctx.metadata);
+    const evidence = MarketRuleEvidenceSchema.parse({
+      schemaVersion: "cex-market-rule-evidence/v1",
+      exchange: ctx.normalizedCex,
+      marketType: "spot",
+      canonicalPair: identity2.canonicalPair,
+      unifiedSymbol: identity2.unifiedSymbol,
+      sourceSymbol: identity2.sourceSymbol,
+      baseAsset: identity2.baseAsset,
+      quoteAsset: identity2.quoteAsset,
+      active: true,
+      precisionMode,
+      priceIncrement: precisionIncrement(precision.price, precisionMode, "price increment"),
+      amountIncrement: precisionIncrement(precision.amount, precisionMode, "amount increment"),
+      minimumAmount: canonicalNonnegativeDecimal(amountLimits.min, "minimum amount"),
+      minimumNotional: canonicalNonnegativeDecimal(costLimits.min, "minimum notional"),
+      ...optionalDecimalFields([
+        ["maximumAmount", amountLimits.max, "maximum amount"],
+        ["maximumPrice", priceLimits.max, "maximum price"],
+        ["maximumNotional", costLimits.max, "maximum notional"]
+      ]),
+      ...accountScope,
+      observedAt: new Date().toISOString(),
+      sourceMethod: "ccxt.loadMarkets",
+      digestAlgorithm: "sha256-canonical-json-v1",
+      sourceDigest: evidenceSourceDigest({
+        action: "FetchMarketRules",
+        exchange: ctx.normalizedCex,
+        requestedKey: identity2.canonicalPair,
+        accountSelector: accountScope.accountSelector,
+        sourceMethod: "ccxt.loadMarkets",
+        source: identity2.market,
+        broker: ctx.broker
+      })
     });
+    successWithProof(ctx, evidence);
   } catch (error48) {
-    safeLogError(`Error fetching account ID ${cex3}`, error48);
-    ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
-      message: `Error fetching account ID from ${cex3}`
-    }, null);
+    failVenueDiscovery(ctx, error48, `FetchMarketRules ${ctx.normalizedCex}/${ctx.symbol}`);
   }
 }
-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);
+async function handleFetchCurrencyEvidence(ctx) {
+  if (!requireSymbol(ctx)) {
+    return;
   }
-  const feesPayload = parsePayloadForAction(ctx, FetchFeesPayloadSchema);
-  if (feesPayload === null)
+  const payload = parsePayloadForAction(ctx, FetchCurrencyPayloadSchema);
+  if (payload === null) {
     return;
-  const includeAllFees = feesPayload.includeAllFees || feesPayload.includeFundingFees === true;
+  }
+  const asset = ctx.symbol.trim().toUpperCase();
+  const requestedAlias = payload.network.trim().toUpperCase();
   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
-        })
-      });
-    }
-    const tokenCode = symbol2.toUpperCase();
-    const { fundingFeeSource, fundingFeesByCurrency } = await fetchFundingFees([
-      tokenCode
-    ]);
+    const exchange = evidenceExchange(ctx.broker);
+    if (exchange.has?.fetchCurrencies === false || typeof exchange.fetchCurrencies !== "function") {
+      throw new Error(`venue_discovery_unavailable: fetchCurrencies unavailable for ${asset}`);
+    }
+    const currencies = await exchange.fetchCurrencies();
+    const currency = currencies[asset];
+    if (!isRecord(currency)) {
+      throw new Error(`venue_discovery_unavailable: currency not found for ${asset}`);
+    }
+    const networkEvidence = buildTransferNetworkEvidence(currency);
+    const brokerNetworkId = normalizeBrokerNetworkId(requestedAlias);
+    const resolution = networkEvidence.aliases[requestedAlias] ?? networkEvidence.aliases[brokerNetworkId];
+    if (!resolution?.networkKey) {
+      throw new Error(`network_alias_unresolved: ${asset}/${requestedAlias} is not available in discovered transfer networks`);
+    }
+    const networks = isRecord(currency.networks) ? currency.networks : {};
+    const networkCandidate = networks[resolution.networkKey];
+    if (!isRecord(networkCandidate) || typeof networkCandidate.deposit !== "boolean" || typeof networkCandidate.withdraw !== "boolean") {
+      throw new Error(`venue_discovery_unavailable: transfer availability is incomplete for ${asset}/${requestedAlias}`);
+    }
+    const network = networkCandidate;
+    const limits = isRecord(network.limits) ? network.limits : {};
+    const withdrawalLimits = isRecord(limits.withdraw) ? limits.withdraw : {};
+    const accountScope = resolveEvidenceAccountScope(ctx.selectedBrokerAccount, ctx.metadata);
+    const evidence = TransferNetworkEvidenceSchema.parse({
+      schemaVersion: "cex-transfer-network-evidence/v1",
+      exchange: ctx.normalizedCex,
+      asset,
+      operatorNetworkAlias: requestedAlias,
+      brokerNetworkId,
+      exchangeNetworkId: resolution.exchangeNetworkId,
+      depositAvailable: network.deposit,
+      withdrawalAvailable: network.withdraw,
+      withdrawalFee: canonicalOptionalDecimal(network.fee, "withdrawal fee") ?? null,
+      withdrawalLimits: {
+        minimum: canonicalOptionalDecimal(withdrawalLimits.min, "minimum withdrawal") ?? null,
+        maximum: canonicalOptionalDecimal(withdrawalLimits.max, "maximum withdrawal") ?? null
+      },
+      ...accountScope,
+      observedAt: new Date().toISOString(),
+      sourceMethod: "ccxt.fetchCurrencies",
+      digestAlgorithm: "sha256-canonical-json-v1",
+      sourceDigest: evidenceSourceDigest({
+        action: "FetchCurrency",
+        exchange: ctx.normalizedCex,
+        requestedKey: `${asset}/${requestedAlias}`,
+        accountSelector: accountScope.accountSelector,
+        sourceMethod: "ccxt.fetchCurrencies",
+        source: network,
+        broker: ctx.broker
+      })
+    });
+    successWithProof(ctx, evidence);
+  } catch (error48) {
+    safeLogRedactedError(`FetchCurrency failed for ${ctx.normalizedCex}/${asset}/${requestedAlias}`, error48);
+    const sanitized = sanitizeVenueError(error48, ctx.broker);
+    const isAliasError = sanitized.startsWith("network_alias_unresolved:");
+    const message = isAliasError || sanitized.startsWith("venue_discovery_unavailable:") ? sanitized : `venue_discovery_unavailable: ${sanitized}`;
+    ctx.wrappedCallback({
+      code: stableGrpcErrorCode(message) ?? mapCcxtErrorToGrpcStatus(error48) ?? grpc8.status.UNIMPLEMENTED,
+      message
+    }, null);
+  }
+}
+
+// src/handlers/execute-action/pass-through.ts
+async function handleFetchAccountId(ctx) {
+  const { cex: cex3, broker } = ctx;
+  try {
+    const accountId = await broker.fetchAccountId();
     return ctx.wrappedCallback(null, {
       proof: ctx.verity.proof,
-      result: JSON.stringify({
-        feeScope: "token",
-        symbol: tokenCode,
-        fundingFeeSource,
-        fundingFeesByCurrency
-      })
+      result: JSON.stringify({ accountId })
     });
   } catch (error48) {
-    safeLogError(`Error fetching fees for ${symbol2} from ${cex3}`, error48);
+    safeLogError(`Error fetching account ID ${cex3}`, error48);
     ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
-      message: `Error fetching fees from ${cex3}`
+      code: grpc9.status.INTERNAL,
+      message: `Error fetching account ID from ${cex3}`
     }, null);
   }
 }
 async function handleFetchDepositAddresses(ctx) {
-  const {
-    call,
-    wrappedCallback,
-    policy,
-    brokers,
-    metadata,
-    normalizedCex,
-    cex: cex3,
-    symbol: symbol2,
-    selectedBrokerAccount,
-    broker,
-    verity,
-    applyVerityToBroker,
-    useVerity,
-    verityProverUrl,
-    otelMetrics
-  } = ctx;
-  const verityProof = verity.proof;
+  const { policy, cex: cex3, symbol: symbol2, broker } = ctx;
   if (!symbol2) {
     return ctx.wrappedCallback({
-      code: grpc7.status.INVALID_ARGUMENT,
+      code: grpc9.status.INVALID_ARGUMENT,
       message: `ValidationError: Symbol required`
     }, null);
   }
@@ -311647,14 +312597,14 @@ async function handleFetchDepositAddresses(ctx) {
   } catch (error48) {
     const message = getErrorMessage(error48);
     return ctx.wrappedCallback({
-      code: stableGrpcErrorCode(message) ?? grpc7.status.INVALID_ARGUMENT,
+      code: stableGrpcErrorCode(message) ?? grpc9.status.INVALID_ARGUMENT,
       message
     }, null);
   }
   const depositValidation = validateDeposit(policy, cex3, depositNetwork.brokerNetworkId, symbol2);
   if (!depositValidation.valid) {
     return ctx.wrappedCallback({
-      code: grpc7.status.PERMISSION_DENIED,
+      code: grpc9.status.PERMISSION_DENIED,
       message: `policy_deposit_denied: ${depositValidation.error}`
     }, null);
   }
@@ -311680,45 +312630,30 @@ async function handleFetchDepositAddresses(ctx) {
       });
     }
     ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
+      code: grpc9.status.INTERNAL,
       message: "Deposit confirmation failed"
     }, null);
   } catch (error48) {
     safeLogError("Fetch Deposit Addresses confirmation failed", error48);
     const message = getErrorMessage(error48);
     ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
+      code: grpc9.status.INTERNAL,
       message: "Fetch Deposit Addresses confirmation failed: " + message
     }, null);
   }
 }
 async function handleFetchBalances(ctx) {
-  const {
-    call,
-    wrappedCallback,
-    policy,
-    brokers,
-    metadata,
-    normalizedCex,
-    cex: cex3,
-    symbol: symbol2,
-    selectedBrokerAccount,
-    broker,
-    verity,
-    applyVerityToBroker,
-    useVerity,
-    verityProverUrl,
-    otelMetrics
-  } = ctx;
-  const verityProof = verity.proof;
+  const { call, cex: cex3, symbol: symbol2, broker } = ctx;
   try {
-    const payload = call.request.payload || {};
-    const providedBalanceType = payload.balanceType;
+    const payload = {
+      ...call.request.payload ?? {}
+    };
+    const providedBalanceType = typeof payload.balanceType === "string" ? payload.balanceType : undefined;
     const balanceType = (providedBalanceType ?? "total").toString();
     const validBalanceTypes = new Set(["free", "used", "total"]);
     if (!validBalanceTypes.has(balanceType)) {
       return ctx.wrappedCallback({
-        code: grpc7.status.INVALID_ARGUMENT,
+        code: grpc9.status.INVALID_ARGUMENT,
         message: `ValidationError: invalid balanceType '${providedBalanceType}'. Expected one of: free | used | total`
       }, null);
     }
@@ -311759,33 +312694,16 @@ async function handleFetchBalances(ctx) {
   } catch (error48) {
     safeLogError(`Error fetching balance from ${cex3}`, error48);
     ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
+      code: grpc9.status.INTERNAL,
       message: `Failed to fetch balance from ${cex3}`
     }, null);
   }
 }
 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;
+  const { cex: cex3, symbol: symbol2, broker } = ctx;
   if (!symbol2) {
     return ctx.wrappedCallback({
-      code: grpc7.status.INVALID_ARGUMENT,
+      code: grpc9.status.INVALID_ARGUMENT,
       message: `ValidationError: Symbol required`
     }, null);
   }
@@ -311798,18 +312716,20 @@ async function handleFetchTicker(ctx) {
   } catch (error48) {
     safeLogError(`Error fetching ticker from ${cex3}`, error48);
     ctx.wrappedCallback({
-      code: grpc7.status.INTERNAL,
+      code: grpc9.status.INTERNAL,
       message: `Failed to fetch ticker from ${cex3}`
     }, null);
   }
 }
 async function handlePassThrough(ctx) {
   if (ctx.action === Action.FetchCurrency)
-    return handleFetchCurrency(ctx);
+    return handleFetchCurrencyEvidence(ctx);
   if (ctx.action === Action.FetchAccountId)
     return handleFetchAccountId(ctx);
   if (ctx.action === Action.FetchFees)
-    return handleFetchFees(ctx);
+    return handleFetchFeesEvidence(ctx);
+  if (ctx.action === Action.FetchMarketRules)
+    return handleFetchMarketRulesEvidence(ctx);
   if (ctx.action === Action.FetchDepositAddresses)
     return handleFetchDepositAddresses(ctx);
   if (ctx.action === Action.FetchBalances)
@@ -311819,7 +312739,7 @@ async function handlePassThrough(ctx) {
 }
 
 // src/handlers/execute-action/perp-config.ts
-import * as grpc8 from "@grpc/grpc-js";
+import * as grpc10 from "@grpc/grpc-js";
 function exchangeSupports(broker, capability) {
   return broker.has?.[capability] === true;
 }
@@ -311838,14 +312758,14 @@ async function handleGetPerpConfigState(ctx) {
   }
   if (!broker) {
     return wrappedCallback({
-      code: grpc8.status.INVALID_ARGUMENT,
+      code: grpc10.status.INVALID_ARGUMENT,
       message: `Invalid CEX key: ${cex3}`
     }, null);
   }
   const exchange = broker;
   if (!exchangeSupports(exchange, "fetchPositions")) {
     return wrappedCallback({
-      code: grpc8.status.UNIMPLEMENTED,
+      code: grpc10.status.UNIMPLEMENTED,
       message: `${normalizedCex} does not support fetchPositions`
     }, null);
   }
@@ -311862,7 +312782,7 @@ async function handleGetPerpConfigState(ctx) {
   } catch (error48) {
     safeLogError(`GetPerpConfigState failed for ${cex3}`, error48);
     ctx.wrappedCallback({
-      code: grpc8.status.INTERNAL,
+      code: grpc10.status.INTERNAL,
       message: `GetPerpConfigState failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
@@ -311875,14 +312795,14 @@ async function handleSetPerpConfigState(ctx) {
   }
   if (!broker) {
     return wrappedCallback({
-      code: grpc8.status.INVALID_ARGUMENT,
+      code: grpc10.status.INVALID_ARGUMENT,
       message: `Invalid CEX key: ${cex3}`
     }, null);
   }
   const exchange = broker;
   if (!exchangeSupports(exchange, "setLeverage")) {
     return wrappedCallback({
-      code: grpc8.status.UNIMPLEMENTED,
+      code: grpc10.status.UNIMPLEMENTED,
       message: `${normalizedCex} does not support setLeverage`
     }, null);
   }
@@ -311903,7 +312823,7 @@ async function handleSetPerpConfigState(ctx) {
   } catch (error48) {
     safeLogError(`SetPerpConfigState failed for ${cex3}`, error48);
     ctx.wrappedCallback({
-      code: grpc8.status.INTERNAL,
+      code: grpc10.status.INTERNAL,
       message: `SetPerpConfigState failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
@@ -311918,7 +312838,7 @@ async function handlePerpConfig(ctx) {
 }
 
 // src/handlers/execute-action/treasury-call.ts
-import * as grpc9 from "@grpc/grpc-js";
+import * as grpc11 from "@grpc/grpc-js";
 async function handleTreasuryCall(ctx) {
   const { broker } = ctx;
   const callValue = parsePayloadForAction(ctx, CallPayloadSchema);
@@ -311929,7 +312849,7 @@ async function handleTreasuryCall(ctx) {
   try {
     if (callValue.functionName.startsWith("_") || callValue.functionName.includes("constructor") || callValue.functionName.includes("prototype")) {
       return ctx.wrappedCallback({
-        code: grpc9.status.PERMISSION_DENIED,
+        code: grpc11.status.PERMISSION_DENIED,
         message: "Access to the requested function is denied"
       }, null);
     }
@@ -311944,7 +312864,7 @@ async function handleTreasuryCall(ctx) {
     const fn = broker[callValue.functionName];
     if (typeof fn !== "function" || broker.has?.[callValue.functionName] === false) {
       return ctx.wrappedCallback({
-        code: grpc9.status.INVALID_ARGUMENT,
+        code: grpc11.status.INVALID_ARGUMENT,
         message: `Function not found on broker: ${callValue.functionName}`
       }, null);
     }
@@ -312023,7 +312943,7 @@ function asFiniteNumber(value) {
 }
 
 // src/handlers/execute-action/withdraw.ts
-import * as grpc10 from "@grpc/grpc-js";
+import * as grpc12 from "@grpc/grpc-js";
 async function handleWithdraw(ctx) {
   const {
     call,
@@ -312046,7 +312966,7 @@ async function handleWithdraw(ctx) {
   const verityProof = verity.proof;
   if (!symbol2) {
     return ctx.wrappedCallback({
-      code: grpc10.status.INVALID_ARGUMENT,
+      code: grpc12.status.INVALID_ARGUMENT,
       message: `ValidationError: Symbol required`
     }, null);
   }
@@ -312059,21 +312979,21 @@ async function handleWithdraw(ctx) {
   } catch (error48) {
     const message = getErrorMessage(error48);
     return ctx.wrappedCallback({
-      code: stableGrpcErrorCode(message) ?? grpc10.status.INVALID_ARGUMENT,
+      code: stableGrpcErrorCode(message) ?? grpc12.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,
+      code: grpc12.status.PERMISSION_DENIED,
       message: `policy_withdrawal_denied: ${transferValidation.error}`
     }, null);
   }
   const travelRule = resolveTravelRuleDecision(policy, cex3, transferValue.recipientAddress);
   if (travelRule.mode === "denied") {
     return ctx.wrappedCallback({
-      code: grpc10.status.FAILED_PRECONDITION,
+      code: grpc12.status.FAILED_PRECONDITION,
       message: `travel_rule_denied: ${travelRule.error}`
     }, null);
   }
@@ -312140,7 +313060,7 @@ async function handleWithdraw(ctx) {
         payload: { recipientAddress: transferValue.recipientAddress }
       }
     });
-    const code = mapCcxtErrorToGrpcStatus(error48) ?? grpc10.status.INTERNAL;
+    const code = mapCcxtErrorToGrpcStatus(error48) ?? grpc12.status.INTERNAL;
     ctx.wrappedCallback({
       code,
       message: `Withdraw failed: ${sanitizeErrorDetail(error48)}`
@@ -312149,33 +313069,152 @@ async function handleWithdraw(ctx) {
 }
 
 // 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
+function valid() {
+  return { valid: true };
+}
+function requireSymbol2(request) {
+  return request.symbol?.trim() ? valid() : { valid: false, message: "symbol is required" };
+}
+function requireSpotSymbol(request) {
+  const symbol2 = request.symbol?.trim() ?? "";
+  return /^[^/\s]+\/[^/\s]+$/.test(symbol2) ? valid() : {
+    valid: false,
+    message: "symbol must be a slash-delimited spot pair"
+  };
+}
+function validatePayload(schema, request) {
+  const parsed = parsePayload(schema, request.payload);
+  return parsed.success ? valid() : { valid: false, message: parsed.message };
+}
+function validateSymbolAndPayload(schema) {
+  return (request) => {
+    const symbolValidation = requireSymbol2(request);
+    return symbolValidation.valid ? validatePayload(schema, request) : symbolValidation;
+  };
+}
+function validateSpotSymbolAndPayload(schema) {
+  return (request) => {
+    const symbolValidation = requireSpotSymbol(request);
+    return symbolValidation.valid ? validatePayload(schema, request) : symbolValidation;
+  };
+}
+function validateFetchBalances(request) {
+  const balanceType = request.payload?.balanceType;
+  if (balanceType !== undefined && !new Set(["free", "used", "total"]).has(balanceType)) {
+    return {
+      valid: false,
+      message: "balanceType must be free, used, or total"
+    };
+  }
+  return valid();
+}
+var ACTION_DESCRIPTORS = {
+  [Action.Deposit]: {
+    handler: handleDeposit,
+    access: "write",
+    batchable: false
+  },
+  [Action.Withdraw]: {
+    handler: handleWithdraw,
+    access: "write",
+    batchable: false
+  },
+  [Action.Call]: {
+    handler: handleTreasuryCall,
+    access: "write",
+    batchable: false
+  },
+  [Action.InternalTransfer]: {
+    handler: handleInternalTransfer,
+    access: "write",
+    batchable: false
+  },
+  [Action.CreateOrder]: {
+    handler: handleOrders,
+    access: "write",
+    batchable: false
+  },
+  [Action.GetOrderDetails]: {
+    handler: handleOrders,
+    access: "read",
+    batchable: false
+  },
+  [Action.CancelOrder]: {
+    handler: handleOrders,
+    access: "write",
+    batchable: false
+  },
+  [Action.FetchCurrency]: {
+    handler: handlePassThrough,
+    access: "read",
+    batchable: true,
+    validateBatchRequest: validateSymbolAndPayload(FetchCurrencyPayloadSchema)
+  },
+  [Action.FetchAccountId]: {
+    handler: handlePassThrough,
+    access: "read",
+    batchable: true,
+    validateBatchRequest: (request) => validatePayload(EmptyActionPayloadSchema, request)
+  },
+  [Action.FetchFees]: {
+    handler: handlePassThrough,
+    access: "read",
+    batchable: true,
+    validateBatchRequest: validateSpotSymbolAndPayload(FetchFeesPayloadSchema)
+  },
+  [Action.FetchDepositAddresses]: {
+    handler: handlePassThrough,
+    access: "read",
+    batchable: false
+  },
+  [Action.FetchBalances]: {
+    handler: handlePassThrough,
+    access: "read",
+    batchable: true,
+    validateBatchRequest: validateFetchBalances
+  },
+  [Action.FetchTicker]: {
+    handler: handlePassThrough,
+    access: "read",
+    batchable: true,
+    validateBatchRequest: validateSymbolAndPayload(EmptyActionPayloadSchema)
+  },
+  [Action.GetPerpConfigState]: {
+    handler: handlePerpConfig,
+    access: "read",
+    batchable: true,
+    validateBatchRequest: (request) => validatePayload(GetPerpConfigStatePayloadSchema, request)
+  },
+  [Action.SetPerpConfigState]: {
+    handler: handlePerpConfig,
+    access: "write",
+    batchable: false
+  },
+  [Action.FetchMarketRules]: {
+    handler: handlePassThrough,
+    access: "read",
+    batchable: true,
+    validateBatchRequest: validateSpotSymbolAndPayload(EmptyActionPayloadSchema)
+  },
+  [Action.Batch]: {
+    handler: (ctx) => handleBatch(ctx, getActionDescriptor),
+    access: "read",
+    batchable: false
+  }
 };
+function getActionDescriptor(action) {
+  return ACTION_DESCRIPTORS[action];
+}
 async function dispatchExecuteAction(ctx) {
-  const handler = ACTION_HANDLERS[ctx.action];
-  if (!handler) {
+  const descriptor = getActionDescriptor(ctx.action);
+  if (!descriptor) {
     ctx.wrappedCallback({
-      code: grpc11.status.INVALID_ARGUMENT,
+      code: grpc13.status.INVALID_ARGUMENT,
       message: "Invalid Action"
     }, null);
     return;
   }
-  await handler(ctx);
+  await descriptor.handler(ctx);
 }
 
 // src/handlers/execute-action/handler.ts
@@ -312191,7 +313230,7 @@ function grpcStatusName(error48) {
   if (typeof error48.code !== "number") {
     return "UNKNOWN";
   }
-  return grpc12.status[error48.code] ?? "UNKNOWN";
+  return grpc14.status[error48.code] ?? "UNKNOWN";
 }
 function createExecuteActionHandler(deps) {
   const {
@@ -312239,7 +313278,7 @@ function createExecuteActionHandler(deps) {
           otelMetrics?.recordCounter("execute_action_errors_total", 1, {
             action: actionName,
             cex: cex3 || "unknown",
-            error_type: error48.code ? grpc12.status[error48.code] || "unknown" : "unknown"
+            error_type: error48.code ? grpc14.status[error48.code] || "unknown" : "unknown"
           });
         } else {
           otelMetrics?.recordCounter("execute_action_success_total", 1, {
@@ -312262,13 +313301,13 @@ function createExecuteActionHandler(deps) {
       });
       if (!authenticateRequest(call, whitelistIps)) {
         return wrappedCallback({
-          code: grpc12.status.PERMISSION_DENIED,
+          code: grpc14.status.PERMISSION_DENIED,
           message: "Access denied: Unauthorized IP"
         }, null);
       }
       if (!action || !cex3) {
         return wrappedCallback({
-          code: grpc12.status.INVALID_ARGUMENT,
+          code: grpc14.status.INVALID_ARGUMENT,
           message: "`action` AND `cex` fields are required"
         }, null);
       }
@@ -312278,17 +313317,20 @@ function createExecuteActionHandler(deps) {
       const broker = selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, call.metadata) ?? (isPublicMarketDataAction(action, call.request.payload) ? createPublicBroker(normalizedCex) : null);
       if (!broker) {
         return wrappedCallback({
-          code: grpc12.status.UNAUTHENTICATED,
+          code: grpc14.status.UNAUTHENTICATED,
           message: `This Exchange is not registered and No API metadata was found`
         }, null);
       }
       const verity = { proof: "" };
-      const applyVerityToBroker = (targetBroker) => {
+      const applyVerityToBroker = (targetBroker, proofState = verity) => {
         if (!useVerity)
           return;
         const override = buildHttpClientOverrideFromMetadata(metadata, verityProverUrl, (proof, notaryPubKey) => {
-          verity.proof = proof;
-          log.debug(`Verity proof:`, { proof, notaryPubKey });
+          proofState.proof = proof;
+          log.debug(`Verity proof received`, {
+            has_proof: proof.length > 0,
+            has_notary_public_key: Boolean(notaryPubKey)
+          });
         });
         targetBroker.setHttpClientOverride(override, verityHttpClientOverridePredicate);
       };
@@ -312324,7 +313366,7 @@ function createExecuteActionHandler(deps) {
     } catch (error48) {
       safeLogError("ExecuteAction unhandled error", error48);
       return wrappedCallback({
-        code: grpc12.status.INTERNAL,
+        code: grpc14.status.INTERNAL,
         message: "ExecuteAction failed unexpectedly"
       }, null);
     }
@@ -312384,7 +313426,7 @@ class SubscribeBrokerLifecycle {
   }
 }
 // src/handlers/subscribe/handler.ts
-import * as grpc13 from "@grpc/grpc-js";
+import * as grpc15 from "@grpc/grpc-js";
 
 // src/helpers/binance-user-data-normalization.ts
 function requireQuantity(entry, key2) {
@@ -312495,8 +313537,8 @@ async function writeSubscribeError(call, isClosed, frame) {
     call.end();
   }
 }
-function grpcStatusName2(status14) {
-  return typeof status14 === "number" ? grpc13.status[status14] ?? "UNKNOWN" : "UNKNOWN";
+function grpcStatusName2(status16) {
+  return typeof status16 === "number" ? grpc15.status[status16] ?? "UNKNOWN" : "UNKNOWN";
 }
 function getBinanceEventMarketId(event) {
   const value = event.s;
@@ -312689,9 +313731,9 @@ function createSubscribeHandler(deps) {
         log.withMetadata(fields).info("Subscribe ended");
       }
     };
-    const writeTerminalError = async (frame, status14 = grpc13.status.UNKNOWN) => {
+    const writeTerminalError = async (frame, status16 = grpc15.status.UNKNOWN) => {
       terminalOutcome = "error";
-      terminalGrpcStatus = grpcStatusName2(status14);
+      terminalGrpcStatus = grpcStatusName2(status16);
       await writeSubscribeError(call, isStreamClosed, frame);
     };
     log.withMetadata(operationalFields).info("Subscribe started");
@@ -312727,7 +313769,7 @@ function createSubscribeHandler(deps) {
         error_type: "permission_denied"
       });
       call.emit("error", {
-        code: grpc13.status.PERMISSION_DENIED,
+        code: grpc15.status.PERMISSION_DENIED,
         message: "Access denied: Unauthorized IP"
       }, null);
       call.destroy(new Error("Access denied: Unauthorized IP"));
@@ -312748,7 +313790,7 @@ function createSubscribeHandler(deps) {
           timestamp: Date.now(),
           symbol: symbol2 || "",
           type: subscriptionType2
-        }, grpc13.status.INVALID_ARGUMENT);
+        }, grpc15.status.INVALID_ARGUMENT);
         return;
       }
       if (isPublicMarketDataSubscription(subscriptionType2)) {
@@ -312805,7 +313847,7 @@ function createSubscribeHandler(deps) {
           timestamp: Date.now(),
           symbol: symbol2,
           type: subscriptionType2
-        }, grpc13.status.NOT_FOUND);
+        }, grpc15.status.NOT_FOUND);
         return;
       }
       if (!selectedBrokerAccount) {
@@ -312840,7 +313882,7 @@ function createSubscribeHandler(deps) {
             timestamp: Date.now(),
             symbol: resolvedSymbol,
             type: subscriptionType2
-          }, grpc13.status.FAILED_PRECONDITION);
+          }, grpc15.status.FAILED_PRECONDITION);
           return;
         }
         const marketId = subscriptionType2 === SubscriptionType.ORDERS ? await getBinanceMarketId(accountBroker, resolvedSymbol) : undefined;
@@ -312854,7 +313896,7 @@ function createSubscribeHandler(deps) {
               timestamp: Date.now(),
               symbol: resolvedSymbol,
               type: subscriptionType2
-            }, grpc13.status.FAILED_PRECONDITION);
+            }, grpc15.status.FAILED_PRECONDITION);
             return;
           }
           userDataSource = userDataStreamSupervisor.subscribe({
@@ -312912,7 +313954,7 @@ function createSubscribeHandler(deps) {
             timestamp: Date.now(),
             symbol: symbol2,
             type: subscriptionType2
-          }, grpc13.status.INVALID_ARGUMENT);
+          }, grpc15.status.INVALID_ARGUMENT);
       }
     } catch (error48) {
       log.error("Error in Subscribe stream:", error48);
@@ -312922,7 +313964,7 @@ function createSubscribeHandler(deps) {
         timestamp: Date.now(),
         symbol: "",
         type: subscriptionType2
-      }, grpc13.status.INTERNAL);
+      }, grpc15.status.INTERNAL);
     } finally {
       call.off("cancelled", closeOwnedBrokerOnCallEnd);
       call.off("error", closeOwnedBrokerOnCallEnd);
@@ -313054,7 +314096,9 @@ var descriptor = {
             FetchFees: 12,
             InternalTransfer: 13,
             GetPerpConfigState: 14,
-            SetPerpConfigState: 15
+            SetPerpConfigState: 15,
+            FetchMarketRules: 16,
+            Batch: 17
           }
         }
       }
@@ -313076,10 +314120,10 @@ var PROTO_LOADER_OPTIONS = {
 var CEX_BROKER_PACKAGE_DEFINITION = protoLoader.fromJSON(node_descriptor_default, PROTO_LOADER_OPTIONS);
 
 // src/server.ts
-var grpcObj = grpc14.loadPackageDefinition(CEX_BROKER_PACKAGE_DEFINITION);
+var grpcObj = grpc16.loadPackageDefinition(CEX_BROKER_PACKAGE_DEFINITION);
 var cexNode = grpcObj.cex_broker;
 function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, otelMetrics, brokerArchiver, orderActivityTracker, withdrawalObservationTracker, subscribeBrokerLifecycle, userDataStreamSupervisor, publicMarketDataFeedSupervisor) {
-  const server = new grpc14.Server;
+  const server = new grpc16.Server;
   server.addService(cexNode.cex_service.service, {
     ExecuteAction: createExecuteActionHandler({
       policy,
@@ -313468,7 +314512,10 @@ class CEXBroker {
       await this.otelMetrics.initialize();
     }
     if (!this.userDataStreamSupervisor && Object.keys(this.brokers).length > 0) {
-      const publisher = new StreamHealthPublisher(streamHealthPublisherConfigFromEnv());
+      const publisher = new StreamHealthPublisher({
+        ...streamHealthPublisherConfigFromEnv(),
+        producerId: USER_DATA_STREAM_HEALTH_PRODUCER_ID
+      });
       this.userDataStreamSupervisor = new UserDataStreamSupervisor({
         brokers: this.brokers,
         publisher
@@ -313481,7 +314528,7 @@ class CEXBroker {
       otelMetrics: this.otelMetrics
     });
     this.server = getServer(this.policy, this.brokers, this.whitelistIps, this.useVerity, this.#verityProverUrl, this.otelMetrics, this.brokerArchiver, this.orderActivityTracker, this.withdrawalObservationTracker, undefined, this.userDataStreamSupervisor, this.publicMarketDataFeedSupervisor);
-    this.server.bindAsync(`0.0.0.0:${this.port}`, grpc15.ServerCredentials.createInsecure(), (err2, port) => {
+    this.server.bindAsync(`0.0.0.0:${this.port}`, grpc17.ServerCredentials.createInsecure(), (err2, port) => {
       if (err2) {
         log.error(err2);
         return;
@@ -313506,7 +314553,8 @@ class CEXBroker {
       this.depositArchivePoller = new DepositArchivePoller({
         brokers: this.brokers,
         archiver: this.brokerArchiver,
-        metrics: this.otelMetrics
+        metrics: this.otelMetrics,
+        coveragePublisher: Object.keys(this.brokers).length > 0 ? new StreamHealthPublisher(depositPollerStreamHealthPublisherConfigFromEnv()) : undefined
       });
       this.depositArchivePoller.start();
       if (this.userDataStreamSupervisor) {
@@ -313539,4 +314587,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=72C8C3614857C3F664756E2164756E21
+//# debugId=9C0805B96506F17064756E2164756E21