@alchemy/cli 0.3.1 → 0.5.0

package/dist/chunk-T2XSNZE3.js

@@ -0,0 +1,1398 @@
+#!/usr/bin/env node
+if(process.argv.includes("--no-color"))process.env.NO_COLOR="1";
+import {
+  CLIError,
+  ErrorCode,
+  debug,
+  errAccessDenied,
+  errAccessKeyRequired,
+  errAdminAPI,
+  errAuthRequired,
+  errInvalidAPIKey,
+  errInvalidAccessKey,
+  errInvalidArgs,
+  errNetwork,
+  errNetworkNotEnabled,
+  errNotFound,
+  errRPC,
+  errRateLimited,
+  errWalletKeyRequired,
+  esc,
+  fetchWithTimeout,
+  getBaseDomain,
+  isJSONMode,
+  isLocalhost,
+  isRevealMode,
+  parseBaseURLOverride,
+  quiet,
+  redactSensitiveText,
+  rgb,
+  verbose
+} from "./chunk-56ZVYB4G.js";
+
+// src/lib/secrets.ts
+function maskSecret(value) {
+  if (value.length <= 8) return "\u2022".repeat(value.length);
+  return value.slice(0, 4) + "\u2022".repeat(value.length - 8) + value.slice(-4);
+}
+function maskIf(value) {
+  return isRevealMode() ? value : maskSecret(value);
+}
+
+// src/lib/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { z } from "zod";
+var KEY_MAP = {
+  "api-key": "api_key",
+  api_key: "api_key",
+  "access-key": "access_key",
+  access_key: "access_key",
+  "webhook-api-key": "webhook_api_key",
+  webhook_api_key: "webhook_api_key",
+  network: "network",
+  verbose: "verbose",
+  "wallet-key-file": "wallet_key_file",
+  wallet_key_file: "wallet_key_file",
+  "wallet-address": "wallet_address",
+  wallet_address: "wallet_address",
+  x402: "x402",
+  "auth-token": "auth_token",
+  auth_token: "auth_token",
+  "auth-token-expires-at": "auth_token_expires_at",
+  auth_token_expires_at: "auth_token_expires_at"
+};
+var SAFE_ID_RE = /^[A-Za-z0-9:_-]{1,128}$/;
+var SAFE_NETWORK_RE = /^[A-Za-z0-9:_-]{1,128}$/;
+var MAX_SECRET_LEN = 512;
+var MAX_APP_NAME_LEN = 128;
+var CONTROL_CHAR_RE = /[\u0000-\u001f\u007f]/;
+var safeTextSchema = (maxLen) => z.string().min(1).max(maxLen).refine((value) => !CONTROL_CHAR_RE.test(value));
+var appConfigSchema = z.object({
+  id: z.string().regex(SAFE_ID_RE),
+  name: safeTextSchema(MAX_APP_NAME_LEN),
+  apiKey: safeTextSchema(MAX_SECRET_LEN),
+  webhookApiKey: safeTextSchema(MAX_SECRET_LEN).optional().catch(void 0)
+}).strip();
+var MAX_PATH_LEN = 4096;
+var configSchema = z.object({
+  api_key: safeTextSchema(MAX_SECRET_LEN).optional().catch(void 0),
+  access_key: safeTextSchema(MAX_SECRET_LEN).optional().catch(void 0),
+  webhook_api_key: safeTextSchema(MAX_SECRET_LEN).optional().catch(void 0),
+  app: appConfigSchema.optional().catch(void 0),
+  network: z.string().regex(SAFE_NETWORK_RE).optional().catch(void 0),
+  verbose: z.boolean().optional().catch(void 0),
+  wallet_key_file: safeTextSchema(MAX_PATH_LEN).optional().catch(void 0),
+  wallet_address: safeTextSchema(MAX_SECRET_LEN).optional().catch(void 0),
+  x402: z.boolean().optional().catch(void 0),
+  auth_token: safeTextSchema(MAX_SECRET_LEN).optional().catch(void 0),
+  auth_token_expires_at: safeTextSchema(MAX_SECRET_LEN).optional().catch(void 0),
+  siwe_token: safeTextSchema(MAX_PATH_LEN).optional().catch(void 0),
+  siwe_token_expires_at: safeTextSchema(MAX_SECRET_LEN).optional().catch(void 0)
+}).strip();
+function sanitizeConfig(input) {
+  const parsed = configSchema.safeParse(input);
+  if (!parsed.success) {
+    return {};
+  }
+  return parsed.data;
+}
+function getHome() {
+  return process.env.HOME || homedir();
+}
+function configPath() {
+  if (process.env.ALCHEMY_CONFIG) return process.env.ALCHEMY_CONFIG;
+  const configHome = process.env.XDG_CONFIG_HOME || join(getHome(), ".config");
+  return join(configHome, "alchemy", "config.json");
+}
+function configDir() {
+  return dirname(configPath());
+}
+function load() {
+  const p = configPath();
+  if (!existsSync(p)) return {};
+  try {
+    const data = readFileSync(p, "utf-8");
+    return sanitizeConfig(JSON.parse(data));
+  } catch {
+    console.error(`warning: could not parse config file at ${p} \u2014 using defaults`);
+    return {};
+  }
+}
+function save(cfg) {
+  const p = configPath();
+  const sanitized = sanitizeConfig(cfg);
+  mkdirSync(dirname(p), { recursive: true, mode: 493 });
+  writeFileSync(p, JSON.stringify(sanitized, null, 2) + "\n", {
+    mode: 384
+  });
+}
+function get(cfg, key) {
+  if (key === "app") {
+    if (!cfg.app) return void 0;
+    return `${cfg.app.name} (${cfg.app.id})`;
+  }
+  const mapped = KEY_MAP[key];
+  if (!mapped) return void 0;
+  const value = cfg[mapped];
+  if (value === void 0) return void 0;
+  if (typeof value === "boolean") return String(value);
+  if (typeof value === "string") return value;
+  return void 0;
+}
+function toMap(cfg) {
+  const m = {};
+  if (cfg.api_key) m["api-key"] = maskIf(cfg.api_key);
+  if (cfg.access_key) m["access-key"] = maskIf(cfg.access_key);
+  if (cfg.webhook_api_key) m["webhook-api-key"] = maskIf(cfg.webhook_api_key);
+  if (cfg.app) m["app"] = `${cfg.app.name} (${cfg.app.id})`;
+  if (cfg.network) m["network"] = cfg.network;
+  if (cfg.verbose !== void 0) m["verbose"] = String(cfg.verbose);
+  if (cfg.wallet_key_file) m["wallet-key-file"] = cfg.wallet_key_file;
+  if (cfg.wallet_address) m["wallet-address"] = cfg.wallet_address;
+  if (cfg.x402 !== void 0) m["x402"] = String(cfg.x402);
+  if (cfg.auth_token) m["auth-token"] = maskIf(cfg.auth_token);
+  if (cfg.auth_token_expires_at) m["auth-token-expires-at"] = cfg.auth_token_expires_at;
+  return m;
+}
+
+// src/lib/terminal-ui.ts
+import * as readline from "readline";
+import { stdin, stdout } from "process";
+var ansi = {
+  cyan: esc("36"),
+  dim: esc("2"),
+  green: esc("32"),
+  red: esc("31"),
+  purple: rgb(180, 160, 255)
+};
+var FLOW_PIPE = "\u2502";
+function optionLabel(option) {
+  return option.label ?? String(option.value);
+}
+function printCancel(message) {
+  if (!message) return;
+  console.log(`  ${ansi.dim(FLOW_PIPE)}`);
+  console.log(`  ${ansi.dim(message)}`);
+}
+function clearRenderedLines(lines) {
+  for (let i = 0; i < lines; i += 1) {
+    readline.clearLine(stdout, 0);
+    readline.cursorTo(stdout, 0);
+    if (i < lines - 1) {
+      readline.moveCursor(stdout, 0, -1);
+    }
+  }
+}
+function suspendStdinKeypressListeners() {
+  const listeners = stdin.listeners("keypress");
+  for (const listener of listeners) {
+    stdin.removeListener("keypress", listener);
+  }
+  return () => {
+    for (const listener of listeners) {
+      stdin.on("keypress", listener);
+    }
+  };
+}
+async function runListPrompt(opts) {
+  if (!stdin.isTTY || !stdout.isTTY) {
+    const initial = opts.initialValue ?? opts.options.find((o) => !o.disabled)?.value ?? null;
+    return { value: initial, cancelled: false };
+  }
+  readline.emitKeypressEvents(stdin);
+  const restoreKeypressListeners = suspendStdinKeypressListeners();
+  const previousRawMode = stdin.isRaw;
+  stdin.resume();
+  stdin.setRawMode(true);
+  let query = "";
+  let cursor = Math.max(
+    0,
+    opts.options.findIndex((o) => o.value === opts.initialValue && !o.disabled)
+  );
+  const selected = /* @__PURE__ */ new Set();
+  const maxVisible = 8;
+  let renderedLines = 0;
+  const getFiltered = () => {
+    if (!opts.filterable || !query.trim()) return opts.options;
+    const q = query.toLowerCase();
+    return opts.options.filter((option) => {
+      const label = optionLabel(option).toLowerCase();
+      const hint = (option.hint ?? "").toLowerCase();
+      const value = String(option.value).toLowerCase();
+      return label.includes(q) || hint.includes(q) || value.includes(q);
+    });
+  };
+  const normalizeCursor = (filtered) => {
+    if (filtered.length === 0) {
+      cursor = 0;
+      return;
+    }
+    if (cursor >= filtered.length) cursor = filtered.length - 1;
+    if (cursor < 0) cursor = 0;
+    if (filtered[cursor]?.disabled) {
+      const next = filtered.findIndex((o) => !o.disabled);
+      cursor = next >= 0 ? next : 0;
+    }
+  };
+  const render = () => {
+    const filtered = getFiltered();
+    normalizeCursor(filtered);
+    if (renderedLines > 0) clearRenderedLines(renderedLines);
+    const lines = [];
+    const suffix = opts.filterable && query ? ` ${ansi.dim(`(${query})`)}` : "";
+    lines.push(`  ${ansi.dim(FLOW_PIPE)}`);
+    lines.push(`  ${ansi.cyan("\u25C6")} ${opts.message}${suffix}`);
+    if (filtered.length === 0) {
+      lines.push(`  ${ansi.dim(FLOW_PIPE)} ${ansi.dim("No matches found")}`);
+    } else {
+      const start = Math.max(0, Math.min(cursor - 3, Math.max(0, filtered.length - maxVisible)));
+      const visible = filtered.slice(start, start + maxVisible);
+      for (let i = 0; i < visible.length; i += 1) {
+        const option = visible[i];
+        const active = start + i === cursor;
+        const disabled = option.disabled === true;
+        const selectedMark = opts.allowMultiple ? selected.has(option.value) ? ansi.green("\u25C6") : ansi.dim("\u25C7") : active ? ansi.cyan("\u25C6") : ansi.dim("\u25C7");
+        const label = optionLabel(option);
+        const value = disabled ? ansi.dim(label) : label;
+        const hint = option.hint ? ` ${ansi.dim(`\u2014 ${option.hint}`)}` : "";
+        lines.push(`  ${ansi.dim(FLOW_PIPE)}  ${selectedMark} ${value}${hint}`);
+      }
+      if (filtered.length > maxVisible) {
+        lines.push(`  ${ansi.dim(FLOW_PIPE)} ${ansi.dim(`${filtered.length} options`)}`);
+      }
+    }
+    if (opts.filterable && query.length === 0 && opts.placeholder) {
+      lines.push(`  ${ansi.dim(FLOW_PIPE)} ${ansi.dim(opts.placeholder)}`);
+    } else if (opts.allowMultiple) {
+      lines.push(`  ${ansi.dim(FLOW_PIPE)} ${ansi.dim("Space to toggle, Enter to confirm")}`);
+    } else {
+      lines.push(`  ${ansi.dim(FLOW_PIPE)} ${ansi.dim("Use arrows and press Enter")}`);
+    }
+    stdout.write(lines.join("\n"));
+    renderedLines = lines.length;
+  };
+  const cleanup = () => {
+    if (renderedLines > 0) clearRenderedLines(renderedLines);
+    stdin.setRawMode(previousRawMode);
+    stdin.removeListener("keypress", onKeypress);
+    restoreKeypressListeners();
+    if (!previousRawMode) {
+      stdin.pause();
+    }
+  };
+  const commitSingleLine = (text) => {
+    if (opts.commitLabel === null) return;
+    const label = opts.commitLabel ?? opts.message;
+    console.log(`  ${ansi.green("\u25C6")} ${label}: ${text}`);
+  };
+  const onKeypress = (str, key) => {
+    const filtered = getFiltered();
+    const current = filtered[cursor];
+    if (key.name === "escape" || key.ctrl && key.name === "c") {
+      cleanup();
+      resolver({ value: null, cancelled: true });
+      return;
+    }
+    if (key.name === "return") {
+      if (opts.allowMultiple) {
+        if (opts.required && selected.size === 0) return;
+        cleanup();
+        const values = Array.from(selected);
+        const labels = opts.options.filter((o) => values.includes(o.value)).map((o) => optionLabel(o)).join(", ");
+        commitSingleLine(labels || "none");
+        resolver({ value: values, cancelled: false });
+        return;
+      }
+      if (!current || current.disabled) return;
+      cleanup();
+      commitSingleLine(optionLabel(current));
+      resolver({ value: current.value, cancelled: false });
+      return;
+    }
+    if (opts.allowMultiple && key.name === "space") {
+      if (!current || current.disabled) return;
+      if (selected.has(current.value)) selected.delete(current.value);
+      else selected.add(current.value);
+      render();
+      return;
+    }
+    if (key.name === "up") {
+      if (filtered.length === 0) return;
+      let next = cursor - 1;
+      while (next >= 0 && filtered[next]?.disabled) next -= 1;
+      if (next >= 0) cursor = next;
+      render();
+      return;
+    }
+    if (key.name === "down") {
+      if (filtered.length === 0) return;
+      let next = cursor + 1;
+      while (next < filtered.length && filtered[next]?.disabled) next += 1;
+      if (next < filtered.length) cursor = next;
+      render();
+      return;
+    }
+    if (opts.filterable && key.name === "backspace") {
+      if (query.length > 0) {
+        query = query.slice(0, -1);
+        render();
+      }
+      return;
+    }
+    if (opts.filterable && str && !key.ctrl && !key.meta && str >= " " && str !== "\x7F") {
+      query += str;
+      cursor = 0;
+      render();
+    }
+  };
+  let resolver;
+  const done = new Promise((resolve) => {
+    resolver = resolve;
+  });
+  stdin.on("keypress", onKeypress);
+  render();
+  return done;
+}
+async function promptText(opts) {
+  if (!stdin.isTTY || !stdout.isTTY) {
+    return opts.defaultValue ?? opts.initialValue ?? "";
+  }
+  stdin.resume();
+  stdin.ref?.();
+  const restoreKeypressListeners = suspendStdinKeypressListeners();
+  const rl = readline.createInterface({ input: stdin, output: stdout, terminal: true });
+  console.log(`  ${ansi.dim(FLOW_PIPE)}`);
+  const question = `  ${ansi.cyan("\u25C6")} ${opts.message}${opts.placeholder ? ` ${ansi.dim(`(${opts.placeholder})`)}` : ""}: `;
+  const previousRawMode = stdin.isRaw;
+  if (previousRawMode) stdin.setRawMode(false);
+  const value = await new Promise((resolve) => {
+    rl.on("SIGINT", () => resolve(null));
+    rl.question(question, (answer) => resolve(answer));
+  });
+  rl.close();
+  restoreKeypressListeners();
+  if (previousRawMode) stdin.setRawMode(true);
+  if (opts.clearAfterSubmit) {
+    clearRenderedLines(2);
+  }
+  if (value === null) {
+    printCancel(opts.cancelMessage);
+    return null;
+  }
+  if (!value.trim() && opts.defaultValue !== void 0) return opts.defaultValue;
+  if (!value.trim() && opts.initialValue !== void 0) return opts.initialValue;
+  return value;
+}
+async function promptConfirm(opts) {
+  const defaultYes = opts.initialValue ?? true;
+  const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+  const answer = await promptText({
+    message: `${opts.message} ${suffix}`,
+    cancelMessage: opts.cancelMessage
+  });
+  if (answer === null) return null;
+  const normalized = answer.trim().toLowerCase();
+  if (!normalized) return defaultYes;
+  if (normalized === "y" || normalized === "yes") return true;
+  if (normalized === "n" || normalized === "no") return false;
+  return defaultYes;
+}
+async function promptSelect(opts) {
+  const result = await runListPrompt({
+    message: opts.message,
+    options: opts.options,
+    initialValue: opts.initialValue,
+    commitLabel: opts.commitLabel ?? "Selected"
+  });
+  if (result.cancelled) {
+    printCancel(opts.cancelMessage);
+    return null;
+  }
+  return result.value;
+}
+async function promptAutocomplete(opts) {
+  const result = await runListPrompt({
+    message: opts.message,
+    options: opts.options,
+    initialValue: opts.initialValue,
+    placeholder: opts.placeholder,
+    filterable: true,
+    commitLabel: opts.commitLabel ?? "Selected"
+  });
+  if (result.cancelled) {
+    printCancel(opts.cancelMessage);
+    return null;
+  }
+  return result.value;
+}
+async function promptMultiselect(opts) {
+  const result = await runListPrompt({
+    message: opts.message,
+    options: opts.options,
+    allowMultiple: true,
+    required: opts.required,
+    commitLabel: "Selected"
+  });
+  if (result.cancelled) {
+    printCancel(opts.cancelMessage);
+    return null;
+  }
+  return result.value;
+}
+async function runWithSpinner(label, doneLabel, fn) {
+  if (!stdout.isTTY) return fn();
+  const spinFrames = ["\u2B16", "\u2B18", "\u2B17", "\u2B19"];
+  let tick = 0;
+  const render = () => {
+    readline.clearLine(stdout, 0);
+    readline.cursorTo(stdout, 0);
+    const spin = spinFrames[tick % spinFrames.length];
+    stdout.write(`  ${ansi.dim(FLOW_PIPE)} ${ansi.purple(spin)} ${label}`);
+    tick += 1;
+  };
+  render();
+  const timer = setInterval(render, 160);
+  try {
+    const result = await fn();
+    clearInterval(timer);
+    readline.clearLine(stdout, 0);
+    readline.cursorTo(stdout, 0);
+    stdout.write(`  ${ansi.green("\u25C6")} ${doneLabel}
+`);
+    return result;
+  } catch (err) {
+    clearInterval(timer);
+    readline.clearLine(stdout, 0);
+    readline.cursorTo(stdout, 0);
+    stdout.write(`  ${ansi.red("\u2717")} ${label}
+`);
+    throw err;
+  }
+}
+
+// src/lib/ui.ts
+import Table from "cli-table3";
+var ansi2 = {
+  green: esc("32"),
+  red: esc("31"),
+  dim: esc("2"),
+  cyan: esc("36"),
+  bold: esc("1"),
+  yellow: esc("33"),
+  // Alchemy brand colors
+  brand: rgb(54, 63, 249),
+  // Primary #363FF9
+  brandSecondary: rgb(139, 92, 246)
+  // Secondary #8B5CF6
+};
+var stripAnsi = (s) => s.replace(/\x1B\[[0-9;]*m/g, "");
+function wrap(fn) {
+  return (s) => isJSONMode() ? s : fn(s);
+}
+var green = wrap(ansi2.green);
+var red = wrap(ansi2.red);
+var dim = wrap(ansi2.dim);
+var cyan = wrap(ansi2.cyan);
+var bold = wrap(ansi2.bold);
+var yellow = wrap(ansi2.yellow);
+var brand = wrap(ansi2.brand);
+var suppressBrandedHelp = false;
+function setBrandedHelpSuppressed(suppressed) {
+  suppressBrandedHelp = suppressed;
+}
+function successBadge() {
+  return isJSONMode() ? "Success" : ansi2.green("\u2713");
+}
+function failBadge() {
+  return isJSONMode() ? "Failed" : ansi2.red("\u2717");
+}
+async function withSpinner(label, doneLabel, fn) {
+  if (isJSONMode() || quiet) return fn();
+  return runWithSpinner(label, doneLabel, fn);
+}
+function printKeyValueBox(pairs) {
+  if (isJSONMode()) return;
+  if (pairs.length === 0) {
+    console.log(`  ${ansi2.brand("\u250C\u2500\u2500\u2510")}`);
+    console.log(`  ${ansi2.brand("\u2514\u2500\u2500\u2518")}`);
+    return;
+  }
+  const keyWidth = Math.max(...pairs.map(([k]) => stripAnsi(k).length));
+  const contentRows = pairs.map(([key, value]) => {
+    const visibleKeyLen = stripAnsi(key).length;
+    const paddedKey = key + " ".repeat(Math.max(0, keyWidth - visibleKeyLen));
+    return `${ansi2.dim(paddedKey)}  ${value}`;
+  });
+  const contentWidth = Math.max(...contentRows.map((row) => stripAnsi(row).length));
+  const top = `\u250C${"\u2500".repeat(contentWidth + 2)}\u2510`;
+  const bottom = `\u2514${"\u2500".repeat(contentWidth + 2)}\u2518`;
+  console.log(`  ${ansi2.dim(top)}`);
+  for (const row of contentRows) {
+    const visibleLen = stripAnsi(row).length;
+    const padded = row + " ".repeat(Math.max(0, contentWidth - visibleLen));
+    console.log(`  ${ansi2.dim("\u2502")} ${padded} ${ansi2.dim("\u2502")}`);
+  }
+  console.log(`  ${ansi2.dim(bottom)}`);
+}
+function emptyState(message) {
+  if (isJSONMode()) return;
+  console.log(`
+  ${ansi2.dim(`\u25CB ${message}`)}`);
+}
+function printSyntaxJSON(obj) {
+  if (isJSONMode()) {
+    console.log(JSON.stringify(obj));
+    return;
+  }
+  const raw = JSON.stringify(obj, null, 2);
+  const highlighted = raw.replace(
+    /("(?:\\.|[^"\\])*")\s*(:)?|(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)|(\btrue\b|\bfalse\b|\bnull\b)/g,
+    (match, str, colon, num, lit) => {
+      if (str && colon) return ansi2.brand(str) + colon;
+      if (str) return ansi2.green(str);
+      if (num) return ansi2.cyan(num);
+      if (lit) return ansi2.yellow(lit);
+      return match;
+    }
+  );
+  console.log(highlighted);
+}
+function printTable(headers, rows) {
+  if (isJSONMode()) {
+    const objects = rows.map(
+      (row) => Object.fromEntries(headers.map((h, i) => [h, row[i] ?? null]))
+    );
+    console.log(JSON.stringify(objects, null, 2));
+    return;
+  }
+  const table = new Table({
+    head: headers.map((h) => ansi2.brand(ansi2.bold(h))),
+    chars: {
+      top: "\u2500",
+      "top-mid": "\u252C",
+      "top-left": "\u250C",
+      "top-right": "\u2510",
+      bottom: "\u2500",
+      "bottom-mid": "\u2534",
+      "bottom-left": "\u2514",
+      "bottom-right": "\u2518",
+      left: "\u2502",
+      "left-mid": "\u251C",
+      mid: "\u2500",
+      "mid-mid": "\u253C",
+      right: "\u2502",
+      "right-mid": "\u2524",
+      middle: "\u2502"
+    },
+    style: {
+      head: [],
+      border: [],
+      "padding-left": 1,
+      "padding-right": 1
+    }
+  });
+  for (let i = 0; i < rows.length; i++) {
+    const row = i % 2 === 1 ? rows[i].map((cell) => ansi2.dim(cell)) : rows[i];
+    table.push(row);
+  }
+  const output = table.toString();
+  const dimBorders = output.replace(
+    /[┌┐└┘┬┴├┤┼─│]/g,
+    (ch) => ansi2.dim(ch)
+  );
+  console.log(dimBorders);
+}
+function weiToEth(wei) {
+  const divisor = 10n ** 18n;
+  const whole = wei / divisor;
+  const remainder = wei % divisor;
+  if (remainder === 0n) return `${whole}.0`;
+  const remStr = remainder.toString().padStart(18, "0").replace(/0+$/, "");
+  return `${whole}.${remStr}`;
+}
+function timeAgo(hexTimestamp) {
+  const seconds = parseInt(hexTimestamp, 16);
+  if (isNaN(seconds)) return hexTimestamp;
+  const now = Math.floor(Date.now() / 1e3);
+  const diff = now - seconds;
+  if (diff < 0) return "in the future";
+  if (diff < 60) return `${diff} seconds ago`;
+  if (diff < 3600) return `${Math.floor(diff / 60)} minutes ago`;
+  if (diff < 86400) return `${Math.floor(diff / 3600)} hours ago`;
+  if (diff < 2592e3) return `${Math.floor(diff / 86400)} days ago`;
+  return `${Math.floor(diff / 2592e3)} months ago`;
+}
+var EXPLORER_MAP = {
+  "eth-mainnet": "https://etherscan.io",
+  "eth-sepolia": "https://sepolia.etherscan.io",
+  "eth-holesky": "https://holesky.etherscan.io",
+  "polygon-mainnet": "https://polygonscan.com",
+  "polygon-amoy": "https://amoy.polygonscan.com",
+  "arb-mainnet": "https://arbiscan.io",
+  "arb-sepolia": "https://sepolia.arbiscan.io",
+  "opt-mainnet": "https://optimistic.etherscan.io",
+  "opt-sepolia": "https://sepolia-optimism.etherscan.io",
+  "base-mainnet": "https://basescan.org",
+  "base-sepolia": "https://sepolia.basescan.org"
+};
+function etherscanTxURL(hash, network) {
+  const base = EXPLORER_MAP[network];
+  if (!base) return void 0;
+  return `${base}/tx/${hash}`;
+}
+function brandedHelp(options) {
+  if (isJSONMode() || quiet) return "";
+  if (suppressBrandedHelp && !options?.force) return "";
+  const lerp = (a, b, t) => Math.round(a + (b - a) * t);
+  const gradientAt = (t) => {
+    const c0 = { r: 5, g: 213, b: 255 };
+    const c1 = { r: 54, g: 63, b: 249 };
+    const c2 = { r: 85, g: 51, b: 255 };
+    if (t <= 0.723958) {
+      const p2 = t / 0.723958;
+      return rgb(
+        lerp(c0.r, c1.r, p2),
+        lerp(c0.g, c1.g, p2),
+        lerp(c0.b, c1.b, p2)
+      );
+    }
+    const p = (t - 0.723958) / (1 - 0.723958);
+    return rgb(
+      lerp(c1.r, c2.r, p),
+      lerp(c1.g, c2.g, p),
+      lerp(c1.b, c2.b, p)
+    );
+  };
+  const markLines = [
+    " \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557      \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557",
+    "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D",
+    "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2554\u255D ",
+    "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u255A\u2588\u2588\u2554\u255D  ",
+    "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551   \u2588\u2588\u2551   ",
+    "\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D   \u255A\u2550\u255D   "
+  ];
+  const logo = markLines.map((line, i) => gradientAt(i / (markLines.length - 1))(line)).join("\n");
+  return "\n" + logo + "\n";
+}
+
+// src/lib/admin-client.ts
+var AdminClient = class _AdminClient {
+  static get ADMIN_API_HOST() {
+    return `admin-api.${getBaseDomain()}`;
+  }
+  // Test/debug only: used by mock E2E to route admin requests locally.
+  static ADMIN_API_BASE_URL_ENV = "ALCHEMY_ADMIN_API_BASE_URL";
+  credential;
+  constructor(credential) {
+    if (typeof credential === "string") {
+      this.validateAccessKey(credential);
+      this.credential = { type: "access_key", key: credential };
+    } else {
+      if (credential.type === "access_key") {
+        this.validateAccessKey(credential.key);
+      } else if (!credential.token.trim()) {
+        throw errAuthRequired();
+      }
+      this.credential = credential;
+    }
+  }
+  baseURL() {
+    const override = this.baseURLOverride();
+    if (override) return override.toString().replace(/\/$/, "");
+    return `https://admin-api.${getBaseDomain()}`;
+  }
+  allowedHosts() {
+    const hosts = /* @__PURE__ */ new Set([_AdminClient.ADMIN_API_HOST]);
+    const override = this.baseURLOverride();
+    if (override) hosts.add(override.hostname);
+    return hosts;
+  }
+  allowInsecureTransport(hostname) {
+    return isLocalhost(hostname);
+  }
+  baseURLOverride() {
+    return parseBaseURLOverride(_AdminClient.ADMIN_API_BASE_URL_ENV);
+  }
+  validateAccessKey(accessKey) {
+    if (!accessKey.trim() || /\s/.test(accessKey)) {
+      throw errInvalidAccessKey();
+    }
+  }
+  assertSafeRequestTarget(url) {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      throw errInvalidArgs("Invalid admin API URL.");
+    }
+    if (!this.allowedHosts().has(parsed.hostname)) {
+      throw errInvalidArgs(`Refusing to send credentials to unexpected host: ${parsed.hostname}`);
+    }
+    if (parsed.protocol !== "https:" && !this.allowInsecureTransport(parsed.hostname)) {
+      throw errInvalidArgs("Refusing to send credentials over non-HTTPS connection.");
+    }
+  }
+  async request(method, path, body) {
+    const url = `${this.baseURL()}${path}`;
+    debug(`${method} ${url}`);
+    this.assertSafeRequestTarget(url);
+    const resp = await fetchWithTimeout(url, {
+      method,
+      redirect: "error",
+      headers: {
+        Authorization: `Bearer ${this.credential.type === "access_key" ? this.credential.key : this.credential.token}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      ...body !== void 0 && { body: JSON.stringify(body) }
+    });
+    if (resp.status === 401) {
+      debug(`401 Unauthorized from ${url}`);
+      throw errInvalidAccessKey();
+    }
+    if (resp.status === 403) {
+      const detail = await resp.text().catch(() => "");
+      let reason;
+      try {
+        const parsed = JSON.parse(detail);
+        reason = parsed?.message || parsed?.error?.message || parsed?.error || void 0;
+      } catch {
+        reason = detail || void 0;
+      }
+      throw errAccessDenied(typeof reason === "string" ? reason : void 0);
+    }
+    if (resp.status === 404) {
+      const text = await resp.text().catch(() => "");
+      throw errNotFound(text || path);
+    }
+    if (resp.status === 429) throw errRateLimited();
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw errAdminAPI(resp.status, text);
+    }
+    return resp.json();
+  }
+  async listChains() {
+    const result = await this.request("GET", "/v1/chains");
+    const chains = (Array.isArray(result.data) ? result.data : void 0) ?? (!Array.isArray(result.data) ? result.data?.networks : void 0) ?? (!Array.isArray(result.data) ? result.data?.chains : void 0) ?? result.networks ?? result.chains;
+    if (!Array.isArray(chains)) {
+      throw errAdminAPI(200, "Unexpected response shape for /v1/chains.");
+    }
+    return chains;
+  }
+  async listApps(opts) {
+    const params = new URLSearchParams();
+    if (opts?.cursor) params.set("cursor", opts.cursor);
+    if (opts?.limit) params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    const resp = await this.request(
+      "GET",
+      `/v1/apps${qs ? `?${qs}` : ""}`
+    );
+    return resp.data;
+  }
+  async listAllApps(opts) {
+    const apps = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    let cursor;
+    let pages = 0;
+    do {
+      const page = await this.listApps({
+        ...cursor && { cursor },
+        ...opts?.limit !== void 0 && { limit: opts.limit }
+      });
+      pages += 1;
+      apps.push(...page.apps);
+      cursor = page.cursor;
+      if (cursor && seenCursors.has(cursor)) break;
+      if (cursor) seenCursors.add(cursor);
+    } while (cursor);
+    return { apps, pages };
+  }
+  async getApp(id) {
+    const resp = await this.request("GET", `/v1/apps/${id}`);
+    return resp.data;
+  }
+  async createApp(opts) {
+    const resp = await this.request("POST", "/v1/apps", {
+      name: opts.name,
+      chainNetworks: opts.networks,
+      ...opts.description && { description: opts.description },
+      ...opts.products && { products: opts.products }
+    });
+    return resp.data;
+  }
+  async deleteApp(id) {
+    await this.request("DELETE", `/v1/apps/${id}`);
+  }
+  async updateApp(id, opts) {
+    const resp = await this.request("PATCH", `/v1/apps/${id}`, opts);
+    return resp.data;
+  }
+  async updateNetworkAllowlist(id, networks) {
+    const resp = await this.request("PUT", `/v1/apps/${id}/networks`, {
+      chainNetworks: networks
+    });
+    return resp.data;
+  }
+  async updateAddressAllowlist(id, addresses) {
+    const resp = await this.request("PUT", `/v1/apps/${id}/address-allowlist`, {
+      addressAllowlist: addresses
+    });
+    return resp.data;
+  }
+  async updateOriginAllowlist(id, origins) {
+    const resp = await this.request("PUT", `/v1/apps/${id}/origin-allowlist`, {
+      originAllowlist: origins
+    });
+    return resp.data;
+  }
+  async updateIpAllowlist(id, ips) {
+    const resp = await this.request("PUT", `/v1/apps/${id}/ip-allowlist`, {
+      ipAllowlist: ips
+    });
+    return resp.data;
+  }
+};
+
+// src/lib/interaction.ts
+import { stdin as stdin2, stdout as stdout2 } from "process";
+function isTruthy(value) {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+function isNonInteractiveEnv() {
+  return isTruthy(process.env.ALCHEMY_NON_INTERACTIVE);
+}
+function isInteractiveAllowed(program) {
+  if (!stdin2.isTTY || !stdout2.isTTY) return false;
+  if (isJSONMode()) return false;
+  if (isNonInteractiveEnv()) return false;
+  if (program && program.opts().interactive === false) return false;
+  return true;
+}
+
+// src/lib/resolve.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/lib/client.ts
+var Client = class _Client {
+  apiKey;
+  network;
+  // Test/debug only: used by mock E2E to route CLI requests locally.
+  static RPC_BASE_URL_ENV = "ALCHEMY_RPC_BASE_URL";
+  constructor(apiKey, network) {
+    this.apiKey = apiKey;
+    this.network = network;
+    this.validateNetwork(network);
+  }
+  validateNetwork(network) {
+    if (this.rpcBaseURLOverride()) {
+      return;
+    }
+    const domain = getBaseDomain();
+    const hostname = `${network}.g.${domain}`;
+    let parsed;
+    try {
+      parsed = new URL(`https://${hostname}`);
+    } catch {
+      throw errInvalidArgs(
+        `Unknown network '${network}'. Run 'alchemy network list' to see available networks.`
+      );
+    }
+    if (!parsed.hostname.endsWith(`.g.${domain}`)) {
+      throw errInvalidArgs(
+        `Unknown network '${network}'. Run 'alchemy network list' to see available networks.`
+      );
+    }
+  }
+  rpcBaseURLOverride() {
+    return parseBaseURLOverride(_Client.RPC_BASE_URL_ENV);
+  }
+  rpcBaseURL() {
+    const override = this.rpcBaseURLOverride();
+    if (override) return override;
+    return new URL(`https://${this.network}.g.${getBaseDomain()}`);
+  }
+  rpcURL() {
+    return new URL(`/v2/${this.apiKey}`, this.rpcBaseURL()).toString();
+  }
+  enhancedURL() {
+    return new URL(`/nft/v3/${this.apiKey}`, this.rpcBaseURL()).toString();
+  }
+  parseNetworkNotEnabledError(detail) {
+    const match = detail.match(
+      /([A-Z0-9_]+)\s+is not enabled for this app\.\s+Visit this page to enable the network:\s+(https?:\/\/\S+)/i
+    );
+    if (!match) return null;
+    return errNetworkNotEnabled(match[1], detail);
+  }
+  authErrorFromResponseBody(detail) {
+    const networkNotEnabled = this.parseNetworkNotEnabledError(detail);
+    if (networkNotEnabled) return networkNotEnabled;
+    return errInvalidAPIKey(detail || void 0);
+  }
+  tryParseRPCError(text) {
+    try {
+      const parsed = JSON.parse(text);
+      if (parsed?.error?.code !== void 0 && parsed?.error?.message !== void 0) {
+        return errRPC(parsed.error.code, parsed.error.message);
+      }
+    } catch {
+    }
+    return null;
+  }
+  verboseLog(message) {
+    if (verbose) {
+      process.stderr.write(`[verbose] ${message}
+`);
+    }
+  }
+  async doFetch(url, init) {
+    return fetchWithTimeout(url, init);
+  }
+  async call(method, params = []) {
+    const body = {
+      jsonrpc: "2.0",
+      method,
+      params,
+      id: 1
+    };
+    const redactedURL = redactSensitiveText(this.rpcURL());
+    this.verboseLog(`\u2192 POST ${redactedURL}`);
+    this.verboseLog(`  method: ${method}`);
+    const hasParams = Array.isArray(params) ? params.length > 0 : Object.keys(params).length > 0;
+    if (hasParams) {
+      this.verboseLog(`  params: ${JSON.stringify(params)}`);
+    }
+    const startTime = Date.now();
+    const resp = await this.doFetch(this.rpcURL(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    this.verboseLog(`\u2190 ${resp.status} ${resp.statusText} (${Date.now() - startTime}ms)`);
+    if (resp.status === 429) throw errRateLimited();
+    if (resp.status === 401 || resp.status === 403) {
+      const detail = await resp.text().catch(() => "");
+      throw this.authErrorFromResponseBody(detail);
+    }
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      const rpcError = this.tryParseRPCError(text);
+      if (rpcError) throw rpcError;
+      throw errNetwork(`HTTP ${resp.status}: ${text}`);
+    }
+    const rpcResp = await resp.json();
+    if (rpcResp.error) {
+      throw errRPC(rpcResp.error.code, rpcResp.error.message);
+    }
+    return rpcResp.result;
+  }
+  async callEnhanced(path, params) {
+    const url = new URL(`${this.enhancedURL()}/${path}`);
+    for (const [k, v] of Object.entries(params)) {
+      url.searchParams.set(k, v);
+    }
+    const redactedURL = redactSensitiveText(url.toString());
+    this.verboseLog(`\u2192 GET ${redactedURL}`);
+    const startTime = Date.now();
+    const resp = await this.doFetch(url.toString(), {
+      headers: { Accept: "application/json" }
+    });
+    this.verboseLog(`\u2190 ${resp.status} ${resp.statusText} (${Date.now() - startTime}ms)`);
+    if (resp.status === 429) throw errRateLimited();
+    if (resp.status === 401 || resp.status === 403) {
+      const detail = await resp.text().catch(() => "");
+      throw this.authErrorFromResponseBody(detail);
+    }
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      const rpcError = this.tryParseRPCError(text);
+      if (rpcError) throw rpcError;
+      throw errNetwork(`HTTP ${resp.status}: ${text}`);
+    }
+    return resp.json();
+  }
+};
+
+// src/lib/x402-client.ts
+import { signSiwe, createPayment } from "@alchemy/x402";
+var X402Client = class _X402Client {
+  network;
+  privateKey;
+  siweToken = null;
+  static X402_BASE_URL_ENV = "ALCHEMY_X402_BASE_URL";
+  static get DEFAULT_BASE() {
+    return `https://x402.${getBaseDomain()}`;
+  }
+  constructor(privateKey, network) {
+    this.privateKey = privateKey;
+    this.network = network;
+    this.validateNetwork(network);
+  }
+  validateNetwork(network) {
+    if (this.baseURLOverride()) return;
+    if (!/^[A-Za-z0-9:_-]{1,128}$/.test(network)) {
+      throw errInvalidArgs(`Invalid network: ${network}`);
+    }
+  }
+  baseURLOverride() {
+    return parseBaseURLOverride(_X402Client.X402_BASE_URL_ENV);
+  }
+  baseURL() {
+    const override = this.baseURLOverride();
+    if (override) return override;
+    return new URL(_X402Client.DEFAULT_BASE);
+  }
+  rpcURL() {
+    return new URL(`/${this.network}/v2`, this.baseURL()).toString();
+  }
+  enhancedURL() {
+    return new URL(`/${this.network}/nft/v3`, this.baseURL()).toString();
+  }
+  static SIWE_TTL = "1h";
+  static SIWE_EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
+  // refresh 5min before expiry
+  async ensureSiweToken() {
+    if (this.siweToken) return this.siweToken;
+    const cfg = load();
+    if (cfg.siwe_token && cfg.siwe_token_expires_at) {
+      const expiry = new Date(cfg.siwe_token_expires_at);
+      const remaining = expiry.getTime() - Date.now();
+      debug(`SIWE: found cached token (length=${cfg.siwe_token.length}, remaining=${Math.round(remaining / 1e3)}s)`);
+      if (!Number.isNaN(expiry.getTime()) && remaining > _X402Client.SIWE_EXPIRY_BUFFER_MS) {
+        this.siweToken = cfg.siwe_token;
+        return this.siweToken;
+      }
+      debug("SIWE: cached token expired or expiring soon");
+    } else {
+      debug("SIWE: no cached token in config");
+    }
+    debug("SIWE: generating fresh token");
+    this.siweToken = await signSiwe({
+      privateKey: this.privateKey,
+      expiresAfter: _X402Client.SIWE_TTL
+    });
+    const expiresAt = new Date(Date.now() + 60 * 60 * 1e3).toISOString();
+    debug(`SIWE: saving token to config (length=${this.siweToken.length}, expires=${expiresAt})`);
+    save({ ...load(), siwe_token: this.siweToken, siwe_token_expires_at: expiresAt });
+    return this.siweToken;
+  }
+  refreshSiweToken() {
+    this.siweToken = null;
+    const cfg = load();
+    save({ ...cfg, siwe_token: void 0, siwe_token_expires_at: void 0 });
+  }
+  async call(method, params = []) {
+    const body = { jsonrpc: "2.0", method, params, id: 1 };
+    const jsonBody = JSON.stringify(body);
+    const buildInit = (extra) => ({
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `SIWE ${this.siweToken}`,
+        ...extra
+      },
+      body: jsonBody
+    });
+    await this.ensureSiweToken();
+    let resp = await this.doFetch(this.rpcURL(), buildInit());
+    resp = await this.handleAuthAndPayment(resp, {
+      authRetry: async () => {
+        this.refreshSiweToken();
+        await this.ensureSiweToken();
+        return this.doFetch(this.rpcURL(), buildInit());
+      },
+      paymentRetry: async (paymentSig) => this.doFetch(this.rpcURL(), buildInit({ "Payment-Signature": paymentSig }))
+    });
+    if (resp.status === 429) throw errRateLimited();
+    if (resp.status === 402) throw await this.parsePaymentError(resp);
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw errNetwork(`HTTP ${resp.status}: ${text}`);
+    }
+    const rpcResp = await resp.json();
+    if (rpcResp.error) {
+      throw errRPC(rpcResp.error.code, rpcResp.error.message);
+    }
+    return rpcResp.result;
+  }
+  async callEnhanced(path, params) {
+    const url = new URL(`${this.enhancedURL()}/${path}`);
+    for (const [k, v] of Object.entries(params)) {
+      url.searchParams.set(k, v);
+    }
+    const urlStr = url.toString();
+    const buildInit = (extra) => ({
+      headers: {
+        Accept: "application/json",
+        Authorization: `SIWE ${this.siweToken}`,
+        ...extra
+      }
+    });
+    await this.ensureSiweToken();
+    let resp = await this.doFetch(urlStr, buildInit());
+    resp = await this.handleAuthAndPayment(resp, {
+      authRetry: async () => {
+        this.refreshSiweToken();
+        await this.ensureSiweToken();
+        return this.doFetch(urlStr, buildInit());
+      },
+      paymentRetry: async (paymentSig) => this.doFetch(urlStr, buildInit({ "Payment-Signature": paymentSig }))
+    });
+    if (resp.status === 429) throw errRateLimited();
+    if (resp.status === 402) throw await this.parsePaymentError(resp);
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw errNetwork(`HTTP ${resp.status}: ${text}`);
+    }
+    return resp.json();
+  }
+  async callRest(path, options = {}) {
+    const base = new URL(`/${path.replace(/^\//, "")}`, this.baseURL());
+    if (options.query) {
+      for (const [k, v] of Object.entries(options.query)) {
+        if (v !== void 0 && v !== "") base.searchParams.set(k, v);
+      }
+    }
+    const urlStr = base.toString();
+    const method = options.method ?? "GET";
+    const buildInit = (extra) => ({
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `SIWE ${this.siweToken}`,
+        ...extra
+      },
+      ...options.body !== void 0 ? { body: JSON.stringify(options.body) } : {}
+    });
+    await this.ensureSiweToken();
+    let resp = await this.doFetch(urlStr, buildInit());
+    resp = await this.handleAuthAndPayment(resp, {
+      authRetry: async () => {
+        this.refreshSiweToken();
+        await this.ensureSiweToken();
+        return this.doFetch(urlStr, buildInit());
+      },
+      paymentRetry: async (paymentSig) => this.doFetch(urlStr, buildInit({ "Payment-Signature": paymentSig }))
+    });
+    if (resp.status === 429) throw errRateLimited();
+    if (resp.status === 402) throw await this.parsePaymentError(resp);
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw errNetwork(`HTTP ${resp.status}: ${text}`);
+    }
+    return resp.json();
+  }
+  async doFetch(url, init) {
+    return fetchWithTimeout(url, init);
+  }
+  async parsePaymentError(resp) {
+    const text = await resp.text().catch(() => "");
+    try {
+      const body = JSON.parse(text);
+      const reason = body?.extensions?.paymentError?.info?.reason;
+      const message = body?.extensions?.paymentError?.info?.message;
+      const payer = body?.extensions?.paymentError?.info?.payer;
+      if (reason === "insufficient_funds") {
+        const network = body?.accepts?.[0]?.network;
+        const asset = body?.accepts?.[0]?.extra?.name ?? "USDC";
+        const networkLabel = network === "eip155:8453" ? "Base" : network ?? "the payment network";
+        return new CLIError(
+          ErrorCode.PAYMENT_REQUIRED,
+          `Insufficient ${asset} balance on ${networkLabel}. ${message ?? ""}`.trim(),
+          `Fund wallet ${payer ?? ""} with ${asset} on ${networkLabel} to use x402.`.trim()
+        );
+      }
+      return new CLIError(
+        ErrorCode.PAYMENT_REQUIRED,
+        `x402 payment failed: ${message || body?.error || text}`
+      );
+    } catch {
+      return new CLIError(
+        ErrorCode.PAYMENT_REQUIRED,
+        `x402 payment failed: ${text}`
+      );
+    }
+  }
+  async handleAuthAndPayment(resp, retries) {
+    if (resp.status === 401) {
+      const detail = await resp.text().catch(() => "");
+      if (detail.includes("MESSAGE_EXPIRED")) {
+        return retries.authRetry();
+      }
+      throw new CLIError(
+        ErrorCode.AUTH_REQUIRED,
+        `x402 authentication failed: ${detail || "unauthorized"}`,
+        "Check your wallet key and try again."
+      );
+    }
+    if (resp.status === 402) {
+      const paymentRequiredHeader = resp.headers.get("payment-required");
+      if (!paymentRequiredHeader) {
+        throw new CLIError(
+          ErrorCode.PAYMENT_REQUIRED,
+          "x402 payment required but no Payment-Required header received."
+        );
+      }
+      const paymentSignature = await createPayment({
+        privateKey: this.privateKey,
+        paymentRequiredHeader
+      });
+      return retries.paymentRetry(paymentSignature);
+    }
+    return resp;
+  }
+};
+
+// src/lib/resolve.ts
+function resolveAPIKey(program, cfg) {
+  const opts = program.opts();
+  if (opts.apiKey) return opts.apiKey;
+  if (process.env.ALCHEMY_API_KEY) return process.env.ALCHEMY_API_KEY;
+  const config = cfg ?? load();
+  if (config.api_key) return config.api_key;
+  if (config.app?.apiKey) return config.app.apiKey;
+  return void 0;
+}
+function resolveAccessKey(program, cfg) {
+  const opts = program.opts();
+  if (opts.accessKey) return opts.accessKey;
+  if (process.env.ALCHEMY_ACCESS_KEY) return process.env.ALCHEMY_ACCESS_KEY;
+  const config = cfg ?? load();
+  if (config.access_key) return config.access_key;
+  return void 0;
+}
+function resolveNetwork(program, cfg, defaultNetwork) {
+  const opts = program.opts();
+  if (opts.network) return opts.network;
+  if (process.env.ALCHEMY_NETWORK) return process.env.ALCHEMY_NETWORK;
+  const config = cfg ?? load();
+  if (config.network) return config.network;
+  return defaultNetwork ?? "eth-mainnet";
+}
+function resolveAppId(program, cfg) {
+  const opts = program.opts();
+  if (opts.appId) return opts.appId;
+  const config = cfg ?? load();
+  if (config.app?.id) return config.app.id;
+  return void 0;
+}
+function resolveAuthToken(cfg) {
+  const config = cfg ?? load();
+  if (!config.auth_token?.trim()) return void 0;
+  if (config.auth_token_expires_at) {
+    const expiry = new Date(config.auth_token_expires_at);
+    if (!Number.isNaN(expiry.getTime()) && expiry <= /* @__PURE__ */ new Date()) {
+      return void 0;
+    }
+  }
+  return config.auth_token;
+}
+function adminClientFromFlags(program) {
+  const cfg = load();
+  const accessKey = resolveAccessKey(program, cfg);
+  if (accessKey) return new AdminClient(accessKey);
+  const authToken = resolveAuthToken(cfg);
+  if (authToken) return new AdminClient({ type: "auth_token", token: authToken });
+  throw errAccessKeyRequired();
+}
+function resolveX402(program, cfg) {
+  const opts = program.opts();
+  if (opts.x402) return true;
+  const config = cfg ?? load();
+  return config.x402 === true;
+}
+function resolveX402Client(program) {
+  const cfg = load();
+  if (!resolveX402(program, cfg)) return null;
+  const walletKey = resolveWalletKey(program, cfg);
+  if (!walletKey) return null;
+  return new X402Client(walletKey, resolveNetwork(program, cfg));
+}
+function resolveWalletKey(program, cfg) {
+  const opts = program.opts();
+  if (opts.walletKeyFile) {
+    return readFileSync2(opts.walletKeyFile, "utf-8").trim();
+  }
+  if (process.env.ALCHEMY_WALLET_KEY) {
+    return process.env.ALCHEMY_WALLET_KEY;
+  }
+  const config = cfg ?? load();
+  if (config.wallet_key_file) {
+    return readFileSync2(config.wallet_key_file, "utf-8").trim();
+  }
+  return void 0;
+}
+function clientFromFlags(program, opts) {
+  const cfg = load();
+  const network = resolveNetwork(program, cfg, opts?.defaultNetwork);
+  debug(`using network=${network}`);
+  const programOpts = program.opts();
+  if (programOpts.accessKey) {
+    throw errInvalidArgs(
+      "--access-key is for admin commands (apps, chains, webhooks). Use --api-key for RPC commands."
+    );
+  }
+  if (resolveX402(program, cfg)) {
+    const walletKey = resolveWalletKey(program, cfg);
+    if (!walletKey) throw errWalletKeyRequired();
+    return new X402Client(walletKey, network);
+  }
+  const apiKey = resolveAPIKey(program, cfg);
+  if (!apiKey) throw errAuthRequired();
+  return new Client(apiKey, network);
+}
+
+export {
+  maskIf,
+  KEY_MAP,
+  configPath,
+  configDir,
+  load,
+  save,
+  get,
+  toMap,
+  promptText,
+  promptConfirm,
+  promptSelect,
+  promptAutocomplete,
+  promptMultiselect,
+  green,
+  red,
+  dim,
+  bold,
+  yellow,
+  brand,
+  setBrandedHelpSuppressed,
+  successBadge,
+  failBadge,
+  withSpinner,
+  printKeyValueBox,
+  emptyState,
+  printSyntaxJSON,
+  printTable,
+  weiToEth,
+  timeAgo,
+  etherscanTxURL,
+  brandedHelp,
+  AdminClient,
+  isInteractiveAllowed,
+  resolveAPIKey,
+  resolveNetwork,
+  resolveAppId,
+  resolveAuthToken,
+  adminClientFromFlags,
+  resolveX402Client,
+  resolveWalletKey,
+  clientFromFlags
+};