@usherlabs/cex-broker 0.3.0 → 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 {
@@ -292744,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",
@@ -292754,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",
@@ -292983,6 +293034,7 @@ class DepositArchivePoller {
   #cursors = new Map;
   #lastArchivedByTarget = new Map;
   #unsupportedLogged = new Set;
+  #coverage = new Map;
   #config;
   constructor(params) {
     this.params = params;
@@ -292993,6 +293045,7 @@ class DepositArchivePoller {
       return;
     }
     log.info("\uD83D\uDCE5 Deposit archive poller started");
+    this.params.coveragePublisher?.start();
     this.#schedule(0);
   }
   async stop() {
@@ -293002,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()) {
@@ -293037,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) {
@@ -293055,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;
@@ -293068,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);
@@ -293101,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;
       }
@@ -293141,7 +293317,7 @@ class DepositArchivePoller {
         }
         targetDeposits2.set(identity, {
           status: classification.archiveStatus,
-          timestamp: depositTimestamp(record),
+          timestamp: depositTimestampMs,
           progressKey: classification.progressKey,
           highWatermark: classification.highWatermark
         });
@@ -293164,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}`;
@@ -296042,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;
@@ -296077,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;
@@ -296111,6 +296301,7 @@ function forwarderPost(url2, body, authToken, timeoutMs) {
 }
 
 class StreamHealthPublisher {
+  #producerId;
   #deploymentId;
   #statePath;
   #heartbeatMs;
@@ -296125,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) {
@@ -296149,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",
@@ -296262,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,
@@ -296289,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 } : {}
         }
       };
     });
@@ -296317,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) {
@@ -296380,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 = {
@@ -296950,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;
@@ -296958,7 +297159,7 @@ class AccountWorker {
     }
     if (failureKind) {
       this.#snapshot.lastFailureKind = failureKind;
-      this.#snapshot.lastFailureReason = failureReason ?? "";
+      this.#snapshot.lastFailureReason = failureReason2 ?? "";
     }
     this.onChange();
   }
@@ -297082,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";
@@ -310734,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);
@@ -310743,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(),
@@ -310816,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";
@@ -310868,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:")) {
@@ -310928,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);
 }
@@ -310950,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) {
@@ -311127,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) {
@@ -311259,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,
@@ -311276,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);
   }
@@ -311285,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);
   }
@@ -311301,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);
   }
@@ -311342,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,
@@ -311363,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 = {
@@ -311424,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);
   }
@@ -311441,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);
     }
@@ -311521,7 +312185,7 @@ async function handleCreateOrder(ctx) {
       });
     }
     ctx.wrappedCallback({
-      code: grpc6.status.INTERNAL,
+      code: grpc7.status.INTERNAL,
       message: `Order Creation failed: ${sanitizeErrorDetail(error48)}`
     }, null);
   }
@@ -311553,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);
     }
@@ -311594,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);
   }
@@ -311626,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);
     }
@@ -311658,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);
   }
@@ -311673,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);
   }
@@ -311940,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);
   }
@@ -311973,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);
     }
@@ -312052,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);
   }
@@ -312091,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)
@@ -312112,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;
 }
@@ -312131,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);
   }
@@ -312155,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);
   }
@@ -312168,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);
   }
@@ -312196,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);
   }
@@ -312211,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);
@@ -312222,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);
     }
@@ -312237,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);
     }
@@ -312316,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,
@@ -312339,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);
   }
@@ -312352,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);
   }
@@ -312433,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)}`
@@ -312442,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
@@ -312484,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 {
@@ -312532,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, {
@@ -312555,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);
       }
@@ -312571,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);
       };
@@ -312617,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);
     }
@@ -312677,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) {
@@ -312788,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;
@@ -312982,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");
@@ -313020,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"));
@@ -313041,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)) {
@@ -313098,7 +313847,7 @@ function createSubscribeHandler(deps) {
           timestamp: Date.now(),
           symbol: symbol2,
           type: subscriptionType2
-        }, grpc13.status.NOT_FOUND);
+        }, grpc15.status.NOT_FOUND);
         return;
       }
       if (!selectedBrokerAccount) {
@@ -313133,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;
@@ -313147,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({
@@ -313205,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);
@@ -313215,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);
@@ -313347,7 +314096,9 @@ var descriptor = {
             FetchFees: 12,
             InternalTransfer: 13,
             GetPerpConfigState: 14,
-            SetPerpConfigState: 15
+            SetPerpConfigState: 15,
+            FetchMarketRules: 16,
+            Batch: 17
           }
         }
       }
@@ -313369,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,
@@ -313761,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
@@ -313774,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;
@@ -313799,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) {
@@ -313832,4 +314587,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=46EFCE207D029E0F64756E2164756E21
+//# debugId=9C0805B96506F17064756E2164756E21