@oracle-agent/oracle 0.11.0 → 0.12.0

package/src/public-control/policy-render.mjs

@@ -1,69 +0,0 @@
-// Oracle Control — human-readable grant renderer (Slice A).
-//
-// Renders a validated public grant into deterministic plain text a user can
-// review before approving. Rendering is a PRESENTATION of the deterministic
-// policy only — it never adds, removes, or reinterprets authority, and it only
-// ever surfaces public grant material (no keys, tokens, paths, or secrets).
-//
-// Output is byte-for-byte deterministic for a given grant: fixed field order,
-// fixed labels, UTC timestamps derived purely from expiresAt, and the sha256
-// grant id from the canonical form. Tests assert exact output.
-
-import { normalizeGrant, grantId, isReadonlyAction, GRANT_VERSION } from "./policy-schema.mjs";
-
-const LABEL_WIDTH = 14;
-
-function row(label, value) {
-  return `${(label + ":").padEnd(LABEL_WIDTH)}${value}`;
-}
-
-/** Deterministic UTC ISO string from unix seconds. */
-function isoUtc(unixSeconds) {
-  return new Date(unixSeconds * 1000).toISOString();
-}
-
-/** "50 bps (0.50%)" — deterministic fixed-2 percentage. */
-export function formatBps(bps) {
-  return `${bps} bps (${(bps / 100).toFixed(2)}%)`;
-}
-
-/** Group wei digits for readability: 1000000 -> "1,000,000". Deterministic. */
-export function formatWei(weiString) {
-  const s = String(weiString);
-  return `${s.replace(/\B(?=(\d{3})+(?!\d))/g, ",")} wei`;
-}
-
-/**
- * Render a grant as deterministic human-readable text.
- * Validates/normalizes first (throws GrantValidationError on bad input), so a
- * grant that cannot be rendered is a grant that cannot be authorized.
- */
-export function renderGrant(input, opts = {}) {
-  const g = normalizeGrant(input, opts);
-  const id = grantId(g);
-  const readonlyOnly = g.actions.every((a) => isReadonlyAction(a));
-
-  const lines = [
-    "ORACLE CONTROL GRANT (deterministic authorization)",
-    "==================================================",
-    row("Grant ID", id),
-    row("Version", String(GRANT_VERSION)),
-    row("Chain", String(g.chainId)),
-    row("Agent", g.agentAddress),
-    row("Account", g.accountAddress),
-    row("Actions", g.actions.join(", ")),
-    row("Targets", g.targets.length ? g.targets.join(", ") : "(none — read/simulate only)"),
-    row("Max value", formatWei(g.maxValueWei)),
-    row("Max gas", formatWei(g.maxGasWei)),
-    row("Max slippage", formatBps(g.maxSlippageBps)),
-    row("Expires", `${isoUtc(g.expiresAt)} (unix ${g.expiresAt})`),
-    row("Nonce", g.nonce),
-    row("Revocation", g.revocationKey),
-    "--------------------------------------------------",
-    readonlyOnly
-      ? "Scope: read/simulate only — this grant cannot move funds."
-      : "Scope: includes state-changing actions bounded by the caps above.",
-    "Self-custodial: this grant contains public data only and can be revoked at any time via the revocation key.",
-  ];
-  return lines.join("\n");
-}

package/src/public-control/policy-schema.mjs

@@ -1,318 +0,0 @@
-// Oracle Control — public grant policy schema (Slice A).
-//
-// Oracle Control is DETERMINISTIC AUTHORIZATION: a grant either validates or it
-// does not, with no advisory judgement involved (that is Oracle Router's job,
-// and Router output must never gate anything here).
-//
-// This module is dependency-free (node builtins only, no npm packages) and
-// fully deterministic: same input object => same normalized grant => same
-// canonical string => same grant id, regardless of key order, address casing,
-// array ordering, or numeric representation (number / bigint / decimal string).
-//
-// Self-custody boundary: a grant only ever references PUBLIC material —
-// chain id, the agent's public address, the user's own account address,
-// action scopes, target contracts, spend/gas/slippage ceilings, expiry,
-// nonce, and a public revocation key identifier. Nothing here may carry or
-// derive private keys, bearer tokens, keystore paths, or session secrets.
-//
-// Fail-closed rules enforced by validateGrant / normalizeGrant:
-//   - every required field must be present (expiry, chain, agent, account, ...)
-//   - unknown fields are rejected (no smuggling extra authority)
-//   - broad wildcard actions are rejected by default ("*", "*:*", "verb:*")
-//   - empty targets are only allowed when EVERY action is read/simulate scoped
-//   - expiresAt is required and, when a reference `now` is supplied, must be
-//     strictly in the future
-
-import { createHash } from "node:crypto";
-
-export const GRANT_VERSION = 1;
-
-/** Every field is required. Order here is documentation only; canonical form
- *  always sorts keys alphabetically. */
-export const REQUIRED_FIELDS = Object.freeze([
-  "chainId",
-  "agentAddress",
-  "accountAddress",
-  "actions",
-  "targets",
-  "maxValueWei",
-  "maxGasWei",
-  "maxSlippageBps",
-  "expiresAt",
-  "nonce",
-  "revocationKey",
-]);
-
-/** Action verbs that never touch state; only these may have empty targets. */
-export const READONLY_ACTION_VERBS = Object.freeze(["read", "simulate"]);
-
-export const MAX_SLIPPAGE_BPS = 10_000;
-export const MAX_NONCE_LENGTH = 128;
-export const MAX_REVOCATION_KEY_LENGTH = 256;
-export const MAX_ACTIONS = 64;
-export const MAX_TARGETS = 256;
-
-const ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
-// verb:resource — lowercase verb, resource may carry dots/dashes/underscores.
-const ACTION_RE = /^[a-z][a-z0-9_-]*:[a-z0-9._-]+$/;
-// wildcard-bearing action (only accepted when explicitly opted in, and never
-// with a wildcard verb).
-const ACTION_WILDCARD_RE = /^[a-z][a-z0-9_-]*:\*$/;
-const NONCE_RE = /^[A-Za-z0-9._:-]+$/;
-const REVOCATION_KEY_RE = /^[A-Za-z0-9._:-]+$/;
-const DECIMAL_RE = /^(0|[1-9][0-9]*)$/;
-
-export class GrantValidationError extends Error {
-  constructor(errors) {
-    const lines = errors.map((e) => `${e.field}: ${e.message}`);
-    super(`invalid grant (${errors.length} error${errors.length === 1 ? "" : "s"}): ${lines.join("; ")}`);
-    this.name = "GrantValidationError";
-    this.errors = errors;
-  }
-}
-
-function isPlainObject(v) {
-  return v != null && typeof v === "object" && !Array.isArray(v);
-}
-
-/** Parse a non-negative integer amount (number | bigint | decimal string)
- *  into a canonical decimal string. Returns null when unparseable. */
-function toAmountString(v) {
-  if (typeof v === "bigint") {
-    return v >= 0n ? v.toString(10) : null;
-  }
-  if (typeof v === "number") {
-    if (!Number.isSafeInteger(v) || v < 0) return null;
-    return String(v);
-  }
-  if (typeof v === "string") {
-    const s = v.trim();
-    if (!DECIMAL_RE.test(s)) return null;
-    return s;
-  }
-  return null;
-}
-
-function toSafeInt(v) {
-  if (typeof v === "bigint") {
-    if (v < 0n || v > BigInt(Number.MAX_SAFE_INTEGER)) return null;
-    return Number(v);
-  }
-  if (typeof v === "number") {
-    if (!Number.isSafeInteger(v) || v < 0) return null;
-    return v;
-  }
-  if (typeof v === "string") {
-    const s = v.trim();
-    if (!DECIMAL_RE.test(s)) return null;
-    const n = Number(s);
-    return Number.isSafeInteger(n) ? n : null;
-  }
-  return null;
-}
-
-/** True when the action verb is read-only (read/simulate). */
-export function isReadonlyAction(action) {
-  const verb = String(action).split(":")[0];
-  return READONLY_ACTION_VERBS.includes(verb);
-}
-
-/**
- * Validate a grant. Never throws; returns { ok, errors, grant } where `grant`
- * is the normalized form when ok, else null.
- *
- * Options:
- *   allowWildcardActions  (default false) — permit "verb:*" actions. Broad
- *                         wildcards ("*", "*:*", wildcard verbs) are ALWAYS
- *                         rejected regardless of this flag.
- *   now                   (unix seconds) — when provided, expiresAt must be
- *                         strictly greater than it. Pass explicitly for
- *                         deterministic validation; omitted means no liveness
- *                         check (pure shape validation).
- */
-export function validateGrant(input, opts = {}) {
-  const errors = [];
-  const push = (field, message) => errors.push({ field, message });
-
-  if (!isPlainObject(input)) {
-    push("grant", "grant must be a plain object");
-    return { ok: false, errors, grant: null };
-  }
-
-  // Fail closed on unknown fields.
-  for (const key of Object.keys(input)) {
-    if (!REQUIRED_FIELDS.includes(key)) push(key, "unknown field is not allowed");
-  }
-  for (const key of REQUIRED_FIELDS) {
-    if (!(key in input) || input[key] == null) push(key, "required field is missing");
-  }
-  if (errors.length) return { ok: false, errors, grant: null };
-
-  const out = {};
-
-  // chainId
-  const chainId = toSafeInt(input.chainId);
-  if (chainId == null || chainId <= 0) push("chainId", "must be a positive integer chain id");
-  else out.chainId = chainId;
-
-  // addresses
-  for (const field of ["agentAddress", "accountAddress"]) {
-    const v = input[field];
-    if (typeof v !== "string" || !ADDRESS_RE.test(v.trim())) {
-      push(field, "must be a 0x-prefixed 20-byte hex address");
-    } else {
-      out[field] = v.trim().toLowerCase();
-    }
-  }
-
-  // actions
-  if (!Array.isArray(input.actions) || input.actions.length === 0) {
-    push("actions", "must be a non-empty array of action scopes");
-  } else if (input.actions.length > MAX_ACTIONS) {
-    push("actions", `too many actions (max ${MAX_ACTIONS})`);
-  } else {
-    const actions = [];
-    for (const raw of input.actions) {
-      const a = typeof raw === "string" ? raw.trim() : null;
-      if (!a) {
-        push("actions", "action entries must be non-empty strings");
-        continue;
-      }
-      if (a.includes("*")) {
-        if (opts.allowWildcardActions === true && ACTION_WILDCARD_RE.test(a)) {
-          actions.push(a);
-        } else {
-          push("actions", `broad wildcard action "${a}" is rejected (fail closed)`);
-        }
-        continue;
-      }
-      if (!ACTION_RE.test(a)) {
-        push("actions", `malformed action "${a}" (expected verb:resource)`);
-        continue;
-      }
-      actions.push(a);
-    }
-    out.actions = [...new Set(actions)].sort();
-  }
-
-  // targets
-  if (!Array.isArray(input.targets)) {
-    push("targets", "must be an array of contract addresses");
-  } else if (input.targets.length > MAX_TARGETS) {
-    push("targets", `too many targets (max ${MAX_TARGETS})`);
-  } else {
-    const targets = [];
-    for (const raw of input.targets) {
-      const t = typeof raw === "string" ? raw.trim() : null;
-      if (!t || !ADDRESS_RE.test(t)) {
-        push("targets", `target "${raw}" must be a 0x-prefixed 20-byte hex address (wildcards not allowed)`);
-        continue;
-      }
-      targets.push(t.toLowerCase());
-    }
-    out.targets = [...new Set(targets)].sort();
-    if (out.targets.length === 0 && Array.isArray(out.actions)) {
-      const nonReadonly = out.actions.filter((a) => !isReadonlyAction(a));
-      if (nonReadonly.length > 0 || out.actions.length === 0) {
-        push(
-          "targets",
-          `empty targets are only allowed for read/simulate scopes (blocked by: ${nonReadonly.join(", ") || "no valid actions"})`
-        );
-      }
-    }
-  }
-
-  // amounts
-  for (const field of ["maxValueWei", "maxGasWei"]) {
-    const amt = toAmountString(input[field]);
-    if (amt == null) push(field, "must be a non-negative integer wei amount");
-    else out[field] = amt;
-  }
-
-  // slippage
-  const bps = toSafeInt(input.maxSlippageBps);
-  if (bps == null || bps > MAX_SLIPPAGE_BPS) {
-    push("maxSlippageBps", `must be an integer between 0 and ${MAX_SLIPPAGE_BPS}`);
-  } else {
-    out.maxSlippageBps = bps;
-  }
-
-  // expiry — required (checked above); must be a positive unix-seconds int and,
-  // when `now` is supplied, strictly in the future.
-  // Date-renderable ceiling in unix seconds. JS Date maxes at 8.64e15 ms, so a
-  // seconds value above 8.64e12 overflows the renderer (isoUtc does *1000).
-  // Also well within the AA lane's uint48 bound, so a schema-valid expiry always
-  // fits both the on-chain validUntil field and the human render. Reject rather
-  // than render a bogus far-future date (fail closed on the seconds-vs-ms mistake).
-  const MAX_UNIX_SECONDS = 8_640_000_000_000;
-  const expiresAt = toSafeInt(input.expiresAt);
-  if (expiresAt == null || expiresAt <= 0) {
-    push("expiresAt", "must be a positive unix-seconds timestamp");
-  } else if (expiresAt > MAX_UNIX_SECONDS) {
-    push("expiresAt", "exceeds the max unix-seconds timestamp (pass seconds, not milliseconds)");
-  } else {
-    out.expiresAt = expiresAt;
-    if (opts.now != null) {
-      const now = toSafeInt(opts.now);
-      if (now == null) push("expiresAt", "opts.now must be a unix-seconds integer");
-      else if (expiresAt <= now) push("expiresAt", `grant is expired (expiresAt ${expiresAt} <= now ${now})`);
-    }
-  }
-
-  // nonce
-  const nonce =
-    typeof input.nonce === "string"
-      ? input.nonce.trim()
-      : toSafeInt(input.nonce) != null
-        ? String(toSafeInt(input.nonce))
-        : null;
-  if (!nonce || nonce.length > MAX_NONCE_LENGTH || !NONCE_RE.test(nonce)) {
-    push("nonce", `must be a non-empty string (max ${MAX_NONCE_LENGTH} chars, [A-Za-z0-9._:-])`);
-  } else {
-    out.nonce = nonce;
-  }
-
-  // revocationKey — a PUBLIC identifier used to revoke this grant; never a secret.
-  const rk = typeof input.revocationKey === "string" ? input.revocationKey.trim() : null;
-  if (!rk || rk.length > MAX_REVOCATION_KEY_LENGTH || !REVOCATION_KEY_RE.test(rk)) {
-    push("revocationKey", `must be a non-empty public identifier (max ${MAX_REVOCATION_KEY_LENGTH} chars, [A-Za-z0-9._:-])`);
-  } else {
-    out.revocationKey = rk;
-  }
-
-  if (errors.length) return { ok: false, errors, grant: null };
-  return { ok: true, errors: [], grant: out };
-}
-
-/** Validate + normalize; throws GrantValidationError on any failure. */
-export function normalizeGrant(input, opts = {}) {
-  const { ok, errors, grant } = validateGrant(input, opts);
-  if (!ok) throw new GrantValidationError(errors);
-  return grant;
-}
-
-/**
- * Deterministic canonical JSON for a grant: validates/normalizes first, then
- * serializes with alphabetically sorted keys (arrays already sorted + deduped
- * by normalization). Identical grants — regardless of input key order, address
- * casing, or numeric representation — always produce the identical string.
- */
-export function canonicalizeGrant(input, opts = {}) {
-  const g = normalizeGrant(input, opts);
-  const keys = Object.keys(g).sort();
-  const parts = keys.map((k) => `${JSON.stringify(k)}:${JSON.stringify(g[k])}`);
-  return `{"version":${GRANT_VERSION},${parts.join(",")}}`;
-}
-
-/** sha256 hex of the canonical form — stable public identifier for a grant. */
-export function grantId(input, opts = {}) {
-  return createHash("sha256").update(canonicalizeGrant(input, opts), "utf8").digest("hex");
-}
-
-/** Deterministic expiry check against an explicit unix-seconds `now`. */
-export function isExpired(grant, nowSeconds) {
-  const now = toSafeInt(nowSeconds);
-  const exp = toSafeInt(isPlainObject(grant) ? grant.expiresAt : null);
-  if (now == null || exp == null) return true; // fail closed
-  return exp <= now;
-}

package/src/public-control/runtime-config.mjs

@@ -1,275 +0,0 @@
-// Oracle Control — public runtime config: chain/bundler/paymaster registry
-// (Slice K).
-//
-// This module is pure config parsing. It never makes a live network call and
-// never imports the private executor stack — its only job is to turn env
-// vars into a validated, in-memory registry of PUBLIC endpoints (chain
-// metadata, bundler URLs, paymaster URLs, and the public HTTP bind) that the
-// rest of Oracle Control (aa-adapter.mjs, bundler-client.mjs, http.mjs) can
-// read from.
-//
-// Hard boundaries for this file:
-//   - Imports ONLY from ./aa-adapter.mjs (ENTRYPOINT_V07 — the single source
-//     of truth for the deployed EntryPoint address this codebase targets)
-//     and node builtins. NEVER from the private executor stack
-//     (get-signer.mjs, keystore.mjs, exec-policy.mjs, local-signer/*,
-//     adapters/*, mint-capability.mjs) — this module must never be wired to
-//     private operator wallet, and holds no secrets of any kind.
-//   - bundlerUrl/paymasterUrl are treated as PUBLIC endpoints (the same way a
-//     public RPC URL is public) — but they are still scanned for anything
-//     secret-SHAPED (a bearer token, an api-key-looking query param, a raw
-//     private-key hex blob, a PEM block) and rejected outright if found.
-//     Fail closed: a config that looks like it's carrying a credential in a
-//     URL must never load.
-//   - resolveChain() fails closed on any chainId not in the registry — no
-//     silent fallback to a made-up chain.
-//   - entryPoint is never read from env or invented; it is always pinned to
-//     aa-adapter.mjs's ENTRYPOINT_V07 and asserted equal for every seeded
-//     chain, so a typo/drift in this file can never point a chain at the
-//     wrong EntryPoint deployment.
-//   - redactedConfig() strips the query string (and any embedded userinfo)
-//     off every bundler/paymaster URL before it is considered "safe to log"
-//     — even though the full URL already passed the secret-shape scan at
-//     load time, a log line is a wider blast radius than an in-memory
-//     config object, so this view is deliberately more conservative.
-
-import { ENTRYPOINT_V07 } from "./aa-adapter.mjs";
-
-export class RuntimeConfigError extends Error {
-  constructor(message) {
-    super(`runtime-config: ${message}`);
-    this.name = "RuntimeConfigError";
-  }
-}
-
-function fail(message) {
-  throw new RuntimeConfigError(message);
-}
-
-// ---------------------------------------------------------------------------
-// Secret-shape guard for public endpoint URLs (fail closed)
-// ---------------------------------------------------------------------------
-
-/** String-value shapes that must never appear in a bundler/paymaster URL.
- *  Mirrors the posture of connect-agent.mjs's FORBIDDEN_VALUE_RULES /
- *  bundler-client.mjs's SecretLeakError checks, scoped to what a URL could
- *  plausibly carry (query-string credentials, embedded key material). */
-const SECRET_URL_RULES = Object.freeze([
-  // 32-byte hex — the shape of a raw EVM private key / session secret.
-  { rule: "raw-32-byte-hex-key", re: /0x[0-9a-fA-F]{64}/ },
-  { rule: "bearer-token", re: /bearer\s+[A-Za-z0-9._~+/=-]+/i },
-  { rule: "pem-private-key", re: /-----BEGIN[A-Z ]*PRIVATE KEY-----/ },
-  { rule: "authorization-header", re: /authorization\s*:/i },
-  // Credential-shaped query/path segment: ?api_key=..., ?token=..., ?secret=...,
-  // ?password=..., ?auth=..., ?access_token=..., ?bearer=..., or userinfo
-  // (user:pass@host) embedded in the URL itself.
-  {
-    rule: "credential-shaped-param",
-    re: /[?&](api[_-]?key|apikey|key|token|access[_-]?token|secret|password|passwd|auth|bearer)=/i,
-  },
-  { rule: "embedded-userinfo", re: /^[a-z][a-z0-9+.-]*:\/\/[^/@\s]+:[^/@\s]+@/i },
-]);
-
-function assertPublicUrlSafe(value, label) {
-  if (typeof value !== "string" || value.trim() === "") {
-    fail(`${label} must be a non-empty string URL`);
-  }
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    fail(`${label} is not a valid URL: ${value}`);
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    fail(`${label} must be an http(s) URL, got scheme ${parsed.protocol}`);
-  }
-  for (const { rule, re } of SECRET_URL_RULES) {
-    if (re.test(value)) {
-      fail(`${label} looks like it carries secret material (rule: ${rule}) — refusing to load a credential-shaped public endpoint`);
-    }
-  }
-  return value;
-}
-
-// ---------------------------------------------------------------------------
-// Chain registry seed
-// ---------------------------------------------------------------------------
-
-/** Base metadata for every chain Oracle Control's public runtime config
- *  knows about out of the box. entryPoint is intentionally NOT stored here —
- *  it is always ENTRYPOINT_V07, asserted below, so there is exactly one
- *  place (aa-adapter.mjs) that can ever define it. */
-const CHAIN_SEEDS = Object.freeze([
-  { chainId: 8453, name: "Base" },
-  { chainId: 42161, name: "Arbitrum" },
-]);
-
-export const DEFAULT_CHAIN_ID = 8453;
-export const DEFAULT_PUBLIC_HOST = "127.0.0.1";
-export const DEFAULT_PUBLIC_PORT = 8799;
-const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1"]);
-
-function buildChainEntry(seed, env) {
-  const entry = {
-    name: seed.name,
-    entryPoint: ENTRYPOINT_V07,
-  };
-  // entryPoint must always equal aa-adapter's ENTRYPOINT_V07 for every
-  // supported chain — asserted here (not just "set here") so a future edit
-  // that tries to override it per-chain is caught immediately.
-  if (entry.entryPoint !== ENTRYPOINT_V07) {
-    fail(`chain ${seed.chainId} entryPoint drifted from aa-adapter ENTRYPOINT_V07`);
-  }
-
-  const bundlerVar = `ORACLE_BUNDLER_URL_${seed.chainId}`;
-  const paymasterVar = `ORACLE_PAYMASTER_URL_${seed.chainId}`;
-  const bundlerRaw = env[bundlerVar];
-  const paymasterRaw = env[paymasterVar];
-
-  if (bundlerRaw != null && String(bundlerRaw).trim() !== "") {
-    entry.bundlerUrl = assertPublicUrlSafe(String(bundlerRaw), bundlerVar);
-  }
-  if (paymasterRaw != null && String(paymasterRaw).trim() !== "") {
-    entry.paymasterUrl = assertPublicUrlSafe(String(paymasterRaw), paymasterVar);
-  }
-
-  return entry;
-}
-
-function parsePort(raw, label) {
-  const n = Number(raw);
-  if (!Number.isInteger(n) || n < 0 || n > 65535) {
-    fail(`${label} must be an integer port 0-65535, got ${JSON.stringify(raw)}`);
-  }
-  return n;
-}
-
-function parsePublicHost(raw, label) {
-  const host = String(raw).trim();
-  const normalized = host.toLowerCase().replace(/^\[|\]$/g, "");
-  if (!LOOPBACK_HOSTS.has(normalized)) {
-    fail(`${label} must be a loopback host, got ${JSON.stringify(raw)}`);
-  }
-  return normalized === "::1" ? "::1" : host;
-}
-
-/**
- * Parse the public runtime config (chain/bundler/paymaster registry + public
- * HTTP bind) from an env-like object. Pure function, no I/O, no network.
- *
- * @param {object} [env] defaults to process.env; any plain object of
- *   string-ish values works (this is what makes it deterministically
- *   testable without touching real process.env).
- * @returns {{
- *   chains: Record<string, {name:string, entryPoint:string, bundlerUrl?:string, paymasterUrl?:string}>,
- *   defaultChainId: number,
- *   publicHost: string,
- *   publicPort: number,
- * }}
- */
-export function loadPublicConfig(env = process.env) {
-  if (env == null || typeof env !== "object") {
-    fail("env must be an object");
-  }
-
-  const chains = {};
-  for (const seed of CHAIN_SEEDS) {
-    chains[String(seed.chainId)] = buildChainEntry(seed, env);
-  }
-
-  const rawDefaultChainId = env.ORACLE_DEFAULT_CHAIN_ID;
-  let defaultChainId = DEFAULT_CHAIN_ID;
-  if (rawDefaultChainId != null && String(rawDefaultChainId).trim() !== "") {
-    const n = Number(rawDefaultChainId);
-    if (!Number.isInteger(n)) {
-      fail(`ORACLE_DEFAULT_CHAIN_ID must be an integer chain id, got ${JSON.stringify(rawDefaultChainId)}`);
-    }
-    if (chains[String(n)] == null) {
-      fail(`ORACLE_DEFAULT_CHAIN_ID ${n} is not a registered chain (known: ${Object.keys(chains).join(", ")})`);
-    }
-    defaultChainId = n;
-  }
-
-  const publicHost = (() => {
-    const v = env.ORACLE_PUBLIC_HOST ?? env.MAD_PUBLIC_HOST;
-    return v != null && String(v).trim() !== "" ? parsePublicHost(v, "ORACLE_PUBLIC_HOST") : DEFAULT_PUBLIC_HOST;
-  })();
-
-  const publicPort = (() => {
-    const v = env.ORACLE_PUBLIC_PORT ?? env.MAD_PUBLIC_PORT;
-    if (v == null || String(v).trim() === "") return DEFAULT_PUBLIC_PORT;
-    return parsePort(v, "ORACLE_PUBLIC_PORT");
-  })();
-
-  return Object.freeze({
-    chains: Object.freeze(chains),
-    defaultChainId,
-    publicHost,
-    publicPort,
-  });
-}
-
-/**
- * Resolve a single chain entry from a loaded config. Fails closed on any
- * chainId not present in the registry — never falls back to a guessed/
- * default chain.
- *
- * @param {ReturnType<typeof loadPublicConfig>} config
- * @param {number|string} chainId
- */
-export function resolveChain(config, chainId) {
-  if (config == null || typeof config.chains !== "object") {
-    fail("resolveChain: config must be a loadPublicConfig() result");
-  }
-  const key = String(chainId);
-  const entry = config.chains[key];
-  if (entry == null) {
-    fail(`unsupported chainId ${key} (registered: ${Object.keys(config.chains).join(", ") || "none"})`);
-  }
-  return entry;
-}
-
-/** Drop the query string and any userinfo from a URL, keeping only
- *  scheme://host:port/path — safe to write to a log line even though the
- *  full URL already passed the load-time secret-shape scan. */
-function redactUrl(value) {
-  try {
-    const u = new URL(value);
-    u.search = "";
-    u.username = "";
-    u.password = "";
-    return u.toString();
-  } catch {
-    return "[unparseable-url-redacted]";
-  }
-}
-
-/**
- * Safe-to-log view of a loaded config: chain names/entryPoints/host/port
- * pass through unchanged (none of that is secret-shaped), bundler/paymaster
- * URLs are stripped down to origin+path only.
- *
- * @param {ReturnType<typeof loadPublicConfig>} config
- */
-export function redactedConfig(config) {
-  if (config == null || typeof config.chains !== "object") {
-    fail("redactedConfig: config must be a loadPublicConfig() result");
-  }
-  const chains = {};
-  for (const [chainId, entry] of Object.entries(config.chains)) {
-    chains[chainId] = {
-      name: entry.name,
-      entryPoint: entry.entryPoint,
-      ...(entry.bundlerUrl != null ? { bundlerUrl: redactUrl(entry.bundlerUrl) } : {}),
-      ...(entry.paymasterUrl != null ? { paymasterUrl: redactUrl(entry.paymasterUrl) } : {}),
-    };
-  }
-  return Object.freeze({
-    chains: Object.freeze(chains),
-    defaultChainId: config.defaultChainId,
-    publicHost: config.publicHost,
-    publicPort: config.publicPort,
-  });
-}
-
-export const _internal = { assertPublicUrlSafe, SECRET_URL_RULES, CHAIN_SEEDS };