@blazephoenix/sdk 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -4716,12 +4716,278 @@ function phoenixCheck(pv, tokenIn, tokenOut) {
     disclaimer: 'Deterministic checks derived from on-chain state, not financial advice. "blocked" is a real answer \u2014 we fail closed rather than guess.'
   };
 }
+
+// src/constants.ts
+var API_BASE = "https://blazephoenix.xyz";
+var DEPLOYMENTS_URL = `${API_BASE}/api/deployments`;
+var SUPPORTED_CHAIN_IDS = [8453, 1, 10, 42161, 4663];
+var CHAINS = {
+  1: {
+    chainId: 1,
+    name: "Ethereum",
+    key: "ETHEREUM",
+    explorer: "https://etherscan.io",
+    weth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    blockTime: 12
+  },
+  8453: {
+    chainId: 8453,
+    name: "Base",
+    key: "BASE",
+    explorer: "https://basescan.org",
+    weth: "0x4200000000000000000000000000000000000006",
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    bzpx: "0x23113e72165a034265Ab8Bf2277CCB7a85Cb7483",
+    staking: "0x3f60C7aa0c36a78D200405feBE143d2Cf3fA0c77",
+    blockTime: 2
+  },
+  10: {
+    chainId: 10,
+    name: "Optimism",
+    key: "OPTIMISM",
+    explorer: "https://optimistic.etherscan.io",
+    weth: "0x4200000000000000000000000000000000000006",
+    usdc: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    blockTime: 2
+  },
+  42161: {
+    chainId: 42161,
+    name: "Arbitrum",
+    key: "ARBITRUM",
+    explorer: "https://arbiscan.io",
+    weth: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    usdc: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    blockTime: 0.25
+  },
+  // Robinhood Chain — the dollar asset is USDG, not USDC; the `usdc` field
+  // carries the chain's canonical dollar token. Explorer is Blockscout.
+  4663: {
+    chainId: 4663,
+    name: "Robinhood",
+    key: "ROBINHOOD",
+    explorer: "https://robinhoodchain.blockscout.com",
+    weth: "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73",
+    usdc: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+    blockTime: 2
+  }
+};
+var ALIASES = {
+  "1": 1,
+  eth: 1,
+  ethereum: 1,
+  mainnet: 1,
+  "8453": 8453,
+  base: 8453,
+  "10": 10,
+  op: 10,
+  optimism: 10,
+  "42161": 42161,
+  arb: 42161,
+  arbitrum: 42161,
+  "arbitrum-one": 42161,
+  "4663": 4663,
+  rh: 4663,
+  robinhood: 4663,
+  "robinhood-chain": 4663
+};
+function resolveChain(chain) {
+  const id = ALIASES[String(chain).trim().toLowerCase()];
+  if (!id) {
+    throw new Error(
+      `Unsupported chain "${chain}" \u2014 use 8453/base, 1/eth, 10/optimism, 42161/arbitrum or 4663/robinhood`
+    );
+  }
+  return id;
+}
+function tryResolveChain(chain) {
+  return ALIASES[String(chain).trim().toLowerCase()];
+}
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var NATIVE_TOKEN = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var FEE_BPS = 28;
+var SWAP_TOPIC0 = "0xd6d34547c69c5ee3d2667625c188acf1006abb93e0ee7cf03925c67cf7760413";
+var SURPLUS_TOPIC0 = "0x1a3afef0f067eb51a6bfec6ab3625a4408dd8c3571b72836483e68feb70d1026";
+var EXECUTION_PROOF_TOPIC0 = "0xb5a62bcb8753e37706da20862f2a32a16831ef0144567eb15b1da49547e9f84c";
+var FEE_TOPIC0 = "0x18fa25e22e0f1f39ef2130081363ba86a1259e598e669558683dabfc15bfe731";
+
+// src/rpc.ts
+var isTransport = (v) => typeof v === "function";
+var isEip1193 = (v) => !!v && typeof v === "object" && typeof v.request === "function";
+var isSource = (v) => typeof v === "string" || Array.isArray(v) || isTransport(v) || isEip1193(v);
+function isAllowedRpcUrl(url) {
+  let u;
+  try {
+    u = new URL(url.trim());
+  } catch {
+    return false;
+  }
+  if (u.protocol === "https:" || u.protocol === "wss:") return true;
+  if (u.protocol === "http:" || u.protocol === "ws:") {
+    return u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]";
+  }
+  return false;
+}
+function urlTransport(url, o) {
+  if (!isAllowedRpcUrl(url)) {
+    throw new BlazeError("bad_request", `refusing RPC URL "${redact(url)}": use https:// or wss:// (http/ws only for localhost)`);
+  }
+  const u = url.trim();
+  return u.startsWith("ws") ? viem.webSocket(u, { timeout: o.timeoutMs, retryCount: o.retries }) : viem.http(u, { timeout: o.timeoutMs, retryCount: o.retries, batch: o.batch });
+}
+function redact(url) {
+  try {
+    const u = new URL(url);
+    const path = u.pathname.length > 1 ? "/\u2026" : "";
+    return `${u.protocol}//${u.host}${path}`;
+  } catch {
+    return "<invalid url>";
+  }
+}
+function scrubUrls(text) {
+  return text.replace(/\b(?:https?|wss?):\/\/[^\s"'<>]+/gi, (m) => redact(m));
+}
+function transportFrom(src, opts = {}) {
+  const o = {
+    timeoutMs: opts.timeoutMs ?? 1e4,
+    retries: opts.retries ?? 2,
+    batch: opts.batch ?? false
+  };
+  if (isTransport(src)) return src;
+  if (isEip1193(src)) return viem.custom(src, { retryCount: o.retries });
+  if (typeof src === "string") return urlTransport(src, o);
+  if (Array.isArray(src)) {
+    const list = src.map((u) => u.trim()).filter(Boolean);
+    if (list.length === 0) throw new BlazeError("rpc_required", "empty RPC list");
+    if (list.length === 1) return urlTransport(list[0], o);
+    return viem.fallback(list.map((u) => urlTransport(u, { ...o, retries: 0 })), { retryCount: o.retries });
+  }
+  throw new BlazeError("bad_request", "unrecognised rpc value");
+}
+var RPC_HELP = "BlazePhoenix SDK 1.x runs 100% on YOUR RPC \u2014 it ships no endpoints and never reads through our servers. Pass `rpc` (a URL, a list of URLs, a wallet provider or a viem transport), e.g. new BlazePhoenix({ rpc: { base: process.env.BASE_RPC_URL } }). Any provider's free tier is enough.";
+var RpcRouter = class {
+  perChain = /* @__PURE__ */ new Map();
+  single;
+  opts;
+  constructor(config, opts = {}) {
+    this.opts = opts;
+    if (config === void 0 || config === null || config === "") return;
+    if (isSource(config)) {
+      this.single = { source: config };
+      return;
+    }
+    if (typeof config !== "object") throw new BlazeError("bad_request", "rpc must be a URL, a list, a provider, a transport or a per-chain map");
+    for (const [k, v] of Object.entries(config)) {
+      if (v === void 0 || v === null || v === "") continue;
+      const id = tryResolveChain(k);
+      if (!id) throw new BlazeError("bad_request", `rpc map: unknown chain "${k}"`);
+      if (!isSource(v)) throw new BlazeError("bad_request", `rpc map: bad value for chain "${k}"`);
+      this.perChain.set(id, { source: v, chainId: id });
+    }
+  }
+  /** Chains with an explicitly configured RPC (a single source reports none). */
+  configuredChains() {
+    return SUPPORTED_CHAIN_IDS.filter((id) => this.perChain.has(id));
+  }
+  hasAny() {
+    return !!this.single || this.perChain.size > 0;
+  }
+  /** The chain to use when a request names none: the only configured one. */
+  async defaultChain() {
+    if (this.perChain.size === 1) return [...this.perChain.keys()][0];
+    if (this.single && this.perChain.size === 0) {
+      const id = await this.verify(this.single);
+      const c = tryResolveChain(id);
+      if (!c) throw new BlazeError("rpc_chain_mismatch", `your RPC serves chain ${id}, which BlazePhoenix is not deployed on`);
+      return c;
+    }
+    throw new BlazeError("bad_request", "this request needs `chain` (several RPCs are configured)");
+  }
+  slotFor(chainId) {
+    const s = this.perChain.get(chainId) ?? this.single;
+    if (!s) {
+      throw new BlazeError(
+        "rpc_required",
+        `no RPC configured for ${CHAINS[chainId].name} (${chainId}). ${RPC_HELP}`,
+        { details: { chainId } }
+      );
+    }
+    return s;
+  }
+  clientOf(s) {
+    if (!s.client) {
+      s.client = viem.createPublicClient({ transport: transportFrom(s.source, this.opts) });
+    }
+    return s.client;
+  }
+  verify(s) {
+    if (!s.verified) {
+      const c = this.clientOf(s);
+      s.verified = c.getChainId().catch((e) => {
+        s.verified = void 0;
+        throw new BlazeError("rpc_error", `your RPC did not answer eth_chainId: ${scrubUrls(String(e?.message ?? e))}`, { cause: e });
+      });
+    }
+    return s.verified;
+  }
+  /** A PublicClient for `chain`, over YOUR node, after checking it really is that chain. */
+  async client(chain) {
+    const chainId = resolveChain(chain);
+    const s = this.slotFor(chainId);
+    const actual = await this.verify(s);
+    if (actual !== chainId) {
+      throw new BlazeError(
+        "rpc_chain_mismatch",
+        `your RPC serves chain ${actual}, not ${CHAINS[chainId].name} (${chainId}) \u2014 configure one per chain: rpc: { base: "\u2026", eth: "\u2026" }`,
+        { details: { expected: chainId, actual } }
+      );
+    }
+    return this.clientOf(s);
+  }
+};
+function rpcFromEnv(env = globalEnv()) {
+  const split = (v) => {
+    const list = v.split(",").map((s) => s.trim()).filter(Boolean);
+    return list.length === 1 ? list[0] : list;
+  };
+  const map = {};
+  for (const id of SUPPORTED_CHAIN_IDS) {
+    const v = env[`BLAZEPHOENIX_RPC_${CHAINS[id].key}`] ?? env[`BLAZEPHOENIX_RPC_${id}`];
+    if (v && v.trim()) map[String(id)] = split(v);
+  }
+  const single = env.BLAZEPHOENIX_RPC_URL;
+  if (Object.keys(map).length > 0) {
+    if (single && single.trim()) {
+      throw new BlazeError(
+        "bad_request",
+        "set either BLAZEPHOENIX_RPC_URL (one node) or the per-chain BLAZEPHOENIX_RPC_<CHAIN> variables, not both"
+      );
+    }
+    return map;
+  }
+  return single && single.trim() ? split(single) : void 0;
+}
+function globalEnv() {
+  const p = globalThis.process;
+  return p?.env ?? {};
+}
+
+// src/errors.ts
+function scrubCause(c, depth = 0) {
+  if (c === void 0 || c === null || depth > 8) return void 0;
+  if (!(c instanceof Error)) return scrubUrls(String(c));
+  const inner = scrubCause(c.cause, depth + 1);
+  const out = new Error(scrubUrls(c.message), inner !== void 0 ? { cause: inner } : void 0);
+  out.name = c.name;
+  return out;
+}
 var BlazeError = class extends Error {
   code;
   details;
   revert;
   constructor(code, message, opts = {}) {
-    super(message, opts.cause !== void 0 ? { cause: opts.cause } : void 0);
+    super(message, opts.cause !== void 0 ? { cause: scrubCause(opts.cause) } : void 0);
     this.name = "BlazeError";
     this.code = code;
     this.details = opts.details;
@@ -4884,101 +5150,6 @@ function minOutFor(netOut, slippageBps, floor) {
   return bySlip > floor ? bySlip : floor;
 }
 
-// src/constants.ts
-var API_BASE = "https://blazephoenix.xyz";
-var DEPLOYMENTS_URL = `${API_BASE}/api/deployments`;
-var SUPPORTED_CHAIN_IDS = [8453, 1, 10, 42161, 4663];
-var CHAINS = {
-  1: {
-    chainId: 1,
-    name: "Ethereum",
-    key: "ETHEREUM",
-    explorer: "https://etherscan.io",
-    weth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-    usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    blockTime: 12
-  },
-  8453: {
-    chainId: 8453,
-    name: "Base",
-    key: "BASE",
-    explorer: "https://basescan.org",
-    weth: "0x4200000000000000000000000000000000000006",
-    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    bzpx: "0x23113e72165a034265Ab8Bf2277CCB7a85Cb7483",
-    staking: "0x3f60C7aa0c36a78D200405feBE143d2Cf3fA0c77",
-    blockTime: 2
-  },
-  10: {
-    chainId: 10,
-    name: "Optimism",
-    key: "OPTIMISM",
-    explorer: "https://optimistic.etherscan.io",
-    weth: "0x4200000000000000000000000000000000000006",
-    usdc: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
-    blockTime: 2
-  },
-  42161: {
-    chainId: 42161,
-    name: "Arbitrum",
-    key: "ARBITRUM",
-    explorer: "https://arbiscan.io",
-    weth: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-    usdc: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
-    blockTime: 0.25
-  },
-  // Robinhood Chain — the dollar asset is USDG, not USDC; the `usdc` field
-  // carries the chain's canonical dollar token. Explorer is Blockscout.
-  4663: {
-    chainId: 4663,
-    name: "Robinhood",
-    key: "ROBINHOOD",
-    explorer: "https://robinhoodchain.blockscout.com",
-    weth: "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73",
-    usdc: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
-    blockTime: 2
-  }
-};
-var ALIASES = {
-  "1": 1,
-  eth: 1,
-  ethereum: 1,
-  mainnet: 1,
-  "8453": 8453,
-  base: 8453,
-  "10": 10,
-  op: 10,
-  optimism: 10,
-  "42161": 42161,
-  arb: 42161,
-  arbitrum: 42161,
-  "arbitrum-one": 42161,
-  "4663": 4663,
-  rh: 4663,
-  robinhood: 4663,
-  "robinhood-chain": 4663
-};
-function resolveChain(chain) {
-  const id = ALIASES[String(chain).trim().toLowerCase()];
-  if (!id) {
-    throw new Error(
-      `Unsupported chain "${chain}" \u2014 use 8453/base, 1/eth, 10/optimism, 42161/arbitrum or 4663/robinhood`
-    );
-  }
-  return id;
-}
-function tryResolveChain(chain) {
-  return ALIASES[String(chain).trim().toLowerCase()];
-}
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-var NATIVE_TOKEN = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
-var PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-var FEE_BPS = 28;
-var SWAP_TOPIC0 = "0xd6d34547c69c5ee3d2667625c188acf1006abb93e0ee7cf03925c67cf7760413";
-var SURPLUS_TOPIC0 = "0x1a3afef0f067eb51a6bfec6ab3625a4408dd8c3571b72836483e68feb70d1026";
-var EXECUTION_PROOF_TOPIC0 = "0xb5a62bcb8753e37706da20862f2a32a16831ef0144567eb15b1da49547e9f84c";
-var FEE_TOPIC0 = "0x18fa25e22e0f1f39ef2130081363ba86a1259e598e669558683dabfc15bfe731";
-
 // src/deployments.ts
 var Z = ZERO_ADDRESS;
 var pending = () => ({ core: Z, hub: Z, solver: Z, router: Z, quoter: Z });
@@ -5185,6 +5356,7 @@ var Registry = class {
   fetchedAt = 0;
   lastError;
   mode;
+  remoteVersions;
   url;
   ttlMs;
   fetchFn;
@@ -5193,6 +5365,7 @@ var Registry = class {
   overrides = /* @__PURE__ */ new Map();
   constructor(opts = {}, overrides) {
     this.mode = opts.mode ?? "auto";
+    this.remoteVersions = opts.remoteVersions ?? false;
     this.url = opts.url ?? DEPLOYMENTS_URL;
     this.ttlMs = opts.ttlMs ?? 10 * 6e4;
     this.fetchFn = opts.fetchFn ?? globalThis.fetch;
@@ -5324,7 +5497,7 @@ var Registry = class {
     if (!isValidSelector(selector)) throw new BlazeError("bad_request", `bad version selector "${selector}"`);
     const ov = this.overrides.get(chainId);
     const sel = ov?.version && selector === "latest" ? ov.version : selector;
-    const candidates = this.doc.versions.filter((v) => matchesSelector(v.version, sel) && isDeployed(v.chains[chainId])).sort((a, b) => compareVersions(b.version, a.version));
+    const candidates = this.doc.versions.filter((v) => matchesSelector(v.version, sel) && isDeployed(v.chains[chainId])).filter((v) => this.remoteVersions || this.isPinned(v.version, chainId)).sort((a, b) => compareVersions(b.version, a.version));
     const pick = candidates[0];
     if (ov && (ov.router || ov.quoter)) {
       const base = pick ? { ...pick.chains[chainId] } : {
@@ -5344,9 +5517,10 @@ var Registry = class {
     }
     if (!pick) {
       const deployed = this.versionsOn(chainId);
+      const remoteOnly = this.remoteVersions ? [] : deployed.filter((v) => matchesSelector(v, sel) && !this.isPinned(v, chainId));
       throw new BlazeError(
         "not_deployed",
-        `no BlazePhoenix deployment matching version "${selector}" on chain ${chainId}` + (deployed.length ? ` (deployed: ${deployed.join(", ")})` : ""),
+        `no BlazePhoenix deployment matching version "${selector}" on chain ${chainId}` + (deployed.length ? ` (deployed: ${deployed.join(", ")})` : "") + (remoteOnly.length ? ` \u2014 ${remoteOnly.join(", ")} is known only from the fetched registry; update the SDK, or set registry.remoteVersions after checking the addresses yourself` : ""),
         { details: { chainId, selector, deployed } }
       );
     }
@@ -5355,6 +5529,11 @@ var Registry = class {
     const source = src("router") === "remote" || src("quoter") === "remote" ? "remote" : "embedded";
     return { chainId, version: pick.version, status: pick.status, contracts: { ...set }, source };
   }
+  /** Router and Quoter both pinned in this package (not filled by a fetched document). */
+  isPinned(version, chainId) {
+    const src = (k) => this.fieldSource[`${version}|${chainId}|${k}`];
+    return src("router") === "embedded" && src("quoter") === "embedded";
+  }
   latestKnownVersion(selector) {
     const all = this.doc.versions.map((v) => v.version).sort((a, b) => compareVersions(b, a));
     const m = selector ? all.find((v) => matchesSelector(v, selector)) : void 0;
@@ -5471,162 +5650,6 @@ function fromBaseUnits(v, decimals, maxDp) {
   frac = frac.replace(/0+$/, "");
   return `${neg ? "-" : ""}${whole}${frac ? `.${frac}` : ""}`;
 }
-var isTransport = (v) => typeof v === "function";
-var isEip1193 = (v) => !!v && typeof v === "object" && typeof v.request === "function";
-var isSource = (v) => typeof v === "string" || Array.isArray(v) || isTransport(v) || isEip1193(v);
-function isAllowedRpcUrl(url) {
-  let u;
-  try {
-    u = new URL(url.trim());
-  } catch {
-    return false;
-  }
-  if (u.protocol === "https:" || u.protocol === "wss:") return true;
-  if (u.protocol === "http:" || u.protocol === "ws:") {
-    return u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]";
-  }
-  return false;
-}
-function urlTransport(url, o) {
-  if (!isAllowedRpcUrl(url)) {
-    throw new BlazeError("bad_request", `refusing RPC URL "${redact(url)}": use https:// or wss:// (http/ws only for localhost)`);
-  }
-  const u = url.trim();
-  return u.startsWith("ws") ? viem.webSocket(u, { timeout: o.timeoutMs, retryCount: o.retries }) : viem.http(u, { timeout: o.timeoutMs, retryCount: o.retries, batch: o.batch });
-}
-function redact(url) {
-  try {
-    const u = new URL(url);
-    const path = u.pathname.length > 1 ? "/\u2026" : "";
-    return `${u.protocol}//${u.host}${path}`;
-  } catch {
-    return "<invalid url>";
-  }
-}
-function transportFrom(src, opts = {}) {
-  const o = {
-    timeoutMs: opts.timeoutMs ?? 1e4,
-    retries: opts.retries ?? 2,
-    batch: opts.batch ?? false
-  };
-  if (isTransport(src)) return src;
-  if (isEip1193(src)) return viem.custom(src, { retryCount: o.retries });
-  if (typeof src === "string") return urlTransport(src, o);
-  if (Array.isArray(src)) {
-    const list = src.map((u) => u.trim()).filter(Boolean);
-    if (list.length === 0) throw new BlazeError("rpc_required", "empty RPC list");
-    if (list.length === 1) return urlTransport(list[0], o);
-    return viem.fallback(list.map((u) => urlTransport(u, { ...o, retries: 0 })), { retryCount: o.retries });
-  }
-  throw new BlazeError("bad_request", "unrecognised rpc value");
-}
-var RPC_HELP = "BlazePhoenix SDK 1.x runs 100% on YOUR RPC \u2014 it ships no endpoints and never reads through our servers. Pass `rpc` (a URL, a list of URLs, a wallet provider or a viem transport), e.g. new BlazePhoenix({ rpc: { base: process.env.BASE_RPC_URL } }). Any provider's free tier is enough.";
-var RpcRouter = class {
-  perChain = /* @__PURE__ */ new Map();
-  single;
-  opts;
-  constructor(config, opts = {}) {
-    this.opts = opts;
-    if (config === void 0 || config === null || config === "") return;
-    if (isSource(config)) {
-      this.single = { source: config };
-      return;
-    }
-    if (typeof config !== "object") throw new BlazeError("bad_request", "rpc must be a URL, a list, a provider, a transport or a per-chain map");
-    for (const [k, v] of Object.entries(config)) {
-      if (v === void 0 || v === null || v === "") continue;
-      const id = tryResolveChain(k);
-      if (!id) throw new BlazeError("bad_request", `rpc map: unknown chain "${k}"`);
-      if (!isSource(v)) throw new BlazeError("bad_request", `rpc map: bad value for chain "${k}"`);
-      this.perChain.set(id, { source: v, chainId: id });
-    }
-  }
-  /** Chains with an explicitly configured RPC (a single source reports none). */
-  configuredChains() {
-    return SUPPORTED_CHAIN_IDS.filter((id) => this.perChain.has(id));
-  }
-  hasAny() {
-    return !!this.single || this.perChain.size > 0;
-  }
-  /** The chain to use when a request names none: the only configured one. */
-  async defaultChain() {
-    if (this.perChain.size === 1) return [...this.perChain.keys()][0];
-    if (this.single && this.perChain.size === 0) {
-      const id = await this.verify(this.single);
-      const c = tryResolveChain(id);
-      if (!c) throw new BlazeError("rpc_chain_mismatch", `your RPC serves chain ${id}, which BlazePhoenix is not deployed on`);
-      return c;
-    }
-    throw new BlazeError("bad_request", "this request needs `chain` (several RPCs are configured)");
-  }
-  slotFor(chainId) {
-    const s = this.perChain.get(chainId) ?? this.single;
-    if (!s) {
-      throw new BlazeError(
-        "rpc_required",
-        `no RPC configured for ${CHAINS[chainId].name} (${chainId}). ${RPC_HELP}`,
-        { details: { chainId } }
-      );
-    }
-    return s;
-  }
-  clientOf(s) {
-    if (!s.client) {
-      s.client = viem.createPublicClient({ transport: transportFrom(s.source, this.opts) });
-    }
-    return s.client;
-  }
-  verify(s) {
-    if (!s.verified) {
-      const c = this.clientOf(s);
-      s.verified = c.getChainId().catch((e) => {
-        s.verified = void 0;
-        throw new BlazeError("rpc_error", `your RPC did not answer eth_chainId: ${e?.message ?? e}`, { cause: e });
-      });
-    }
-    return s.verified;
-  }
-  /** A PublicClient for `chain`, over YOUR node, after checking it really is that chain. */
-  async client(chain) {
-    const chainId = resolveChain(chain);
-    const s = this.slotFor(chainId);
-    const actual = await this.verify(s);
-    if (actual !== chainId) {
-      throw new BlazeError(
-        "rpc_chain_mismatch",
-        `your RPC serves chain ${actual}, not ${CHAINS[chainId].name} (${chainId}) \u2014 configure one per chain: rpc: { base: "\u2026", eth: "\u2026" }`,
-        { details: { expected: chainId, actual } }
-      );
-    }
-    return this.clientOf(s);
-  }
-};
-function rpcFromEnv(env = globalEnv()) {
-  const split = (v) => {
-    const list = v.split(",").map((s) => s.trim()).filter(Boolean);
-    return list.length === 1 ? list[0] : list;
-  };
-  const map = {};
-  for (const id of SUPPORTED_CHAIN_IDS) {
-    const v = env[`BLAZEPHOENIX_RPC_${CHAINS[id].key}`] ?? env[`BLAZEPHOENIX_RPC_${id}`];
-    if (v && v.trim()) map[String(id)] = split(v);
-  }
-  const single = env.BLAZEPHOENIX_RPC_URL;
-  if (Object.keys(map).length > 0) {
-    if (single && single.trim()) {
-      throw new BlazeError(
-        "bad_request",
-        "set either BLAZEPHOENIX_RPC_URL (one node) or the per-chain BLAZEPHOENIX_RPC_<CHAIN> variables, not both"
-      );
-    }
-    return map;
-  }
-  return single && single.trim() ? split(single) : void 0;
-}
-function globalEnv() {
-  const p = globalThis.process;
-  return p?.env ?? {};
-}
 
 // src/client.ts
 var HEX_ADDR2 = /^0x[0-9a-fA-F]{40}$/;
@@ -5702,6 +5725,8 @@ var BlazePhoenix = class {
       checks.push({ name: `code:${k}`, ok: !!code && code !== "0x", detail: code && code !== "0x" ? `${(code.length - 2) / 2} bytes` : "no code at address" });
     });
     if (featuresOf(dep.version).introspection) {
+      if (isZero(c.hub)) checks.push({ name: "hub", ok: false, detail: "zero address" });
+      if (isZero(c.solver)) checks.push({ name: "solver", ok: false, detail: "zero address" });
       const eq = (a, b) => a.toLowerCase() === b.toLowerCase();
       const read = async (fn) => {
         try {
@@ -5756,16 +5781,19 @@ var BlazePhoenix = class {
         return { address: c.weth, native: true };
       case "WETH":
         return { address: c.weth, native: false };
+      // `usdc` holds each chain's one dollar asset: USDG on Robinhood Chain, USDC
+      // elsewhere. The other symbol names a different token there, so it is refused.
       case "USDC":
       case "USDG":
-        return { address: c.usdc, native: false };
+        if (s.toUpperCase() === (chainId === 4663 ? "USDG" : "USDC")) return { address: c.usdc, native: false };
+        break;
       case "BZPX":
         if (c.bzpx) return { address: c.bzpx, native: false };
         break;
     }
     throw new BlazeError(
       "bad_request",
-      `${side}: "${ref}" is not a 0x address or a built-in symbol (ETH, WETH, USDC, BZPX) on ${c.name} \u2014 pass the token address`
+      `${side}: "${ref}" is not a 0x address or a built-in symbol (ETH, WETH, ${chainId === 4663 ? "USDG" : "USDC"}, BZPX) on ${c.name} \u2014 pass the token address`
     );
   }
   async decimalsOf(client, chainId, t) {
@@ -5912,7 +5940,7 @@ var BlazePhoenix = class {
   async quoteBatch(reqs) {
     const fail = (e) => ({
       ok: false,
-      error: { code: e instanceof BlazeError ? e.code : "error", message: e?.message ?? String(e) }
+      error: { code: e instanceof BlazeError ? e.code : "error", message: scrubUrls(e?.message ?? String(e)) }
     });
     const out = new Array(reqs.length);
     const groups = /* @__PURE__ */ new Map();
@@ -6155,6 +6183,12 @@ var BlazePhoenix = class {
         if (r.status !== "success") throw new BlazeError("reverted", `approval transaction reverted (${approvalHash})`);
       }
       plan = { ...plan, approval: { ...plan.approval, current: plan.approval.amount } };
+      if (Date.now() - plan.quote.quotedAt > maxAge) {
+        if (!req) {
+          throw new BlazeError("bad_request", `plan went older than ${maxAge}ms while the approval confirmed${approvalHash ? ` (${approvalHash})` : ""} \u2014 the swap was NOT sent; rebuild the plan, or pass \`request\` so it can be rebuilt`);
+        }
+        plan = await this.buildSwap({ ...req, from: req.from ?? account.address });
+      }
     }
     if (opts.simulate ?? true) {
       const sim = await this.simulate(plan, account.address);
@@ -6203,11 +6237,16 @@ var BlazePhoenix = class {
     const staking = CHAINS[chainId].staking;
     if (!staking) throw new BlazeError("not_deployed", `no BlazePhoenix staking engine on ${CHAINS[chainId].name}`);
     const client = await this.rpc.client(chainId);
-    const blockNumber = await client.getBlockNumber();
-    const [r, isSolvent] = await Promise.all([
-      client.readContract({ address: staking, abi: STAKING_SOLVENCY_ABI, functionName: "solvency", blockNumber }),
-      client.readContract({ address: staking, abi: STAKING_SOLVENCY_ABI, functionName: "isSolvent", blockNumber })
-    ]);
+    let blockNumber, r, isSolvent;
+    try {
+      blockNumber = await client.getBlockNumber();
+      [r, isSolvent] = await Promise.all([
+        client.readContract({ address: staking, abi: STAKING_SOLVENCY_ABI, functionName: "solvency", blockNumber }),
+        client.readContract({ address: staking, abi: STAKING_SOLVENCY_ABI, functionName: "isSolvent", blockNumber })
+      ]);
+    } catch (e) {
+      throw new BlazeError("rpc_error", `solvency read failed on your RPC: ${scrubUrls(String(e?.message ?? e))}`, { cause: e });
+    }
     const s = r;
     return {
       chainId,