@zoralabs/cli 0.2.2 → 0.2.4

package/dist/index.js

@@ -0,0 +1,4106 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { Command as Command11 } from "commander";
+import { ExitPromptError } from "@inquirer/core";
+import "fs";
+import { setApiBaseUrl } from "@zoralabs/coins-sdk";
+
+// src/commands/auth.ts
+import { Command } from "commander";
+
+// src/lib/config.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  chmodSync
+} from "fs";
+import { join } from "path";
+import { homedir, platform } from "os";
+function getConfigDir() {
+  if (platform() === "win32") {
+    return join(
+      process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"),
+      "zora"
+    );
+  }
+  return join(homedir(), ".config", "zora");
+}
+var CONFIG_DIR = getConfigDir();
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var WALLET_FILE = join(CONFIG_DIR, "wallet.json");
+var CONFIG_VERSION = 1;
+var WALLET_VERSION = 1;
+function assertVersion(parsed, expectedVersion, filePath) {
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`${filePath}: expected an object`);
+  }
+  const obj = parsed;
+  if (!("version" in obj)) {
+    throw new Error(`${filePath}: missing required field "version"`);
+  }
+  if (obj.version !== expectedVersion) {
+    throw new Error(
+      `${filePath}: unsupported version ${obj.version} (expected ${expectedVersion})`
+    );
+  }
+}
+var configReadOnly = false;
+function readConfig() {
+  if (!existsSync(CONFIG_FILE)) return { version: CONFIG_VERSION };
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch (err) {
+    console.error(
+      `Warning: could not parse ${CONFIG_FILE}: ${err.message}. Run 'zora auth configure' to fix.`
+    );
+    configReadOnly = true;
+    return { version: CONFIG_VERSION };
+  }
+  try {
+    assertVersion(parsed, CONFIG_VERSION, CONFIG_FILE);
+  } catch (err) {
+    console.error(
+      `Warning: ${err.message}. Delete ${CONFIG_FILE} or run 'zora auth configure' to reset.`
+    );
+    configReadOnly = true;
+    return { version: CONFIG_VERSION };
+  }
+  return parsed;
+}
+var IS_WINDOWS = platform() === "win32";
+function writeSecure(filePath, data) {
+  writeFileSync(filePath, data, IS_WINDOWS ? {} : { mode: 384 });
+  if (!IS_WINDOWS) {
+    chmodSync(filePath, 384);
+  }
+}
+function writeConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeSecure(
+    CONFIG_FILE,
+    JSON.stringify({ ...config, version: CONFIG_VERSION }, null, 2) + "\n"
+  );
+}
+function readWallet() {
+  if (!existsSync(WALLET_FILE)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(WALLET_FILE, "utf-8"));
+  } catch (err) {
+    throw new Error(`${WALLET_FILE}: ${err.message}`);
+  }
+  assertVersion(parsed, WALLET_VERSION, WALLET_FILE);
+  const obj = parsed;
+  if (typeof obj.privateKey !== "string" || !obj.privateKey) {
+    throw new Error(`${WALLET_FILE}: missing or invalid "privateKey" field`);
+  }
+  return parsed;
+}
+function writeWallet(wallet) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeSecure(
+    WALLET_FILE,
+    JSON.stringify({ ...wallet, version: WALLET_VERSION }, null, 2) + "\n"
+  );
+}
+function getEnvApiKey() {
+  const envKey = process.env.ZORA_API_KEY;
+  if (envKey === void 0) return void 0;
+  if (!envKey) {
+    console.error(
+      "ZORA_API_KEY is set but empty. Provide a valid key or unset the variable."
+    );
+    process.exit(1);
+  }
+  return envKey;
+}
+function getApiKey() {
+  return getEnvApiKey() ?? readConfig().apiKey;
+}
+function saveApiKey(apiKey) {
+  const config = readConfig();
+  config.apiKey = apiKey;
+  writeConfig(config);
+}
+function getPrivateKey() {
+  return readWallet()?.privateKey;
+}
+function savePrivateKey(privateKey) {
+  writeWallet({ privateKey });
+}
+function getWalletPath() {
+  return WALLET_FILE;
+}
+function getAnalyticsId() {
+  return readConfig().analyticsId;
+}
+function saveAnalyticsId(id) {
+  if (configReadOnly) return;
+  const config = readConfig();
+  config.analyticsId = id;
+  writeConfig(config);
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+// src/lib/mask-key.ts
+function maskKey(key) {
+  if (key.length <= 12) return "***";
+  return key.slice(0, 8) + "..." + key.slice(-4);
+}
+
+// src/lib/output.ts
+var VALID_OUTPUT_MODES = ["table", "json", "live"];
+var getOutputMode = (cmd, defaultMode) => {
+  const raw = cmd.optsWithGlobals().output;
+  if (!raw) return defaultMode;
+  if (VALID_OUTPUT_MODES.includes(raw)) return raw;
+  return outputErrorAndExit(
+    false,
+    `Invalid --output value: ${raw}.`,
+    `Supported: ${VALID_OUTPUT_MODES.join(", ")}`
+  );
+};
+var getJson = (cmd) => getOutputMode(cmd, "table") === "json";
+var getYes = (cmd) => cmd.optsWithGlobals().yes ?? false;
+var outputJson = (data) => {
+  console.log(JSON.stringify(data, null, 2));
+};
+var outputErrorAndExit = (json, message, suggestion) => {
+  if (json) {
+    const payload = { error: message };
+    if (suggestion) payload.suggestion = suggestion;
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.error(`\x1B[31mError:\x1B[0m ${message}`);
+    if (suggestion) {
+      console.error(`\x1B[2m${suggestion}\x1B[0m`);
+    }
+  }
+  process.exit(1);
+};
+var outputData = (json, opts) => {
+  if (json) {
+    outputJson(opts.json);
+  } else {
+    opts.table();
+  }
+};
+var getLiveConfig = (cmd, defaultMode) => {
+  const mode = getOutputMode(cmd, defaultMode);
+  const live = mode === "live";
+  const intervalRaw = parseInt(cmd.optsWithGlobals().interval, 10);
+  const intervalSeconds = isNaN(intervalRaw) || intervalRaw < 5 ? 30 : intervalRaw;
+  return { live, intervalSeconds };
+};
+
+// src/lib/prompt.ts
+import confirm from "@inquirer/confirm";
+import select from "@inquirer/select";
+import password from "@inquirer/password";
+var confirmOrDefault = async (opts, nonInteractive) => {
+  if (nonInteractive) return true;
+  return confirm(opts);
+};
+var selectOrDefault = async (opts, nonInteractive) => {
+  if (nonInteractive) return opts.default;
+  return select(opts);
+};
+var passwordOrFail = async (json, opts, nonInteractive) => {
+  if (nonInteractive) {
+    outputErrorAndExit(
+      json,
+      "This command requires interactive input. Remove --yes to proceed."
+    );
+  }
+  return password(opts);
+};
+
+// src/lib/analytics.ts
+import { PostHog } from "posthog-node";
+import { createHash, randomUUID } from "crypto";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+
+// src/lib/constants.ts
+var BASE_CHAIN_ID = 8453;
+var WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
+var USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var ZORA_ADDRESS = "0x1111111111166b7FE7bd91427724B487980aFc69";
+var USDC_DECIMALS = 6;
+var BASE_TRADE_TOKENS = {
+  eth: {
+    symbol: "ETH",
+    decimals: 18,
+    trade: { type: "eth" },
+    priceAddress: WETH_ADDRESS,
+    fixedPriceUsd: void 0
+  },
+  usdc: {
+    symbol: "USDC",
+    decimals: USDC_DECIMALS,
+    trade: {
+      type: "erc20",
+      address: USDC_ADDRESS
+    },
+    priceAddress: USDC_ADDRESS,
+    fixedPriceUsd: 1
+  },
+  zora: {
+    symbol: "ZORA",
+    decimals: 18,
+    trade: {
+      type: "erc20",
+      address: ZORA_ADDRESS
+    },
+    priceAddress: ZORA_ADDRESS,
+    fixedPriceUsd: void 0
+  }
+};
+var POSTHOG_TOKEN = "phc_F3nLidy5mjn4xWQ6PYujO96MVig7UoszINhUUY0usOx";
+var POSTHOG_HOST = "https://us.i.posthog.com";
+
+// src/lib/wallet.ts
+import { apiPost } from "@zoralabs/coins-sdk";
+import { createPublicClient, createWalletClient, custom } from "viem";
+import { base } from "viem/chains";
+import { privateKeyToAccount } from "viem/accounts";
+var normalizeKey = (key) => key.startsWith("0x") ? key : `0x${key}`;
+var resolveAccount = (json = false) => {
+  const envKey = process.env.ZORA_PRIVATE_KEY;
+  const key = envKey || getPrivateKey();
+  if (!key) {
+    console.error(
+      "No wallet configured. Run 'zora setup' to create or import one."
+    );
+    return process.exit(1);
+  }
+  try {
+    return privateKeyToAccount(normalizeKey(key));
+  } catch (err) {
+    console.error(
+      `\u2717 Invalid private key: ${err instanceof Error ? err.message : String(err)}`
+    );
+    console.error("  Run 'zora setup --force' to replace it.");
+    return process.exit(1);
+  }
+};
+function formatRpcError(error) {
+  if (typeof error === "string") return error;
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === "object" && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return JSON.stringify(error);
+}
+function createCliRpcTransport(chainId = base.id) {
+  return custom({
+    async request({
+      method,
+      params
+    }) {
+      let response;
+      try {
+        response = await apiPost("/cli-rpc", {
+          chainId,
+          method,
+          params: params ?? []
+        });
+      } catch (err) {
+        throw new Error(`CLI RPC request failed: ${formatRpcError(err)}`);
+      }
+      if (response.error) {
+        throw new Error(
+          `CLI RPC request failed: ${formatRpcError(response.error)}`
+        );
+      }
+      const payload = response.data;
+      if (payload && typeof payload === "object" && "error" in payload && payload.error) {
+        throw new Error(
+          `CLI RPC request failed: ${formatRpcError(payload.error)}`
+        );
+      }
+      if (payload && typeof payload === "object" && "result" in payload) {
+        return payload.result;
+      }
+      return payload;
+    }
+  });
+}
+function createClients(account) {
+  const transport = createCliRpcTransport();
+  const publicClient = createPublicClient({
+    chain: base,
+    transport
+  });
+  const walletClient = createWalletClient({
+    chain: base,
+    transport,
+    account
+  });
+  return { publicClient, walletClient };
+}
+
+// src/lib/analytics.ts
+var SHUTDOWN_TIMEOUT_MS = 2e3;
+var client = null;
+var distinctId = null;
+var isDisabled = () => process.env.ZORA_NO_ANALYTICS === "1" || process.env.DO_NOT_TRACK === "1" || process.env.CI !== void 0 || process.env.NODE_ENV === "test";
+var getOrCreateDistinctId = () => {
+  if (distinctId) return distinctId;
+  try {
+    const stored = getAnalyticsId();
+    if (stored) {
+      distinctId = stored;
+      return distinctId;
+    }
+    distinctId = randomUUID();
+    saveAnalyticsId(distinctId);
+    return distinctId;
+  } catch {
+    distinctId = randomUUID();
+    return distinctId;
+  }
+};
+var getClient = () => {
+  if (!client) {
+    client = new PostHog(POSTHOG_TOKEN, { host: POSTHOG_HOST });
+  }
+  return client;
+};
+var commonProperties = () => ({
+  cli_version: true ? "0.2.4" : "development",
+  os: process.platform,
+  arch: process.arch,
+  node_version: process.version
+});
+var hashApiKey = (key) => createHash("sha256").update(key).digest("hex").slice(0, 16);
+var getWalletAddress = () => {
+  try {
+    const key = process.env.ZORA_PRIVATE_KEY || getPrivateKey();
+    if (!key) return void 0;
+    return privateKeyToAccount2(normalizeKey(key)).address;
+  } catch {
+    return void 0;
+  }
+};
+var identified = false;
+var identify = () => {
+  try {
+    if (isDisabled() || identified) return;
+    identified = true;
+    const id = getOrCreateDistinctId();
+    const apiKey = getApiKey();
+    const walletAddress = getWalletAddress();
+    if (!apiKey && !walletAddress) {
+      return;
+    }
+    getClient().identify({
+      distinctId: id,
+      properties: {
+        api_key_hash: apiKey ? hashApiKey(apiKey) : void 0,
+        wallet_address: walletAddress ?? void 0
+      }
+    });
+  } catch {
+  }
+};
+var track = (event, properties) => {
+  try {
+    if (isDisabled()) return;
+    getClient().capture({
+      distinctId: getOrCreateDistinctId(),
+      event,
+      properties: { ...commonProperties(), ...properties }
+    });
+  } catch {
+  }
+};
+var shutdownAnalytics = async () => {
+  if (!client) return;
+  const flushing = client;
+  client = null;
+  try {
+    await Promise.race([
+      flushing.shutdown(),
+      new Promise((resolve) => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS))
+    ]);
+  } catch {
+  }
+};
+
+// src/commands/auth.ts
+var authCommand = new Command("auth").description(
+  "Manage API key authentication.\nAPI key is optional \u2014 without one, requests are rate-limited.\nGet a key at https://zora.co/settings/developer"
+);
+authCommand.command("configure").description("Set your Zora API key").option("--yes", "Skip interactive prompt and execute directly").action(async function() {
+  const json = getJson(this);
+  const nonInteractive = getYes(this);
+  if (getEnvApiKey()) {
+    outputData(json, {
+      json: {
+        status: "env_override",
+        message: "API key is set via ZORA_API_KEY environment variable."
+      },
+      table: () => console.log(
+        "API key is set via ZORA_API_KEY environment variable. Unset it to configure manually."
+      )
+    });
+    return;
+  }
+  const existing = getApiKey();
+  if (existing) {
+    console.log(`Current key: ${maskKey(existing)}`);
+  }
+  console.log("Get your API key from: https://zora.co/settings/developer\n");
+  const apiKey = await passwordOrFail(
+    json,
+    { message: "Paste your API key:" },
+    nonInteractive
+  );
+  const trimmed = apiKey.trim();
+  if (!trimmed) {
+    outputErrorAndExit(
+      json,
+      "No API key provided.",
+      "Usage: zora auth configure"
+    );
+  }
+  try {
+    saveApiKey(trimmed);
+    outputData(json, {
+      json: { saved: true, path: getConfigPath() },
+      table: () => console.log(`API key saved to ${getConfigPath()}`)
+    });
+    track("cli_auth_configure", {
+      output_format: json ? "json" : "text"
+    });
+  } catch (err) {
+    outputErrorAndExit(
+      json,
+      `Failed to save API key: ${err.message}`
+    );
+  }
+});
+authCommand.command("status").description("Check authentication status").action(function() {
+  const json = getJson(this);
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    outputData(json, {
+      json: { authenticated: false },
+      table: () => {
+        console.log(
+          "No API key configured. The CLI works without one, but requests are rate-limited."
+        );
+        console.log(
+          "Run 'zora auth configure' to set an API key for higher rate limits."
+        );
+      }
+    });
+    track("cli_auth_status", {
+      authenticated: false,
+      source: null,
+      output_format: json ? "json" : "text"
+    });
+    return;
+  }
+  const source = getEnvApiKey() ? "env (ZORA_API_KEY)" : getConfigPath();
+  outputData(json, {
+    json: { authenticated: true, key: maskKey(apiKey), source },
+    table: () => {
+      console.log(`Authenticated: ${maskKey(apiKey)}`);
+      console.log(`Source: ${source}`);
+    }
+  });
+  track("cli_auth_status", {
+    authenticated: true,
+    source: getEnvApiKey() ? "env" : "file",
+    output_format: json ? "json" : "text"
+  });
+});
+
+// src/commands/balance.tsx
+import { Command as Command2 } from "commander";
+import { Box as Box3, Text as Text3 } from "ink";
+import { getProfileBalances, setApiKey } from "@zoralabs/coins-sdk";
+
+// src/lib/render.tsx
+import { render, renderToString } from "ink";
+var renderOnce = (element) => {
+  const columns = process.stdout.columns || 80;
+  const output = renderToString(element, { columns });
+  console.log(output);
+};
+var renderLive = async (element) => {
+  const instance = render(element);
+  await instance.waitUntilExit();
+};
+
+// src/components/BalanceView.tsx
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useRef } from "react";
+import { Box as Box2, Text as Text2, useInput, useApp } from "ink";
+import Spinner from "ink-spinner";
+
+// src/components/table.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var PADDING_LEFT = 1;
+var truncate = (str, max) => {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 1) + "\u2026";
+};
+var computeColumnWidths = (columns, fullWidth) => {
+  const baseWidths = columns.map((col) => col.width);
+  const totalBase = baseWidths.reduce((sum, w) => sum + w, 0);
+  if (!fullWidth) return baseWidths;
+  const width = process.stdout.columns ?? 80;
+  const available = width - PADDING_LEFT;
+  if (available <= totalBase) return baseWidths;
+  const computed = baseWidths.map(
+    (w) => Math.max(1, Math.floor(w / totalBase * available))
+  );
+  let remainder = available - computed.reduce((sum, w) => sum + w, 0);
+  for (let i = 0; i < computed.length && remainder > 0; i++) {
+    computed[i]++;
+    remainder--;
+  }
+  return computed;
+};
+var Table = ({
+  columns,
+  data,
+  title,
+  subtitle,
+  fullWidth = true,
+  footer
+}) => {
+  const widths = computeColumnWidths(columns, fullWidth);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingTop: 1, paddingBottom: 1, children: [
+    title && /* @__PURE__ */ jsxs(Box, { paddingLeft: PADDING_LEFT, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: title }),
+      subtitle && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " ",
+        subtitle
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { paddingLeft: PADDING_LEFT, children: columns.map((col, i) => /* @__PURE__ */ jsx(Box, { width: widths[i], children: /* @__PURE__ */ jsx(Text, { bold: true, dimColor: true, wrap: "truncate", children: col.header }) }, col.header)) }),
+    data.map((row, i) => /* @__PURE__ */ jsx(Box, { paddingLeft: PADDING_LEFT, children: columns.map((col, colIdx) => {
+      const colWidth = widths[colIdx];
+      const value = col.noTruncate ? col.accessor(row) : truncate(col.accessor(row), colWidth - 2);
+      const colorName = col.color?.(row);
+      return /* @__PURE__ */ jsx(Box, { width: colWidth, children: /* @__PURE__ */ jsx(
+        Text,
+        {
+          color: colorName,
+          wrap: col.noTruncate ? "wrap" : "truncate",
+          children: value
+        }
+      ) }, col.header);
+    }) }, i)),
+    footer && /* @__PURE__ */ jsx(Box, { paddingLeft: PADDING_LEFT, marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "wrap", children: footer }) })
+  ] });
+};
+
+// src/lib/format.ts
+import { format, formatDistanceStrict } from "date-fns";
+import { formatEther } from "viem";
+function formatCompactUsd(value) {
+  if (!value || Number(value) === 0) return "$0";
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    notation: "compact",
+    minimumFractionDigits: 1,
+    maximumFractionDigits: 1
+  }).format(Number(value));
+}
+var NO_CHANGE = { text: "-", color: void 0 };
+function formatMcapChange(marketCap, delta) {
+  if (!delta || !marketCap) return NO_CHANGE;
+  const currentMCap = Number(marketCap);
+  const absoluteDelta = Number(delta);
+  const previousMCap = currentMCap - absoluteDelta;
+  if (currentMCap === 0 || previousMCap === 0) return NO_CHANGE;
+  const percentChange = absoluteDelta / previousMCap * 100;
+  const plusPrefix = percentChange >= 0 ? "+" : "";
+  const text = `${plusPrefix}${percentChange.toFixed(1)}%`;
+  const color = percentChange > 0 ? "green" : percentChange < 0 ? "red" : void 0;
+  return { text, color };
+}
+function formatUsd(value) {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  }).format(value);
+}
+function formatHolders(count) {
+  return new Intl.NumberFormat("en-US").format(count);
+}
+function formatRelativeTime(date, now = /* @__PURE__ */ new Date()) {
+  const diffMs = now.getTime() - date.getTime();
+  if (diffMs < 6e4) return "just now";
+  return formatDistanceStrict(date, now, { addSuffix: true });
+}
+function formatAbsoluteTime(date) {
+  return format(date, "yyyy-MM-dd h:mm a");
+}
+function formatCreatedAt(isoDate, now) {
+  if (!isoDate) return "-";
+  const date = new Date(isoDate);
+  if (isNaN(date.getTime())) return "-";
+  return `${formatRelativeTime(date, now)} (${formatAbsoluteTime(date)})`;
+}
+var formatEthDisplay = (wei) => {
+  const eth = formatEther(wei);
+  const parts = eth.split(".");
+  if (!parts[1]) return eth;
+  const trimmed = parts[1].replace(/0+$/, "") || "0";
+  return `${parts[0]}.${trimmed}`;
+};
+var formatCoinsDisplay = (coinsOut) => new Intl.NumberFormat("en-US", {
+  maximumFractionDigits: 2
+}).format(Number(coinsOut));
+
+// src/lib/balance-format.ts
+var COIN_DECIMALS = 18;
+var parseRawBalance = (rawBalance) => Number(normalizeTokenAmount(rawBalance));
+var normalizeTokenAmount = (rawBalance, decimals = COIN_DECIMALS) => {
+  try {
+    const value = BigInt(rawBalance);
+    const divisor = 10n ** BigInt(decimals);
+    const whole = value / divisor;
+    const fraction = value % divisor;
+    if (fraction === 0n) return whole.toString();
+    const fractionText = fraction.toString().padStart(decimals, "0").replace(/0+$/, "");
+    return `${whole}.${fractionText}`;
+  } catch {
+    console.warn(`Warning: could not parse token amount "${rawBalance}"`);
+    return rawBalance;
+  }
+};
+var formatBalanceAsUsd = (balance, priceInUsdc) => {
+  if (!priceInUsdc) return "-";
+  const value = parseRawBalance(balance) * Number(priceInUsdc);
+  if (value < 0.01) return "<$0.01";
+  return formatUsd(value);
+};
+var formatBalance = (balance) => {
+  const n = parseRawBalance(balance);
+  if (n === 0) return "0";
+  if (n < 1e-3) return "<0.001";
+  if (n < 1) return n.toFixed(4);
+  return new Intl.NumberFormat("en-US", {
+    notation: "compact",
+    compactDisplay: "short",
+    maximumFractionDigits: 1
+  }).format(n);
+};
+var trimTrailingZeros = (value) => {
+  if (!value.includes(".")) return value;
+  const trimmed = value.replace(/0+$/, "").replace(/\.$/, "");
+  return trimmed || "0";
+};
+
+// src/lib/balance-columns.tsx
+var SORT_LABELS = {
+  "usd-value": "USD Value",
+  balance: "Balance",
+  "market-cap": "Market Cap",
+  "price-change": "Price Change"
+};
+var walletColumns = [
+  { header: "Name", width: 14, accessor: (row) => row.name },
+  {
+    header: "Symbol",
+    width: 10,
+    noTruncate: true,
+    accessor: (row) => row.symbol
+  },
+  { header: "Balance", width: 20, accessor: (row) => row.balance },
+  { header: "USD Value", width: 16, accessor: (row) => row.usdValue }
+];
+var balanceColumns = [
+  { header: "#", width: 5, accessor: (row) => String(row.rank) },
+  {
+    header: "Name",
+    width: 24,
+    accessor: (row) => row.coin?.name ?? "Unknown"
+  },
+  {
+    header: "Symbol",
+    width: 12,
+    noTruncate: true,
+    accessor: (row) => row.coin?.symbol ?? ""
+  },
+  {
+    header: "Balance",
+    width: 14,
+    accessor: (row) => formatBalance(row.balance)
+  },
+  {
+    header: "USD Value",
+    width: 14,
+    accessor: (row) => formatBalanceAsUsd(row.balance, row.coin?.tokenPrice?.priceInUsdc)
+  },
+  {
+    header: "Market Cap",
+    width: 14,
+    accessor: (row) => formatCompactUsd(row.coin?.marketCap)
+  },
+  {
+    header: "24h Change",
+    width: 12,
+    accessor: (row) => formatMcapChange(row.coin?.marketCap, row.coin?.marketCapDelta24h).text,
+    color: (row) => formatMcapChange(row.coin?.marketCap, row.coin?.marketCapDelta24h).color
+  }
+];
+
+// src/hooks/use-auto-refresh.ts
+import { useState, useEffect, useCallback } from "react";
+var useAutoRefresh = (intervalSeconds, enabled) => {
+  const [refreshCount, setRefreshCount] = useState(0);
+  const [secondsUntilRefresh, setSecondsUntilRefresh] = useState(intervalSeconds);
+  const [resetCount, setResetCount] = useState(0);
+  const triggerManualRefresh = useCallback(() => {
+    if (!enabled) return;
+    setRefreshCount((c) => c + 1);
+    setSecondsUntilRefresh(intervalSeconds);
+    setResetCount((c) => c + 1);
+  }, [enabled, intervalSeconds]);
+  useEffect(() => {
+    if (!enabled) return;
+    setSecondsUntilRefresh(intervalSeconds);
+    const ticker = setInterval(() => {
+      setSecondsUntilRefresh((prev) => {
+        if (prev <= 1) {
+          setRefreshCount((c) => c + 1);
+          return intervalSeconds;
+        }
+        return prev - 1;
+      });
+    }, 1e3);
+    return () => clearInterval(ticker);
+  }, [enabled, intervalSeconds, resetCount]);
+  if (!enabled) {
+    return { refreshCount: 0, secondsUntilRefresh: 0, triggerManualRefresh };
+  }
+  return { refreshCount, secondsUntilRefresh, triggerManualRefresh };
+};
+
+// src/components/BalanceView.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var BalanceView = ({
+  fetchData,
+  sort,
+  mode = "full",
+  autoRefresh = false,
+  intervalSeconds = 30
+}) => {
+  const { exit } = useApp();
+  const [loading, setLoading] = useState2(true);
+  const [isRefreshing, setIsRefreshing] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [data, setData] = useState2(null);
+  const { refreshCount, secondsUntilRefresh, triggerManualRefresh } = useAutoRefresh(intervalSeconds, autoRefresh);
+  const [manualRefreshCount, setManualRefreshCount] = useState2(0);
+  const hasLoadedOnce = useRef(false);
+  const load = useCallback2(async () => {
+    if (hasLoadedOnce.current) {
+      setIsRefreshing(true);
+    } else {
+      setLoading(true);
+    }
+    setError(null);
+    try {
+      const result = await fetchData();
+      setData(result);
+      hasLoadedOnce.current = true;
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    }
+    setLoading(false);
+    setIsRefreshing(false);
+  }, [fetchData]);
+  useEffect2(() => {
+    load();
+  }, [refreshCount, manualRefreshCount]);
+  useInput((input, key) => {
+    if (input === "q" || key.escape) {
+      exit();
+      return;
+    }
+    if (input === "r" && !loading) {
+      triggerManualRefresh();
+      setManualRefreshCount((c) => c + 1);
+    }
+  });
+  if (error && !data) {
+    return /* @__PURE__ */ jsxs2(
+      Box2,
+      {
+        flexDirection: "column",
+        paddingLeft: 1,
+        paddingTop: 1,
+        paddingBottom: 1,
+        children: [
+          /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+            "Error: ",
+            error
+          ] }),
+          /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Press q to exit" }) })
+        ]
+      }
+    );
+  }
+  if (loading && !data) {
+    return /* @__PURE__ */ jsx2(Box2, { paddingLeft: 1, paddingTop: 1, children: /* @__PURE__ */ jsxs2(Text2, { children: [
+      /* @__PURE__ */ jsx2(Spinner, { type: "dots" }),
+      " Loading\u2026"
+    ] }) });
+  }
+  if (!data) return null;
+  const hints = ["r refresh"];
+  if (autoRefresh) hints.push(`auto: ${secondsUntilRefresh}s`);
+  hints.push("q quit");
+  const footer = hints.join("  \xB7  ");
+  const showWallet = mode === "full" || mode === "wallet";
+  const showCoins = mode === "full" || mode === "coins";
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    isRefreshing && /* @__PURE__ */ jsx2(Box2, { paddingLeft: 1, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      /* @__PURE__ */ jsx2(Spinner, { type: "dots" }),
+      " Refreshing\u2026"
+    ] }) }),
+    showWallet && /* @__PURE__ */ jsx2(
+      Table,
+      {
+        columns: walletColumns,
+        data: data.walletBalances,
+        title: "Wallet"
+      }
+    ),
+    showCoins && data.rankedBalances.length === 0 ? /* @__PURE__ */ jsxs2(
+      Box2,
+      {
+        flexDirection: "column",
+        paddingLeft: 1,
+        paddingTop: 1,
+        paddingBottom: 1,
+        children: [
+          /* @__PURE__ */ jsx2(Text2, { children: "No coin balances found." }),
+          /* @__PURE__ */ jsxs2(Box2, { marginTop: 1, flexDirection: "column", children: [
+            /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Buy coins to see them here:" }),
+            /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+              " zora buy ",
+              "<address>",
+              " --eth 0.001"
+            ] })
+          ] })
+        ]
+      }
+    ) : showCoins ? /* @__PURE__ */ jsx2(
+      Table,
+      {
+        columns: balanceColumns,
+        data: data.rankedBalances,
+        title: `Coins \xB7 sorted by ${SORT_LABELS[sort]}`,
+        subtitle: `${data.rankedBalances.length} of ${data.total}`
+      }
+    ) : null,
+    /* @__PURE__ */ jsx2(Box2, { paddingLeft: 1, paddingBottom: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: footer }) })
+  ] });
+};
+
+// src/lib/wallet-balances.ts
+import { getTokenInfo } from "@zoralabs/coins-sdk";
+import {
+  createPublicClient as createPublicClient2,
+  erc20Abi,
+  formatUnits,
+  http
+} from "viem";
+import { base as base2 } from "viem/chains";
+var TRACKED_TOKENS = [
+  {
+    name: "Ether",
+    symbol: "ETH",
+    address: WETH_ADDRESS,
+    decimals: 18,
+    priceAddress: WETH_ADDRESS,
+    isNative: true
+  },
+  {
+    name: "USD Coin",
+    symbol: "USDC",
+    address: USDC_ADDRESS,
+    decimals: USDC_DECIMALS,
+    priceAddress: USDC_ADDRESS,
+    fixedPriceUsd: 1
+  },
+  {
+    name: "ZORA",
+    symbol: "ZORA",
+    address: ZORA_ADDRESS,
+    decimals: 18,
+    priceAddress: ZORA_ADDRESS
+  }
+];
+var fetchTokenPriceUsd = async (address, chainId = BASE_CHAIN_ID) => {
+  try {
+    const res = await getTokenInfo({ address, chainId });
+    return res.data?.erc20Token?.currency?.priceUsd ? Number(res.data.erc20Token.currency.priceUsd) : null;
+  } catch (err) {
+    console.warn(
+      `Warning: failed to fetch price for ${address}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+};
+var fetchWalletBalances = async (walletAddress) => {
+  const publicClient = createPublicClient2({ chain: base2, transport: http() });
+  const nativeToken = TRACKED_TOKENS.find((t) => t.isNative);
+  const erc20Tokens = TRACKED_TOKENS.filter((t) => !t.isNative);
+  const [ethBalance, multicallResults] = await Promise.all([
+    publicClient.getBalance({ address: walletAddress }),
+    publicClient.multicall({
+      contracts: erc20Tokens.map((t) => ({
+        address: t.address,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [walletAddress]
+      }))
+    })
+  ]);
+  const rawBalances = /* @__PURE__ */ new Map();
+  if (nativeToken) rawBalances.set(nativeToken, ethBalance);
+  erc20Tokens.forEach((token, i) => {
+    if (multicallResults[i].status === "success") {
+      rawBalances.set(token, multicallResults[i].result);
+    } else {
+      console.warn(`Warning: failed to fetch balance for ${token.symbol}`);
+      rawBalances.set(token, 0n);
+    }
+  });
+  const priceResults = await Promise.allSettled(
+    TRACKED_TOKENS.map(async (token) => {
+      const balance = rawBalances.get(token) ?? 0n;
+      let priceUsd = null;
+      if (token.fixedPriceUsd != null) {
+        priceUsd = token.fixedPriceUsd;
+      } else if (balance > 0n || token.isNative) {
+        priceUsd = await fetchTokenPriceUsd(token.priceAddress);
+      }
+      return { token, balance, priceUsd };
+    })
+  );
+  const resolved = priceResults.map((result, i) => {
+    if (result.status === "fulfilled") return result.value;
+    const token = TRACKED_TOKENS[i];
+    console.warn(`Warning: failed to resolve token ${token.symbol}`);
+    return { token, balance: rawBalances.get(token) ?? 0n, priceUsd: null };
+  });
+  const visible = resolved.filter((r) => r.balance > 0n || r.token.isNative);
+  const intermediate = visible.map(({ token, balance, priceUsd }) => {
+    const human = formatUnits(balance, token.decimals);
+    const usdValue = priceUsd !== null ? Number(human) * priceUsd : null;
+    return { token, human, priceUsd, usdValue };
+  });
+  const walletBalances = intermediate.map(
+    ({ token, human, usdValue }) => ({
+      name: token.name,
+      symbol: token.symbol,
+      balance: trimTrailingZeros(human),
+      usdValue: usdValue !== null ? formatUsd(usdValue) : "-"
+    })
+  );
+  const walletBalancesJson = intermediate.map(
+    ({ token, human, priceUsd, usdValue }) => ({
+      name: token.name,
+      symbol: token.symbol,
+      address: token.isNative ? null : token.address,
+      balance: trimTrailingZeros(human),
+      priceUsd,
+      usdValue: usdValue !== null ? Number(usdValue.toFixed(6)) : null
+    })
+  );
+  return { walletBalances, walletBalancesJson };
+};
+
+// src/commands/balance.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var SORT_MAP = {
+  "usd-value": "USD_VALUE",
+  balance: "BALANCE",
+  "market-cap": "MARKET_CAP",
+  "price-change": "PRICE_CHANGE"
+};
+var SORT_OPTIONS = Object.keys(SORT_LABELS).join(", ");
+var extractErrorMessage = (error) => {
+  if (typeof error === "object" && error !== null && "error" in error) {
+    return String(error.error);
+  }
+  return JSON.stringify(error);
+};
+var formatBalanceJson = (balance, rank) => {
+  const priceUsd = balance.coin?.tokenPrice?.priceInUsdc;
+  const marketCap = balance.coin?.marketCap ? Number(balance.coin.marketCap) : null;
+  const marketCapDelta24h = balance.coin?.marketCapDelta24h ? Number(balance.coin.marketCapDelta24h) : null;
+  const volume24h = balance.coin?.volume24h ? Number(balance.coin.volume24h) : null;
+  const totalVolume = balance.coin?.totalVolume ? Number(balance.coin.totalVolume) : null;
+  const priceUsdValue = priceUsd ? Number(priceUsd) : null;
+  const usdValue = priceUsdValue !== null ? Number((parseRawBalance(balance.balance) * priceUsdValue).toFixed(6)) : null;
+  const marketCapChange24h = marketCap !== null && marketCapDelta24h !== null && marketCap - marketCapDelta24h !== 0 ? Number(
+    (marketCapDelta24h / (marketCap - marketCapDelta24h) * 100).toFixed(
+      4
+    )
+  ) : null;
+  return {
+    rank,
+    name: balance.coin?.name ?? null,
+    symbol: balance.coin?.symbol ?? null,
+    coinType: balance.coin?.coinType ?? null,
+    chainId: balance.coin?.chainId ?? null,
+    address: balance.coin?.address ?? null,
+    creatorHandle: balance.coin?.creatorProfile?.handle ?? null,
+    previewImage: balance.coin?.mediaContent?.previewImage?.medium ?? null,
+    balance: normalizeTokenAmount(balance.balance),
+    usdValue,
+    priceUsd: priceUsdValue,
+    marketCap,
+    marketCapDelta24h,
+    marketCapChange24h,
+    volume24h,
+    totalVolume
+  };
+};
+function resolveContext(json) {
+  const account = resolveAccount(json);
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    outputErrorAndExit(
+      json,
+      "Not authenticated. Run 'zora auth configure' to set your API key."
+    );
+  }
+  setApiKey(apiKey);
+  return account;
+}
+function renderWallet(json, walletResult) {
+  outputData(json, {
+    json: { wallet: walletResult.walletBalancesJson },
+    table: () => {
+      renderOnce(
+        /* @__PURE__ */ jsx3(
+          Table,
+          {
+            columns: walletColumns,
+            data: walletResult.walletBalances,
+            title: "Wallet"
+          }
+        )
+      );
+    }
+  });
+}
+function renderCoins(json, balances, total, sort) {
+  const rankedBalances = balances.map((balance, index) => ({
+    ...balance,
+    rank: index + 1
+  }));
+  outputData(json, {
+    json: {
+      coins: rankedBalances.map(
+        (balance) => formatBalanceJson(balance, balance.rank)
+      )
+    },
+    table: () => {
+      if (balances.length === 0) {
+        console.log("\n No coin balances found.\n");
+        console.log(" Buy coins to see them here:");
+        console.log("   zora buy <address> --eth 0.001\n");
+      } else {
+        renderOnce(
+          /* @__PURE__ */ jsx3(
+            Table,
+            {
+              columns: balanceColumns,
+              data: rankedBalances,
+              title: `Coins \xB7 sorted by ${SORT_LABELS[sort]}`,
+              subtitle: `${balances.length} of ${total}`
+            }
+          )
+        );
+      }
+    }
+  });
+}
+async function fetchCoins(json, address, sort, limit) {
+  let response;
+  try {
+    response = await getProfileBalances({
+      identifier: address,
+      count: limit,
+      sortOption: SORT_MAP[sort]
+    });
+  } catch (err) {
+    outputErrorAndExit(
+      json,
+      `Request failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (response.error) {
+    outputErrorAndExit(
+      json,
+      `API error: ${extractErrorMessage(response.error)}`
+    );
+  }
+  const edges = response.data?.profile?.coinBalances?.edges ?? [];
+  const balances = edges.map(
+    (e) => e.node
+  );
+  const total = response.data?.profile?.coinBalances?.count ?? balances.length;
+  return { balances, total };
+}
+function validateCoinOpts(json, sort, limitStr) {
+  if (!SORT_MAP[sort]) {
+    outputErrorAndExit(
+      json,
+      `Invalid --sort value: ${sort}.`,
+      `Supported: ${SORT_OPTIONS}`
+    );
+  }
+  const limit = parseInt(limitStr, 10);
+  if (isNaN(limit) || limit <= 0 || limit > 20) {
+    outputErrorAndExit(
+      json,
+      `Invalid --limit value: ${limitStr}. Must be an integer between 1 and 20.`
+    );
+  }
+  return { sort, limit };
+}
+var balanceCommand = new Command2("balance").description("Show balances in your wallet").action(async function() {
+  const output = getOutputMode(this, "live");
+  const json = output === "json";
+  const account = resolveContext(json);
+  const { live, intervalSeconds } = getLiveConfig(this, "live");
+  const sort = "usd-value";
+  const limit = 10;
+  const fetchBalanceData = async () => {
+    const [walletResult, coinsResult] = await Promise.allSettled([
+      fetchWalletBalances(account.address),
+      fetchCoins(json, account.address, sort, limit)
+    ]);
+    if (walletResult.status === "rejected" || coinsResult.status === "rejected") {
+      const err = walletResult.status === "rejected" ? walletResult.reason : coinsResult.reason;
+      throw new Error(err instanceof Error ? err.message : String(err));
+    }
+    const rankedBalances = coinsResult.value.balances.map(
+      (balance, index) => ({
+        ...balance,
+        rank: index + 1
+      })
+    );
+    return {
+      walletBalances: walletResult.value.walletBalances,
+      walletBalancesJson: walletResult.value.walletBalancesJson,
+      rankedBalances,
+      total: coinsResult.value.total
+    };
+  };
+  if (json) {
+    const data = await fetchBalanceData().catch(
+      (err) => outputErrorAndExit(
+        json,
+        `Request failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    outputData(json, {
+      json: {
+        wallet: data.walletBalancesJson,
+        coins: data.rankedBalances.map(
+          (balance) => formatBalanceJson(balance, balance.rank)
+        )
+      },
+      table: () => {
+      }
+    });
+    track("cli_balances", {
+      sort,
+      limit,
+      live: false,
+      result_count: data.rankedBalances.length,
+      total_count: data.total,
+      output_format: "json"
+    });
+  } else if (live) {
+    await renderLive(
+      /* @__PURE__ */ jsx3(
+        BalanceView,
+        {
+          fetchData: fetchBalanceData,
+          sort,
+          mode: "full",
+          autoRefresh: live,
+          intervalSeconds
+        }
+      )
+    );
+    track("cli_balances", {
+      sort,
+      limit,
+      live,
+      interval: intervalSeconds,
+      output_format: "live"
+    });
+  } else {
+    const data = await fetchBalanceData().catch(
+      (err) => outputErrorAndExit(
+        json,
+        `Request failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    renderOnce(
+      /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx3(
+          Table,
+          {
+            columns: walletColumns,
+            data: data.walletBalances,
+            title: "Wallet"
+          }
+        ),
+        data.rankedBalances.length === 0 ? /* @__PURE__ */ jsxs3(
+          Box3,
+          {
+            flexDirection: "column",
+            paddingLeft: 1,
+            paddingTop: 1,
+            paddingBottom: 1,
+            children: [
+              /* @__PURE__ */ jsx3(Text3, { children: "No coin balances found." }),
+              /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+                /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Buy coins to see them here:" }),
+                /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+                  " zora buy ",
+                  "<address>",
+                  " --eth 0.001"
+                ] })
+              ] })
+            ]
+          }
+        ) : /* @__PURE__ */ jsx3(
+          Table,
+          {
+            columns: balanceColumns,
+            data: data.rankedBalances,
+            title: `Coins \xB7 sorted by ${SORT_LABELS[sort]}`,
+            subtitle: `${data.rankedBalances.length} of ${data.total}`
+          }
+        )
+      ] })
+    );
+    track("cli_balances", {
+      sort,
+      limit,
+      live: false,
+      result_count: data.rankedBalances.length,
+      total_count: data.total,
+      output_format: "text"
+    });
+  }
+});
+balanceCommand.command("spendable").description("Show wallet token balances (ETH, USDC, ZORA)").action(async function() {
+  const output = getOutputMode(this, "live");
+  const json = output === "json";
+  const account = resolveContext(json);
+  const { live, intervalSeconds } = getLiveConfig(this, "live");
+  const fetchSpendableData = async () => {
+    const walletResult = await fetchWalletBalances(account.address);
+    return {
+      walletBalances: walletResult.walletBalances,
+      walletBalancesJson: walletResult.walletBalancesJson,
+      rankedBalances: [],
+      total: 0
+    };
+  };
+  if (json) {
+    const data = await fetchSpendableData().catch(
+      (err) => outputErrorAndExit(
+        json,
+        `Request failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    outputData(json, {
+      json: { wallet: data.walletBalancesJson },
+      table: () => {
+      }
+    });
+  } else if (live) {
+    await renderLive(
+      /* @__PURE__ */ jsx3(
+        BalanceView,
+        {
+          fetchData: fetchSpendableData,
+          sort: "usd-value",
+          mode: "wallet",
+          autoRefresh: live,
+          intervalSeconds
+        }
+      )
+    );
+  } else {
+    const walletResult = await fetchWalletBalances(account.address).catch(
+      (err) => outputErrorAndExit(
+        json,
+        `Request failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    renderWallet(json, walletResult);
+  }
+});
+balanceCommand.command("coins").description("Show coin positions").option("--sort <sort>", `Sort by: ${SORT_OPTIONS}`, "usd-value").option("--limit <n>", "Number of results (max 20)", "10").action(async function(opts) {
+  const output = getOutputMode(this, "live");
+  const json = output === "json";
+  const { sort, limit } = validateCoinOpts(json, opts.sort, opts.limit);
+  const account = resolveContext(json);
+  const { live, intervalSeconds } = getLiveConfig(this, "live");
+  const fetchCoinsData = async () => {
+    const { balances, total } = await fetchCoins(
+      json,
+      account.address,
+      sort,
+      limit
+    );
+    const rankedBalances = balances.map((balance, index) => ({
+      ...balance,
+      rank: index + 1
+    }));
+    return {
+      walletBalances: [],
+      walletBalancesJson: [],
+      rankedBalances,
+      total
+    };
+  };
+  if (json) {
+    const data = await fetchCoinsData();
+    renderCoins(json, data.rankedBalances, data.total, sort);
+  } else if (live) {
+    await renderLive(
+      /* @__PURE__ */ jsx3(
+        BalanceView,
+        {
+          fetchData: fetchCoinsData,
+          sort,
+          mode: "coins",
+          autoRefresh: live,
+          intervalSeconds
+        }
+      )
+    );
+  } else {
+    const { balances, total } = await fetchCoins(
+      json,
+      account.address,
+      sort,
+      limit
+    );
+    renderCoins(json, balances, total, sort);
+  }
+});
+
+// src/commands/buy.ts
+import { Command as Command3 } from "commander";
+import confirm2 from "@inquirer/confirm";
+import { parseUnits, formatUnits as formatUnits3, isAddress } from "viem";
+import {
+  setApiKey as setApiKey2,
+  getCoin,
+  tradeCoin,
+  createTradeCall
+} from "@zoralabs/coins-sdk";
+
+// src/lib/trade-helpers.ts
+import {
+  parseEther,
+  formatUnits as formatUnits2,
+  isAddressEqual,
+  parseEventLogs,
+  erc20Abi as erc20Abi2
+} from "viem";
+var GAS_RESERVE = parseEther("0.00001");
+var BUY_AMOUNT_CHECKS = {
+  eth: (opts) => opts.eth !== void 0,
+  usd: (opts) => opts.usd !== void 0,
+  percent: (opts) => opts.percent !== void 0,
+  all: (opts) => opts.all === true
+};
+var SELL_AMOUNT_CHECKS = {
+  amount: (opts) => opts.amount !== void 0,
+  usd: (opts) => opts.usd !== void 0,
+  percent: (opts) => opts.percent !== void 0,
+  all: (opts) => opts.all === true
+};
+var getAmountMode = (json, opts, checks, flagNames) => {
+  const provided = Object.entries(checks).filter(([, isProvided]) => isProvided(opts)).map(([mode]) => mode);
+  if (provided.length === 0) {
+    outputErrorAndExit(json, `Specify one amount flag: ${flagNames}`);
+  }
+  if (provided.length > 1) {
+    outputErrorAndExit(json, `Only one amount flag allowed: ${flagNames}`);
+  }
+  return provided[0];
+};
+var parsePercentageLikeValue = (value) => {
+  if (!/^\d+(\.\d+)?$/.test(value)) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+};
+var formatAmountDisplay = (amount, decimals) => {
+  const formatted = formatUnits2(amount, decimals);
+  const parts = formatted.split(".");
+  if (!parts[1]) {
+    return new Intl.NumberFormat("en-US", {
+      maximumFractionDigits: 2
+    }).format(Number(formatted));
+  }
+  const twoDecimal = `${parts[0]}.${parts[1].slice(0, 2)}`;
+  let maxDecimals = 2;
+  if (Number(twoDecimal) === 0 && amount > 0n) {
+    const sigIndex = parts[1].search(/[1-9]/);
+    maxDecimals = sigIndex === -1 ? 6 : Math.min(sigIndex + 4, parts[1].length);
+  }
+  const truncated = `${parts[0]}.${parts[1].slice(0, maxDecimals)}`;
+  return new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: maxDecimals
+  }).format(Number(truncated));
+};
+var getReceivedAmountFromReceipt = ({
+  receipt,
+  tokenAddress,
+  recipient
+}) => {
+  const transfers = parseEventLogs({
+    abi: erc20Abi2,
+    eventName: "Transfer",
+    logs: receipt.logs,
+    strict: false
+  });
+  const matchingTransfers = transfers.filter((transfer) => {
+    const to = transfer.args?.to;
+    if (!to) return false;
+    return isAddressEqual(transfer.address, tokenAddress) && isAddressEqual(to, recipient);
+  });
+  if (matchingTransfers.length === 0) {
+    throw new Error("No matching Transfer event found in receipt.");
+  }
+  const amount = matchingTransfers.reduce((total, transfer) => {
+    const value = transfer.args?.value;
+    if (value === void 0) {
+      throw new Error("Transfer event missing amount.");
+    }
+    return total + value;
+  }, 0n);
+  const lastTransfer = matchingTransfers[matchingTransfers.length - 1];
+  const logIndex = lastTransfer?.logIndex ?? null;
+  return { amount, logIndex };
+};
+var printDebugRequest = (label, tradeParameters) => {
+  if (process.env.ZORA_API_TARGET) {
+    console.error(`[debug] API target: ${process.env.ZORA_API_TARGET}`);
+  }
+  console.error(`
+[debug] ${label} \u2014 Quote Request:`);
+  console.error(
+    JSON.stringify(
+      {
+        tokenIn: tradeParameters.sell,
+        tokenOut: tradeParameters.buy,
+        amountIn: tradeParameters.amountIn.toString(),
+        slippage: tradeParameters.slippage,
+        chainId: 8453,
+        sender: tradeParameters.sender,
+        recipient: tradeParameters.recipient || tradeParameters.sender
+      },
+      null,
+      2
+    )
+  );
+};
+var printDebugResponse = (label, quoteResponse) => {
+  console.error(`
+[debug] ${label} \u2014 Quote Response:`);
+  console.error(JSON.stringify(quoteResponse, null, 2));
+  console.error("");
+};
+var printQuote = (json, info) => {
+  if (json) {
+    outputJson({
+      action: "quote",
+      coin: info.coinSymbol,
+      address: info.address,
+      spend: {
+        amount: formatUnits2(info.amountIn, info.inputTokenDecimals),
+        raw: info.amountIn.toString(),
+        symbol: info.inputTokenSymbol
+      },
+      estimated: {
+        amount: formatUnits2(BigInt(info.amountOut), 18),
+        raw: info.amountOut,
+        symbol: info.coinSymbol
+      },
+      slippage: info.slippagePct
+    });
+    return;
+  }
+  console.log(`
+ Buy ${info.coinName} (${info.coinSymbol})
+`);
+  console.log(`   Amount       ${info.spendAmount}`);
+  console.log(`   You get      ~${info.coinsFormatted} ${info.coinSymbol}`);
+  console.log(`   Slippage     ${info.slippagePct}%
+`);
+};
+var printTradeResult = (json, info) => {
+  const receivedAmount = formatUnits2(info.receivedAmountOut, 18);
+  const receivedFormatted = formatCoinsDisplay(receivedAmount);
+  if (json) {
+    outputJson({
+      action: "buy",
+      coin: info.coinSymbol,
+      address: info.address,
+      spent: {
+        amount: formatUnits2(info.amountIn, info.inputTokenDecimals),
+        raw: info.amountIn.toString(),
+        symbol: info.inputTokenSymbol
+      },
+      received: {
+        amount: receivedAmount,
+        raw: info.receivedAmountOut.toString(),
+        symbol: info.coinSymbol
+      },
+      tx: info.txHash
+    });
+    return;
+  }
+  console.log(`
+ Bought ${info.coinName}
+`);
+  console.log(`   Spent        ${info.spendAmount} ${info.inputTokenSymbol}`);
+  console.log(`   Received     ${receivedFormatted} ${info.coinSymbol}`);
+  console.log(`   Tx           ${info.txHash}
+`);
+};
+
+// src/commands/buy.ts
+var buyCommand = new Command3("buy").description("Buy a coin").argument("<address>", "Coin contract address (0x\u2026)").option("--eth <value>", "Buy with ETH amount").option("--usd <value>", "Buy with USD equivalent (use with --token)").option("--token <asset>", "Token to spend: eth, usdc, zora", "eth").option("--percent <value>", "Buy with percentage of ETH balance").option("--all", "Swap all ETH for coin").option("--quote", "Print quote and exit without trading").option("--yes", "Skip confirmation and execute directly").option("--slippage <pct>", "Slippage tolerance percent", "1").option("--debug", "Print full quote request/response JSON").action(async function(coinAddress, opts) {
+  const json = getJson(this);
+  const debug = opts.debug === true;
+  if (!isAddress(coinAddress)) {
+    outputErrorAndExit(json, `Invalid address: ${coinAddress}`);
+  }
+  const tokenKey = opts.token.toLowerCase();
+  if (!(tokenKey in BASE_TRADE_TOKENS)) {
+    outputErrorAndExit(
+      json,
+      `Invalid --token value: ${opts.token}. Use: eth, usdc, zora`
+    );
+  }
+  const inputToken = BASE_TRADE_TOKENS[tokenKey];
+  const amountMode = getAmountMode(
+    json,
+    opts,
+    BUY_AMOUNT_CHECKS,
+    "--eth, --usd, --percent, or --all"
+  );
+  const slippagePct = parsePercentageLikeValue(opts.slippage);
+  if (slippagePct === void 0 || slippagePct < 0 || slippagePct > 99) {
+    outputErrorAndExit(
+      json,
+      "Invalid --slippage value. Must be between 0 and 99."
+    );
+  }
+  const slippage = slippagePct / 100;
+  const apiKey = getApiKey();
+  if (apiKey) {
+    setApiKey2(apiKey);
+  }
+  const account = resolveAccount(json);
+  const { publicClient, walletClient } = createClients(account);
+  let token;
+  try {
+    const response = await getCoin({ address: coinAddress });
+    token = response.data?.zora20Token;
+  } catch (err) {
+    outputErrorAndExit(
+      json,
+      `Failed to fetch coin: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!token) {
+    outputErrorAndExit(json, `Coin not found: ${coinAddress}`);
+  }
+  const coinName = token.name;
+  const coinSymbol = token.symbol;
+  let amountIn;
+  if (amountMode === "usd") {
+    const usdVal = parsePercentageLikeValue(opts.usd);
+    if (usdVal === void 0 || usdVal <= 0) {
+      outputErrorAndExit(
+        json,
+        "Invalid --usd value. Must be a positive number."
+      );
+      return;
+    }
+    let priceUsd;
+    if (inputToken.fixedPriceUsd != null) {
+      priceUsd = inputToken.fixedPriceUsd;
+    } else {
+      const fetched = await fetchTokenPriceUsd(inputToken.priceAddress);
+      if (fetched === null) {
+        outputErrorAndExit(
+          json,
+          `Failed to fetch ${inputToken.symbol} price.`
+        );
+        return;
+      }
+      priceUsd = fetched;
+    }
+    const tokenAmount = usdVal / priceUsd;
+    amountIn = parseUnits(
+      tokenAmount.toFixed(inputToken.decimals),
+      inputToken.decimals
+    );
+    if (amountIn === 0n) {
+      outputErrorAndExit(json, "Calculated amount is zero. USD too small.");
+    }
+    if (debug) {
+      console.error(
+        `[debug] $${usdVal} USD = ${formatUnits3(amountIn, inputToken.decimals)} ${inputToken.symbol} (price: $${priceUsd})`
+      );
+    }
+  } else if (amountMode === "eth") {
+    const val = parsePercentageLikeValue(opts.eth);
+    if (val === void 0 || val <= 0) {
+      outputErrorAndExit(
+        json,
+        "Invalid --eth value. Must be a positive number."
+      );
+    }
+    try {
+      amountIn = parseUnits(opts.eth, inputToken.decimals);
+    } catch {
+      outputErrorAndExit(
+        json,
+        "Invalid --eth value. Must be a positive number."
+      );
+    }
+  } else {
+    const isEth = tokenKey === "eth";
+    let balance;
+    if (isEth) {
+      balance = await publicClient.getBalance({
+        address: account.address
+      });
+    } else {
+      const tokenAddress = inputToken.trade.address;
+      balance = await publicClient.readContract({
+        address: tokenAddress,
+        abi: [
+          {
+            name: "balanceOf",
+            type: "function",
+            stateMutability: "view",
+            inputs: [{ name: "account", type: "address" }],
+            outputs: [{ name: "", type: "uint256" }]
+          }
+        ],
+        functionName: "balanceOf",
+        args: [account.address]
+      });
+    }
+    if (balance === 0n) {
+      outputErrorAndExit(
+        json,
+        `No ${inputToken.symbol} balance. Deposit ${inputToken.symbol} to ${account.address} on Base.`
+      );
+    }
+    const gasReserve = isEth ? GAS_RESERVE : 0n;
+    if (isEth && balance <= gasReserve) {
+      outputErrorAndExit(
+        json,
+        `Balance too low (${formatEthDisplay(balance)} ETH). Need >${formatEthDisplay(GAS_RESERVE)} ETH for gas.`
+      );
+    }
+    const spendableBalance = balance - gasReserve;
+    if (amountMode === "all") {
+      amountIn = spendableBalance;
+    } else {
+      const pct = parsePercentageLikeValue(opts.percent);
+      if (pct === void 0 || pct <= 0 || pct > 100) {
+        outputErrorAndExit(
+          json,
+          "Invalid --percent value. Must be between 0 and 100."
+        );
+      }
+      amountIn = pct === 100 ? spendableBalance : spendableBalance * BigInt(Math.round(pct * 100)) / 10000n;
+      if (amountIn === 0n) {
+        outputErrorAndExit(
+          json,
+          "Calculated amount is zero. Balance too low."
+        );
+      }
+    }
+  }
+  let swapAmountUsd;
+  if (amountMode === "usd") {
+    swapAmountUsd = parsePercentageLikeValue(opts.usd);
+  } else {
+    const priceUsd = inputToken.fixedPriceUsd ?? await fetchTokenPriceUsd(inputToken.priceAddress);
+    if (priceUsd != null) {
+      swapAmountUsd = Number(
+        (Number(formatUnits3(amountIn, inputToken.decimals)) * priceUsd).toFixed(2)
+      );
+    }
+  }
+  const tradeParameters = {
+    sell: inputToken.trade,
+    buy: { type: "erc20", address: coinAddress },
+    amountIn,
+    slippage,
+    sender: account.address
+  };
+  if (debug) {
+    printDebugRequest("buy", tradeParameters);
+  }
+  let amountOut;
+  try {
+    const quote = await createTradeCall(tradeParameters);
+    if (debug) {
+      printDebugResponse("buy", quote);
+    }
+    if (!quote.quote?.amountOut || quote.quote.amountOut === "0") {
+      outputErrorAndExit(
+        json,
+        "Quote returned zero output. Amount may be too small."
+      );
+    }
+    amountOut = quote.quote.amountOut;
+  } catch (err) {
+    if (debug) {
+      console.error(
+        `
+[debug] buy \u2014 Quote Error:
+${err instanceof Error ? err.stack || err.message : String(err)}
+`
+      );
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    const errorType = err?.errorType;
+    const errorBody = err?.errorBody;
+    if (errorType === "LIQUIDITY" || msg.includes("Not enough liquidity")) {
+      if (json) {
+        outputJson({ error: errorBody ?? msg });
+        process.exit(1);
+      }
+      outputErrorAndExit(
+        json,
+        "Not enough available liquidity for your swap. Please try swapping fewer tokens."
+      );
+    }
+    outputErrorAndExit(
+      json,
+      `Quote failed: ${msg}`,
+      "Check the coin address is valid and try again. Use --debug for full error details."
+    );
+  }
+  const spendAmount = formatUnits3(amountIn, inputToken.decimals);
+  const spendFormatted = new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: 6
+  }).format(Number(spendAmount));
+  const coinsOut = formatUnits3(BigInt(amountOut), 18);
+  const coinsFormatted = formatCoinsDisplay(coinsOut);
+  if (opts.quote) {
+    printQuote(json, {
+      coinName,
+      coinSymbol,
+      address: coinAddress,
+      spendAmount: `${spendFormatted} ${inputToken.symbol}`,
+      amountIn,
+      inputTokenSymbol: inputToken.symbol,
+      inputTokenDecimals: inputToken.decimals,
+      coinsFormatted,
+      amountOut,
+      slippagePct
+    });
+    track("cli_buy", {
+      action: "quote",
+      coin_address: coinAddress,
+      coin_name: coinName,
+      coin_symbol: coinSymbol,
+      amount_mode: amountMode,
+      swap_amount_usd: swapAmountUsd,
+      valueUsd: swapAmountUsd,
+      swapCoinType: token.coinType ?? null,
+      slippage: slippagePct,
+      output_format: json ? "json" : "table"
+    });
+    return;
+  }
+  if (!opts.yes) {
+    printQuote(false, {
+      coinName,
+      coinSymbol,
+      address: coinAddress,
+      spendAmount: `${spendFormatted} ${inputToken.symbol}`,
+      amountIn,
+      inputTokenSymbol: inputToken.symbol,
+      inputTokenDecimals: inputToken.decimals,
+      coinsFormatted,
+      amountOut,
+      slippagePct
+    });
+    const ok = await confirm2({
+      message: "Confirm?",
+      default: false
+    });
+    if (!ok) {
+      process.exit(0);
+    }
+  }
+  let receipt;
+  let txHash;
+  let receivedAmountOut = BigInt(amountOut);
+  let swapLogIndex = null;
+  const swapCoinType = token.coinType ?? null;
+  try {
+    receipt = await tradeCoin({
+      tradeParameters,
+      walletClient,
+      publicClient,
+      account
+    });
+  } catch (err) {
+    track("cli_buy", {
+      action: "trade",
+      coin_address: coinAddress,
+      coin_name: coinName,
+      coin_symbol: coinSymbol,
+      amount_mode: amountMode,
+      swap_amount_usd: swapAmountUsd,
+      valueUsd: swapAmountUsd,
+      swapCoinType,
+      slippage: slippagePct,
+      output_format: json ? "json" : "table",
+      success: false,
+      error_type: err instanceof Error ? err.constructor.name : "unknown"
+    });
+    await shutdownAnalytics();
+    outputErrorAndExit(
+      json,
+      `Transaction failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  txHash = receipt.transactionHash;
+  try {
+    const result = getReceivedAmountFromReceipt({
+      receipt,
+      tokenAddress: coinAddress,
+      recipient: account.address
+    });
+    receivedAmountOut = result.amount;
+    swapLogIndex = result.logIndex;
+  } catch (err) {
+    console.warn(
+      `Warning: transaction succeeded but could not determine received amount: ${err instanceof Error ? err.message : String(err)}`
+    );
+    console.warn(`Tx: ${txHash}`);
+  }
+  printTradeResult(json, {
+    coinName,
+    coinSymbol,
+    address: coinAddress,
+    spendAmount,
+    amountIn,
+    inputTokenSymbol: inputToken.symbol,
+    inputTokenDecimals: inputToken.decimals,
+    receivedAmountOut,
+    txHash
+  });
+  track("cli_buy", {
+    action: "trade",
+    coin_address: coinAddress,
+    coin_name: coinName,
+    coin_symbol: coinSymbol,
+    amount_mode: amountMode,
+    input_amount: amountIn.toString(),
+    input_token_symbol: inputToken.symbol,
+    swap_amount_usd: swapAmountUsd,
+    valueUsd: swapAmountUsd,
+    swapCoinType,
+    transactionHash: txHash,
+    logIndex: swapLogIndex,
+    slippage: slippagePct,
+    output_format: json ? "json" : "table",
+    success: true,
+    tx_hash: txHash
+  });
+});
+
+// src/commands/explore.tsx
+import { Command as Command4 } from "commander";
+import {
+  setApiKey as setApiKey3,
+  getCoinsTopVolume24h,
+  getCoinsMostValuable,
+  getCoinsNew,
+  getCoinsTopGainers,
+  getCoinsLastTraded,
+  getCoinsLastTradedUnique,
+  getExploreTopVolumeAll24h,
+  getExploreTopVolumeCreators24h,
+  getExploreNewAll,
+  getExploreFeaturedCreators,
+  getExploreFeaturedVideos,
+  getCreatorCoins,
+  getMostValuableCreatorCoins,
+  getMostValuableAll,
+  getMostValuableTrends,
+  getNewTrends,
+  getTopVolumeTrends24h,
+  getTrendingAll,
+  getTrendingCreators,
+  getTrendingPosts,
+  getTrendingTrends
+} from "@zoralabs/coins-sdk";
+
+// src/lib/types.ts
+var SORT_LABELS2 = {
+  mcap: "Top by Market Cap",
+  volume: "Top by 24h Volume",
+  new: "New",
+  gainers: "Top Gainers (24h)",
+  "last-traded": "Last Traded",
+  "last-traded-unique": "Last Traded (Unique)",
+  trending: "Trending",
+  featured: "Featured"
+};
+var TYPE_LABELS = {
+  all: "all",
+  trend: "trends",
+  "creator-coin": "creator coins",
+  post: "posts"
+};
+var COIN_TYPE_DISPLAY = {
+  CONTENT: "post",
+  CREATOR: "creator-coin",
+  TREND: "trend"
+};
+
+// src/components/ExploreView.tsx
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback3, useRef as useRef2 } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput2, useApp as useApp2 } from "ink";
+import Spinner2 from "ink-spinner";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var COLUMNS = [
+  { header: "#", width: 4, accessor: (c) => String(c.rank) },
+  { header: "Name", width: 20, accessor: (c) => c.name ?? "Unknown" },
+  { header: "Address", width: 44, accessor: (c) => c.address ?? "" },
+  {
+    header: "Type",
+    width: 14,
+    accessor: (c) => COIN_TYPE_DISPLAY[c.coinType ?? ""] ?? c.coinType ?? ""
+  },
+  {
+    header: "Market Cap",
+    width: 12,
+    accessor: (c) => formatCompactUsd(c.marketCap)
+  },
+  {
+    header: "24h Vol",
+    width: 12,
+    accessor: (c) => formatCompactUsd(c.volume24h)
+  },
+  {
+    header: "24h Change",
+    width: 11,
+    accessor: (c) => formatMcapChange(c.marketCap, c.marketCapDelta24h).text,
+    color: (c) => formatMcapChange(c.marketCap, c.marketCapDelta24h).color
+  }
+];
+var CACHE_TTL_MS = 6e4;
+var CACHE_KEY_FIRST = "__first__";
+var ExploreView = ({
+  fetchPage,
+  sort,
+  type,
+  limit,
+  initialCursor,
+  cacheTtlMs = CACHE_TTL_MS,
+  autoRefresh = false,
+  intervalSeconds = 30
+}) => {
+  const { exit } = useApp2();
+  const [loading, setLoading] = useState3(true);
+  const [error, setError] = useState3(null);
+  const [coins, setCoins] = useState3([]);
+  const [pageInfo, setPageInfo] = useState3(null);
+  const [page, setPage] = useState3(1);
+  const [cursorHistory, setCursorHistory] = useState3(
+    []
+  );
+  const [currentCursor, setCurrentCursor] = useState3(
+    initialCursor
+  );
+  const cache = useRef2(/* @__PURE__ */ new Map());
+  const { refreshCount, secondsUntilRefresh, triggerManualRefresh } = useAutoRefresh(intervalSeconds, autoRefresh);
+  const [manualRefreshCount, setManualRefreshCount] = useState3(0);
+  const loadPage = useCallback3(
+    async (cursor) => {
+      const cacheKey = cursor ?? CACHE_KEY_FIRST;
+      const cached = cache.current.get(cacheKey);
+      const isFresh = cached && Date.now() - cached.fetchedAt < cacheTtlMs;
+      if (isFresh) {
+        setCoins(cached.result.coins);
+        setPageInfo(cached.result.pageInfo ?? null);
+        setError(null);
+        setLoading(false);
+        return;
+      }
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await fetchPage(cursor);
+        cache.current.set(cacheKey, { result, fetchedAt: Date.now() });
+        setCoins(result.coins);
+        setPageInfo(result.pageInfo ?? null);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+      }
+      setLoading(false);
+    },
+    [fetchPage, cacheTtlMs]
+  );
+  useEffect3(() => {
+    if (refreshCount === 0) return;
+    const cacheKey = currentCursor ?? CACHE_KEY_FIRST;
+    cache.current.delete(cacheKey);
+  }, [refreshCount, currentCursor]);
+  useEffect3(() => {
+    loadPage(currentCursor);
+  }, [currentCursor, loadPage, refreshCount, manualRefreshCount]);
+  useInput2((input, key) => {
+    if (input === "q" || key.escape) {
+      exit();
+      return;
+    }
+    if (loading) return;
+    const canGoNext = pageInfo?.hasNextPage && pageInfo.endCursor;
+    const canGoPrev = cursorHistory.length > 0;
+    if ((input === "n" || key.rightArrow) && canGoNext) {
+      setCursorHistory((prev) => [...prev, currentCursor]);
+      setCurrentCursor(pageInfo.endCursor);
+      setPage((p) => p + 1);
+    }
+    if ((input === "p" || key.leftArrow) && canGoPrev) {
+      const prev = cursorHistory[cursorHistory.length - 1];
+      setCursorHistory((h) => h.slice(0, -1));
+      setCurrentCursor(prev);
+      setPage((p) => p - 1);
+    }
+    if (input === "r") {
+      const cacheKey = currentCursor ?? CACHE_KEY_FIRST;
+      cache.current.delete(cacheKey);
+      triggerManualRefresh();
+      setManualRefreshCount((c) => c + 1);
+    }
+  });
+  if (error) {
+    return /* @__PURE__ */ jsxs4(
+      Box4,
+      {
+        flexDirection: "column",
+        paddingLeft: 1,
+        paddingTop: 1,
+        paddingBottom: 1,
+        children: [
+          /* @__PURE__ */ jsxs4(Text4, { color: "red", children: [
+            "Error: ",
+            error
+          ] }),
+          /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Press q to exit" }) })
+        ]
+      }
+    );
+  }
+  if (loading) {
+    return /* @__PURE__ */ jsx4(Box4, { paddingLeft: 1, paddingTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(Spinner2, { type: "dots" }),
+      " Loading\u2026"
+    ] }) });
+  }
+  if (coins.length === 0) {
+    return /* @__PURE__ */ jsxs4(
+      Box4,
+      {
+        flexDirection: "column",
+        paddingLeft: 1,
+        paddingTop: 1,
+        paddingBottom: 1,
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { children: "No coins found." }),
+          /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, flexDirection: "column", children: [
+            /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Try a different sort or type:" }),
+            /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " zora explore --sort volume --type all" }),
+            /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " zora explore --sort new --type all" })
+          ] }),
+          /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Press q to exit" }) })
+        ]
+      }
+    );
+  }
+  const title = type !== "all" ? `${SORT_LABELS2[sort]} \xB7 ${TYPE_LABELS[type]}` : SORT_LABELS2[sort];
+  const subtitle = `Page ${page} \xB7 ${coins.length} result${coins.length !== 1 ? "s" : ""}`;
+  const rankedCoins = coins.map((c, i) => ({
+    ...c,
+    rank: (page - 1) * limit + i + 1
+  }));
+  const hints = [];
+  if (cursorHistory.length > 0) hints.push("\u2190 prev");
+  if (pageInfo?.hasNextPage) hints.push("\u2192 next");
+  hints.push("r refresh");
+  if (autoRefresh) hints.push(`auto: ${secondsUntilRefresh}s`);
+  hints.push("q quit");
+  const footer = hints.join("  \xB7  ");
+  return /* @__PURE__ */ jsx4(
+    Table,
+    {
+      data: rankedCoins,
+      columns: COLUMNS,
+      title,
+      subtitle,
+      footer
+    }
+  );
+};
+
+// src/commands/explore.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var QUERY_MAP = {
+  mcap: {
+    all: getMostValuableAll,
+    trend: getMostValuableTrends,
+    "creator-coin": getMostValuableCreatorCoins,
+    post: getCoinsMostValuable
+  },
+  volume: {
+    all: getExploreTopVolumeAll24h,
+    trend: getTopVolumeTrends24h,
+    "creator-coin": getExploreTopVolumeCreators24h,
+    post: getCoinsTopVolume24h
+  },
+  new: {
+    all: getExploreNewAll,
+    trend: getNewTrends,
+    "creator-coin": getCreatorCoins,
+    post: getCoinsNew
+  },
+  gainers: {
+    post: getCoinsTopGainers
+  },
+  "last-traded": {
+    post: getCoinsLastTraded
+  },
+  "last-traded-unique": {
+    post: getCoinsLastTradedUnique
+  },
+  trending: {
+    all: getTrendingAll,
+    trend: getTrendingTrends,
+    "creator-coin": getTrendingCreators,
+    post: getTrendingPosts
+  },
+  featured: {
+    "creator-coin": getExploreFeaturedCreators,
+    post: getExploreFeaturedVideos
+  }
+};
+var SORT_OPTIONS2 = Object.keys(SORT_LABELS2).join(", ");
+var exploreCommand = new Command4("explore").description("Browse top, new, and highest volume coins").option("--sort <sort>", `Sort by: ${SORT_OPTIONS2}`, "mcap").option(
+  "--type <type>",
+  "Filter by type: all, trend, creator-coin, post (availability varies by sort)",
+  "post"
+).option("--limit <n>", "Number of results (max 20)", "10").option("--after <cursor>", "Pagination cursor from a previous result").action(async function(opts) {
+  const output = getOutputMode(this, "live");
+  const json = output === "json";
+  const sort = opts.sort;
+  const type = opts.type;
+  const limit = parseInt(opts.limit, 10);
+  const after = opts.after;
+  if (isNaN(limit) || limit <= 0 || limit > 20) {
+    outputErrorAndExit(
+      json,
+      `Invalid --limit value: ${opts.limit}. Must be an integer between 1 and 20.`,
+      "Usage: zora explore --limit 10"
+    );
+  }
+  if (!QUERY_MAP[sort]) {
+    outputErrorAndExit(
+      json,
+      `Invalid --sort value: ${sort}.`,
+      `Supported: ${SORT_OPTIONS2}`
+    );
+  }
+  if (!QUERY_MAP[sort][type]) {
+    const supported = Object.keys(QUERY_MAP[sort]);
+    outputErrorAndExit(
+      json,
+      `Invalid --type for --sort ${sort}.`,
+      `Supported: ${supported.join(", ")}`
+    );
+  }
+  const apiKey = getApiKey();
+  if (apiKey) {
+    setApiKey3(apiKey);
+  }
+  const queryFn = QUERY_MAP[sort][type];
+  if (json) {
+    let response;
+    try {
+      response = await queryFn({ count: limit, after });
+    } catch (err) {
+      outputErrorAndExit(
+        json,
+        `Request failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (response.error) {
+      const msg = typeof response.error === "object" && response.error.error ? response.error.error : JSON.stringify(response.error);
+      outputErrorAndExit(json, `API error: ${msg}`);
+    }
+    const edges = response.data?.exploreList?.edges ?? [];
+    const coins = edges.map((e) => e.node);
+    const pageInfo = response.data?.exploreList?.pageInfo;
+    outputJson({ coins, pageInfo: pageInfo ?? null });
+    track("cli_explore", {
+      sort,
+      type,
+      limit,
+      paginated: after !== void 0,
+      result_count: coins.length,
+      has_next_page: pageInfo?.hasNextPage ?? false,
+      output_format: "json"
+    });
+  } else {
+    const { live, intervalSeconds } = getLiveConfig(this, "live");
+    const fetchPage = async (cursor) => {
+      const response = await queryFn({ count: limit, after: cursor });
+      if (response.error) {
+        const msg = typeof response.error === "object" && response.error.error ? response.error.error : JSON.stringify(response.error);
+        throw new Error(msg);
+      }
+      const edges = response.data?.exploreList?.edges ?? [];
+      const coins = edges.map((e) => e.node);
+      const pageInfo = response.data?.exploreList?.pageInfo;
+      return { coins, pageInfo };
+    };
+    await renderLive(
+      /* @__PURE__ */ jsx5(
+        ExploreView,
+        {
+          fetchPage,
+          sort,
+          type,
+          limit,
+          initialCursor: after,
+          autoRefresh: live,
+          intervalSeconds
+        }
+      )
+    );
+    track("cli_explore", {
+      sort,
+      type,
+      limit,
+      live,
+      interval: intervalSeconds,
+      paginated: after !== void 0,
+      output_format: "text"
+    });
+  }
+});
+
+// src/commands/get.tsx
+import { Command as Command5 } from "commander";
+import { setApiKey as setApiKey4 } from "@zoralabs/coins-sdk";
+
+// src/lib/coin-ref.ts
+import { getCoin as getCoin2, getProfile, getTrend } from "@zoralabs/coins-sdk";
+var COIN_TYPE_MAP = {
+  CONTENT: "post",
+  CREATOR: "creator-coin",
+  TREND: "trend"
+};
+function mapCoinType(raw) {
+  if (!raw) return "unknown";
+  return COIN_TYPE_MAP[raw] ?? "unknown";
+}
+function coinFromToken(token) {
+  return {
+    name: token.name ?? "Unknown",
+    address: token.address ?? "",
+    coinType: mapCoinType(token.coinType),
+    marketCap: token.marketCap ?? "0",
+    marketCapDelta24h: token.marketCapDelta24h ?? "0",
+    volume24h: token.volume24h ?? "0",
+    uniqueHolders: token.uniqueHolders ?? 0,
+    createdAt: token.createdAt,
+    creatorAddress: token.creatorAddress,
+    creatorHandle: token.creatorProfile?.handle
+  };
+}
+function parseCoinRef(identifier, type) {
+  if (identifier.startsWith("0x")) {
+    return { kind: "address", address: identifier };
+  }
+  if (type === "creator-coin") {
+    return { kind: "prefixed", type: "creator-coin", name: identifier };
+  }
+  if (type === "trend") {
+    return { kind: "prefixed", type: "trend", name: identifier };
+  }
+  return { kind: "ambiguous", name: identifier };
+}
+async function resolveByAddress(address) {
+  const response = await getCoin2({ address });
+  if (response.error || !response.data?.zora20Token) {
+    return {
+      kind: "not-found",
+      message: `No coin found at address ${address}`
+    };
+  }
+  return { kind: "found", coin: coinFromToken(response.data.zora20Token) };
+}
+async function resolveByTrendTicker(ticker) {
+  const response = await getTrend({ ticker });
+  if (response.error || !response.data?.trendCoin) {
+    return {
+      kind: "not-found",
+      message: `No trend coin found with ticker "${ticker}"`
+    };
+  }
+  return { kind: "found", coin: coinFromToken(response.data.trendCoin) };
+}
+async function resolveByCreatorName(name) {
+  const response = await getProfile({ identifier: name });
+  if (response.error || !response.data?.profile) {
+    return {
+      kind: "not-found",
+      message: `No creator found with name "${name}"`
+    };
+  }
+  const profile = response.data.profile;
+  if (!profile.creatorCoin) {
+    return {
+      kind: "not-found",
+      message: `"${name}" does not have a creator coin`
+    };
+  }
+  return resolveByAddress(profile.creatorCoin.address);
+}
+async function resolveCoin(ref) {
+  switch (ref.kind) {
+    case "address":
+      return resolveByAddress(ref.address);
+    case "prefixed":
+      if (ref.type === "trend") {
+        return resolveByTrendTicker(ref.name);
+      }
+      return resolveByCreatorName(ref.name);
+    case "ambiguous":
+      return resolveByCreatorName(ref.name);
+  }
+}
+
+// src/components/CoinDetail.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var LABEL_WIDTH = 18;
+function Row({
+  label,
+  children
+}) {
+  return /* @__PURE__ */ jsxs5(Box5, { children: [
+    /* @__PURE__ */ jsx6(Box5, { width: LABEL_WIDTH, flexShrink: 0, children: /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: label }) }),
+    /* @__PURE__ */ jsx6(Text5, { children })
+  ] });
+}
+function CoinDetail({ coin }) {
+  const change = formatMcapChange(coin.marketCap, coin.marketCapDelta24h);
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingLeft: 1, children: [
+    /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text5, { bold: true, children: coin.name }),
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        coin.coinType,
+        " ",
+        "\xB7",
+        " ",
+        coin.address
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Row, { label: "Market Cap", children: formatCompactUsd(coin.marketCap) }),
+      /* @__PURE__ */ jsx6(Row, { label: "24h Volume", children: formatCompactUsd(coin.volume24h) }),
+      /* @__PURE__ */ jsx6(Row, { label: "24h Change", children: /* @__PURE__ */ jsx6(Text5, { color: change.color, children: change.text }) }),
+      /* @__PURE__ */ jsx6(Row, { label: "Holders", children: formatHolders(coin.uniqueHolders) }),
+      coin.coinType === "post" && (coin.creatorHandle ?? coin.creatorAddress) && /* @__PURE__ */ jsx6(Row, { label: "Creator", children: coin.creatorHandle ?? coin.creatorAddress }),
+      /* @__PURE__ */ jsx6(Row, { label: "Created", children: formatCreatedAt(coin.createdAt) })
+    ] }),
+    /* @__PURE__ */ jsx6(Box5, { marginBottom: 1 })
+  ] });
+}
+
+// src/commands/get.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function formatCoinJson(coin) {
+  return {
+    name: coin.name,
+    address: coin.address,
+    coinType: coin.coinType,
+    marketCap: coin.marketCap,
+    marketCapDelta24h: coin.marketCapDelta24h,
+    volume24h: coin.volume24h,
+    uniqueHolders: coin.uniqueHolders,
+    createdAt: coin.createdAt ?? null,
+    creatorAddress: coin.creatorAddress ?? null,
+    creatorHandle: coin.creatorHandle ?? null
+  };
+}
+var VALID_TYPES = ["creator-coin", "post", "trend"];
+var getCommand = new Command5("get").description("Look up a coin by address or name").argument("<identifier>", "Coin address (0x...) or creator name").option("--type <type>", "Coin type: creator-coin, post, trend").action(async function(identifier, opts) {
+  const json = getJson(this);
+  if (opts.type !== void 0 && !VALID_TYPES.includes(opts.type)) {
+    outputErrorAndExit(
+      json,
+      `Invalid --type value: ${opts.type}.`,
+      `Supported: ${VALID_TYPES.join(", ")}`
+    );
+  }
+  const type = opts.type;
+  if (type === "post" && !identifier.startsWith("0x")) {
+    outputErrorAndExit(
+      json,
+      "Posts can only be looked up by address.",
+      "Use: zora get 0x..."
+    );
+  }
+  const ref = parseCoinRef(identifier, opts.type);
+  const apiKey = getApiKey();
+  if (apiKey) {
+    setApiKey4(apiKey);
+  }
+  let result;
+  try {
+    result = await resolveCoin(ref);
+  } catch (err) {
+    outputErrorAndExit(
+      json,
+      `Request failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return;
+  }
+  if (type && result.kind === "found" && result.coin.coinType !== type) {
+    outputErrorAndExit(
+      json,
+      `Coin at ${result.coin.address} is a ${result.coin.coinType}, not a ${type}.`,
+      `Use: zora get ${result.coin.address} --type ${result.coin.coinType}`
+    );
+    return;
+  }
+  if (result.kind === "not-found") {
+    outputErrorAndExit(json, result.message);
+    return;
+  }
+  outputData(json, {
+    json: formatCoinJson(result.coin),
+    table: () => {
+      renderOnce(/* @__PURE__ */ jsx7(CoinDetail, { coin: result.coin }));
+    }
+  });
+  track("cli_get", {
+    lookup_type: identifier.startsWith("0x") ? "address" : "name",
+    coin_type_filter: type ?? null,
+    found: result.kind === "found",
+    coin_type: result.kind === "found" ? result.coin.coinType : null,
+    output_format: json ? "json" : "text"
+  });
+});
+
+// src/commands/price-history.tsx
+import { Command as Command6 } from "commander";
+import { setApiKey as setApiKey5, apiGet } from "@zoralabs/coins-sdk";
+
+// src/components/PriceHistory.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var LABEL_WIDTH2 = 18;
+var Row2 = ({
+  label,
+  children
+}) => /* @__PURE__ */ jsxs6(Box6, { children: [
+  /* @__PURE__ */ jsx8(Box6, { width: LABEL_WIDTH2, flexShrink: 0, children: /* @__PURE__ */ jsx8(Text6, { dimColor: true, children: label }) }),
+  /* @__PURE__ */ jsx8(Text6, { children })
+] });
+var PriceHistory = ({
+  coin,
+  coinType,
+  interval,
+  high,
+  low,
+  change,
+  sparklineText
+}) => /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingLeft: 1, children: [
+  /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Row2, { label: "Coin", children: coin }),
+    /* @__PURE__ */ jsx8(Row2, { label: "Type", children: coinType }),
+    /* @__PURE__ */ jsx8(Row2, { label: "Interval", children: interval }),
+    /* @__PURE__ */ jsx8(Row2, { label: "High", children: high }),
+    /* @__PURE__ */ jsx8(Row2, { label: "Low", children: low }),
+    /* @__PURE__ */ jsx8(Row2, { label: "Change", children: /* @__PURE__ */ jsx8(Text6, { color: change.color, children: change.text }) })
+  ] }),
+  sparklineText.length > 0 && /* @__PURE__ */ jsx8(Box6, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx8(Text6, { children: sparklineText }) }),
+  /* @__PURE__ */ jsx8(Box6, { marginBottom: 1 })
+] });
+
+// src/lib/sparkline.ts
+var BLOCKS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+var sparkline = (values) => {
+  if (values.length <= 1) return values.length === 1 ? BLOCKS[4] : "";
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const range = max - min;
+  if (range === 0) return BLOCKS[4].repeat(values.length);
+  return values.map((v) => {
+    const idx = Math.round((v - min) / range * (BLOCKS.length - 1));
+    return BLOCKS[idx];
+  }).join("");
+};
+var MAX_SPARKLINE_WIDTH = 50;
+var downsample = (values, maxWidth) => {
+  if (values.length <= maxWidth) return values;
+  const bucketSize = values.length / maxWidth;
+  const result = [];
+  for (let i = 0; i < maxWidth; i++) {
+    const start = Math.floor(i * bucketSize);
+    const end = Math.floor((i + 1) * bucketSize);
+    let sum = 0;
+    for (let j = start; j < end; j++) {
+      sum += values[j];
+    }
+    result.push(sum / (end - start));
+  }
+  return result;
+};
+
+// src/commands/price-history.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var VALID_TYPES2 = ["creator-coin", "post", "trend"];
+var VALID_INTERVALS = ["1h", "24h", "1w", "1m", "ALL"];
+var INTERVAL_TO_API_FIELD = {
+  "1h": "oneHour",
+  "24h": "oneDay",
+  "1w": "oneWeek",
+  "1m": "oneMonth",
+  ALL: "all"
+};
+var formatPrice = (price) => {
+  if (price >= 1) {
+    return `$${price.toFixed(2)}`;
+  }
+  if (price >= 0.01) {
+    return `$${price.toFixed(4)}`;
+  }
+  return `$${price.toPrecision(4)}`;
+};
+var formatChange = (first, last) => {
+  if (first === 0) return { text: "-", color: void 0 };
+  const pct = (last - first) / first * 100;
+  const prefix = pct >= 0 ? "+" : "";
+  const text = `${prefix}${pct.toFixed(1)}%`;
+  const color = pct > 0 ? "green" : pct < 0 ? "red" : void 0;
+  return { text, color };
+};
+var fetchPriceHistory = async (address, interval) => {
+  const response = await apiGet("/coinPriceHistory", {
+    address
+  });
+  const data = response.data;
+  const token = data?.zora20Token;
+  if (!token) return [];
+  const field = INTERVAL_TO_API_FIELD[interval];
+  const points = token[field];
+  if (!points || points.length === 0) return [];
+  return points.map((p) => ({
+    timestamp: p.timestamp,
+    price: Number(p.closePrice)
+  }));
+};
+var priceHistoryCommand = new Command6("price-history").description("Display price history for a coin").argument("<identifier>", "Coin address (0x...) or name").option("--type <type>", "Coin type: creator-coin, post, trend").option(
+  "--interval <interval>",
+  `Time range: ${VALID_INTERVALS.join(", ")}`,
+  "1w"
+).action(async function(identifier, opts) {
+  const json = getJson(this);
+  const interval = opts.interval ?? "1w";
+  if (!VALID_INTERVALS.includes(interval)) {
+    outputErrorAndExit(
+      json,
+      `Invalid --interval value: ${interval}.`,
+      `Supported: ${VALID_INTERVALS.join(", ")}`
+    );
+  }
+  if (opts.type !== void 0 && !VALID_TYPES2.includes(opts.type)) {
+    outputErrorAndExit(
+      json,
+      `Invalid --type value: ${opts.type}.`,
+      `Supported: ${VALID_TYPES2.join(", ")}`
+    );
+  }
+  if (opts.type === "post" && !identifier.startsWith("0x")) {
+    outputErrorAndExit(
+      json,
+      "Posts can only be looked up by address.",
+      "Use: zora price-history 0x..."
+    );
+  }
+  const ref = parseCoinRef(identifier, opts.type);
+  const apiKey = getApiKey();
+  if (apiKey) {
+    setApiKey5(apiKey);
+  }
+  let result;
+  try {
+    result = await resolveCoin(ref);
+  } catch (err) {
+    outputErrorAndExit(
+      json,
+      `Request failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return;
+  }
+  if (result.kind === "not-found") {
+    outputErrorAndExit(json, result.message, result.suggestion);
+    return;
+  }
+  const { coin } = result;
+  let prices;
+  try {
+    prices = await fetchPriceHistory(coin.address, interval);
+  } catch (err) {
+    outputErrorAndExit(
+      json,
+      `Failed to fetch price data: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return;
+  }
+  if (prices.length === 0) {
+    outputErrorAndExit(
+      json,
+      `No price data found for ${coin.name} in the last ${interval}.`,
+      "Try a longer interval with --interval"
+    );
+    return;
+  }
+  const priceValues = prices.map((p) => p.price);
+  const high = Math.max(...priceValues);
+  const low = Math.min(...priceValues);
+  const change = formatChange(
+    priceValues[0],
+    priceValues[priceValues.length - 1]
+  );
+  const sparklineText = sparkline(
+    downsample(priceValues, MAX_SPARKLINE_WIDTH)
+  );
+  outputData(json, {
+    json: {
+      coin: coin.name,
+      type: coin.coinType,
+      interval,
+      high,
+      low,
+      change: priceValues[0] === 0 ? null : (priceValues[priceValues.length - 1] - priceValues[0]) / priceValues[0],
+      prices: prices.map((p) => ({
+        timestamp: p.timestamp,
+        price: p.price
+      }))
+    },
+    table: () => {
+      renderOnce(
+        /* @__PURE__ */ jsx9(
+          PriceHistory,
+          {
+            coin: coin.name,
+            coinType: coin.coinType,
+            interval,
+            high: formatPrice(high),
+            low: formatPrice(low),
+            change,
+            sparklineText
+          }
+        )
+      );
+    }
+  });
+  track("cli_price_history", {
+    lookup_type: identifier.startsWith("0x") ? "address" : "name",
+    coin_type: coin.coinType,
+    interval,
+    data_points: prices.length,
+    output_format: json ? "json" : "text"
+  });
+});
+
+// src/commands/sell.ts
+import { Command as Command7 } from "commander";
+import confirm3 from "@inquirer/confirm";
+import {
+  erc20Abi as erc20Abi3,
+  formatUnits as formatUnits4,
+  isAddress as isAddress2,
+  parseUnits as parseUnits2
+} from "viem";
+import {
+  createTradeCall as createTradeCall2,
+  getCoin as getCoin3,
+  setApiKey as setApiKey6,
+  tradeCoin as tradeCoin2
+} from "@zoralabs/coins-sdk";
+function printSellQuote(output, info) {
+  if (output === "json") {
+    outputJson({
+      action: "quote",
+      coin: info.coinSymbol,
+      address: info.address,
+      sell: {
+        amount: formatUnits4(info.amountIn, info.coinDecimals),
+        raw: info.amountIn.toString(),
+        symbol: info.coinSymbol
+      },
+      estimated: {
+        amount: formatUnits4(BigInt(info.quoteAmountOut), info.outputDecimals),
+        raw: info.quoteAmountOut,
+        symbol: info.outputSymbol
+      },
+      slippage: info.slippagePct
+    });
+    return;
+  }
+  console.log(`
+ Sell ${info.coinName} (${info.coinSymbol})
+`);
+  console.log(`   Amount       ${info.soldFormatted} ${info.coinSymbol}`);
+  console.log(
+    `   You get      ~${info.receivedFormatted} ${info.outputSymbol}`
+  );
+  console.log(`   Slippage     ${info.slippagePct}%
+`);
+}
+function printSellResult(output, info) {
+  const receivedAmount = formatUnits4(
+    info.receivedAmountOut,
+    info.outputDecimals
+  );
+  const receivedFormatted = formatAmountDisplay(
+    info.receivedAmountOut,
+    info.outputDecimals
+  );
+  if (output === "json") {
+    outputJson({
+      action: "sell",
+      coin: info.coinSymbol,
+      address: info.address,
+      sold: {
+        amount: formatUnits4(info.amountIn, info.coinDecimals),
+        raw: info.amountIn.toString(),
+        symbol: info.coinSymbol
+      },
+      received: {
+        amount: receivedAmount,
+        raw: info.receivedAmountOut.toString(),
+        symbol: info.outputSymbol,
+        source: info.receivedSource
+      },
+      tx: info.txHash
+    });
+    return;
+  }
+  console.log(`
+ Sold ${info.coinName}
+`);
+  console.log(`   Sold         ${info.soldFormatted} ${info.coinSymbol}`);
+  console.log(
+    `   Received     ${info.receivedSource === "quote" ? "~" : ""}${receivedFormatted} ${info.outputSymbol}`
+  );
+  if (info.receivedSource === "quote") {
+    console.log("   Note         based on quote");
+  }
+  console.log(`   Tx           ${info.txHash}
+`);
+}
+var sellCommand = new Command7("sell").description("Sell a coin").argument("<address>", "Coin contract address (0x\u2026)").option("--amount <value>", "Sell specific number of coins").option("--usd <value>", "Sell USD equivalent worth of coins").option("--percent <value>", "Sell percentage of coin balance").option("--all", "Sell entire coin balance").option("--to <asset>", "Receive asset: eth, usdc, zora", "eth").option("--token <asset>", "Receive asset: eth, usdc, zora (alias for --to)").option("--quote", "Print quote and exit without trading").option("--yes", "Skip confirmation and execute directly").option("--slippage <pct>", "Slippage tolerance percent", "1").option("--debug", "Print full quote request/response JSON").action(async function(coinAddress, opts) {
+  const json = getJson(this);
+  const debug = opts.debug === true;
+  if (!isAddress2(coinAddress)) {
+    outputErrorAndExit(json, `Invalid address: ${coinAddress}`);
+  }
+  const output = json ? "json" : "table";
+  const outputAsset = opts.token ? opts.token.toLowerCase() : opts.to;
+  if (!(outputAsset in BASE_TRADE_TOKENS)) {
+    outputErrorAndExit(
+      json,
+      `Invalid --${opts.token ? "token" : "to"} value: ${outputAsset}. Use: eth, usdc, zora`
+    );
+  }
+  const outputToken = BASE_TRADE_TOKENS[outputAsset];
+  const amountMode = getAmountMode(
+    json,
+    opts,
+    SELL_AMOUNT_CHECKS,
+    "--amount, --usd, --percent, or --all"
+  );
+  const slippagePct = parsePercentageLikeValue(opts.slippage);
+  if (slippagePct === void 0 || slippagePct < 0 || slippagePct > 99) {
+    outputErrorAndExit(
+      json,
+      "Invalid --slippage value. Must be between 0 and 99."
+    );
+  }
+  const slippage = slippagePct / 100;
+  const apiKey = getApiKey();
+  if (apiKey) {
+    setApiKey6(apiKey);
+  }
+  const account = resolveAccount(json);
+  const { publicClient, walletClient } = createClients(account);
+  let token;
+  try {
+    const response = await getCoin3({ address: coinAddress });
+    token = response.data?.zora20Token;
+  } catch (err) {
+    outputErrorAndExit(
+      json,
+      `Failed to fetch coin: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!token) {
+    outputErrorAndExit(json, `Coin not found: ${coinAddress}`);
+  }
+  const coinName = token.name;
+  const coinSymbol = token.symbol;
+  const coinDecimals = Number(token.decimals ?? 18);
+  let amountIn;
+  if (amountMode === "usd") {
+    const usdVal = parsePercentageLikeValue(opts.usd);
+    if (usdVal === void 0 || usdVal <= 0) {
+      outputErrorAndExit(
+        json,
+        "Invalid --usd value. Must be a positive number."
+      );
+      return;
+    }
+    const coinPriceUsd = await fetchTokenPriceUsd(coinAddress);
+    if (coinPriceUsd === null || coinPriceUsd <= 0) {
+      outputErrorAndExit(
+        json,
+        `Failed to fetch ${coinSymbol} price for USD conversion.`
+      );
+      return;
+    }
+    const coinAmount = usdVal / coinPriceUsd;
+    amountIn = parseUnits2(coinAmount.toFixed(coinDecimals), coinDecimals);
+    if (amountIn === 0n) {
+      outputErrorAndExit(json, "Calculated amount is zero. USD too small.");
+    }
+    if (debug) {
+      console.error(
+        `[debug] $${usdVal} USD = ${formatUnits4(amountIn, coinDecimals)} ${coinSymbol} (coin price: $${coinPriceUsd})`
+      );
+    }
+  } else if (amountMode === "amount") {
+    const val = parsePercentageLikeValue(opts.amount);
+    if (val === void 0 || val <= 0) {
+      outputErrorAndExit(
+        json,
+        "Invalid --amount value. Must be a positive number."
+      );
+    }
+    try {
+      amountIn = parseUnits2(opts.amount, coinDecimals);
+    } catch {
+      outputErrorAndExit(json, "Invalid --amount value for token decimals.");
+    }
+  } else {
+    const balance = await publicClient.readContract({
+      abi: erc20Abi3,
+      address: coinAddress,
+      functionName: "balanceOf",
+      args: [account.address]
+    });
+    if (balance === 0n) {
+      outputErrorAndExit(
+        json,
+        `No ${coinSymbol} balance. Buy some first or pick a different wallet.`
+      );
+    }
+    if (amountMode === "all") {
+      amountIn = balance;
+    } else {
+      const pct = parsePercentageLikeValue(opts.percent);
+      if (pct === void 0 || pct <= 0 || pct > 100) {
+        outputErrorAndExit(
+          json,
+          "Invalid --percent value. Must be between 0 and 100."
+        );
+      }
+      amountIn = pct === 100 ? balance : balance * BigInt(Math.round(pct * 100)) / 10000n;
+      if (amountIn === 0n) {
+        outputErrorAndExit(
+          json,
+          "Calculated amount is zero. Balance too low."
+        );
+      }
+    }
+  }
+  let swapAmountUsd;
+  if (amountMode === "usd") {
+    swapAmountUsd = parsePercentageLikeValue(opts.usd);
+  } else {
+    const coinPriceUsd = await fetchTokenPriceUsd(coinAddress);
+    if (coinPriceUsd !== null && coinPriceUsd > 0) {
+      swapAmountUsd = Number(
+        (Number(formatUnits4(amountIn, coinDecimals)) * coinPriceUsd).toFixed(
+          2
+        )
+      );
+    }
+  }
+  const tradeParameters = {
+    sell: { type: "erc20", address: coinAddress },
+    buy: outputToken.trade,
+    amountIn,
+    slippage,
+    sender: account.address
+  };
+  if (debug) {
+    printDebugRequest("sell", tradeParameters);
+  }
+  let quoteAmountOut;
+  try {
+    const quote = await createTradeCall2(tradeParameters);
+    if (debug) {
+      printDebugResponse("sell", quote);
+    }
+    if (!quote.quote?.amountOut || quote.quote.amountOut === "0") {
+      outputErrorAndExit(
+        json,
+        "Quote returned zero output. Amount may be too small."
+      );
+    }
+    quoteAmountOut = quote.quote.amountOut;
+  } catch (err) {
+    if (debug) {
+      console.error(
+        `
+[debug] sell \u2014 Quote Error:
+${err instanceof Error ? err.stack || err.message : String(err)}
+`
+      );
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    const errorType = err?.errorType;
+    const errorBody = err?.errorBody;
+    if (errorType === "LIQUIDITY" || msg.includes("Not enough liquidity")) {
+      if (json) {
+        outputJson({ error: errorBody ?? msg });
+        process.exit(1);
+      }
+      outputErrorAndExit(
+        json,
+        "Not enough available liquidity for your swap. Please try swapping fewer tokens."
+      );
+    }
+    outputErrorAndExit(
+      json,
+      `Quote failed: ${msg}`,
+      "Check the coin address and amount, then try again. Use --debug for full error details."
+    );
+  }
+  const soldFormatted = formatAmountDisplay(amountIn, coinDecimals);
+  const receivedFormatted = formatAmountDisplay(
+    BigInt(quoteAmountOut),
+    outputToken.decimals
+  );
+  if (opts.quote) {
+    printSellQuote(output, {
+      coinName,
+      coinSymbol,
+      address: coinAddress,
+      soldFormatted,
+      amountIn,
+      coinDecimals,
+      receivedFormatted,
+      quoteAmountOut,
+      outputSymbol: outputToken.symbol,
+      outputDecimals: outputToken.decimals,
+      slippagePct
+    });
+    track("cli_sell", {
+      action: "quote",
+      coin_address: coinAddress,
+      coin_name: coinName,
+      coin_symbol: coinSymbol,
+      amount_mode: amountMode,
+      swap_amount_usd: swapAmountUsd,
+      valueUsd: swapAmountUsd,
+      swapCoinType: token.coinType ?? null,
+      output_asset: outputAsset,
+      slippage: slippagePct,
+      output_format: output
+    });
+    return;
+  }
+  if (!opts.yes) {
+    printSellQuote("table", {
+      coinName,
+      coinSymbol,
+      address: coinAddress,
+      soldFormatted,
+      amountIn,
+      coinDecimals,
+      receivedFormatted,
+      quoteAmountOut,
+      outputSymbol: outputToken.symbol,
+      outputDecimals: outputToken.decimals,
+      slippagePct
+    });
+    const ok = await confirm3({
+      message: "Confirm?",
+      default: false
+    });
+    if (!ok) {
+      console.error("Aborted.");
+      process.exit(0);
+    }
+  }
+  let receipt;
+  let txHash;
+  let receivedAmountOut = BigInt(quoteAmountOut);
+  let receivedSource = "quote";
+  let swapLogIndex = null;
+  const swapCoinType = token.coinType ?? null;
+  try {
+    receipt = await tradeCoin2({
+      tradeParameters,
+      walletClient,
+      publicClient,
+      account
+    });
+  } catch (err) {
+    track("cli_sell", {
+      action: "trade",
+      coin_address: coinAddress,
+      coin_name: coinName,
+      coin_symbol: coinSymbol,
+      amount_mode: amountMode,
+      swap_amount_usd: swapAmountUsd,
+      valueUsd: swapAmountUsd,
+      swapCoinType,
+      output_asset: outputAsset,
+      slippage: slippagePct,
+      output_format: output,
+      success: false,
+      error_type: err instanceof Error ? err.constructor.name : "unknown"
+    });
+    await shutdownAnalytics();
+    outputErrorAndExit(
+      json,
+      `Transaction failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  txHash = receipt.transactionHash;
+  if (outputToken.trade.type === "erc20") {
+    try {
+      const result = getReceivedAmountFromReceipt({
+        receipt,
+        tokenAddress: outputToken.trade.address,
+        recipient: account.address
+      });
+      receivedAmountOut = result.amount;
+      swapLogIndex = result.logIndex;
+      receivedSource = "receipt";
+    } catch {
+    }
+  }
+  printSellResult(output, {
+    coinName,
+    coinSymbol,
+    address: coinAddress,
+    amountIn,
+    coinDecimals,
+    soldFormatted,
+    receivedAmountOut,
+    outputSymbol: outputToken.symbol,
+    outputDecimals: outputToken.decimals,
+    receivedSource,
+    txHash
+  });
+  track("cli_sell", {
+    action: "trade",
+    coin_address: coinAddress,
+    coin_name: coinName,
+    coin_symbol: coinSymbol,
+    amount_mode: amountMode,
+    swap_amount_usd: swapAmountUsd,
+    valueUsd: swapAmountUsd,
+    swapCoinType,
+    transactionHash: txHash,
+    logIndex: swapLogIndex,
+    output_asset: outputAsset,
+    slippage: slippagePct,
+    output_format: output,
+    success: true,
+    tx_hash: txHash
+  });
+});
+
+// src/commands/send.ts
+import { Command as Command8 } from "commander";
+import confirm4 from "@inquirer/confirm";
+import {
+  erc20Abi as erc20Abi4,
+  formatUnits as formatUnits5,
+  isAddress as isAddress3,
+  parseUnits as parseUnits3
+} from "viem";
+import { setApiKey as setApiKey7 } from "@zoralabs/coins-sdk";
+var SEND_AMOUNT_CHECKS = {
+  amount: (opts) => opts.amount !== void 0,
+  percent: (opts) => opts.percent !== void 0,
+  all: (opts) => opts.all === true
+};
+var VALID_TYPES3 = ["creator-coin", "post", "trend"];
+function printSendPreview(info) {
+  const usdStr = info.amountUsd != null ? ` ($${info.amountUsd.toFixed(2)})` : "";
+  console.log(`
+ Send ${info.name} (${info.symbol})
+`);
+  console.log(
+    `   Amount       ${info.amountFormatted} ${info.symbol}${usdStr}`
+  );
+  console.log(`   To           ${info.to}`);
+  console.log(`
+   Ensure receiving wallet can receive on Base.`);
+  console.log("");
+}
+function printSendResult(json, info) {
+  if (json) {
+    outputJson({
+      action: "send",
+      coin: info.symbol,
+      address: info.address,
+      sent: {
+        amount: formatUnits5(info.amount, info.decimals),
+        raw: info.amount.toString(),
+        symbol: info.symbol,
+        amountUsd: info.amountUsd
+      },
+      to: info.to,
+      tx: info.txHash
+    });
+    return;
+  }
+  const usdStr = info.amountUsd != null ? ` ($${info.amountUsd.toFixed(2)})` : "";
+  console.log(`
+ Sent ${info.name}
+`);
+  console.log(
+    `   Amount       ${info.amountFormatted} ${info.symbol}${usdStr}`
+  );
+  console.log(`   To           ${info.to}`);
+  console.log(`   Tx           ${info.txHash}
+`);
+}
+var sendCommand = new Command8("send").description("Send coins or ETH to an address").argument("<identifier>", "Coin address, name, or token (eth, usdc, zora)").requiredOption("--to <address>", "Recipient address (0x...)").option("--type <type>", "Coin type: creator-coin, post, trend").option("--amount <value>", "Send specific amount").option("--percent <value>", "Send percentage of balance (1-100)").option("--all", "Send entire balance").option("--yes", "Skip confirmation").action(async function(identifier, opts) {
+  const json = getJson(this);
+  if (!isAddress3(opts.to)) {
+    outputErrorAndExit(
+      json,
+      `Invalid recipient address: ${opts.to}`,
+      "Must be a valid 0x address."
+    );
+  }
+  const recipient = opts.to;
+  if (opts.type !== void 0 && !VALID_TYPES3.includes(opts.type)) {
+    outputErrorAndExit(
+      json,
+      `Invalid --type value: ${opts.type}.`,
+      `Supported: ${VALID_TYPES3.join(", ")}`
+    );
+  }
+  const amountMode = getAmountMode(
+    json,
+    opts,
+    SEND_AMOUNT_CHECKS,
+    "--amount, --percent, or --all"
+  );
+  const isEth = identifier.toLowerCase() === "eth";
+  if (isEth) {
+    if (opts.type) {
+      outputErrorAndExit(json, "--type is not valid when sending ETH.");
+    }
+    const account = resolveAccount(json);
+    const { publicClient, walletClient } = createClients(account);
+    const balance = await publicClient.getBalance({
+      address: account.address
+    });
+    if (balance === 0n) {
+      outputErrorAndExit(
+        json,
+        `No ETH balance. Deposit ETH to ${account.address} on Base.`
+      );
+    }
+    let amount;
+    if (amountMode === "amount") {
+      const val = parsePercentageLikeValue(opts.amount);
+      if (val === void 0 || val <= 0) {
+        outputErrorAndExit(
+          json,
+          "Invalid --amount value. Must be a positive number."
+        );
+      }
+      try {
+        amount = parseUnits3(opts.amount, 18);
+      } catch {
+        outputErrorAndExit(
+          json,
+          "Invalid --amount value. Must be a valid ETH amount."
+        );
+      }
+      if (amount === 0n) {
+        outputErrorAndExit(
+          json,
+          "Amount too small \u2014 rounds to zero at 18 decimal places."
+        );
+      }
+      if (amount + GAS_RESERVE > balance) {
+        outputErrorAndExit(
+          json,
+          `Insufficient balance. Have ${formatEthDisplay(balance)} ETH (need to reserve ~${formatEthDisplay(GAS_RESERVE)} ETH for gas).`
+        );
+      }
+    } else {
+      if (balance <= GAS_RESERVE) {
+        outputErrorAndExit(
+          json,
+          `Balance too low (${formatEthDisplay(balance)} ETH). Need >${formatEthDisplay(GAS_RESERVE)} ETH for gas.`
+        );
+      }
+      const spendable = balance - GAS_RESERVE;
+      if (amountMode === "all") {
+        amount = spendable;
+      } else {
+        const pct = parsePercentageLikeValue(opts.percent);
+        if (pct === void 0 || pct <= 0 || pct > 100) {
+          outputErrorAndExit(
+            json,
+            "Invalid --percent value. Must be between 0 and 100."
+          );
+        }
+        amount = pct === 100 ? spendable : spendable * BigInt(Math.round(pct * 100)) / 10000n;
+        if (amount === 0n) {
+          outputErrorAndExit(
+            json,
+            "Calculated amount is zero. Balance too low."
+          );
+        }
+      }
+    }
+    const amountFormatted = formatEthDisplay(amount);
+    let amountUsd = null;
+    const ethPriceUsd = await fetchTokenPriceUsd(WETH_ADDRESS);
+    if (ethPriceUsd != null) {
+      amountUsd = Number(
+        (Number(formatUnits5(amount, 18)) * ethPriceUsd).toFixed(2)
+      );
+    }
+    if (!opts.yes) {
+      printSendPreview({
+        name: "ETH",
+        symbol: "ETH",
+        amountFormatted,
+        amountUsd,
+        to: recipient
+      });
+      const ok = await confirm4({ message: "Confirm?", default: false });
+      if (!ok) {
+        console.error("Aborted.");
+        process.exit(0);
+      }
+    }
+    let txHash;
+    try {
+      txHash = await walletClient.sendTransaction({
+        to: recipient,
+        value: amount
+      });
+    } catch (err) {
+      track("cli_send", {
+        asset: "eth",
+        output_format: json ? "json" : "table",
+        success: false,
+        error_type: err instanceof Error ? err.constructor.name : "unknown"
+      });
+      await shutdownAnalytics();
+      outputErrorAndExit(
+        json,
+        `Transaction failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    await publicClient.waitForTransactionReceipt({
+      hash: txHash
+    });
+    printSendResult(json, {
+      name: "ETH",
+      symbol: "ETH",
+      address: null,
+      amount,
+      decimals: 18,
+      amountFormatted,
+      amountUsd,
+      to: recipient,
+      txHash
+    });
+    track("cli_send", {
+      asset: "eth",
+      amount_mode: amountMode,
+      amount_usd: amountUsd,
+      transactionHash: txHash,
+      output_format: json ? "json" : "table",
+      success: true,
+      tx_hash: txHash
+    });
+  } else {
+    const knownTokenKey = identifier.toLowerCase();
+    const knownToken = knownTokenKey !== "eth" && knownTokenKey in BASE_TRADE_TOKENS ? BASE_TRADE_TOKENS[knownTokenKey] : void 0;
+    if (knownToken && opts.type) {
+      outputErrorAndExit(
+        json,
+        `--type is not valid when sending ${knownToken.symbol}.`
+      );
+    }
+    let tokenAddress;
+    let tokenName;
+    if (knownToken) {
+      const trade = knownToken.trade;
+      tokenAddress = trade.address;
+      tokenName = knownToken.symbol;
+    } else {
+      const apiKey = getApiKey();
+      if (apiKey) {
+        setApiKey7(apiKey);
+      }
+      const ref = parseCoinRef(identifier, opts.type);
+      let result;
+      try {
+        result = await resolveCoin(ref);
+      } catch (err) {
+        outputErrorAndExit(
+          json,
+          `Request failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      if (result.kind === "not-found") {
+        outputErrorAndExit(json, result.message, result.suggestion);
+      }
+      tokenAddress = result.coin.address;
+      tokenName = result.coin.name;
+    }
+    const account = resolveAccount(json);
+    const { publicClient, walletClient } = createClients(account);
+    let balance;
+    let decimals;
+    let symbol;
+    if (knownToken) {
+      balance = await publicClient.readContract({
+        abi: erc20Abi4,
+        address: tokenAddress,
+        functionName: "balanceOf",
+        args: [account.address]
+      });
+      decimals = knownToken.decimals;
+      symbol = knownToken.symbol;
+    } else {
+      const results = await Promise.all([
+        publicClient.readContract({
+          abi: erc20Abi4,
+          address: tokenAddress,
+          functionName: "balanceOf",
+          args: [account.address]
+        }),
+        publicClient.readContract({
+          abi: erc20Abi4,
+          address: tokenAddress,
+          functionName: "decimals"
+        }),
+        publicClient.readContract({
+          abi: erc20Abi4,
+          address: tokenAddress,
+          functionName: "symbol"
+        })
+      ]);
+      balance = results[0];
+      decimals = results[1];
+      symbol = results[2];
+    }
+    if (balance === 0n) {
+      outputErrorAndExit(
+        json,
+        `No ${symbol} balance. Buy some first or pick a different wallet.`
+      );
+    }
+    let amount;
+    if (amountMode === "amount") {
+      const val = parsePercentageLikeValue(opts.amount);
+      if (val === void 0 || val <= 0) {
+        outputErrorAndExit(
+          json,
+          "Invalid --amount value. Must be a positive number."
+        );
+      }
+      try {
+        amount = parseUnits3(opts.amount, decimals);
+      } catch {
+        outputErrorAndExit(
+          json,
+          "Invalid --amount value for token decimals."
+        );
+      }
+      if (amount === 0n) {
+        outputErrorAndExit(
+          json,
+          `Amount too small \u2014 rounds to zero at ${decimals} decimal places.`
+        );
+      }
+      if (amount > balance) {
+        outputErrorAndExit(
+          json,
+          `Insufficient balance. Have ${formatAmountDisplay(balance, decimals)} ${symbol}.`
+        );
+      }
+    } else if (amountMode === "all") {
+      amount = balance;
+    } else {
+      const pct = parsePercentageLikeValue(opts.percent);
+      if (pct === void 0 || pct <= 0 || pct > 100) {
+        outputErrorAndExit(
+          json,
+          "Invalid --percent value. Must be between 0 and 100."
+        );
+      }
+      amount = pct === 100 ? balance : balance * BigInt(Math.round(pct * 100)) / 10000n;
+      if (amount === 0n) {
+        outputErrorAndExit(
+          json,
+          "Calculated amount is zero. Balance too low."
+        );
+      }
+    }
+    const amountFormatted = formatAmountDisplay(amount, decimals);
+    let amountUsd = null;
+    const priceAddress = knownToken ? knownToken.priceAddress : tokenAddress;
+    const priceUsd = knownToken?.fixedPriceUsd ?? await fetchTokenPriceUsd(priceAddress);
+    if (priceUsd != null) {
+      amountUsd = Number(
+        (Number(formatUnits5(amount, decimals)) * priceUsd).toFixed(2)
+      );
+    }
+    if (!opts.yes) {
+      printSendPreview({
+        name: tokenName,
+        symbol,
+        amountFormatted,
+        amountUsd,
+        to: recipient
+      });
+      const ok = await confirm4({ message: "Confirm?", default: false });
+      if (!ok) {
+        console.error("Aborted.");
+        process.exit(0);
+      }
+    }
+    let txHash;
+    try {
+      txHash = await walletClient.writeContract({
+        abi: erc20Abi4,
+        address: tokenAddress,
+        functionName: "transfer",
+        args: [recipient, amount]
+      });
+    } catch (err) {
+      track("cli_send", {
+        asset: knownToken ? knownTokenKey : "coin",
+        coin_address: tokenAddress,
+        coin_name: tokenName,
+        coin_symbol: symbol,
+        output_format: json ? "json" : "table",
+        success: false,
+        error_type: err instanceof Error ? err.constructor.name : "unknown"
+      });
+      await shutdownAnalytics();
+      outputErrorAndExit(
+        json,
+        `Transaction failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    await publicClient.waitForTransactionReceipt({ hash: txHash });
+    printSendResult(json, {
+      name: tokenName,
+      symbol,
+      address: tokenAddress,
+      amount,
+      decimals,
+      amountFormatted,
+      amountUsd,
+      to: recipient,
+      txHash
+    });
+    track("cli_send", {
+      asset: knownToken ? knownTokenKey : "coin",
+      coin_address: tokenAddress,
+      coin_name: tokenName,
+      coin_symbol: symbol,
+      amount_mode: amountMode,
+      amount_usd: amountUsd,
+      transactionHash: txHash,
+      output_format: json ? "json" : "table",
+      success: true,
+      tx_hash: txHash
+    });
+  }
+});
+
+// src/commands/setup.ts
+import { Command as Command9 } from "commander";
+import { generatePrivateKey, privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+
+// src/lib/strings.ts
+var DEPOSIT_INSTRUCTIONS = "Deposit ETH or USDC to this address on Base to start trading.\n\n  You can do this from:\n  - Coinbase \u2014 withdraw directly to Base\n  - Another wallet (MetaMask, Rainbow, etc.) \u2014 send on Base network\n  - Bridge from other chains \u2014 use https://superbridge.app/base";
+var NO_WALLET_CONFIGURED = "No wallet configured.";
+var NO_WALLET_SUGGESTION = "Run 'zora setup' to create or import one.";
+var SAVE_ERROR_HINT = "Check that the directory exists and is writable.";
+var BACKUP_WARNING = "Back up this file \u2014 it's the only copy of your key.";
+
+// src/commands/setup.ts
+var isValidPrivateKey = (key) => /^(0x)?[0-9a-fA-F]{64}$/.test(key);
+var toAccount = (json, key, errorPrefix) => {
+  try {
+    return privateKeyToAccount3(normalizeKey(key));
+  } catch {
+    outputErrorAndExit(
+      json,
+      `\u2717 ${errorPrefix} isn't a valid private key.`
+    );
+  }
+};
+var setupCommand = new Command9("setup").description("Set up your Zora wallet").option("--create", "Create a new wallet without prompting").option("--force", "Overwrite existing wallet without prompting").option("--yes", "Skip interactive prompt and execute directly").action(async function(options) {
+  const json = getJson(this);
+  const nonInteractive = getYes(this);
+  const envKey = process.env.ZORA_PRIVATE_KEY;
+  if (envKey !== void 0) {
+    if (!isValidPrivateKey(envKey)) {
+      outputErrorAndExit(
+        json,
+        "\u2717 ZORA_PRIVATE_KEY isn't a valid private key.",
+        "Fix it and run zora setup again."
+      );
+    }
+    const account = toAccount(json, envKey, "ZORA_PRIVATE_KEY");
+    outputData(json, {
+      json: { source: "env", address: account.address },
+      table: () => {
+        console.log("  Using wallet from ZORA_PRIVATE_KEY.\n");
+        console.log(`  Address: ${account.address}
+`);
+        console.log(`  ${DEPOSIT_INSTRUCTIONS}`);
+      }
+    });
+    track("cli_setup", {
+      action: "env_detected",
+      source: "env",
+      output_format: json ? "json" : "text"
+    });
+    return;
+  }
+  let existing;
+  if (!options.force) {
+    try {
+      existing = getPrivateKey();
+    } catch (err) {
+      outputErrorAndExit(
+        json,
+        `\u2717 Could not read wallet: ${err.message}`,
+        "Run 'zora setup --force' to overwrite it."
+      );
+    }
+  }
+  if (existing) {
+    const account = toAccount(json, existing, "Stored private key");
+    const truncated = `${account.address.slice(0, 6)}\u2026${account.address.slice(-4)}`;
+    console.log(`  Wallet already configured: ${truncated}
+`);
+    if (!options.force) {
+      outputErrorAndExit(
+        json,
+        "Wallet already exists.",
+        "Use --force to overwrite."
+      );
+    }
+  }
+  let choice;
+  if (options.create) {
+    choice = "create";
+  } else {
+    choice = await selectOrDefault(
+      {
+        message: "How do you want to set up your wallet?",
+        choices: [
+          {
+            name: "Create a new wallet (recommended)",
+            value: "create"
+          },
+          { name: "Import a private key", value: "import" }
+        ],
+        default: "create"
+      },
+      nonInteractive
+    );
+  }
+  if (choice === "import") {
+    let importedKey;
+    while (!importedKey) {
+      const input = await passwordOrFail(
+        json,
+        { message: "Paste your private key:" },
+        nonInteractive
+      );
+      if (isValidPrivateKey(input.trim())) {
+        importedKey = input.trim();
+      } else {
+        console.error(
+          "\u2717 Not a valid private key. Must be 64 hex characters, with or without a 0x prefix.\n"
+        );
+      }
+    }
+    const account = toAccount(json, importedKey, "Imported key");
+    try {
+      savePrivateKey(importedKey);
+    } catch {
+      outputErrorAndExit(
+        json,
+        `\u2717 Couldn't save to ${getWalletPath()}.`,
+        SAVE_ERROR_HINT
+      );
+    }
+    outputData(json, {
+      json: {
+        action: "imported",
+        address: account.address,
+        path: getWalletPath()
+      },
+      table: () => {
+        console.log("\n\u2713 Wallet imported\n");
+        console.log(`  Address:     ${account.address}`);
+        console.log(`  Private key: saved to ${getWalletPath()}
+`);
+        console.log(`  ${BACKUP_WARNING}
+`);
+        console.log(`  ${DEPOSIT_INSTRUCTIONS}`);
+      }
+    });
+    track("cli_setup", {
+      action: "imported",
+      source: "file",
+      output_format: json ? "json" : "text"
+    });
+    return;
+  }
+  if (choice === "create") {
+    const privateKey = generatePrivateKey();
+    const account = toAccount(json, privateKey, "Generated key");
+    try {
+      savePrivateKey(privateKey);
+    } catch {
+      outputErrorAndExit(
+        json,
+        `\u2717 Couldn't save to ${getWalletPath()}.`,
+        SAVE_ERROR_HINT
+      );
+    }
+    outputData(json, {
+      json: {
+        action: "created",
+        address: account.address,
+        path: getWalletPath()
+      },
+      table: () => {
+        console.log("\n\u2713 Wallet created\n");
+        console.log(`  Address:     ${account.address}`);
+        console.log(`  Private key: saved to ${getWalletPath()}
+`);
+        console.log(`  ${BACKUP_WARNING}
+`);
+        console.log(`  ${DEPOSIT_INSTRUCTIONS}`);
+      }
+    });
+    track("cli_setup", {
+      action: "created",
+      source: "file",
+      output_format: json ? "json" : "text"
+    });
+  }
+});
+
+// src/commands/wallet.ts
+import { Command as Command10 } from "commander";
+import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
+var resolvePrivateKey = () => {
+  const envKey = process.env.ZORA_PRIVATE_KEY;
+  if (envKey) {
+    return { key: envKey, source: "env" };
+  }
+  const fileKey = getPrivateKey();
+  if (fileKey !== void 0) {
+    return { key: fileKey, source: "file" };
+  }
+  return void 0;
+};
+var walletCommand = new Command10("wallet").description(
+  "Manage your Zora wallet"
+);
+walletCommand.command("info").description("Show wallet address and storage location").action(function() {
+  const json = getJson(this);
+  const resolved = resolvePrivateKey();
+  if (!resolved) {
+    outputErrorAndExit(json, NO_WALLET_CONFIGURED, NO_WALLET_SUGGESTION);
+  }
+  let account;
+  try {
+    account = privateKeyToAccount4(normalizeKey(resolved.key));
+  } catch {
+    const msg = resolved.source === "env" ? "ZORA_PRIVATE_KEY is not a valid private key." : "Stored private key is invalid.";
+    const suggestion = resolved.source === "env" ? void 0 : "Run 'zora setup --force' to replace it.";
+    outputErrorAndExit(json, `\u2717 ${msg}`, suggestion);
+  }
+  const source = resolved.source === "env" ? "env (ZORA_PRIVATE_KEY)" : getWalletPath();
+  outputData(json, {
+    json: { address: account.address, source },
+    table: () => {
+      console.log(`  Address: ${account.address}`);
+      console.log(`  Source:  ${source}`);
+    }
+  });
+  track("cli_wallet_info", {
+    source: resolved.source,
+    output_format: json ? "json" : "text"
+  });
+});
+walletCommand.command("export").description("Print the raw private key to stdout").option("--force", "Skip the confirmation prompt").option("--yes", "Skip interactive prompt and execute directly").action(async function(options) {
+  const json = getJson(this);
+  const nonInteractive = getYes(this);
+  const resolved = resolvePrivateKey();
+  if (!resolved) {
+    outputErrorAndExit(json, NO_WALLET_CONFIGURED, NO_WALLET_SUGGESTION);
+  }
+  if (!options.force) {
+    console.log(
+      "  \u26A0  Your private key grants full access to your wallet."
+    );
+    console.log(
+      "  Anyone who sees it can steal your funds. Never share it.\n"
+    );
+    const ok = await confirmOrDefault(
+      { message: "Export private key?", default: false },
+      nonInteractive
+    );
+    if (!ok) {
+      console.error("Aborted.");
+      process.exit(0);
+    }
+  }
+  console.log(resolved.key);
+  track("cli_wallet_export", {
+    output_format: json ? "json" : "text"
+  });
+});
+
+// src/components/Zorb.tsx
+import { Text as Text7, Box as Box7 } from "ink";
+
+// src/lib/zorb-pixels.ts
+function supportsTruecolor() {
+  if (!process.stdout.isTTY) return false;
+  const ct = process.env.COLORTERM;
+  if (ct === "truecolor" || ct === "24bit") return true;
+  if (typeof process.stdout.getColorDepth === "function") {
+    return process.stdout.getColorDepth() >= 24;
+  }
+  return false;
+}
+function hexToRgb(hex) {
+  const n = parseInt(hex.replace("#", ""), 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function clamp(v, min, max) {
+  return v < min ? min : v > max ? max : v;
+}
+function alphaOver(bg, fg, a) {
+  return [lerp(bg[0], fg[0], a), lerp(bg[1], fg[1], a), lerp(bg[2], fg[2], a)];
+}
+function gaussian(dist, sigma) {
+  if (sigma <= 0) return dist <= 0 ? 1 : 0;
+  return Math.exp(-(dist * dist) / (2 * sigma * sigma));
+}
+var BASE_COLOR = hexToRgb("#A1723A");
+var LAYERS = [
+  // 1: Dark maroon shadow
+  {
+    cx: 0.54,
+    cy: 0.45,
+    radius: 0.53,
+    color: hexToRgb("#531002"),
+    blur: 0.062,
+    opacity: 1
+  },
+  // 2: Blue body
+  {
+    cx: 0.6,
+    cy: 0.38,
+    radius: 0.43,
+    color: hexToRgb("#2B5DF0"),
+    blur: 0.124,
+    opacity: 1
+  },
+  // 3: Blue accent (gradient from center color to transparent)
+  {
+    cx: 0.59,
+    cy: 0.38,
+    radius: 0.45,
+    color: hexToRgb("#387AFA"),
+    blur: 0.046,
+    opacity: 1,
+    gradient: { gcx: 0.66, gcy: 0.26 }
+  },
+  // 4: Pink glow
+  {
+    cx: 0.66,
+    cy: 0.27,
+    radius: 0.23,
+    color: hexToRgb("#FCB8D4"),
+    blur: 0.093,
+    opacity: 1
+  },
+  // 5: White specular
+  {
+    cx: 0.66,
+    cy: 0.27,
+    radius: 0.09,
+    color: hexToRgb("#FFFFFF"),
+    blur: 0.062,
+    opacity: 1
+  },
+  // 6: Dark ring (transparent → black → transparent, opacity 0.9)
+  {
+    cx: 0.6,
+    cy: 0.36,
+    radius: 0.82,
+    color: [0, 0, 0],
+    blur: 0.046,
+    opacity: 0.9,
+    ring: true
+  }
+];
+function computeLayerAlpha(nx, ny, layer) {
+  const dx = nx - layer.cx;
+  const dy = ny - layer.cy;
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  const radialFalloff = gaussian(Math.max(0, dist - layer.radius), layer.blur);
+  if (layer.ring) {
+    const normalizedDist = dist / layer.radius;
+    const ringProfile = gaussian(normalizedDist - 0.7, 0.15) * radialFalloff;
+    return { alpha: ringProfile * layer.opacity, color: layer.color };
+  }
+  if (layer.gradient) {
+    const gdx = nx - layer.gradient.gcx;
+    const gdy = ny - layer.gradient.gcy;
+    const gDist = Math.sqrt(gdx * gdx + gdy * gdy);
+    const gradientT = clamp(gDist / (layer.radius * 1.2), 0, 1);
+    const alpha = radialFalloff * (1 - gradientT);
+    return { alpha: alpha * layer.opacity, color: layer.color };
+  }
+  return { alpha: radialFalloff * layer.opacity, color: layer.color };
+}
+function circleAlpha(px, py, size) {
+  const cx = (size - 1) / 2;
+  const cy = (size - 1) / 2;
+  const r = size / 2;
+  const dx = px - cx;
+  const dy = py - cy;
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  return clamp(r - dist + 0.5, 0, 1);
+}
+function generateZorbPixels(size) {
+  const grid = [];
+  for (let y = 0; y < size; y++) {
+    const row = [];
+    for (let x = 0; x < size; x++) {
+      const nx = x / (size - 1);
+      const ny = y / (size - 1);
+      let pixel = [...BASE_COLOR];
+      for (const layer of LAYERS) {
+        const { alpha, color } = computeLayerAlpha(nx, ny, layer);
+        if (alpha > 1e-3) {
+          pixel = alphaOver(pixel, color, alpha);
+        }
+      }
+      const ca = circleAlpha(x, y, size);
+      pixel = [
+        Math.round(pixel[0] * ca),
+        Math.round(pixel[1] * ca),
+        Math.round(pixel[2] * ca)
+      ];
+      row.push(pixel);
+    }
+    grid.push(row);
+  }
+  return grid;
+}
+
+// src/components/Zorb.tsx
+import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
+var LOWER_HALF_BLOCK = "\u2584";
+var UPPER_HALF_BLOCK = "\u2580";
+function rgbString([r, g, b]) {
+  return `rgb(${r},${g},${b})`;
+}
+function isBlack([r, g, b]) {
+  return r === 0 && g === 0 && b === 0;
+}
+function Zorb({ size = 20 }) {
+  if (!supportsTruecolor()) return null;
+  const grid = generateZorbPixels(size);
+  const rows = [];
+  for (let y = 0; y < size; y += 2) {
+    const topRow = grid[y];
+    const bottomRow = y + 1 < size ? grid[y + 1] : void 0;
+    const cells = [];
+    for (let x = 0; x < size; x++) {
+      const top = topRow[x];
+      const bottom = bottomRow ? bottomRow[x] : [0, 0, 0];
+      const topIsBlack = isBlack(top);
+      const bottomIsBlack = isBlack(bottom);
+      if (topIsBlack && bottomIsBlack) {
+        cells.push(/* @__PURE__ */ jsx10(Text7, { children: " " }, x));
+      } else if (topIsBlack) {
+        cells.push(
+          /* @__PURE__ */ jsx10(Text7, { color: rgbString(bottom), children: LOWER_HALF_BLOCK }, x)
+        );
+      } else if (bottomIsBlack) {
+        cells.push(
+          /* @__PURE__ */ jsx10(Text7, { color: rgbString(top), children: UPPER_HALF_BLOCK }, x)
+        );
+      } else {
+        cells.push(
+          /* @__PURE__ */ jsx10(
+            Text7,
+            {
+              backgroundColor: rgbString(top),
+              color: rgbString(bottom),
+              children: LOWER_HALF_BLOCK
+            },
+            x
+          )
+        );
+      }
+    }
+    rows.push(/* @__PURE__ */ jsx10(Text7, { children: cells }, y));
+  }
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx10(Text7, { children: " " }),
+    rows,
+    /* @__PURE__ */ jsx10(Text7, { children: " " })
+  ] });
+}
+
+// src/index.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+if (process.env.ZORA_API_TARGET) {
+  setApiBaseUrl(process.env.ZORA_API_TARGET);
+}
+var version = true ? "0.2.4" : JSON.parse(
+  readFileSync2(new URL("../package.json", import.meta.url), "utf-8")
+).version;
+var buildProgram = () => {
+  const program2 = new Command11().name("zora").description("Zora CLI").version(version).option(
+    "--output <format>",
+    "Output format: table, json, live (default varies by command)"
+  ).option(
+    "--interval <seconds>",
+    "Auto-refresh interval in seconds (min 5)",
+    "30"
+  );
+  program2.addCommand(authCommand);
+  program2.addCommand(balanceCommand);
+  program2.addCommand(buyCommand);
+  program2.addCommand(exploreCommand);
+  program2.addCommand(getCommand);
+  program2.addCommand(priceHistoryCommand);
+  program2.addCommand(setupCommand);
+  program2.addCommand(walletCommand);
+  program2.addCommand(sellCommand);
+  program2.addCommand(sendCommand);
+  return program2;
+};
+var program = buildProgram();
+if (!process.env.VITEST) {
+  const showingHelp = process.argv.length <= 2 || process.argv.includes("--help") || process.argv.includes("-h");
+  if (showingHelp && !process.argv.includes("--output") && supportsTruecolor()) {
+    renderOnce(/* @__PURE__ */ jsx11(Zorb, { size: 20 }));
+  }
+  console.warn(
+    "\x1B[33m\u26A0 Beta:\x1B[0m This CLI is in beta and should be used with caution."
+  );
+  identify();
+  try {
+    await program.parseAsync();
+  } catch (err) {
+    if (err instanceof ExitPromptError) {
+      console.log("\nAborted.");
+      process.exit(0);
+    }
+    throw err;
+  } finally {
+    await shutdownAnalytics();
+  }
+}
+export {
+  buildProgram
+};