hood-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1996 @@
+#!/usr/bin/env node
+import {
+  MAINNET_ADDRESSES,
+  MAINNET_EXPLORER_URL,
+  ODYSSEY_ADDRESSES,
+  STOCK_TOKEN_DECIMALS,
+  StockTokenEligibilityError,
+  TESTNET_ADDRESSES,
+  TESTNET_STOCK_TOKENS,
+  USDG_DECIMALS,
+  buildSwapTx,
+  createHoodClient,
+  ensureApproval,
+  erc20Abi,
+  formatUsdg,
+  getMultiplier,
+  getPortfolio,
+  getQuote,
+  getRecentLaunches,
+  getStockToken,
+  getStockTokenByAddress,
+  getUsdgBalance,
+  isStockTokenAddress,
+  isStockTokenSymbol,
+  listPricedStockTokens,
+  listStockTokens,
+  odysseyTradedEvent,
+  quoteSwap,
+  watchLaunches,
+  watchTransfers
+} from "./chunk-CWEBZB3L.js";
+
+// src/program.ts
+import { Command as Command14 } from "commander";
+import { readFileSync as readFileSync4 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname3, join as join2 } from "path";
+
+// src/commands/price.ts
+import { Command } from "commander";
+
+// src/context.ts
+import { privateKeyToAccount } from "viem/accounts";
+import { http, isHex } from "viem";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/errors.ts
+var EXIT = {
+  OK: 0,
+  /** Generic runtime failure. */
+  ERROR: 1,
+  /** Bad usage / invalid arguments. */
+  USAGE: 2,
+  /** Network / RPC unreachable or timed out. */
+  NETWORK: 3,
+  /** A guard rail refused the action (eligibility, spend cap, unconfirmed). */
+  GUARD: 4,
+  /** The requested resource was not found (unknown symbol, missing tx). */
+  NOT_FOUND: 5,
+  /** Wallet required but not configured / wrong password. */
+  WALLET: 6
+};
+var CliError = class extends Error {
+  exitCode;
+  hint;
+  cause;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = options.exitCode ?? EXIT.ERROR;
+    this.hint = options.hint;
+    this.cause = options.cause;
+  }
+};
+var usageError = (m, hint) => new CliError(m, { exitCode: EXIT.USAGE, hint });
+var guardError = (m, hint) => new CliError(m, { exitCode: EXIT.GUARD, hint });
+var notFoundError = (m, hint) => new CliError(m, { exitCode: EXIT.NOT_FOUND, hint });
+var walletError = (m, hint) => new CliError(m, { exitCode: EXIT.WALLET, hint });
+function toCliError(err) {
+  if (err instanceof CliError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  const name = err instanceof Error ? err.name : "";
+  switch (name) {
+    case "UnknownSymbolError":
+      return new CliError(message, { exitCode: EXIT.NOT_FOUND, cause: err, hint: "Run `hood stocks` to list every Stock Token symbol." });
+    case "FeedNotFoundError":
+      return new CliError(message, { exitCode: EXIT.NOT_FOUND, cause: err, hint: "This token has no Chainlink feed \u2014 try `hood token <address>` for on-chain data." });
+    case "StaleFeedError":
+      return new CliError(message, { exitCode: EXIT.ERROR, cause: err, hint: "Stock feeds pause outside market hours (24/5). Pass --max-age to widen the window." });
+    case "NoRouteError":
+      return new CliError(message, { exitCode: EXIT.NOT_FOUND, cause: err, hint: "No Uniswap v3 pool with liquidity connects these tokens on this network." });
+    case "StockTokenEligibilityError":
+      return new CliError("Stock Token acquisition is gated.", {
+        exitCode: EXIT.GUARD,
+        cause: err,
+        hint: "Stock Tokens are tokenized securities and may not be sold to US persons. Re-run with --acknowledge-eligibility if you are eligible."
+      });
+    case "NoAccountError":
+      return new CliError("This action needs a wallet.", {
+        exitCode: EXIT.WALLET,
+        cause: err,
+        hint: "Configure one with `hood config set wallet`, or set ROBINHOOD_CHAIN_PRIVATE_KEY."
+      });
+    case "FeedConnectionError":
+      return new CliError(message, { exitCode: EXIT.NETWORK, cause: err });
+  }
+  if (/fetch failed|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|socket hang up|network|timeout/i.test(message)) {
+    return new CliError("Could not reach the Robinhood Chain RPC.", {
+      exitCode: EXIT.NETWORK,
+      cause: err,
+      hint: "Check your connection, or set a custom RPC with `hood config set rpc <url>`."
+    });
+  }
+  return new CliError(message, { exitCode: EXIT.ERROR, cause: err });
+}
+
+// src/config.ts
+var CONFIG_KEYS = ["network", "rpc", "testnetRpc", "alchemyKey", "maxSpendUsd"];
+function configDir() {
+  return process.env.HOOD_CONFIG_DIR ?? join(homedir(), ".config", "hood");
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function defaultKeystorePath() {
+  return join(configDir(), "keystore.json");
+}
+function loadConfig() {
+  const path = configPath();
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    throw usageError(`Config at ${path} is not valid JSON.`, "Delete it or fix it by hand.");
+  }
+}
+function saveConfig(config) {
+  const path = configPath();
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+}
+function setConfigValue(config, key, value) {
+  const next = { ...config };
+  switch (key) {
+    case "network":
+      if (value !== "mainnet" && value !== "testnet") throw usageError('network must be "mainnet" or "testnet".');
+      next.network = value;
+      break;
+    case "rpc":
+      next.rpc = value;
+      break;
+    case "testnetRpc":
+      next.testnetRpc = value;
+      break;
+    case "alchemyKey":
+      next.alchemyKey = value;
+      break;
+    case "maxSpendUsd": {
+      const n = Number(value);
+      if (!Number.isFinite(n) || n < 0) throw usageError("maxSpendUsd must be a non-negative number.");
+      next.maxSpendUsd = n;
+      break;
+    }
+    default:
+      throw usageError(`Unknown config key "${key}".`, `Valid keys: ${CONFIG_KEYS.join(", ")}, wallet.`);
+  }
+  return next;
+}
+function redactedConfig(config) {
+  return {
+    network: config.network ?? "mainnet",
+    rpc: config.rpc ?? null,
+    testnetRpc: config.testnetRpc ?? null,
+    alchemyKey: config.alchemyKey ? maskKey(config.alchemyKey) : null,
+    walletAddress: config.walletAddress ?? null,
+    walletKeystore: config.walletKeystore ?? (config.walletAddress ? defaultKeystorePath() : null),
+    maxSpendUsd: config.maxSpendUsd ?? null
+  };
+}
+function maskKey(key) {
+  if (key.length <= 6) return "\u2022\u2022\u2022\u2022";
+  return `${key.slice(0, 3)}\u2026${key.slice(-3)}`;
+}
+
+// src/keystore.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+import { randomBytes, scryptSync, createCipheriv, createDecipheriv, timingSafeEqual } from "crypto";
+var SCRYPT = { N: 1 << 15, r: 8, p: 1, keylen: 32 };
+function deriveKey(password, salt) {
+  return scryptSync(password, salt, SCRYPT.keylen, {
+    N: SCRYPT.N,
+    r: SCRYPT.r,
+    p: SCRYPT.p,
+    maxmem: 128 * 1024 * 1024
+  });
+}
+function writeKeystore(path, privateKey, address, password) {
+  if (password.length < 8) throw walletError("Wallet password must be at least 8 characters.");
+  const salt = randomBytes(32);
+  const iv = randomBytes(12);
+  const key = deriveKey(password, salt);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const plaintext = Buffer.from(privateKey.replace(/^0x/, ""), "hex");
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const file = {
+    version: 1,
+    address,
+    kdf: "scrypt",
+    kdfparams: { ...SCRYPT, salt: salt.toString("hex") },
+    cipher: "aes-256-gcm",
+    iv: iv.toString("hex"),
+    ciphertext: ciphertext.toString("hex"),
+    tag: tag.toString("hex")
+  };
+  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
+  writeFileSync2(path, JSON.stringify(file, null, 2) + "\n", { mode: 384 });
+}
+function decryptKeystore(path, password) {
+  const file = readKeystoreFile(path);
+  const salt = Buffer.from(file.kdfparams.salt, "hex");
+  const key = deriveKey(password, salt);
+  const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(file.iv, "hex"));
+  decipher.setAuthTag(Buffer.from(file.tag, "hex"));
+  try {
+    const plaintext = Buffer.concat([
+      decipher.update(Buffer.from(file.ciphertext, "hex")),
+      decipher.final()
+    ]);
+    return `0x${plaintext.toString("hex")}`;
+  } catch {
+    throw walletError("Wrong wallet password.", "The keystore could not be decrypted.");
+  }
+}
+function passwordsMatch(a, b) {
+  const ba = Buffer.from(a);
+  const bb = Buffer.from(b);
+  if (ba.length !== bb.length) return false;
+  return timingSafeEqual(ba, bb);
+}
+function keystoreExists(path) {
+  return existsSync2(path);
+}
+function readKeystoreFile(path) {
+  if (!existsSync2(path)) throw walletError(`No keystore at ${path}.`, "Create one with `hood config set wallet`.");
+  try {
+    const file = JSON.parse(readFileSync2(path, "utf8"));
+    if (file.version !== 1 || file.cipher !== "aes-256-gcm") throw new Error("unsupported keystore");
+    return file;
+  } catch (err) {
+    if (err instanceof Error && err.name === "CliError") throw err;
+    throw walletError(`Keystore at ${path} is corrupt or unsupported.`);
+  }
+}
+
+// src/prompt.ts
+import { createInterface } from "readline";
+
+// src/ui/ansi.ts
+var colorEnabled = process.env.FORCE_COLOR ? process.env.FORCE_COLOR !== "0" : !!process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+function setColorEnabled(enabled) {
+  colorEnabled = enabled;
+}
+var wrap = (open, close) => (s) => colorEnabled ? `\x1B[${open}m${s}\x1B[${close}m` : String(s);
+var bold = wrap(1, 22);
+var dim = wrap(2, 22);
+var italic = wrap(3, 23);
+var underline = wrap(4, 24);
+var red = wrap(31, 39);
+var green = wrap(32, 39);
+var yellow = wrap(33, 39);
+var blue = wrap(34, 39);
+var magenta = wrap(35, 39);
+var cyan = wrap(36, 39);
+var white = wrap(37, 39);
+var gray = wrap(90, 39);
+function accent(s) {
+  return colorEnabled ? `\x1B[38;5;79m${s}\x1B[39m` : s;
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function width(s) {
+  return stripAnsi(s).length;
+}
+function padEnd(s, len) {
+  const w = width(s);
+  return w >= len ? s : s + " ".repeat(len - w);
+}
+function padStart(s, len) {
+  const w = width(s);
+  return w >= len ? s : " ".repeat(len - w) + s;
+}
+function truncate(s, len) {
+  if (s.length <= len) return s;
+  if (len <= 1) return s.slice(0, len);
+  return s.slice(0, len - 1) + "\u2026";
+}
+
+// src/prompt.ts
+function canPrompt() {
+  return !!process.stdin.isTTY;
+}
+async function confirm(question) {
+  if (!canPrompt()) {
+    throw guardError("Confirmation required but stdin is not a terminal.", "Re-run in an interactive shell, or pass --yes to skip the prompt.");
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await new Promise((resolve2) => {
+      rl.question(`${yellow("?")} ${bold(question)} ${dim("[y/N]")} `, resolve2);
+    });
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function readPassword(label = "Wallet password:", envVar = "HOOD_WALLET_PASSWORD") {
+  const fromEnv = process.env[envVar];
+  if (fromEnv) return fromEnv;
+  if (!canPrompt()) {
+    throw guardError("A wallet password is required.", `Set ${envVar} or run in an interactive terminal.`);
+  }
+  return new Promise((resolve2, reject) => {
+    const stdin = process.stdin;
+    process.stderr.write(`${dim(label)} `);
+    stdin.setRawMode?.(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let value = "";
+    const onData = (chunk) => {
+      for (const ch of chunk) {
+        if (ch === "\n" || ch === "\r" || ch === "") {
+          cleanup();
+          process.stderr.write("\n");
+          resolve2(value);
+          return;
+        }
+        if (ch === "") {
+          cleanup();
+          process.stderr.write("\n");
+          reject(guardError("Aborted."));
+          return;
+        }
+        if (ch === "\x7F" || ch === "\b") {
+          value = value.slice(0, -1);
+        } else {
+          value += ch;
+        }
+      }
+    };
+    const cleanup = () => {
+      stdin.setRawMode?.(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+    };
+    stdin.on("data", onData);
+  });
+}
+
+// src/context.ts
+function resolveRpcUrl(config, network, override) {
+  if (override) return override;
+  if (network === "testnet") return config.testnetRpc;
+  if (config.alchemyKey) return `https://robinhood-mainnet.g.alchemy.com/v2/${config.alchemyKey}`;
+  return config.rpc;
+}
+function buildTransport(rpcUrl) {
+  return http(rpcUrl, { retryCount: 5, retryDelay: 500, timeout: 2e4 });
+}
+function createContext(opts) {
+  const config = loadConfig();
+  const network = opts.network ?? config.network ?? "mainnet";
+  const rpcUrl = resolveRpcUrl(config, network, opts.rpc);
+  let readClient = null;
+  let walletClient = null;
+  return {
+    config,
+    network,
+    json: !!opts.json,
+    verbose: !!opts.verbose,
+    assumeYes: !!opts.yes,
+    acknowledgeEligibility: !!opts.acknowledgeEligibility,
+    rpcUrl,
+    read() {
+      if (!readClient) {
+        readClient = createHoodClient({ chain: network, transport: buildTransport(rpcUrl) });
+      }
+      return readClient;
+    },
+    async wallet() {
+      if (walletClient) return walletClient;
+      const account = await loadAccount(config);
+      walletClient = createHoodClient({
+        chain: network,
+        transport: buildTransport(rpcUrl),
+        account,
+        acknowledgeStockTokenEligibility: !!opts.acknowledgeEligibility
+      });
+      return walletClient;
+    }
+  };
+}
+async function loadAccount(config) {
+  const envKey = process.env.ROBINHOOD_CHAIN_PRIVATE_KEY;
+  if (envKey) {
+    const key = envKey.startsWith("0x") ? envKey : `0x${envKey}`;
+    if (!isHex(key) || key.length !== 66) {
+      throw walletError("ROBINHOOD_CHAIN_PRIVATE_KEY is not a valid 32-byte hex key.");
+    }
+    return privateKeyToAccount(key);
+  }
+  const keystorePath = config.walletKeystore ?? defaultKeystorePath();
+  if (!keystoreExists(keystorePath)) {
+    throw walletError("No wallet configured.", "Run `hood config set wallet`, or set ROBINHOOD_CHAIN_PRIVATE_KEY.");
+  }
+  const password = await readPassword();
+  const privateKey = decryptKeystore(keystorePath, password);
+  return privateKeyToAccount(privateKey);
+}
+
+// src/output.ts
+function jsonReplacer(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+function printJson(data) {
+  process.stdout.write(JSON.stringify(data, jsonReplacer, 2) + "\n");
+}
+function printHuman(block) {
+  process.stdout.write(block + "\n");
+}
+function printResult(json, human, asJson) {
+  if (asJson) printJson(json);
+  else printHuman(human());
+}
+function warn(message) {
+  process.stderr.write(yellow("! " + message) + "\n");
+}
+function presentError(err, opts) {
+  const cli = toCliError(err);
+  if (opts.json) {
+    printJson({ error: cli.message, hint: cli.hint ?? null, exitCode: cli.exitCode });
+  } else {
+    process.stderr.write(red(bold("\u2717 ") + cli.message) + "\n");
+    if (cli.hint) process.stderr.write(dim("  " + cli.hint) + "\n");
+    if (opts.verbose && cli.cause) {
+      const cause = cli.cause instanceof Error ? cli.cause.stack ?? cli.cause.message : String(cli.cause);
+      process.stderr.write(dim("\n" + cause) + "\n");
+    } else if (cli.cause && cli.exitCode !== EXIT.GUARD) {
+      process.stderr.write(dim("  Run with --verbose for the raw cause.") + "\n");
+    }
+  }
+  return cli.exitCode;
+}
+
+// src/action.ts
+function toGlobalOptions(raw) {
+  return {
+    json: !!raw.json,
+    network: raw.network,
+    rpc: raw.rpc,
+    verbose: !!raw.verbose,
+    yes: !!raw.yes,
+    acknowledgeEligibility: !!raw.acknowledgeEligibility
+  };
+}
+async function runWith(command, fn) {
+  const raw = command.optsWithGlobals();
+  if (raw.color === false) setColorEnabled(false);
+  const ctx = createContext(toGlobalOptions(raw));
+  try {
+    await fn(ctx);
+  } catch (err) {
+    process.exitCode = presentError(err, { json: ctx.json, verbose: ctx.verbose });
+  }
+}
+
+// src/prices.ts
+import { formatUnits, parseUnits } from "viem";
+function usdgAddress(client) {
+  return client.network === "testnet" ? TESTNET_ADDRESSES.usdg : MAINNET_ADDRESSES.usdg;
+}
+async function getDexPriceUsd(client, token2, decimals = 18) {
+  const usdg = usdgAddress(client);
+  if (token2.toLowerCase() === usdg.toLowerCase()) return 1;
+  try {
+    const quote = await quoteSwap(client, {
+      tokenIn: token2,
+      tokenOut: usdg,
+      amountIn: parseUnits("1", decimals)
+    });
+    return Number(formatUnits(quote.amountOut, USDG_DECIMALS));
+  } catch {
+    return null;
+  }
+}
+async function getOracleQuote(client, symbol, maxAgeSeconds) {
+  try {
+    return await getQuote(client, symbol, maxAgeSeconds ? { maxAgeSeconds } : {});
+  } catch {
+    return null;
+  }
+}
+async function getPriceRow(client, symbol, address, options = {}) {
+  const [oracle, dexUsd] = await Promise.all([
+    getOracleQuote(client, symbol, options.maxAgeSeconds),
+    options.withDex === false ? Promise.resolve(null) : getDexPriceUsd(client, address, options.decimals)
+  ]);
+  const oracleUsd = oracle?.priceUsd ?? null;
+  const premium = oracleUsd && dexUsd ? (dexUsd - oracleUsd) / oracleUsd : null;
+  return {
+    symbol,
+    address,
+    oracleUsd,
+    oracleAgeSeconds: oracle?.ageSeconds ?? null,
+    dexUsd,
+    premium
+  };
+}
+
+// src/resolve.ts
+import { getAddress, isAddress } from "viem";
+async function resolveToken(client, input) {
+  const raw = input.trim();
+  const upper = raw.toUpperCase();
+  const testnet = client.network === "testnet";
+  if (upper === "USDG") {
+    return {
+      address: testnet ? TESTNET_ADDRESSES.usdg : MAINNET_ADDRESSES.usdg,
+      symbol: "USDG",
+      decimals: USDG_DECIMALS,
+      isStock: false,
+      hasFeed: false
+    };
+  }
+  if (upper === "WETH" || upper === "ETH") {
+    return {
+      address: testnet ? TESTNET_ADDRESSES.weth : MAINNET_ADDRESSES.weth,
+      symbol: "WETH",
+      decimals: 18,
+      isStock: false,
+      hasFeed: false
+    };
+  }
+  if (testnet) {
+    const t = TESTNET_STOCK_TOKENS[upper];
+    if (t) return { address: t, symbol: upper, decimals: STOCK_TOKEN_DECIMALS, isStock: true, hasFeed: false };
+  } else if (isStockTokenSymbol(upper)) {
+    const token2 = getStockToken(upper);
+    return {
+      address: token2.address,
+      symbol: token2.symbol,
+      decimals: token2.decimals,
+      isStock: true,
+      hasFeed: token2.feed !== null
+    };
+  }
+  if (isAddress(raw)) {
+    const address = getAddress(raw);
+    const known = client.network === "mainnet" ? getStockTokenByAddress(address) : null;
+    if (known) {
+      return {
+        address,
+        symbol: known.symbol,
+        decimals: known.decimals,
+        isStock: true,
+        hasFeed: known.feed !== null
+      };
+    }
+    const [symbol, decimals] = await Promise.all([
+      client.public.readContract({ address, abi: erc20Abi, functionName: "symbol" }).catch(() => "TOKEN"),
+      client.public.readContract({ address, abi: erc20Abi, functionName: "decimals" }).catch(() => 18)
+    ]);
+    return {
+      address,
+      symbol,
+      decimals: Number(decimals),
+      isStock: client.network === "mainnet" ? isStockTokenAddress(address) : false,
+      hasFeed: false
+    };
+  }
+  if (raw.startsWith("0x")) throw usageError(`"${raw}" is not a valid address.`);
+  throw notFoundError(
+    `Unknown token "${raw}".`,
+    testnet ? `Testnet tokens: USDG, WETH, ${Object.keys(TESTNET_STOCK_TOKENS).join(", ")}, or a 0x address.` : "Use a Stock Token ticker (run `hood stocks`), USDG, WETH, or a 0x address."
+  );
+}
+
+// src/ui/table.ts
+function renderTable(rows, columns, options = {}) {
+  const gap = options.gap ?? 2;
+  const maxWidth = options.maxWidth ?? process.stdout.columns ?? 80;
+  const measured = columns.map((col) => {
+    const cells = rows.map((r) => col.cell(r));
+    const contentWidth = Math.max(width(col.header), ...cells.map((c) => width(c)), 0);
+    return { col, cells, contentWidth: Math.max(contentWidth, col.min ?? 0) };
+  });
+  const sep = " ".repeat(gap);
+  const totalWidth = (cols) => cols.reduce((sum, m) => sum + m.contentWidth, 0) + gap * Math.max(0, cols.length - 1);
+  let visible = measured;
+  if (totalWidth(visible) > maxWidth && visible.length > 1) {
+    const dropOrder = visible.map((m, i) => ({ i, priority: m.col.priority ?? 100 })).filter((x) => x.i !== 0).sort((a, b) => a.priority - b.priority);
+    const dropped = /* @__PURE__ */ new Set();
+    for (const { i } of dropOrder) {
+      if (totalWidth(visible.filter((_, idx) => !dropped.has(idx))) <= maxWidth) break;
+      dropped.add(i);
+    }
+    visible = measured.filter((_, idx) => !dropped.has(idx));
+  }
+  const line = (getCell, rowIdx) => visible.map((m) => {
+    const raw = getCell(m, rowIdx);
+    return m.col.align === "right" ? padStart(raw, m.contentWidth) : padEnd(raw, m.contentWidth);
+  }).join(sep);
+  const headerLine = visible.map(
+    (m) => m.col.align === "right" ? padStart(dim(m.col.header), m.contentWidth) : padEnd(dim(m.col.header), m.contentWidth)
+  ).join(sep);
+  const rule = gray("\u2500".repeat(Math.min(totalWidth(visible), maxWidth)));
+  const body = rows.map((_, rowIdx) => line((m) => m.cells[rowIdx], rowIdx));
+  return [headerLine, rule, ...body].join("\n");
+}
+function renderKeyValue(pairs, options = {}) {
+  const labelWidth = options.labelWidth ?? Math.max(...pairs.map(([k]) => width(k)), 0);
+  return pairs.map(([k, v]) => `${padEnd(dim(k), labelWidth)}  ${v}`).join("\n");
+}
+
+// src/ui/live.ts
+function liveRegion() {
+  const tty = !!process.stdout.isTTY;
+  if (!tty) {
+    let first = true;
+    return {
+      render: (frame) => {
+        if (!first) process.stdout.write("\n");
+        first = false;
+        process.stdout.write(frame + "\n");
+      },
+      stop: () => {
+      }
+    };
+  }
+  let prevLines = 0;
+  process.stdout.write("\x1B[?25l");
+  let stopped = false;
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    process.stdout.write("\x1B[?25h");
+  };
+  process.on("exit", stop);
+  const render = (frame) => {
+    const lines = frame.split("\n");
+    let out = "";
+    if (prevLines > 0) out += `\x1B[${prevLines}A`;
+    for (const line of lines) out += `\r\x1B[K${line}
+`;
+    for (let i = lines.length; i < prevLines; i++) out += "\r\x1B[K\n";
+    const extra = Math.max(0, prevLines - lines.length);
+    if (extra > 0) out += `\x1B[${extra}A`;
+    process.stdout.write(out);
+    prevLines = lines.length;
+  };
+  return { render, stop };
+}
+
+// src/ui/spinner.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function spinner(text) {
+  if (!process.stderr.isTTY) {
+    process.stderr.write(dim(text) + "\n");
+    return {
+      update: () => {
+      },
+      stop: () => {
+      },
+      succeed: (t) => t && process.stderr.write(dim(t) + "\n"),
+      fail: (t) => t && process.stderr.write(dim(t) + "\n")
+    };
+  }
+  let label = text;
+  let i = 0;
+  const render = () => {
+    process.stderr.write(`\r\x1B[K${dim(FRAMES[i % FRAMES.length] + " " + label)}`);
+    i += 1;
+  };
+  render();
+  const timer = setInterval(render, 80);
+  const clear = () => {
+    clearInterval(timer);
+    process.stderr.write("\r\x1B[K");
+  };
+  return {
+    update: (t) => {
+      label = t;
+    },
+    stop: clear,
+    succeed: (t) => {
+      clear();
+      if (t) process.stderr.write(dim("\u2713 " + t) + "\n");
+    },
+    fail: (t) => {
+      clear();
+      if (t) process.stderr.write(dim("\u2717 " + t) + "\n");
+    }
+  };
+}
+async function withSpinner(text, fn) {
+  const s = spinner(text);
+  try {
+    const result = await fn(s);
+    s.stop();
+    return result;
+  } catch (err) {
+    s.stop();
+    throw err;
+  }
+}
+
+// src/format.ts
+import { formatUnits as formatUnits2 } from "viem";
+function usd(value) {
+  if (!Number.isFinite(value)) return "\u2014";
+  const abs = Math.abs(value);
+  const digits = abs === 0 ? 2 : abs < 0.01 ? 6 : abs < 1 ? 4 : 2;
+  return "$" + value.toLocaleString("en-US", {
+    minimumFractionDigits: digits,
+    maximumFractionDigits: digits
+  });
+}
+function num(value, maxFrac = 4) {
+  if (!Number.isFinite(value)) return "\u2014";
+  return value.toLocaleString("en-US", { maximumFractionDigits: maxFrac });
+}
+function pct(ratio) {
+  if (!Number.isFinite(ratio)) return dim("\u2014");
+  const p = ratio * 100;
+  const sign = p > 0 ? "+" : "";
+  const s = `${sign}${p.toFixed(2)}%`;
+  if (p > 0) return green(s);
+  if (p < 0) return red(s);
+  return s;
+}
+function shortAddress(address) {
+  if (address.length <= 12) return address;
+  return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+}
+function addr(a) {
+  return shortAddress(a);
+}
+function age(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "\u2014";
+  const s = Math.floor(seconds);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ${m % 60}m`;
+  const d = Math.floor(h / 24);
+  return `${d}d ${h % 24}h`;
+}
+function timestamp(unixSeconds) {
+  if (!unixSeconds) return "\u2014";
+  return new Date(unixSeconds * 1e3).toISOString().replace("T", " ").replace(".000Z", "Z");
+}
+function tokenAmount(raw, decimals, maxFrac = 6) {
+  const full = formatUnits2(raw, decimals);
+  if (!full.includes(".")) return full;
+  const [whole, frac] = full.split(".");
+  const trimmed = (frac ?? "").slice(0, maxFrac).replace(/0+$/, "");
+  return trimmed ? `${whole}.${trimmed}` : whole;
+}
+
+// src/commands/price.ts
+function priceCommand() {
+  return new Command("price").description("Chainlink oracle price + DEX price + premium for a Stock Token").argument("<symbol>", "ticker (AAPL) or token address").option("--watch", "live-updating view (repaints in place)", false).option("--interval <ms>", "refresh interval for --watch", "4000").option("--max-age <seconds>", "max acceptable Chainlink answer age").option("--no-dex", "skip the Uniswap price probe (oracle only)").action(
+    (symbol, opts, command) => runWith(command, async (ctx) => {
+      await price(ctx, symbol, opts);
+    })
+  );
+}
+async function price(ctx, symbol, opts) {
+  const client = ctx.read();
+  const token2 = await resolveToken(client, symbol);
+  const maxAgeSeconds = opts.maxAge ? Number(opts.maxAge) : void 0;
+  const fetchRow = () => getPriceRow(client, token2.symbol, token2.address, {
+    maxAgeSeconds,
+    withDex: opts.dex,
+    decimals: token2.decimals
+  });
+  if (!opts.watch) {
+    const row = await withSpinner(`Pricing ${token2.symbol}\u2026`, () => fetchRow());
+    printResult(row, () => renderPrice(row, token2.symbol, ctx.network), ctx.json);
+    if (row.oracleUsd === null && row.dexUsd === null) process.exitCode = EXIT.NOT_FOUND;
+    return;
+  }
+  const interval = Math.max(1e3, Number(opts.interval) || 4e3);
+  const region = liveRegion();
+  const tick = async () => {
+    try {
+      const row = await fetchRow();
+      if (ctx.json) process.stdout.write(JSON.stringify(row, (_k, v) => typeof v === "bigint" ? v.toString() : v) + "\n");
+      else region.render(renderPrice(row, token2.symbol, ctx.network, true));
+    } catch {
+    }
+  };
+  await tick();
+  const timer = setInterval(tick, interval);
+  const shutdown = () => {
+    clearInterval(timer);
+    region.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+function renderPrice(row, symbol, network, watch2 = false) {
+  const pairs = [];
+  pairs.push(["Oracle", row.oracleUsd !== null ? bold(usd(row.oracleUsd)) : dim("no fresh feed")]);
+  if (row.oracleAgeSeconds !== null) pairs.push(["Updated", dim(age(row.oracleAgeSeconds) + " ago")]);
+  pairs.push(["DEX", row.dexUsd !== null ? usd(row.dexUsd) : dim("no pool")]);
+  pairs.push(["Premium", row.premium !== null ? pct(row.premium) : dim("\u2014")]);
+  pairs.push(["Token", gray(addr(row.address))]);
+  const header = `${accent("\u25C8")} ${bold(symbol)} ${dim("\xB7 Robinhood Chain " + network)}`;
+  const foot = watch2 ? "\n" + dim("  \u27F3 live \xB7 Ctrl-C to stop") : "";
+  return `${header}
+${renderKeyValue(pairs, { labelWidth: 8 })}${foot}`;
+}
+
+// src/commands/stocks.ts
+import { Command as Command2 } from "commander";
+
+// src/pmap.ts
+async function pMap(items, mapper, concurrency = 8) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const limit = Math.max(1, Math.min(concurrency, items.length || 1));
+  async function worker() {
+    while (cursor < items.length) {
+      const index = cursor++;
+      results[index] = await mapper(items[index], index);
+    }
+  }
+  await Promise.all(Array.from({ length: limit }, worker));
+  return results;
+}
+
+// src/commands/stocks.ts
+function stocksCommand() {
+  return new Command2("stocks").description("The full Stock Token board with live Chainlink prices").option("--sort <key>", "sort by symbol | price | premium (premium implies --dex)", "symbol").option("--dex", "also probe Uniswap for DEX price + premium (slower)", false).option("--priced", "only tokens with a live Chainlink feed", false).option("--limit <n>", "show at most n rows").action(
+    (opts, command) => runWith(command, async (ctx) => {
+      await stocks(ctx, opts);
+    })
+  );
+}
+async function stocks(ctx, opts) {
+  const sort = opts.sort;
+  if (!["symbol", "price", "premium"].includes(sort)) {
+    throw usageError(`--sort must be one of: symbol, price, premium (got "${opts.sort}").`);
+  }
+  const withDex = opts.dex || sort === "premium";
+  const client = ctx.read();
+  const tokens = opts.priced || sort === "premium" ? listPricedStockTokens() : listStockTokens();
+  const rows = await withSpinner(
+    withDex ? `Pricing ${tokens.length} tokens (oracle + DEX)\u2026` : `Pricing ${tokens.length} tokens\u2026`,
+    () => pMap(
+      tokens,
+      async (t) => {
+        const oracle = t.feed ? await getOracleQuote(client, t.symbol) : null;
+        const dexUsd = withDex ? await getDexPriceUsd(client, t.address, t.decimals) : null;
+        const premium = oracle && dexUsd ? (dexUsd - oracle.priceUsd) / oracle.priceUsd : null;
+        return {
+          symbol: t.symbol,
+          name: t.name.replace(/\s*•\s*Robinhood Token$/, ""),
+          address: t.address,
+          oracleUsd: oracle?.priceUsd ?? null,
+          ageSeconds: oracle?.ageSeconds ?? null,
+          dexUsd,
+          premium
+        };
+      },
+      withDex ? 6 : 16
+    )
+  );
+  sortRows(rows, sort);
+  const limited = opts.limit ? rows.slice(0, Math.max(0, Number(opts.limit))) : rows;
+  printResult(
+    { network: ctx.network, count: limited.length, tokens: limited },
+    () => renderBoard(limited, withDex, ctx.network),
+    ctx.json
+  );
+}
+function sortRows(rows, sort) {
+  if (sort === "symbol") rows.sort((a, b) => a.symbol.localeCompare(b.symbol));
+  else if (sort === "price") rows.sort((a, b) => (b.oracleUsd ?? -1) - (a.oracleUsd ?? -1));
+  else rows.sort((a, b) => (b.premium ?? -Infinity) - (a.premium ?? -Infinity));
+}
+function renderBoard(rows, withDex, network) {
+  const columns = [
+    { header: "SYMBOL", cell: (r) => bold(r.symbol), priority: 100 },
+    { header: "PRICE", align: "right", priority: 90, cell: (r) => r.oracleUsd !== null ? usd(r.oracleUsd) : dim("\u2014") },
+    { header: "AGE", align: "right", priority: 40, cell: (r) => r.ageSeconds !== null ? dim(age(r.ageSeconds)) : dim("\u2014") },
+    { header: "NAME", priority: 20, cell: (r) => dim(truncate(r.name, 24)) }
+  ];
+  if (withDex) {
+    columns.splice(2, 0, { header: "DEX", align: "right", priority: 70, cell: (r) => r.dexUsd !== null ? usd(r.dexUsd) : dim("\u2014") });
+    columns.splice(3, 0, { header: "PREMIUM", align: "right", priority: 80, cell: (r) => r.premium !== null ? pct(r.premium) : dim("\u2014") });
+  }
+  columns.push({ header: "ADDRESS", priority: 10, cell: (r) => gray(addr(r.address)) });
+  const priced = rows.filter((r) => r.oracleUsd !== null).length;
+  const header = `${accent("\u25C8")} ${bold("Stock Tokens")} ${dim(`\xB7 ${network} \xB7 ${rows.length} shown \xB7 ${priced} priced`)}`;
+  return `${header}
+${renderTable(rows, columns)}`;
+}
+
+// src/commands/coins.ts
+import { Command as Command3 } from "commander";
+import { formatEther } from "viem";
+var ODYSSEY_FACTORIES = [
+  ODYSSEY_ADDRESSES.bondingCurveFactory,
+  ODYSSEY_ADDRESSES.reflectionFactory,
+  ODYSSEY_ADDRESSES.instantFactory
+];
+function coinsCommand() {
+  return new Command3("coins").description("Memecoin screener \u2014 newest or trending launches").option("--new", "newest launches (default)", false).option("--trending", "rank by bonding-curve trade activity", false).option("--lookback <blocks>", "blocks to scan", "50000").option("--limit <n>", "rows to show", "20").option("--names", "resolve token symbols on-chain", false).action(
+    (opts, command) => runWith(command, async (ctx) => {
+      await coins(ctx, opts);
+    })
+  );
+}
+async function coins(ctx, opts) {
+  if (ctx.network !== "mainnet") throw usageError("The launchpads live on mainnet \u2014 run without --network testnet.");
+  const client = ctx.read();
+  const limit = Math.max(1, Number(opts.limit) || 20);
+  const lookback = BigInt(opts.lookback || "50000");
+  const trending = opts.trending;
+  const rows = trending ? await withSpinner("Ranking by curve activity\u2026", () => trendingRows(ctx, lookback, limit, opts.names)) : await withSpinner("Fetching newest launches\u2026", () => newRows(ctx, lookback, limit, opts.names));
+  printResult(
+    { network: ctx.network, mode: trending ? "trending" : "new", count: rows.length, coins: rows },
+    () => renderScreener(rows, trending),
+    ctx.json
+  );
+}
+async function newRows(ctx, lookback, limit, names) {
+  const launches2 = await getRecentLaunches(ctx.read(), { lookbackBlocks: lookback });
+  const recent = launches2.slice(-limit).reverse();
+  return pMap(recent, (l) => launchToRow(ctx, l, names), names ? 8 : 1);
+}
+async function trendingRows(ctx, lookback, limit, names) {
+  const client = ctx.read();
+  const latest = await client.public.getBlockNumber();
+  const fromBlock = latest > lookback ? latest - lookback : 0n;
+  const chunk = 10000n;
+  const agg = /* @__PURE__ */ new Map();
+  for (let start = fromBlock; start <= latest; start += chunk) {
+    const end = start + chunk - 1n > latest ? latest : start + chunk - 1n;
+    const logs = await client.public.getLogs({
+      address: ODYSSEY_FACTORIES,
+      event: odysseyTradedEvent,
+      fromBlock: start,
+      toBlock: end
+    });
+    for (const log of logs) {
+      const token2 = log.args.token.toLowerCase();
+      const quote = log.args.quoteAmount ?? 0n;
+      const prev = agg.get(token2) ?? { trades: 0, volume: 0n, lastBlock: 0n };
+      prev.trades += 1;
+      prev.volume += quote;
+      if (log.blockNumber > prev.lastBlock) prev.lastBlock = log.blockNumber;
+      agg.set(token2, prev);
+    }
+  }
+  const ranked = [...agg.entries()].map(([token2, v]) => ({ token: token2, ...v })).sort((a, b) => b.trades !== a.trades ? b.trades - a.trades : b.volume > a.volume ? 1 : -1).slice(0, limit);
+  return pMap(
+    ranked,
+    async (r) => ({
+      token: r.token,
+      symbol: names ? await symbolOf(ctx, r.token) : "",
+      creator: null,
+      pool: null,
+      block: r.lastBlock.toString(),
+      trades: r.trades,
+      volumeEth: Number(formatEther(r.volume))
+    }),
+    names ? 8 : 1
+  );
+}
+async function launchToRow(ctx, l, names) {
+  return {
+    token: l.token,
+    symbol: names ? await symbolOf(ctx, l.token) : "",
+    creator: l.creator,
+    pool: l.pool,
+    block: l.blockNumber.toString(),
+    trades: null,
+    volumeEth: null
+  };
+}
+function symbolOf(ctx, token2) {
+  return ctx.read().public.readContract({ address: token2, abi: erc20Abi, functionName: "symbol" }).then((s) => String(s)).catch(() => "");
+}
+function renderScreener(rows, trending) {
+  const header = `${accent("\u25C8")} ${bold(trending ? "Trending coins" : "New coins")} ${dim("\xB7 " + rows.length)}`;
+  if (rows.length === 0) {
+    return `${header}
+${dim(trending ? "No curve trades in the scanned window." : "No launches in the scanned window \u2014 widen --lookback.")}`;
+  }
+  const columns = [
+    { header: "TOKEN", priority: 100, cell: (r) => r.symbol ? bold(r.symbol) : gray(addr(r.token)) },
+    { header: "ADDRESS", priority: 50, cell: (r) => gray(addr(r.token)) }
+  ];
+  if (trending) {
+    columns.push({ header: "TRADES", align: "right", priority: 95, cell: (r) => green(String(r.trades)) });
+    columns.push({ header: "VOL (ETH)", align: "right", priority: 90, cell: (r) => num(r.volumeEth ?? 0, 4) });
+  } else {
+    columns.push({ header: "CREATOR", priority: 40, cell: (r) => r.creator ? gray(addr(r.creator)) : dim("\u2014") });
+    columns.push({ header: "POOL", priority: 30, cell: (r) => r.pool ? gray(addr(r.pool)) : dim("curve") });
+  }
+  columns.push({ header: "BLOCK", align: "right", priority: 20, cell: (r) => dim("#" + r.block) });
+  return `${header}
+${renderTable(rows, columns)}`;
+}
+
+// src/commands/launches.ts
+import { Command as Command4 } from "commander";
+function launchesCommand() {
+  return new Command4("launches").description("Recent memecoin launches from NOXA and The Odyssey").option("--follow", "stream new launches live", false).option("--launchpad <name>", "noxa | odyssey (default: both)").option("--lookback <blocks>", "blocks to scan for the snapshot", "30000").option("--limit <n>", "max rows in the snapshot", "25").option("--names", "resolve each token symbol on-chain", false).action(
+    (opts, command) => runWith(command, async (ctx) => {
+      await launches(ctx, opts);
+    })
+  );
+}
+function validLaunchpad(v) {
+  if (!v) return void 0;
+  if (v !== "noxa" && v !== "odyssey") throw usageError('--launchpad must be "noxa" or "odyssey".');
+  return v;
+}
+async function launches(ctx, opts) {
+  const client = ctx.read();
+  const launchpad = validLaunchpad(opts.launchpad);
+  if (opts.follow) {
+    if (ctx.network !== "mainnet") throw usageError("Launch watching runs on mainnet (the launchpads are mainnet-only).");
+    await follow(ctx, launchpad, opts.names);
+    return;
+  }
+  const raw = await withSpinner(
+    "Scanning launchpad logs\u2026",
+    () => getRecentLaunches(client, { lookbackBlocks: BigInt(opts.lookback || "30000"), launchpad })
+  );
+  const recent = raw.slice(-Math.max(1, Number(opts.limit) || 25)).reverse();
+  const rows = await withSpinner(
+    "Building feed\u2026",
+    () => pMap(recent, (l) => toRow(ctx, l, opts.names), opts.names ? 8 : 1)
+  );
+  printResult(
+    { network: ctx.network, count: rows.length, launches: rows },
+    () => renderFeed(rows, ctx.network),
+    ctx.json
+  );
+}
+async function toRow(ctx, l, resolveNames) {
+  let symbol = "";
+  if (resolveNames) {
+    symbol = await ctx.read().public.readContract({ address: l.token, abi: erc20Abi, functionName: "symbol" }).then((s) => String(s)).catch(() => "");
+  }
+  return {
+    launchpad: l.launchpad,
+    token: l.token,
+    symbol,
+    creator: l.creator,
+    pool: l.pool,
+    block: l.blockNumber.toString(),
+    tx: l.transactionHash
+  };
+}
+async function follow(ctx, launchpad, resolveNames) {
+  const client = ctx.read();
+  process.stderr.write(dim(`Watching ${launchpad ?? "NOXA + Odyssey"} for new launches \u2014 Ctrl-C to stop
+`));
+  const unwatch = watchLaunches(
+    client,
+    (l) => {
+      void toRow(ctx, l, resolveNames).then((r) => {
+        if (ctx.json) {
+          process.stdout.write(JSON.stringify(r) + "\n");
+        } else {
+          const name = r.symbol ? bold(r.symbol) + " " : "";
+          process.stdout.write(
+            `${green("\u25B2")} ${dim(r.launchpad.padEnd(7))} ${name}${gray(addr(r.token))} ${dim("by")} ${gray(addr(r.creator))} ${dim("#" + r.block)}
+`
+          );
+        }
+      });
+    },
+    { launchpad, onError: (e) => process.stderr.write(dim(`(watch retry: ${e.message})
+`)) }
+  );
+  const shutdown = () => {
+    unwatch();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+function renderFeed(rows, network) {
+  const header = `${accent("\u25C8")} ${bold("Launches")} ${dim(`\xB7 ${network} \xB7 ${rows.length}`)}`;
+  if (rows.length === 0) {
+    return `${header}
+${dim("No launches in the scanned window. Widen it with --lookback, or --follow to stream new ones.")}`;
+  }
+  const columns = [
+    { header: "BLOCK", align: "right", priority: 90, cell: (r) => dim("#" + r.block) },
+    { header: "PAD", priority: 100, cell: (r) => r.launchpad === "noxa" ? accent("NOXA") : bold("Odyssey") },
+    { header: "TOKEN", priority: 95, cell: (r) => r.symbol ? bold(r.symbol) : gray(addr(r.token)) },
+    { header: "ADDRESS", priority: 50, cell: (r) => gray(addr(r.token)) },
+    { header: "CREATOR", priority: 40, cell: (r) => gray(addr(r.creator)) },
+    { header: "POOL", priority: 30, cell: (r) => r.pool ? gray(addr(r.pool)) : dim("curve") }
+  ];
+  return `${header}
+${renderTable(rows, columns)}`;
+}
+
+// src/commands/portfolio.ts
+import { Command as Command5 } from "commander";
+import { formatEther as formatEther2, getAddress as getAddress2, isAddress as isAddress2 } from "viem";
+function portfolioCommand() {
+  return new Command5("portfolio").description("Multiplier-correct Stock Token positions + USD totals for an address").argument("<address>", "wallet address to inspect").option("--max-age <seconds>", "max acceptable Chainlink answer age").action(
+    (address, opts, command) => runWith(command, async (ctx) => {
+      await portfolio(ctx, address, opts);
+    })
+  );
+}
+async function portfolio(ctx, address, opts) {
+  if (!isAddress2(address)) throw usageError(`"${address}" is not a valid address.`);
+  const owner = getAddress2(address);
+  const client = ctx.read();
+  const maxAgeSeconds = opts.maxAge ? Number(opts.maxAge) : void 0;
+  const { port, usdg, eth } = await withSpinner(`Reading ${addr(owner)}\u2026`, async () => {
+    const [port2, usdg2, eth2] = await Promise.all([
+      getPortfolio(client, owner, maxAgeSeconds ? { maxAgeSeconds } : {}),
+      getUsdgBalance(client, owner),
+      client.public.getBalance({ address: owner })
+    ]);
+    return { port: port2, usdg: usdg2, eth: eth2 };
+  });
+  const held = port.positions.filter((p) => p.balance > 0n);
+  const usdgFloat = Number(formatUsdg(usdg));
+  const grandTotal = port.totalUsd + usdgFloat;
+  const json = {
+    owner,
+    network: ctx.network,
+    eth: formatEther2(eth),
+    usdg: formatUsdg(usdg),
+    stockValueUsd: port.totalUsd,
+    totalUsd: grandTotal,
+    unpricedSymbols: port.unpricedSymbols,
+    positions: held.map((p) => ({
+      symbol: p.symbol,
+      address: p.address,
+      balance: p.balanceTokens,
+      shareEquivalent: p.shareEquivalent,
+      priceUsd: p.quote?.priceUsd ?? null,
+      valueUsd: p.valueUsd
+    }))
+  };
+  printResult(json, () => renderPortfolio(owner, held, eth, usdgFloat, port.totalUsd, grandTotal, port.unpricedSymbols, ctx.network), ctx.json);
+}
+function renderPortfolio(owner, held, eth, usdg, stockUsd, total, unpriced, network) {
+  const header = `${accent("\u25C8")} ${bold("Portfolio")} ${dim("\xB7 " + addr(owner) + " \xB7 " + network)}`;
+  const summary = renderKeyValue(
+    [
+      ["ETH", num(Number(formatEther2(eth)), 6)],
+      ["USDG", usd(usdg)],
+      ["Stocks", usd(stockUsd)],
+      ["Total", bold(usd(total))]
+    ],
+    { labelWidth: 7 }
+  );
+  if (held.length === 0) {
+    return `${header}
+${summary}
+
+${dim("No Stock Token positions. Fund with `hood swap --sell USDG --buy <ticker>`.")}`;
+  }
+  const sorted = [...held].sort((a, b) => (b.valueUsd ?? -1) - (a.valueUsd ?? -1));
+  const columns = [
+    { header: "SYMBOL", priority: 100, cell: (p) => bold(p.symbol) },
+    { header: "BALANCE", align: "right", priority: 90, cell: (p) => num(p.balanceTokens, 4) },
+    { header: "SHARES", align: "right", priority: 60, cell: (p) => num(p.shareEquivalent, 4) },
+    { header: "PRICE", align: "right", priority: 70, cell: (p) => p.quote ? usd(p.quote.priceUsd) : dim("\u2014") },
+    { header: "VALUE", align: "right", priority: 95, cell: (p) => p.valueUsd !== null ? bold(usd(p.valueUsd)) : dim("unpriced") },
+    { header: "ADDRESS", priority: 20, cell: (p) => gray(addr(p.address)) }
+  ];
+  const footNote = unpriced.length > 0 ? "\n" + dim(`Unpriced (no fresh feed): ${unpriced.join(", ")}`) : "";
+  return `${header}
+${summary}
+
+${renderTable(sorted, columns)}${footNote}`;
+}
+
+// src/commands/tx.ts
+import { Command as Command6 } from "commander";
+import { decodeEventLog, formatEther as formatEther3, formatGwei, isHash } from "viem";
+
+// src/blockscout.ts
+var TESTNET_EXPLORER_URL = "https://explorer.testnet.chain.robinhood.com";
+function explorerBase(network) {
+  return network === "testnet" ? TESTNET_EXPLORER_URL : MAINNET_EXPLORER_URL;
+}
+function txUrl(network, hash) {
+  return `${explorerBase(network)}/tx/${hash}`;
+}
+function addressUrl(network, address) {
+  return `${explorerBase(network)}/address/${address}`;
+}
+async function get(network, path, timeoutMs = 6e3) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${explorerBase(network)}/api/v2${path}`, {
+      signal: controller.signal,
+      headers: { accept: "application/json" }
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function fetchTx(network, hash) {
+  return get(network, `/transactions/${hash}`);
+}
+function fetchToken(network, address) {
+  return get(network, `/tokens/${address}`);
+}
+
+// src/commands/tx.ts
+function txCommand() {
+  return new Command6("tx").description("Decode a transaction: status, transfers, gas, method").argument("<hash>", "transaction hash").action(
+    (hash, _opts, command) => runWith(command, async (ctx) => {
+      await tx(ctx, hash);
+    })
+  );
+}
+async function tx(ctx, hash) {
+  if (!isHash(hash)) throw usageError(`"${hash}" is not a 32-byte transaction hash.`);
+  const client = ctx.read();
+  const { transaction, receipt, block, meta } = await withSpinner("Fetching transaction\u2026", async () => {
+    const transaction2 = await client.public.getTransaction({ hash }).catch(() => null);
+    if (!transaction2) throw notFoundError(`No transaction ${hash} on ${ctx.network}.`);
+    const [receipt2, meta2] = await Promise.all([
+      client.public.getTransactionReceipt({ hash }).catch(() => null),
+      fetchTx(ctx.network, hash)
+    ]);
+    const block2 = receipt2 ? await client.public.getBlock({ blockNumber: receipt2.blockNumber }).catch(() => null) : null;
+    return { transaction: transaction2, receipt: receipt2, block: block2, meta: meta2 };
+  });
+  const raw = [];
+  for (const log of receipt?.logs ?? []) {
+    try {
+      const decoded = decodeEventLog({ abi: erc20Abi, data: log.data, topics: log.topics });
+      if (decoded.eventName !== "Transfer") continue;
+      const args = decoded.args;
+      const known = ctx.network === "mainnet" ? getStockTokenByAddress(log.address) : null;
+      raw.push({
+        token: log.address,
+        from: args.from,
+        to: args.to,
+        rawValue: args.value,
+        knownSymbol: known?.symbol ?? null,
+        knownDecimals: known?.decimals ?? null
+      });
+    } catch {
+    }
+  }
+  const unknownAddresses = [...new Set(raw.filter((r) => r.knownSymbol === null).map((r) => r.token.toLowerCase()))];
+  const resolved = /* @__PURE__ */ new Map();
+  await pMap(
+    unknownAddresses,
+    async (lower) => {
+      const address = raw.find((r) => r.token.toLowerCase() === lower).token;
+      const [symbol, decimals] = await Promise.all([
+        client.public.readContract({ address, abi: erc20Abi, functionName: "symbol" }).catch(() => "TOKEN"),
+        client.public.readContract({ address, abi: erc20Abi, functionName: "decimals" }).catch(() => 18)
+      ]);
+      resolved.set(lower, { symbol: String(symbol), decimals: Number(decimals) });
+    },
+    8
+  );
+  const transfers = raw.map((r) => {
+    const known = r.knownSymbol !== null && r.knownDecimals !== null;
+    const meta2 = known ? { symbol: r.knownSymbol, decimals: r.knownDecimals } : resolved.get(r.token.toLowerCase());
+    return {
+      token: r.token,
+      symbol: meta2?.symbol ?? null,
+      from: r.from,
+      to: r.to,
+      value: meta2 ? tokenAmount(r.rawValue, meta2.decimals) : r.rawValue.toString()
+    };
+  });
+  const status = receipt ? receipt.status === "success" ? "success" : "reverted" : "pending";
+  const gasUsed = receipt?.gasUsed ?? 0n;
+  const gasPrice = receipt?.effectiveGasPrice ?? transaction.gasPrice ?? 0n;
+  const feeEth = formatEther3(gasUsed * gasPrice);
+  const json = {
+    hash,
+    network: ctx.network,
+    status,
+    block: receipt?.blockNumber?.toString() ?? null,
+    timestamp: block ? Number(block.timestamp) : null,
+    from: transaction.from,
+    to: transaction.to,
+    valueEth: formatEther3(transaction.value),
+    nonce: transaction.nonce,
+    method: meta?.decoded_input?.method_call ?? meta?.method ?? null,
+    gasUsed: gasUsed.toString(),
+    gasPriceGwei: formatGwei(gasPrice),
+    feeEth,
+    transfers,
+    explorer: txUrl(ctx.network, hash)
+  };
+  printResult(json, () => renderTx(json, status, transfers), ctx.json);
+}
+function renderTx(j, status, transfers) {
+  const statusBadge = status === "success" ? green("\u25CF success") : status === "reverted" ? red("\u25CF reverted") : dim("\u25CF pending");
+  const header = `${accent("\u25C8")} ${bold("Transaction")} ${dim(addr(j.hash))}  ${statusBadge}`;
+  const pairs = [
+    ["From", gray(j.from ? addr(j.from) : "\u2014")],
+    ["To", gray(j.to ? addr(j.to) : dim("contract creation"))],
+    ["Value", j.valueEth === "0" ? dim("0 ETH") : bold(num(Number(j.valueEth), 8) + " ETH")],
+    ["Method", j.method ? bold(j.method) : dim("\u2014")],
+    ["Block", j.block ? "#" + j.block : dim("pending")],
+    ["When", j.timestamp ? dim(timestamp(j.timestamp)) : dim("\u2014")],
+    ["Gas used", dim(num(Number(j.gasUsed), 0) + ` @ ${num(Number(j.gasPriceGwei), 4)} gwei`)],
+    ["Fee", num(Number(j.feeEth), 8) + " ETH"],
+    ["Explorer", gray(j.explorer)]
+  ];
+  let out = `${header}
+${renderKeyValue(pairs, { labelWidth: 9 })}`;
+  if (transfers.length) {
+    const lines = transfers.map(
+      (t) => `  ${gray(addr(t.from))} ${dim("\u2192")} ${gray(addr(t.to))}  ${bold(t.value)} ${t.symbol ? accent(t.symbol) : gray(addr(t.token))}`
+    );
+    out += `
+
+${dim("Token transfers")}
+${lines.join("\n")}`;
+  }
+  return out;
+}
+
+// src/commands/token.ts
+import { Command as Command7 } from "commander";
+function tokenCommand() {
+  return new Command7("token").description("Inspect a token: metadata, supply, multiplier, price").argument("<address>", "token address or ticker").action(
+    (address, _opts, command) => runWith(command, async (ctx) => {
+      await token(ctx, address);
+    })
+  );
+}
+async function token(ctx, input) {
+  const client = ctx.read();
+  const resolved = await resolveToken(client, input);
+  const { meta, multiplier, oracle, dexUsd, totalSupply } = await withSpinner(`Reading ${resolved.symbol}\u2026`, async () => {
+    const [meta2, multiplier2, oracle2, dexUsd2, totalSupply2] = await Promise.all([
+      fetchToken(ctx.network, resolved.address),
+      resolved.isStock ? getMultiplier(client, resolved.symbol) : Promise.resolve(null),
+      resolved.hasFeed ? getOracleQuote(client, resolved.symbol) : Promise.resolve(null),
+      getDexPriceUsd(client, resolved.address, resolved.decimals),
+      client.public.readContract({ address: resolved.address, abi: erc20Abi, functionName: "totalSupply" }).catch(() => null)
+    ]);
+    return { meta: meta2, multiplier: multiplier2, oracle: oracle2, dexUsd: dexUsd2, totalSupply: totalSupply2 };
+  });
+  const json = {
+    address: resolved.address,
+    symbol: meta?.symbol ?? resolved.symbol,
+    name: meta?.name ?? null,
+    decimals: resolved.decimals,
+    isStockToken: resolved.isStock,
+    totalSupply: totalSupply !== null ? Number(totalSupply) / 10 ** resolved.decimals : null,
+    holders: meta?.holders_count ? Number(meta.holders_count) : meta?.holders ? Number(meta.holders) : null,
+    uiMultiplier: multiplier !== null ? Number(multiplier) / 1e18 : null,
+    oracleUsd: oracle?.priceUsd ?? null,
+    oracleAgeSeconds: oracle?.ageSeconds ?? null,
+    dexUsd,
+    explorer: addressUrl(ctx.network, resolved.address)
+  };
+  printResult(json, () => renderToken(json, resolved.isStock), ctx.json);
+}
+function renderToken(j, isStock) {
+  const header = `${accent("\u25C8")} ${bold(j.symbol)} ${dim(j.name ? "\xB7 " + j.name : "")}`;
+  const pairs = [
+    ["Address", gray(addr(j.address))],
+    ["Decimals", String(j.decimals)],
+    ["Supply", j.totalSupply !== null ? num(j.totalSupply, 0) : dim("\u2014")],
+    ["Holders", j.holders !== null ? num(j.holders, 0) : dim("\u2014")]
+  ];
+  if (isStock) {
+    pairs.push(["Multiplier", j.uiMultiplier !== null ? `${num(j.uiMultiplier, 6)}\xD7` : dim("n/a")]);
+    pairs.push(["Oracle", j.oracleUsd !== null ? bold(usd(j.oracleUsd)) : dim("no feed")]);
+    if (j.oracleAgeSeconds !== null) pairs.push(["Updated", dim(age(j.oracleAgeSeconds) + " ago")]);
+  }
+  pairs.push(["DEX price", j.dexUsd !== null ? usd(j.dexUsd) : dim("no pool")]);
+  pairs.push(["Explorer", gray(j.explorer)]);
+  return `${header}
+${renderKeyValue(pairs, { labelWidth: 10 })}`;
+}
+
+// src/commands/watch.ts
+import { Command as Command8 } from "commander";
+import { formatEther as formatEther4, getAddress as getAddress3, isAddress as isAddress3 } from "viem";
+function watchCommand() {
+  return new Command8("watch").description("Live activity stream for an address or a token (ERC-20 transfers + native ETH)").argument("<addrOrToken>", "wallet address, token address, or ticker to watch").option("--token", "treat the argument as a token (stream ALL transfers of it)", false).action(
+    (target, opts, command) => runWith(command, async (ctx) => {
+      await watch(ctx, target, opts);
+    })
+  );
+}
+async function watch(ctx, target, opts) {
+  const client = ctx.read();
+  if (opts.token || !isAddress3(target)) {
+    const token2 = await resolveToken(client, target);
+    process.stderr.write(dim(`Watching ${token2.symbol} transfers (${addr(token2.address)}) \u2014 Ctrl-C to stop
+`));
+    const unwatch = watchTransfers(client, { token: token2.address }, (t) => {
+      if (ctx.json) {
+        process.stdout.write(JSON.stringify({ ...t, value: t.value.toString() }) + "\n");
+      } else {
+        process.stdout.write(
+          `${gray(addr(t.from))} ${dim("\u2192")} ${gray(addr(t.to))}  ${bold(tokenAmount(t.value, token2.decimals))} ${accent(token2.symbol)}  ${dim("#" + t.blockNumber)}
+`
+        );
+      }
+    });
+    return runUntilInterrupt(unwatch);
+  }
+  if (ctx.network !== "mainnet") throw usageError("Address-mode watch needs the mainnet Stock Token registry \u2014 pass --token for a specific testnet token.");
+  const owner = getAddress3(target);
+  process.stderr.write(dim(`Watching ${addr(owner)} for activity \u2014 Ctrl-C to stop
+`));
+  const unwatchEth = client.public.watchBlocks({
+    onBlock: async (block) => {
+      for (const txHash of block.transactions) {
+        const tx2 = await client.public.getTransaction({ hash: txHash }).catch(() => null);
+        if (!tx2) continue;
+        if (tx2.from.toLowerCase() !== owner.toLowerCase() && tx2.to?.toLowerCase() !== owner.toLowerCase()) continue;
+        if (tx2.value === 0n) continue;
+        const out = tx2.from.toLowerCase() === owner.toLowerCase();
+        const line = `${out ? red("\u2191") : green("\u2193")} ${bold(formatEther4(tx2.value))} ETH  ${dim(out ? "to" : "from")} ${gray(addr(out ? tx2.to : tx2.from))}  ${dim("#" + block.number)}`;
+        if (ctx.json) process.stdout.write(JSON.stringify({ kind: "eth", hash: tx2.hash, from: tx2.from, to: tx2.to, valueEth: formatEther4(tx2.value), block: block.number.toString() }) + "\n");
+        else process.stdout.write(line + "\n");
+      }
+    }
+  });
+  const { MAINNET_ADDRESSES: MAINNET_ADDRESSES2 } = await import("./dist-PVZTS5LZ.js");
+  const unwatchUsdg = watchTransfers(client, { token: MAINNET_ADDRESSES2.usdg }, (t) => {
+    if (t.from.toLowerCase() !== owner.toLowerCase() && t.to.toLowerCase() !== owner.toLowerCase()) return;
+    const out = t.from.toLowerCase() === owner.toLowerCase();
+    if (ctx.json) {
+      process.stdout.write(JSON.stringify({ kind: "usdg", ...t, value: t.value.toString() }) + "\n");
+    } else {
+      process.stdout.write(
+        `${out ? red("\u2191") : green("\u2193")} ${bold(tokenAmount(t.value, 6))} USDG  ${dim(out ? "to" : "from")} ${gray(addr(out ? t.to : t.from))}  ${dim("#" + t.blockNumber)}
+`
+      );
+    }
+  });
+  return runUntilInterrupt(() => {
+    unwatchEth();
+    unwatchUsdg();
+  });
+}
+function runUntilInterrupt(unwatch) {
+  const shutdown = () => {
+    unwatch();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  return new Promise(() => {
+  });
+}
+
+// src/commands/swap.ts
+import { Command as Command9 } from "commander";
+import { formatUnits as formatUnits3, parseUnits as parseUnits2 } from "viem";
+
+// src/spend-cap.ts
+function checkSpendCap({ maxSpendUsd, estimatedUsd }) {
+  if (maxSpendUsd === void 0) return;
+  if (estimatedUsd === null) return;
+  if (estimatedUsd > maxSpendUsd) {
+    throw guardError(
+      `This spends ~$${estimatedUsd.toFixed(2)}, which exceeds your configured cap of $${maxSpendUsd.toFixed(2)}.`,
+      "Raise the cap with `hood config set maxSpendUsd <n>`, or reduce --amount."
+    );
+  }
+}
+
+// src/commands/swap.ts
+function swapCommand() {
+  return new Command9("swap").description("Quote (default) or execute a Uniswap v3 swap between two tokens").requiredOption("--sell <token>", "ticker or address to sell (e.g. USDG)").requiredOption("--buy <token>", "ticker or address to buy").requiredOption("--amount <amount>", "amount of --sell to spend, in whole tokens").option("--slippage <bps>", "slippage tolerance in basis points", "50").option("--execute", "sign and send (default: quote only)", false).action(
+    (opts, command) => runWith(command, async (ctx) => {
+      await swap(ctx, opts);
+    })
+  );
+}
+async function swap(ctx, opts) {
+  const slippageBps = Number(opts.slippage);
+  if (!Number.isFinite(slippageBps) || slippageBps < 0 || slippageBps > 5e3) {
+    throw usageError("--slippage must be a basis-point value between 0 and 5000 (50%).");
+  }
+  const client = opts.execute ? await ctx.wallet() : ctx.read();
+  const [tokenIn, tokenOut] = await Promise.all([resolveToken(client, opts.sell), resolveToken(client, opts.buy)]);
+  const amountIn = parseUnits2(opts.amount, tokenIn.decimals);
+  if (amountIn <= 0n) throw usageError("--amount must be greater than zero.");
+  const quote = await withSpinner(
+    `Quoting ${tokenIn.symbol} \u2192 ${tokenOut.symbol}\u2026`,
+    () => quoteSwap(client, { tokenIn: tokenIn.address, tokenOut: tokenOut.address, amountIn })
+  );
+  const amountOut = formatUnits3(quote.amountOut, tokenOut.decimals);
+  const minOut = formatUnits3(quote.amountOut * BigInt(1e4 - slippageBps) / 10000n, tokenOut.decimals);
+  const rate = Number(amountOut) / Number(opts.amount);
+  const summary = {
+    network: ctx.network,
+    sell: { symbol: tokenIn.symbol, amount: opts.amount },
+    buy: { symbol: tokenOut.symbol, amount: amountOut, minimum: minOut },
+    rate,
+    hops: quote.route.fees.length,
+    slippageBps
+  };
+  if (!opts.execute) {
+    printResult(summary, () => renderQuote(summary, false), ctx.json);
+    return;
+  }
+  const estimatedUsd = await estimateSpendUsd(client, tokenIn.symbol, tokenIn.address, tokenIn.decimals, Number(opts.amount));
+  if (ctx.config.maxSpendUsd !== void 0 && estimatedUsd === null) {
+    warn(`Could not verify this swap against your $${ctx.config.maxSpendUsd} spend cap (no price route for ${tokenIn.symbol}) \u2014 proceeding.`);
+  }
+  checkSpendCap({ maxSpendUsd: ctx.config.maxSpendUsd, estimatedUsd });
+  if (!ctx.json) process.stdout.write(renderQuote(summary, true) + "\n\n");
+  if (!ctx.assumeYes) {
+    const ok = await confirm(`Swap ${opts.amount} ${tokenIn.symbol} for ~${num(Number(amountOut), 6)} ${tokenOut.symbol}?`);
+    if (!ok) throw guardError("Swap cancelled.");
+  }
+  try {
+    const approvalHash = await withSpinner(
+      `Checking ${tokenIn.symbol} allowance\u2026`,
+      () => ensureApproval(client, tokenIn.address, amountIn)
+    );
+    if (approvalHash && !ctx.json) process.stderr.write(dim(`Approved router: ${txUrl(ctx.network, approvalHash)}
+`));
+    const tx2 = buildSwapTx(client, quote, { slippageBps });
+    const hash = await withSpinner(
+      "Sending swap\u2026",
+      () => client.wallet.sendTransaction({ to: tx2.to, data: tx2.data, value: tx2.value, account: client.account, chain: client.chain })
+    );
+    const receipt = await withSpinner("Confirming\u2026", () => client.public.waitForTransactionReceipt({ hash }));
+    const result = { ...summary, hash, status: receipt.status, explorer: txUrl(ctx.network, hash) };
+    printResult(result, () => renderResult(result), ctx.json);
+    if (receipt.status !== "success") process.exitCode = 1;
+  } catch (err) {
+    if (err instanceof StockTokenEligibilityError) {
+      throw guardError(
+        "Stock Token acquisition is gated for non-affirmed operators.",
+        "Re-run with --acknowledge-eligibility if you are eligible (not a US/CA/UK/CH person)."
+      );
+    }
+    throw err;
+  }
+}
+async function estimateSpendUsd(client, symbol, address, decimals, amount) {
+  if (symbol === "USDG") return amount;
+  const perToken = await getDexPriceUsd(client, address, decimals);
+  return perToken !== null ? perToken * amount : null;
+}
+function renderQuote(s, confirming) {
+  const header = confirming ? `${yellow("\u26A0")}  ${bold("Confirm swap")} ${dim("\xB7 " + s.network)}` : `${accent("\u25C8")} ${bold("Swap quote")} ${dim("\xB7 " + s.network + " \xB7 add --execute to send")}`;
+  const pairs = [
+    ["Sell", bold(s.sell.amount) + " " + s.sell.symbol],
+    ["Buy", bold(`~${s.buy.amount}`) + " " + s.buy.symbol],
+    ["Min. received", dim(s.buy.minimum + " " + s.buy.symbol + ` (${(s.slippageBps / 100).toFixed(2)}% slippage)`)],
+    ["Rate", `1 ${s.sell.symbol} \u2248 ${num(s.rate, 6)} ${s.buy.symbol}`],
+    ["Route", dim(s.hops === 1 ? "direct pool" : `${s.hops}-hop route`)]
+  ];
+  return `${header}
+${renderKeyValue(pairs, { labelWidth: 14 })}`;
+}
+function renderResult(r) {
+  const badge = r.status === "success" ? green("\u2713 swap confirmed") : dim("\u2717 reverted");
+  return `${badge}
+${renderKeyValue(
+    [
+      ["Received", bold(`~${r.buy.amount}`) + " " + r.buy.symbol],
+      ["Tx", gray(addr(r.hash))],
+      ["Explorer", gray(r.explorer)]
+    ],
+    { labelWidth: 9 }
+  )}`;
+}
+
+// src/commands/transfer.ts
+import { Command as Command10 } from "commander";
+import { formatEther as formatEther5, formatUnits as formatUnits4, getAddress as getAddress4, isAddress as isAddress4, parseEther, parseUnits as parseUnits3 } from "viem";
+function transferCommand() {
+  return new Command10("transfer").description("Send ETH or an ERC-20 token to an address").requiredOption("--to <address>", "recipient address").requiredOption("--amount <amount>", "amount to send, in whole tokens").option("--token <token>", "ticker or address to send (default: native ETH)").action(
+    (opts, command) => runWith(command, async (ctx) => {
+      await transfer(ctx, opts);
+    })
+  );
+}
+async function transfer(ctx, opts) {
+  if (!isAddress4(opts.to)) throw usageError(`"${opts.to}" is not a valid recipient address.`);
+  const to = getAddress4(opts.to);
+  const client = await ctx.wallet();
+  const isNative = !opts.token;
+  const symbol = isNative ? "ETH" : (await resolveToken(client, opts.token)).symbol;
+  const tokenInfo = isNative ? null : await resolveToken(client, opts.token);
+  const amount = isNative ? parseEther(opts.amount) : parseUnits3(opts.amount, tokenInfo.decimals);
+  if (amount <= 0n) throw usageError("--amount must be greater than zero.");
+  const balance = isNative ? await client.public.getBalance({ address: client.account.address }) : await client.public.readContract({ address: tokenInfo.address, abi: erc20Abi, functionName: "balanceOf", args: [client.account.address] });
+  if (balance < amount) {
+    throw guardError(
+      `Insufficient balance: hold ${formatBalance(balance, isNative, tokenInfo?.decimals)} ${symbol}, need ${opts.amount}.`
+    );
+  }
+  const spendToken = isNative ? ctx.network === "testnet" ? TESTNET_ADDRESSES.weth : MAINNET_ADDRESSES.weth : tokenInfo.address;
+  const estimatedUsd = await estimateSpendUsd2(client, symbol, spendToken, isNative ? 18 : tokenInfo.decimals, Number(opts.amount));
+  if (ctx.config.maxSpendUsd !== void 0 && estimatedUsd === null) {
+    warn(`Could not verify this transfer against your $${ctx.config.maxSpendUsd} spend cap (no price route for ${symbol}) \u2014 proceeding.`);
+  }
+  checkSpendCap({ maxSpendUsd: ctx.config.maxSpendUsd, estimatedUsd });
+  if (!ctx.json) {
+    process.stdout.write(
+      renderConfirm({ to, amount: opts.amount, symbol, network: ctx.network }) + "\n\n"
+    );
+  }
+  if (!ctx.assumeYes) {
+    const ok = await confirm(`Send ${opts.amount} ${symbol} to ${addr(to)}?`);
+    if (!ok) throw guardError("Transfer cancelled.");
+  }
+  const hash = await withSpinner(
+    "Sending\u2026",
+    () => isNative ? client.wallet.sendTransaction({ to, value: amount, account: client.account, chain: client.chain }) : client.wallet.writeContract({ address: tokenInfo.address, abi: erc20Abi, functionName: "transfer", args: [to, amount], account: client.account, chain: client.chain })
+  );
+  const receipt = await withSpinner("Confirming\u2026", () => client.public.waitForTransactionReceipt({ hash }));
+  const result = { to, amount: opts.amount, symbol, hash, status: receipt.status, explorer: txUrl(ctx.network, hash) };
+  printResult(result, () => renderResult2(result), ctx.json);
+  if (receipt.status !== "success") process.exitCode = 1;
+}
+async function estimateSpendUsd2(client, symbol, address, decimals, amount) {
+  if (symbol === "USDG") return amount;
+  const perToken = await getDexPriceUsd(client, address, decimals);
+  return perToken !== null ? perToken * amount : null;
+}
+function formatBalance(balance, isNative, decimals) {
+  return isNative ? formatEther5(balance) : formatUnits4(balance, decimals ?? 18);
+}
+function renderConfirm(s) {
+  const header = `${yellow("\u26A0")}  ${bold("Confirm transfer")} ${dim("\xB7 " + s.network)}`;
+  const pairs = [
+    ["Amount", bold(s.amount) + " " + s.symbol],
+    ["To", gray(s.to)]
+  ];
+  return `${header}
+${renderKeyValue(pairs, { labelWidth: 7 })}`;
+}
+function renderResult2(r) {
+  const badge = r.status === "success" ? green("\u2713 transfer confirmed") : dim("\u2717 reverted");
+  return `${badge}
+${renderKeyValue(
+    [
+      ["Sent", bold(r.amount) + " " + r.symbol + " \u2192 " + addr(r.to)],
+      ["Tx", gray(addr(r.hash))],
+      ["Explorer", gray(r.explorer)]
+    ],
+    { labelWidth: 9 }
+  )}`;
+}
+
+// src/commands/faucet.ts
+import { Command as Command11 } from "commander";
+import { formatEther as formatEther6, formatUnits as formatUnits5 } from "viem";
+var FAUCET_URL = "https://faucet.testnet.chain.robinhood.com/";
+var CHAINLINK_FAUCET_URL = "https://faucets.chain.link/robinhood-testnet";
+function faucetCommand() {
+  return new Command11("faucet").description("Print testnet faucet instructions + current testnet balances").action(
+    (_opts, command) => runWith(command, async (ctx) => {
+      await faucet(ctx);
+    })
+  );
+}
+async function faucet(ctx) {
+  if (ctx.network !== "testnet") {
+    throw usageError("The faucet is testnet-only.", "Re-run with --network testnet.");
+  }
+  let address = null;
+  let balances = null;
+  try {
+    const client = await ctx.wallet();
+    address = client.account.address;
+    balances = await withSpinner("Reading testnet balances\u2026", async () => {
+      const owner = client.account.address;
+      const [eth, ...tokenBalances] = await Promise.all([
+        client.public.getBalance({ address: owner }),
+        ...Object.entries(TESTNET_STOCK_TOKENS).map(
+          ([symbol, token2]) => client.public.readContract({ address: token2, abi: erc20Abi, functionName: "balanceOf", args: [owner] }).then((b) => ({ symbol, balance: formatUnits5(b, 18) }))
+        )
+      ]);
+      return { eth: formatEther6(eth), tokens: tokenBalances };
+    });
+  } catch {
+  }
+  const json = {
+    network: "testnet",
+    chainId: 46630,
+    faucetUrl: FAUCET_URL,
+    chainlinkFaucetUrl: CHAINLINK_FAUCET_URL,
+    note: "The faucet requires Cloudflare Turnstile + Google Sign-In in a real browser and cannot be automated from a CLI. One claim per 24h drips testnet ETH plus 5 of each: TSLA, AMZN, PLTR, NFLX, AMD.",
+    address,
+    balances
+  };
+  printResult(json, () => renderFaucet(json), ctx.json);
+}
+function renderFaucet(j) {
+  const header = `${accent("\u25C8")} ${bold("Testnet faucet")} ${dim("\xB7 chain 46630")}`;
+  const instructions = [
+    dim("The faucet needs a browser session (Cloudflare Turnstile + Google Sign-In) \u2014"),
+    dim("this cannot be automated from a CLI. Claim once per 24h at:"),
+    "",
+    `  ${underline(j.faucetUrl)}`,
+    `  ${dim("Chainlink ETH top-up:")} ${underline(j.chainlinkFaucetUrl)}`,
+    "",
+    dim("Each claim drips testnet ETH + 5 of each: TSLA, AMZN, PLTR, NFLX, AMD.")
+  ].join("\n");
+  if (!j.address || !j.balances) {
+    return `${header}
+${instructions}
+
+${dim("No wallet configured \u2014 run `hood config set wallet` to see your testnet balances here.")}`;
+  }
+  const rows = [["ETH", num(Number(j.balances.eth), 6)]];
+  for (const t of j.balances.tokens) rows.push([t.symbol, num(Number(t.balance), 4)]);
+  return `${header}
+${instructions}
+
+${dim("Wallet " + j.address)}
+${renderKeyValue(rows, { labelWidth: 6 })}`;
+}
+
+// src/commands/deploy-token.ts
+import { Command as Command12 } from "commander";
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve } from "path";
+import { encodeDeployData } from "viem";
+
+// src/generated/erc20.ts
+var HOOD_TOKEN_ABI = [{ "inputs": [{ "internalType": "string", "name": "_name", "type": "string" }, { "internalType": "string", "name": "_symbol", "type": "string" }, { "internalType": "uint8", "name": "_decimals", "type": "uint8" }, { "internalType": "uint256", "name": "_initialSupply", "type": "uint256" }], "stateMutability": "nonpayable", "type": "constructor" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "owner", "type": "address" }, { "indexed": true, "internalType": "address", "name": "spender", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "Approval", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "from", "type": "address" }, { "indexed": true, "internalType": "address", "name": "to", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "Transfer", "type": "event" }, { "inputs": [{ "internalType": "address", "name": "", "type": "address" }, { "internalType": "address", "name": "", "type": "address" }], "name": "allowance", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "spender", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "approve", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "", "type": "address" }], "name": "balanceOf", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "decimals", "outputs": [{ "internalType": "uint8", "name": "", "type": "uint8" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "name", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "symbol", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "totalSupply", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "to", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "transfer", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "from", "type": "address" }, { "internalType": "address", "name": "to", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "transferFrom", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }];
+var HOOD_TOKEN_BYTECODE = "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";
+var HOOD_TOKEN_COMPILER = { "name": "solc", "version": "0.8.36+commit.8a079791.Emscripten.clang", "optimizer": { "enabled": true, "runs": 200 }, "evmVersion": "paris" };
+
+// src/commands/deploy-token.ts
+function deployTokenCommand() {
+  return new Command12("deploy-token").description("Deploy a fixed-supply ERC-20 from a JSON config (direct-rail, no launchpad)").requiredOption("--config <path>", "path to a JSON file: { name, symbol, decimals?, initialSupply }").option("--execute", "sign and send (default: print the plan only)", false).action(
+    (opts, command) => runWith(command, async (ctx) => {
+      await deployToken(ctx, opts);
+    })
+  );
+}
+async function deployToken(ctx, opts) {
+  const config = readConfig(opts.config);
+  const decimals = config.decimals ?? 18;
+  const deployData = encodeDeployData({
+    abi: HOOD_TOKEN_ABI,
+    bytecode: HOOD_TOKEN_BYTECODE,
+    args: [config.name, config.symbol, decimals, BigInt(config.initialSupply)]
+  });
+  const plan = {
+    network: ctx.network,
+    name: config.name,
+    symbol: config.symbol,
+    decimals,
+    initialSupply: config.initialSupply,
+    compiler: HOOD_TOKEN_COMPILER.version,
+    bytecodeBytes: (deployData.length - 2) / 2
+  };
+  if (!opts.execute) {
+    printResult(plan, () => renderPlan(plan, false), ctx.json);
+    return;
+  }
+  const client = await ctx.wallet();
+  if (!ctx.json) process.stdout.write(renderPlan(plan, true) + "\n\n");
+  if (!ctx.assumeYes) {
+    const ok = await confirm(`Deploy ${config.symbol} (${num(config.initialSupply, 0)} supply) on ${ctx.network}? This costs gas and cannot be undone.`);
+    if (!ok) throw guardError("Deploy cancelled.");
+  }
+  const hash = await withSpinner(
+    "Deploying\u2026",
+    () => client.wallet.deployContract({
+      abi: HOOD_TOKEN_ABI,
+      bytecode: HOOD_TOKEN_BYTECODE,
+      args: [config.name, config.symbol, decimals, BigInt(config.initialSupply)],
+      account: client.account,
+      chain: client.chain
+    })
+  );
+  const receipt = await withSpinner("Confirming\u2026", () => client.public.waitForTransactionReceipt({ hash }));
+  if (!receipt.contractAddress) {
+    throw guardError("Deployment transaction confirmed but returned no contract address.", "Check the transaction on the explorer.");
+  }
+  const result = {
+    ...plan,
+    hash,
+    status: receipt.status,
+    address: receipt.contractAddress,
+    explorer: txUrl(ctx.network, hash),
+    tokenExplorer: addressUrl(ctx.network, receipt.contractAddress)
+  };
+  printResult(result, () => renderResult3(result), ctx.json);
+  if (receipt.status !== "success") process.exitCode = 1;
+}
+function readConfig(path) {
+  let raw;
+  try {
+    raw = readFileSync3(resolve(path), "utf8");
+  } catch {
+    throw usageError(`Could not read config file "${path}".`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw usageError(`"${path}" is not valid JSON.`);
+  }
+  const c = parsed;
+  if (typeof c.name !== "string" || !c.name.trim()) throw usageError('Config "name" must be a non-empty string.');
+  if (typeof c.symbol !== "string" || !c.symbol.trim()) throw usageError('Config "symbol" must be a non-empty string.');
+  if (c.decimals !== void 0 && (!Number.isInteger(c.decimals) || c.decimals < 0 || c.decimals > 255)) {
+    throw usageError('Config "decimals" must be an integer 0-255.');
+  }
+  if (!Number.isInteger(c.initialSupply) || c.initialSupply <= 0) {
+    throw usageError('Config "initialSupply" must be a positive whole-token integer.');
+  }
+  return { name: c.name, symbol: c.symbol, decimals: c.decimals, initialSupply: c.initialSupply };
+}
+function renderPlan(p, confirming) {
+  const header = confirming ? `${yellow("\u26A0")}  ${bold("Confirm deploy")} ${dim("\xB7 " + p.network)}` : `${accent("\u25C8")} ${bold("Deploy plan")} ${dim("\xB7 " + p.network + " \xB7 add --execute to send")}`;
+  const pairs = [
+    ["Name", bold(p.name)],
+    ["Symbol", bold(p.symbol)],
+    ["Decimals", String(p.decimals)],
+    ["Supply", num(p.initialSupply, 0) + " " + p.symbol],
+    ["Compiler", dim(p.compiler)],
+    ["Bytecode", dim(p.bytecodeBytes + " bytes")]
+  ];
+  return `${header}
+${renderKeyValue(pairs, { labelWidth: 9 })}`;
+}
+function renderResult3(r) {
+  const badge = r.status === "success" ? green("\u2713 deployed") : dim("\u2717 reverted");
+  return `${badge}
+${renderKeyValue(
+    [
+      ["Token", bold(r.symbol) + "  " + gray(addr(r.address))],
+      ["Tx", gray(addr(r.hash))],
+      ["Explorer", gray(r.tokenExplorer)]
+    ],
+    { labelWidth: 9 }
+  )}`;
+}
+
+// src/commands/config.ts
+import { Command as Command13 } from "commander";
+import { getAddress as getAddress5 } from "viem";
+import { privateKeyToAccount as privateKeyToAccount2, generatePrivateKey } from "viem/accounts";
+function configCommand() {
+  const cmd = new Command13("config").description("Manage hood-cli settings (rpc, wallet, network)");
+  cmd.command("set <key> [value]").description(`set a config value (${CONFIG_KEYS.join(", ")}, wallet)`).action(async (key, value, _opts, command) => {
+    if (command.optsWithGlobals().color === false) setColorEnabled(false);
+    const json = !!command.optsWithGlobals().json;
+    if (key === "wallet") {
+      await setWallet(json, !!command.optsWithGlobals().yes);
+      return;
+    }
+    if (value === void 0) throw usageError(`"hood config set ${key}" needs a value.`);
+    const config = loadConfig();
+    const next = setConfigValue(config, key, value);
+    saveConfig(next);
+    if (json) printJson({ ok: true, key, value });
+    else printHuman(`${green("\u2713")} ${key} = ${value}`);
+  });
+  cmd.command("get <key>").description("print one config value").action((key, _opts, command) => {
+    const json = !!command.optsWithGlobals().json;
+    const view = redactedConfig(loadConfig());
+    if (!(key in view)) throw usageError(`Unknown config key "${key}".`, `Valid keys: ${Object.keys(view).join(", ")}.`);
+    const value = view[key];
+    if (json) printJson({ [key]: value });
+    else printHuman(String(value ?? dim("unset")));
+  });
+  cmd.command("list").description("print the full config (secrets masked)").action((_opts, command) => {
+    const json = !!command.optsWithGlobals().json;
+    const view = redactedConfig(loadConfig());
+    if (json) {
+      printJson(view);
+      return;
+    }
+    const pairs = Object.entries(view).map(([k, v]) => [k, v === null ? dim("unset") : String(v)]);
+    printHuman(`${accent("\u25C8")} ${bold("hood config")}
+${renderKeyValue(pairs, { labelWidth: 14 })}`);
+  });
+  return cmd;
+}
+async function setWallet(json, assumeYes) {
+  const config = loadConfig();
+  const keystorePath = config.walletKeystore ?? defaultKeystorePath();
+  if (keystoreExists(keystorePath) && !assumeYes) {
+    const overwrite = await confirm(`A wallet already exists at ${keystorePath}. Overwrite it?`);
+    if (!overwrite) throw guardError("Wallet setup cancelled.");
+  }
+  const importKey = process.env.ROBINHOOD_CHAIN_IMPORT_KEY;
+  const privateKey = importKey ? importKey.startsWith("0x") ? importKey : `0x${importKey}` : generatePrivateKey();
+  const account = privateKeyToAccount2(privateKey);
+  const password = await readPassword("New wallet password (min 8 chars):");
+  const confirmPassword = await readPassword("Confirm password:");
+  if (!passwordsMatch(password, confirmPassword)) throw guardError("Passwords did not match.");
+  writeKeystore(keystorePath, privateKey, getAddress5(account.address), password);
+  const next = { ...config, walletKeystore: keystorePath, walletAddress: account.address };
+  saveConfig(next);
+  const result = { ok: true, address: account.address, keystore: keystorePath, imported: !!importKey };
+  if (json) {
+    printJson(result);
+    return;
+  }
+  printHuman(
+    `${green("\u2713")} Wallet ${result.imported ? "imported" : "generated"}: ${bold(account.address)}
+` + dim(`  Encrypted keystore: ${keystorePath}`) + (result.imported ? "" : `
+${dim("  This is a NEW address \u2014 fund it before sending anything.")}`)
+  );
+}
+
+// src/program.ts
+function readVersion() {
+  const here = dirname3(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync4(join2(here, "..", "package.json"), "utf8"));
+  return pkg.version;
+}
+function createProgram() {
+  const program2 = new Command14();
+  program2.name("hood").description("The command-line toolkit for Robinhood Chain (4663) \u2014 instant reads, guarded writes.").version(readVersion(), "-v, --version").option("--json", "machine-readable JSON output").option("--network <net>", "mainnet | testnet", "mainnet").option("--rpc <url>", "override the RPC endpoint").option("--verbose", "show raw error causes").option("--yes", "skip interactive confirmation on writes (still requires --execute)").option("--acknowledge-eligibility", "affirm Stock Token acquisition eligibility (non-US/CA/UK/CH)").option("--no-color", "disable ANSI colour").showHelpAfterError("(run `hood --help` for usage)").configureOutput({
+    outputError: (str, write) => write(str)
+  });
+  program2.addCommand(priceCommand());
+  program2.addCommand(stocksCommand());
+  program2.addCommand(coinsCommand());
+  program2.addCommand(launchesCommand());
+  program2.addCommand(portfolioCommand());
+  program2.addCommand(txCommand());
+  program2.addCommand(tokenCommand());
+  program2.addCommand(watchCommand());
+  program2.addCommand(swapCommand());
+  program2.addCommand(transferCommand());
+  program2.addCommand(faucetCommand());
+  program2.addCommand(deployTokenCommand());
+  program2.addCommand(configCommand());
+  return program2;
+}
+
+// src/cli.ts
+var program = createProgram();
+program.exitOverride((err) => {
+  if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
+    process.exit(0);
+  }
+  process.exitCode = 2;
+  throw err;
+});
+process.on("unhandledRejection", (err) => {
+  process.exitCode = presentError(err, { json: process.argv.includes("--json"), verbose: process.argv.includes("--verbose") });
+});
+try {
+  await program.parseAsync(process.argv);
+} catch (err) {
+  if (process.exitCode === void 0) {
+    process.exitCode = presentError(err, { json: process.argv.includes("--json"), verbose: process.argv.includes("--verbose") });
+  }
+}
+//# sourceMappingURL=cli.js.map