@blazephoenix/sdk 1.0.0 → 1.0.1

package/README.md

@@ -64,7 +64,7 @@ new BlazePhoenix();   // reads BLAZEPHOENIX_RPC_BASE / _ETHEREUM / _OPTIMISM / _
 - A chain without a configured node throws `rpc_required` — nothing silently falls back
   to someone else's infrastructure.
 - `https://` and `wss://` only (`http://` allowed for `localhost` — your anvil/geth).
-  URLs are redacted in every error message, because keys live in them.
+  URLs are redacted in every error message and in its `cause` chain, because keys live in them.
 
 ## Versions — pick yours
 
@@ -147,7 +147,7 @@ guesses a token from a ticker.
 
 ## Errors
 
-Every failure is a `BlazeError` with a stable `code`; protocol reverts carry `revert`
+Every failure, `solvency()` included, is a `BlazeError` with a stable `code`; protocol reverts carry `revert`
 (`RouterE` / `QuoterE` / `SolverE` / `HubE` + the reason from the contract's own source):
 
 | code | meaning |
@@ -167,6 +167,8 @@ Every failure is a `BlazeError` with a stable `code`; protocol reverts carry `re
 [`@blazephoenix/mcp`](https://github.com/blazephoenixxyz-crypto/blazephoenix-mcp) wraps this SDK as
 a local MCP server — the agent's tools run on your machine, on your RPC.
 
+For agents, [`llms.txt`](llms.txt) describes this package in the [llmstxt.org](https://llmstxt.org) format.
+
 ## Examples
 
 [`examples/`](examples): `quote.ts`, `watch-fills.ts`, `telegram-bot.ts`, and

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 });
@@ -5471,162 +5642,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 +5717,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 {
@@ -5912,7 +5929,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();
@@ -6203,11 +6220,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,