@zoralabs/cli 0.2.2 → 0.2.3

package/dist/index.js

@@ -0,0 +1,2936 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { Command as Command9 } 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 getJson = (cmd) => cmd.optsWithGlobals().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();
+  }
+};
+
+// 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.3" : "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.ts
+import { Command as Command3 } from "commander";
+import { getProfileBalances, setApiKey as setApiKey2 } from "@zoralabs/coins-sdk";
+
+// src/lib/render.tsx
+import { renderToString } from "ink";
+var renderOnce = (element) => {
+  const output = renderToString(element);
+  console.log(output);
+};
+
+// src/components/table.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var truncate = (str, max) => {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 1) + "\u2026";
+};
+var TableComponent = ({
+  columns,
+  data,
+  title,
+  subtitle
+}) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingTop: 1, paddingBottom: 1, children: [
+  title && /* @__PURE__ */ jsxs(Box, { paddingLeft: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, children: title }),
+    subtitle && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      " ",
+      subtitle
+    ] })
+  ] }),
+  /* @__PURE__ */ jsx(Box, { paddingLeft: 1, children: columns.map((col) => /* @__PURE__ */ jsx(Box, { width: col.width, children: /* @__PURE__ */ jsx(Text, { bold: true, dimColor: true, children: col.header }) }, col.header)) }),
+  data.map((row, i) => /* @__PURE__ */ jsx(Box, { paddingLeft: 1, children: columns.map((col) => {
+    const value = col.noTruncate ? col.accessor(row) : truncate(col.accessor(row), col.width - 2);
+    const colorName = col.color?.(row);
+    return /* @__PURE__ */ jsx(Box, { width: col.width, children: /* @__PURE__ */ jsx(Text, { color: colorName, children: value }) }, col.header);
+  }) }, i))
+] });
+
+// src/commands/explore.tsx
+import { Command as Command2 } from "commander";
+import {
+  setApiKey,
+  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/format.ts
+import { format, formatDistanceStrict } from "date-fns";
+import { formatEther } from "viem";
+var ANSI_CODES = {
+  dim: ["\x1B[2m", "\x1B[22m"],
+  bold: ["\x1B[1m", "\x1B[22m"]
+};
+function styledText(text, style) {
+  const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+  if (!useColor) return text;
+  const [open, close] = ANSI_CODES[style];
+  return `${open}${text}${close}`;
+}
+function formatCurrency(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/types.ts
+var SORT_LABELS = {
+  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/commands/explore.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } 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 formatCompactCurrency = (value) => {
+  if (!value) return "$0";
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    notation: "compact",
+    maximumFractionDigits: 1
+  }).format(Number(value));
+};
+var formatChange = (marketCap, delta) => {
+  if (!delta || !marketCap) return "-";
+  const cap = Number(marketCap);
+  const d = Number(delta);
+  if (cap === 0) return "-";
+  const prevCap = cap - d;
+  if (prevCap === 0) return "-";
+  const pct = d / prevCap * 100;
+  const sign = pct >= 0 ? "+" : "";
+  return `${sign}${pct.toFixed(1)}%`;
+};
+var changeColor = (row) => {
+  if (!row.marketCapDelta24h || !row.marketCap) return void 0;
+  const cap = Number(row.marketCap);
+  const d = Number(row.marketCapDelta24h);
+  if (cap === 0 || cap - d === 0) return void 0;
+  const pct = d / (cap - d) * 100;
+  if (pct > 0) return "green";
+  if (pct < 0) return "red";
+  return void 0;
+};
+var SORT_OPTIONS = Object.keys(SORT_LABELS).join(", ");
+var rankColumn = {
+  header: "#",
+  width: 5,
+  accessor: (r) => String(r.rank)
+};
+var exploreColumns = [
+  { header: "Name", width: 27, accessor: (r) => r.name ?? "Unknown" },
+  { header: "Address", width: 44, accessor: (r) => r.address ?? "" },
+  {
+    header: "Type",
+    width: 16,
+    accessor: (r) => COIN_TYPE_DISPLAY[r.coinType ?? ""] ?? r.coinType ?? ""
+  },
+  {
+    header: "Market Cap",
+    width: 14,
+    accessor: (r) => formatCompactCurrency(r.marketCap)
+  },
+  {
+    header: "24h Vol",
+    width: 14,
+    accessor: (r) => formatCompactCurrency(r.volume24h)
+  },
+  {
+    header: "24h Change",
+    width: 12,
+    accessor: (r) => formatChange(r.marketCap, r.marketCapDelta24h),
+    color: changeColor
+  }
+];
+var exploreCommand = new Command2("explore").description("Browse top, new, and highest volume coins").option("--sort <sort>", `Sort by: ${SORT_OPTIONS}`, "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 json = getJson(this);
+  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_OPTIONS}`
+    );
+  }
+  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) {
+    setApiKey(apiKey);
+  }
+  const queryFn = QUERY_MAP[sort][type];
+  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;
+  if (coins.length === 0) {
+    outputData(json, {
+      json: { coins: [], pageInfo: pageInfo ?? null },
+      table: () => {
+        renderOnce(
+          /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingLeft: 1, marginTop: 1, children: [
+            /* @__PURE__ */ jsx2(Text2, { children: "No coins found." }),
+            /* @__PURE__ */ jsxs2(Box2, { marginTop: 1, flexDirection: "column", children: [
+              /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Try a different sort or type (defaults to posts):" }),
+              /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " zora explore --sort volume --type all" }),
+              /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " zora explore --sort new --type all" })
+            ] })
+          ] })
+        );
+      }
+    });
+    return;
+  }
+  const rankedCoins = coins.map((c, i) => ({ ...c, rank: i + 1 }));
+  const columns = after ? exploreColumns : [rankColumn, ...exploreColumns];
+  const title = type !== "all" ? `${SORT_LABELS[sort]} \xB7 ${TYPE_LABELS[type]}` : SORT_LABELS[sort];
+  const subtitle = `${coins.length} result${coins.length !== 1 ? "s" : ""}`;
+  outputData(json, {
+    json: { coins, pageInfo: pageInfo ?? null },
+    table: () => {
+      renderOnce(
+        /* @__PURE__ */ jsx2(
+          TableComponent,
+          {
+            columns,
+            data: rankedCoins,
+            title,
+            subtitle
+          }
+        )
+      );
+      if (pageInfo?.hasNextPage && pageInfo.endCursor) {
+        console.log(
+          `
+ ${styledText(`Next page: zora explore --sort ${sort} --type ${type} --limit ${limit} --after ${pageInfo.endCursor}`, "dim")}`
+        );
+      }
+    }
+  });
+  track("cli_explore", {
+    sort,
+    type,
+    limit,
+    paginated: after !== void 0,
+    result_count: coins.length,
+    has_next_page: pageInfo?.hasNextPage ?? false,
+    output_format: json ? "json" : "text"
+  });
+});
+
+// src/lib/balance-format.ts
+var COIN_DECIMALS = 18;
+var toHumanBalance = (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 formatUsdValue = (balance, priceInUsdc) => {
+  if (!priceInUsdc) return "-";
+  const value = toHumanBalance(balance) * Number(priceInUsdc);
+  if (value < 0.01) return "<$0.01";
+  return formatUsd(value);
+};
+var formatBalance = (balance) => {
+  const n = toHumanBalance(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: "long",
+    maximumFractionDigits: 1
+  }).format(n);
+};
+var trimTrailingZeros = (value) => {
+  if (!value.includes(".")) return value;
+  const trimmed = value.replace(/0+$/, "").replace(/\.$/, "");
+  return trimmed || "0";
+};
+
+// 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.ts
+var SORT_MAP = {
+  "usd-value": "USD_VALUE",
+  balance: "BALANCE",
+  "market-cap": "MARKET_CAP",
+  "price-change": "PRICE_CHANGE"
+};
+var SORT_LABELS2 = {
+  "usd-value": "USD Value",
+  balance: "Balance",
+  "market-cap": "Market Cap",
+  "price-change": "Price Change"
+};
+var SORT_OPTIONS2 = Object.keys(SORT_MAP).join(", ");
+var extractErrorMessage = (error) => {
+  if (typeof error === "object" && error !== null && "error" in error) {
+    return String(error.error);
+  }
+  return JSON.stringify(error);
+};
+var changeColor2 = (row) => {
+  if (!row.coin?.marketCap || !row.coin.marketCapDelta24h) return void 0;
+  const cap = Number(row.coin.marketCap);
+  const d = Number(row.coin.marketCapDelta24h);
+  if (cap === 0 || cap - d === 0) return void 0;
+  const pct = d / (cap - d) * 100;
+  if (pct > 0) return "green";
+  if (pct < 0) return "red";
+  return void 0;
+};
+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) => formatUsdValue(row.balance, row.coin?.tokenPrice?.priceInUsdc)
+  },
+  {
+    header: "Market Cap",
+    width: 14,
+    accessor: (row) => formatCompactCurrency(row.coin?.marketCap)
+  },
+  {
+    header: "24h Change",
+    width: 12,
+    accessor: (row) => formatChange(row.coin?.marketCap, row.coin?.marketCapDelta24h),
+    color: changeColor2
+  }
+];
+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((toHumanBalance(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."
+    );
+  }
+  setApiKey2(apiKey);
+  return account;
+}
+function renderWallet(json, walletResult) {
+  outputData(json, {
+    json: { wallet: walletResult.walletBalancesJson },
+    table: () => {
+      renderOnce(
+        TableComponent({
+          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(
+          TableComponent({
+            columns: balanceColumns,
+            data: rankedBalances,
+            title: `Coins \xB7 sorted by ${SORT_LABELS2[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_OPTIONS2}`
+    );
+  }
+  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 Command3("balance").description("Show balances in your wallet").action(async function() {
+  const json = getJson(this);
+  const account = resolveContext(json);
+  const sort = "usd-value";
+  const limit = 10;
+  let walletResult;
+  let coinsResult;
+  try {
+    [walletResult, coinsResult] = await Promise.all([
+      fetchWalletBalances(account.address),
+      fetchCoins(json, account.address, sort, limit)
+    ]);
+  } catch (err) {
+    outputErrorAndExit(
+      json,
+      `Request failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const rankedBalances = coinsResult.balances.map((balance, index) => ({
+    ...balance,
+    rank: index + 1
+  }));
+  outputData(json, {
+    json: {
+      wallet: walletResult.walletBalancesJson,
+      coins: rankedBalances.map(
+        (balance) => formatBalanceJson(balance, balance.rank)
+      )
+    },
+    table: () => {
+      renderOnce(
+        TableComponent({
+          columns: walletColumns,
+          data: walletResult.walletBalances,
+          title: "Wallet"
+        })
+      );
+      if (coinsResult.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(
+          TableComponent({
+            columns: balanceColumns,
+            data: rankedBalances,
+            title: `Coins \xB7 sorted by ${SORT_LABELS2[sort]}`,
+            subtitle: `${coinsResult.balances.length} of ${coinsResult.total}`
+          })
+        );
+      }
+    }
+  });
+  track("cli_balances", {
+    sort,
+    limit,
+    result_count: coinsResult.balances.length,
+    total_count: coinsResult.total,
+    output_format: json ? "json" : "text"
+  });
+});
+balanceCommand.command("spendable").description("Show wallet token balances (ETH, USDC, ZORA)").action(async function() {
+  const json = getJson(this);
+  const account = resolveContext(json);
+  let walletResult;
+  try {
+    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_OPTIONS2}`, "usd-value").option("--limit <n>", "Number of results (max 20)", "10").action(async function(opts) {
+  const json = getJson(this);
+  const { sort, limit } = validateCoinOpts(json, opts.sort, opts.limit);
+  const account = resolveContext(json);
+  const { balances, total } = await fetchCoins(
+    json,
+    account.address,
+    sort,
+    limit
+  );
+  renderCoins(json, balances, total, sort);
+});
+
+// src/commands/buy.ts
+import { Command as Command4 } from "commander";
+import confirm2 from "@inquirer/confirm";
+import { parseUnits, formatUnits as formatUnits3, isAddress } from "viem";
+import {
+  setApiKey as setApiKey3,
+  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.001");
+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.");
+  }
+  return matchingTransfers.reduce((total, transfer) => {
+    const value = transfer.args?.value;
+    if (value === void 0) {
+      throw new Error("Transfer event missing amount.");
+    }
+    return total + value;
+  }, 0n);
+};
+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 Command4("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").option("-o, --output <format>", "Output format: table, json", "table").action(async (coinAddress, opts) => {
+  const json = opts.output === "json";
+  const debug = opts.debug === true;
+  if (!isAddress(coinAddress)) {
+    outputErrorAndExit(json, `Invalid address: ${coinAddress}`);
+  }
+  const output = opts.output;
+  if (output !== "table" && output !== "json") {
+    outputErrorAndExit(
+      false,
+      `Invalid --output value: ${output}. Use: table, json`
+    );
+  }
+  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) {
+    setApiKey3(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 >0.001 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 : balance * BigInt(Math.round(pct * 100)) / 10000n;
+      if (amountIn === 0n) {
+        outputErrorAndExit(
+          json,
+          "Calculated amount is zero. Balance too low."
+        );
+      }
+    }
+  }
+  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,
+      slippage: slippagePct,
+      output_format: opts.output
+    });
+    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);
+  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,
+      slippage: slippagePct,
+      output_format: opts.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;
+  try {
+    receivedAmountOut = getReceivedAmountFromReceipt({
+      receipt,
+      tokenAddress: coinAddress,
+      recipient: account.address
+    });
+  } 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,
+    slippage: slippagePct,
+    output_format: opts.output,
+    success: true,
+    tx_hash: txHash
+  });
+});
+
+// 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 Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var LABEL_WIDTH = 18;
+function Row({
+  label,
+  children
+}) {
+  return /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx3(Box3, { width: LABEL_WIDTH, flexShrink: 0, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: label }) }),
+    /* @__PURE__ */ jsx3(Text3, { children })
+  ] });
+}
+function CoinDetail({ coin }) {
+  const change = formatMcapChange(coin.marketCap, coin.marketCapDelta24h);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingLeft: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: coin.name }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        coin.coinType,
+        " ",
+        "\xB7",
+        " ",
+        coin.address
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Row, { label: "Market Cap", children: formatCurrency(coin.marketCap) }),
+      /* @__PURE__ */ jsx3(Row, { label: "24h Volume", children: formatCurrency(coin.volume24h) }),
+      /* @__PURE__ */ jsx3(Row, { label: "24h Change", children: /* @__PURE__ */ jsx3(Text3, { color: change.color, children: change.text }) }),
+      /* @__PURE__ */ jsx3(Row, { label: "Holders", children: formatHolders(coin.uniqueHolders) }),
+      coin.coinType === "post" && (coin.creatorHandle ?? coin.creatorAddress) && /* @__PURE__ */ jsx3(Row, { label: "Creator", children: coin.creatorHandle ?? coin.creatorAddress }),
+      /* @__PURE__ */ jsx3(Row, { label: "Created", children: formatCreatedAt(coin.createdAt) })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginBottom: 1 })
+  ] });
+}
+
+// src/commands/get.tsx
+import { jsx as jsx4 } 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__ */ jsx4(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/sell.ts
+import { Command as Command6 } 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 setApiKey5,
+  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 Command6("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").option("-o, --output <format>", "Output format: table, json", "table").action(async (coinAddress, opts) => {
+  const json = opts.output === "json";
+  const debug = opts.debug === true;
+  if (!isAddress2(coinAddress)) {
+    outputErrorAndExit(json, `Invalid address: ${coinAddress}`);
+  }
+  const output = opts.output;
+  if (output !== "table" && output !== "json") {
+    outputErrorAndExit(
+      false,
+      `Invalid --output value: ${output}. Use: table, json`
+    );
+  }
+  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) {
+    setApiKey5(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."
+        );
+      }
+    }
+  }
+  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,
+      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";
+  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,
+      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 {
+      receivedAmountOut = getReceivedAmountFromReceipt({
+        receipt,
+        tokenAddress: outputToken.trade.address,
+        recipient: account.address
+      });
+      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,
+    output_asset: outputAsset,
+    slippage: slippagePct,
+    output_format: output,
+    success: true,
+    tx_hash: txHash
+  });
+});
+
+// src/commands/setup.ts
+import { Command as Command7 } 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 Command7("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 Command8 } 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 Command8("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 Text4, Box as Box4 } 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 jsx5, jsxs as jsxs4 } 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__ */ jsx5(Text4, { children: " " }, x));
+      } else if (topIsBlack) {
+        cells.push(
+          /* @__PURE__ */ jsx5(Text4, { color: rgbString(bottom), children: LOWER_HALF_BLOCK }, x)
+        );
+      } else if (bottomIsBlack) {
+        cells.push(
+          /* @__PURE__ */ jsx5(Text4, { color: rgbString(top), children: UPPER_HALF_BLOCK }, x)
+        );
+      } else {
+        cells.push(
+          /* @__PURE__ */ jsx5(
+            Text4,
+            {
+              backgroundColor: rgbString(top),
+              color: rgbString(bottom),
+              children: LOWER_HALF_BLOCK
+            },
+            x
+          )
+        );
+      }
+    }
+    rows.push(/* @__PURE__ */ jsx5(Text4, { children: cells }, y));
+  }
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Text4, { children: " " }),
+    rows,
+    /* @__PURE__ */ jsx5(Text4, { children: " " })
+  ] });
+}
+
+// src/index.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+if (process.env.ZORA_API_TARGET) {
+  setApiBaseUrl(process.env.ZORA_API_TARGET);
+}
+var version = true ? "0.2.3" : JSON.parse(
+  readFileSync2(new URL("../package.json", import.meta.url), "utf-8")
+).version;
+var buildProgram = () => {
+  const program2 = new Command9().name("zora").description("Zora CLI").version(version).option("--json", "Output as JSON (for scripts and automation)", false);
+  program2.addCommand(authCommand);
+  program2.addCommand(balanceCommand);
+  program2.addCommand(buyCommand);
+  program2.addCommand(exploreCommand);
+  program2.addCommand(getCommand);
+  program2.addCommand(setupCommand);
+  program2.addCommand(walletCommand);
+  program2.addCommand(sellCommand);
+  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("--json") && supportsTruecolor()) {
+    renderOnce(/* @__PURE__ */ jsx6(Zorb, { size: 20 }));
+  }
+  identify();
+  try {
+    await program.parseAsync();
+  } catch (err) {
+    if (err instanceof ExitPromptError) {
+      console.log("\nAborted.");
+      process.exit(0);
+    }
+    throw err;
+  } finally {
+    await shutdownAnalytics();
+  }
+}
+export {
+  buildProgram
+};