apow-cli 0.1.0

package/dist/detect.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rarityLabels = void 0;
+exports.detectMiners = detectMiners;
+exports.selectBestMiner = selectBestMiner;
+exports.formatHashpower = formatHashpower;
+const MiningAgent_json_1 = __importDefault(require("./abi/MiningAgent.json"));
+const config_1 = require("./config");
+const wallet_1 = require("./wallet");
+const miningAgentAbi = MiningAgent_json_1.default;
+exports.rarityLabels = ["Common", "Uncommon", "Rare", "Epic", "Mythic"];
+async function detectMiners(owner) {
+    const balance = (await wallet_1.publicClient.readContract({
+        address: config_1.config.miningAgentAddress,
+        abi: miningAgentAbi,
+        functionName: "balanceOf",
+        args: [owner],
+    }));
+    if (balance === 0n) {
+        return [];
+    }
+    const miners = [];
+    for (let i = 0n; i < balance; i++) {
+        const tokenId = (await wallet_1.publicClient.readContract({
+            address: config_1.config.miningAgentAddress,
+            abi: miningAgentAbi,
+            functionName: "tokenOfOwnerByIndex",
+            args: [owner, i],
+        }));
+        const [rarityRaw, hashpowerRaw] = await Promise.all([
+            wallet_1.publicClient.readContract({
+                address: config_1.config.miningAgentAddress,
+                abi: miningAgentAbi,
+                functionName: "rarity",
+                args: [tokenId],
+            }),
+            wallet_1.publicClient.readContract({
+                address: config_1.config.miningAgentAddress,
+                abi: miningAgentAbi,
+                functionName: "hashpower",
+                args: [tokenId],
+            }),
+        ]);
+        const rarity = Number(rarityRaw);
+        miners.push({
+            tokenId,
+            rarity,
+            rarityLabel: exports.rarityLabels[rarity] ?? `Tier ${rarity}`,
+            hashpower: Number(hashpowerRaw),
+        });
+    }
+    return miners;
+}
+function selectBestMiner(miners) {
+    return miners.reduce((best, m) => (m.hashpower > best.hashpower ? m : best));
+}
+function formatHashpower(hashpower) {
+    return `${(hashpower / 100).toFixed(2)}x`;
+}

package/dist/errors.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyError = classifyError;
+const patterns = [
+    {
+        test: (m) => m.includes("Not your miner"),
+        classify: () => ({
+            category: "fatal",
+            userMessage: "Miner NFT is not owned by your wallet",
+            recovery: "Check token ID or verify ownership on Basescan",
+        }),
+    },
+    {
+        test: (m) => m.includes("Supply exhausted"),
+        classify: () => ({
+            category: "fatal",
+            userMessage: "All 18.9M mineable AGENT have been mined",
+            recovery: "Mining is complete. Trade AGENT on Uniswap.",
+        }),
+    },
+    {
+        test: (m) => m.includes("No contracts"),
+        classify: () => ({
+            category: "fatal",
+            userMessage: "Smart contract wallets cannot mine",
+            recovery: "Use a regular (EOA) wallet",
+        }),
+    },
+    {
+        test: (m) => m.includes("Sold out") || m.includes("Max supply"),
+        classify: () => ({
+            category: "fatal",
+            userMessage: "All 10,000 mining rigs have been minted",
+            recovery: "Buy a miner NFT on a secondary marketplace",
+        }),
+    },
+    {
+        test: (m) => m.includes("One mine per block"),
+        classify: () => ({
+            category: "transient",
+            userMessage: "One mine per block — waiting for next block",
+            recovery: "",
+        }),
+    },
+    {
+        test: (m) => m.includes("Expired"),
+        classify: () => ({
+            category: "transient",
+            userMessage: "SMHL challenge expired (20s window)",
+            recovery: "Retrying with a fresh challenge...",
+        }),
+    },
+    {
+        test: (m) => m.includes("fetch failed") || m.includes("ECONNREFUSED") || m.includes("ENOTFOUND"),
+        classify: (msg) => {
+            const target = msg.includes("11434") ? "Ollama" : msg.includes("anthropic") ? "Anthropic API" : msg.includes("openai") ? "OpenAI API" : "RPC";
+            return {
+                category: "transient",
+                userMessage: `Could not reach ${target}`,
+                recovery: "Check internet connection and RPC_URL in .env",
+            };
+        },
+    },
+    {
+        test: (m) => /\b40[13]\b/.test(m) && (m.includes("anthropic") || m.includes("openai") || m.toLowerCase().includes("unauthorized") || m.toLowerCase().includes("forbidden")),
+        classify: () => ({
+            category: "setup",
+            userMessage: "LLM API key is invalid or expired",
+            recovery: "Run `apow setup` to configure a valid key",
+        }),
+    },
+    {
+        test: (m) => m.toLowerCase().includes("insufficient funds"),
+        classify: () => ({
+            category: "setup",
+            userMessage: "Not enough ETH for gas",
+            recovery: "Send ETH to your wallet on Base",
+        }),
+    },
+    {
+        test: (m) => m.includes("SMHL solve failed"),
+        classify: () => ({
+            category: "llm",
+            userMessage: "LLM failed to solve the SMHL challenge after 5 attempts",
+            recovery: "Try a different model (gpt-4o-mini recommended) or check your LLM API key",
+        }),
+    },
+];
+function classifyError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    for (const pattern of patterns) {
+        if (pattern.test(message)) {
+            return pattern.classify(message);
+        }
+    }
+    return {
+        category: "transient",
+        userMessage: message.length > 200 ? message.slice(0, 200) + "..." : message,
+        recovery: "",
+    };
+}

package/dist/explorer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.txUrl = txUrl;
+exports.addressUrl = addressUrl;
+exports.tokenUrl = tokenUrl;
+const config_1 = require("./config");
+function baseUrl() {
+    return config_1.config.chainName === "baseSepolia"
+        ? "https://sepolia.basescan.org"
+        : "https://basescan.org";
+}
+function txUrl(hash) {
+    return `${baseUrl()}/tx/${hash}`;
+}
+function addressUrl(addr) {
+    return `${baseUrl()}/address/${addr}`;
+}
+function tokenUrl(contract, tokenId) {
+    return `${baseUrl()}/nft/${contract}/${tokenId.toString()}`;
+}

package/dist/index.js

@@ -0,0 +1,466 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const commander_1 = require("commander");
+const viem_1 = require("viem");
+const MiningAgent_json_1 = __importDefault(require("./abi/MiningAgent.json"));
+const config_1 = require("./config");
+const detect_1 = require("./detect");
+const explorer_1 = require("./explorer");
+const mint_1 = require("./mint");
+const miner_1 = require("./miner");
+const preflight_1 = require("./preflight");
+const stats_1 = require("./stats");
+const ui = __importStar(require("./ui"));
+const wallet_1 = require("./wallet");
+const miningAgentAbi = MiningAgent_json_1.default;
+function saveKeyFile(address, privateKey) {
+    const filename = `wallet-${address}.txt`;
+    const filepath = (0, node_path_1.join)(process.cwd(), filename);
+    const content = [
+        `Address:     ${address}`,
+        `Private Key: ${privateKey}`,
+        ``,
+        `Generated:   ${new Date().toISOString()}`,
+        ``,
+        `Import this key into MetaMask, Phantom, or any EVM wallet.`,
+        `Keep this file safe — anyone with the private key controls your funds.`,
+        "",
+    ].join("\n");
+    (0, node_fs_1.writeFileSync)(filepath, content, { encoding: "utf8", mode: 0o600 });
+    return filepath;
+}
+function parseTokenId(value) {
+    try {
+        return BigInt(value);
+    }
+    catch {
+        throw new Error(`Invalid token ID: ${value}`);
+    }
+}
+function readVersion() {
+    try {
+        const pkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "..", "package.json"), "utf8"));
+        return pkg.version ?? "0.1.0";
+    }
+    catch {
+        return "0.1.0";
+    }
+}
+async function resolveTokenId(tokenIdArg) {
+    if (tokenIdArg) {
+        return parseTokenId(tokenIdArg);
+    }
+    if (!wallet_1.account) {
+        ui.error("No token ID provided and no wallet configured.");
+        ui.hint("Usage: apow mine <tokenId> or configure PRIVATE_KEY in .env");
+        process.exit(1);
+    }
+    const miners = await (0, detect_1.detectMiners)(wallet_1.account.address);
+    if (miners.length === 0) {
+        ui.error("No mining rigs found for this wallet.");
+        ui.hint("Run `apow mint` to mint a miner NFT first.");
+        process.exit(1);
+    }
+    const best = (0, detect_1.selectBestMiner)(miners);
+    if (miners.length === 1) {
+        console.log(`  Using miner #${best.tokenId} (${best.rarityLabel}, ${(0, detect_1.formatHashpower)(best.hashpower)})`);
+    }
+    else {
+        console.log(`  Found ${miners.length} miners — using #${best.tokenId} (${best.rarityLabel}, ${(0, detect_1.formatHashpower)(best.hashpower)})`);
+        for (const m of miners) {
+            const marker = m.tokenId === best.tokenId ? ui.green(" *") : "  ";
+            console.log(`  ${marker} #${m.tokenId} — ${m.rarityLabel} (${(0, detect_1.formatHashpower)(m.hashpower)})`);
+        }
+    }
+    return best.tokenId;
+}
+async function setupWizard() {
+    console.log("");
+    ui.banner(["AgentCoin Miner Setup"]);
+    console.log("");
+    const values = {};
+    // Step 1: Wallet
+    console.log(`  ${ui.bold("Step 1/3: Wallet")}`);
+    const hasWallet = await ui.confirm("Do you have a Base wallet?");
+    let privateKey;
+    let addr;
+    if (hasWallet) {
+        const inputKey = await ui.promptSecret("Private key (0x-prefixed)");
+        if (!inputKey) {
+            ui.error("Private key is required.");
+            return;
+        }
+        if (!/^0x[0-9a-fA-F]{64}$/.test(inputKey)) {
+            ui.error("Invalid private key format. Must be 0x + 64 hex characters.");
+            return;
+        }
+        privateKey = inputKey;
+        const { privateKeyToAccount } = await Promise.resolve().then(() => __importStar(require("viem/accounts")));
+        const walletAccount = privateKeyToAccount(privateKey);
+        addr = walletAccount.address;
+    }
+    else {
+        const { generatePrivateKey, privateKeyToAccount } = await Promise.resolve().then(() => __importStar(require("viem/accounts")));
+        privateKey = generatePrivateKey();
+        const walletAccount = privateKeyToAccount(privateKey);
+        addr = walletAccount.address;
+        console.log("");
+        console.log(`  ${ui.bold("NEW WALLET GENERATED")}`);
+        console.log("");
+        console.log(`  Address:     ${addr}`);
+        console.log(`  Private Key: ${privateKey}`);
+        console.log("");
+        console.log(`  ${ui.yellow("⚠ SAVE YOUR PRIVATE KEY — this is the only time")}`);
+        console.log(`  ${ui.yellow("  it will be displayed. Anyone with this key")}`);
+        console.log(`  ${ui.yellow("  controls your funds.")}`);
+        console.log("");
+        console.log(`  ${ui.dim("Import into Phantom, MetaMask, or any EVM wallet")}`);
+        console.log(`  ${ui.dim("to view your AGENT tokens and Mining Rig NFT.")}`);
+        console.log("");
+        console.log(`  ${ui.dim("Fund this address with ≥0.005 ETH on Base to start.")}`);
+        console.log("");
+        const keyPath = saveKeyFile(addr, privateKey);
+        console.log(`  ${ui.dim(`Key saved to: ${keyPath}`)}`);
+        console.log(`  ${ui.yellow("Back up this file securely, then delete it.")}`);
+        console.log("");
+    }
+    values.PRIVATE_KEY = privateKey;
+    ui.ok(`Wallet: ${addr.slice(0, 6)}...${addr.slice(-4)}`);
+    console.log("");
+    // Step 2: RPC
+    console.log(`  ${ui.bold("Step 2/3: RPC")}`);
+    const rpcUrl = await ui.prompt("Base RPC URL", "https://mainnet.base.org");
+    values.RPC_URL = rpcUrl;
+    // Validate RPC connectivity
+    try {
+        const { createPublicClient, http } = await Promise.resolve().then(() => __importStar(require("viem")));
+        const { base, baseSepolia } = await Promise.resolve().then(() => __importStar(require("viem/chains")));
+        const isSepolia = rpcUrl.toLowerCase().includes("sepolia");
+        const testClient = createPublicClient({
+            chain: isSepolia ? baseSepolia : base,
+            transport: http(rpcUrl),
+        });
+        const blockNumber = await testClient.getBlockNumber();
+        const networkName = isSepolia ? "Base Sepolia" : "Base mainnet";
+        ui.ok(`Connected — ${networkName}, block #${blockNumber.toLocaleString()}`);
+        if (isSepolia)
+            values.CHAIN = "baseSepolia";
+    }
+    catch {
+        ui.fail("Could not connect to RPC");
+        ui.hint("Continuing anyway — you can fix RPC_URL in .env later");
+    }
+    console.log("");
+    // Step 3: LLM
+    console.log(`  ${ui.bold("Step 3/3: LLM Provider")}`);
+    const providerInput = await ui.prompt("Provider (openai/anthropic/gemini/ollama/claude-code/codex)", "openai");
+    const provider = (["openai", "anthropic", "gemini", "ollama", "claude-code", "codex"].includes(providerInput) ? providerInput : "openai");
+    values.LLM_PROVIDER = provider;
+    if (provider === "ollama") {
+        const ollamaUrl = await ui.prompt("Ollama URL", "http://127.0.0.1:11434");
+        values.OLLAMA_URL = ollamaUrl;
+        ui.ok(`Ollama at ${ollamaUrl}`);
+    }
+    else if (provider === "claude-code" || provider === "codex") {
+        ui.ok(`Using local ${provider} CLI — no API key needed`);
+    }
+    else {
+        const apiKey = await ui.promptSecret("API key");
+        if (apiKey) {
+            values.LLM_API_KEY = apiKey;
+            ui.ok(`${provider} key set`);
+        }
+        else {
+            ui.fail("No API key provided");
+            ui.hint(`Set LLM_API_KEY in .env later`);
+        }
+    }
+    const defaultModel = provider === "gemini" ? "gemini-2.5-flash" : provider === "anthropic" ? "claude-sonnet-4-5-20250929" : provider === "claude-code" || provider === "codex" ? "default" : "gpt-4o-mini";
+    const model = await ui.prompt("Model", defaultModel);
+    values.LLM_MODEL = model;
+    if ((0, config_1.isExpensiveModel)(model)) {
+        ui.warn(`${model} is expensive. Consider gpt-4o-mini for lower cost.`);
+    }
+    // Contract addresses
+    values.MINING_AGENT_ADDRESS = config_1.config.miningAgentAddress ?? "";
+    values.AGENT_COIN_ADDRESS = config_1.config.agentCoinAddress ?? "";
+    console.log("");
+    // Check for existing .env
+    const envPath = (0, node_path_1.join)(process.cwd(), ".env");
+    if ((0, node_fs_1.existsSync)(envPath)) {
+        const overwrite = await ui.confirm("Overwrite existing .env?");
+        if (!overwrite) {
+            console.log("  Setup cancelled.");
+            return;
+        }
+    }
+    await (0, config_1.writeEnvFile)(values);
+    ui.ok("Config saved to .env");
+    // Check .gitignore
+    const gitignorePath = (0, node_path_1.join)(process.cwd(), ".gitignore");
+    if ((0, node_fs_1.existsSync)(gitignorePath)) {
+        const gitignore = (0, node_fs_1.readFileSync)(gitignorePath, "utf8");
+        if (!gitignore.includes(".env")) {
+            ui.warn(".gitignore does not include .env — your secrets may be committed!");
+            ui.hint("Add .env and wallet-*.txt to .gitignore");
+        }
+        if (!gitignore.includes("wallet-")) {
+            ui.hint("Consider adding wallet-*.txt to .gitignore");
+        }
+    }
+    console.log("");
+    console.log(`  Next: ${ui.cyan("apow mint")}`);
+    console.log("");
+}
+async function main() {
+    const version = readVersion();
+    const program = new commander_1.Command();
+    // SIGINT handler
+    process.on("SIGINT", () => {
+        ui.stopAll();
+        console.log("");
+        console.log(ui.dim("  Interrupted. Bye!"));
+        process.exit(0);
+    });
+    program
+        .name("apow")
+        .description("Mine AGENT tokens on Base L2 with AI-powered proof of work")
+        .version(version);
+    program
+        .command("setup")
+        .description("Interactive setup wizard — configure wallet, RPC, and LLM")
+        .action(async () => {
+        await setupWizard();
+    });
+    program
+        .command("mint")
+        .description("Mint a new miner NFT")
+        .hook("preAction", async () => {
+        await (0, preflight_1.runPreflight)("wallet");
+    })
+        .action(async () => {
+        await (0, mint_1.runMintFlow)();
+    });
+    program
+        .command("mine")
+        .description("Start the mining loop")
+        .argument("[tokenId]", "Miner token ID (auto-detects if omitted)")
+        .hook("preAction", async () => {
+        await (0, preflight_1.runPreflight)("mining");
+    })
+        .action(async (tokenIdArg) => {
+        const tokenId = await resolveTokenId(tokenIdArg);
+        await (0, miner_1.startMining)(tokenId);
+    });
+    program
+        .command("stats")
+        .description("Show network and miner statistics")
+        .argument("[tokenId]", "Miner token ID (auto-detects if omitted)")
+        .hook("preAction", async () => {
+        await (0, preflight_1.runPreflight)("readonly");
+    })
+        .action(async (tokenIdArg) => {
+        let tokenId;
+        if (tokenIdArg) {
+            tokenId = parseTokenId(tokenIdArg);
+        }
+        else if (wallet_1.account) {
+            try {
+                const miners = await (0, detect_1.detectMiners)(wallet_1.account.address);
+                if (miners.length > 0) {
+                    tokenId = (0, detect_1.selectBestMiner)(miners).tokenId;
+                }
+            }
+            catch {
+                // No miners — show network stats only
+            }
+        }
+        await (0, stats_1.displayStats)(tokenId);
+    });
+    const walletCmd = program
+        .command("wallet")
+        .description("Wallet generation and management");
+    walletCmd
+        .command("new")
+        .description("Generate a new Base wallet (prints key and saves to file)")
+        .action(async () => {
+        const { generatePrivateKey, privateKeyToAccount } = await Promise.resolve().then(() => __importStar(require("viem/accounts")));
+        const key = generatePrivateKey();
+        const acct = privateKeyToAccount(key);
+        console.log("");
+        console.log(`  ${ui.bold("NEW WALLET GENERATED")}`);
+        console.log("");
+        console.log(`  Address:     ${acct.address}`);
+        console.log(`  Private Key: ${key}`);
+        console.log("");
+        console.log(`  ${ui.yellow("⚠ SAVE YOUR PRIVATE KEY — this is the only time")}`);
+        console.log(`  ${ui.yellow("  it will be displayed. Anyone with this key")}`);
+        console.log(`  ${ui.yellow("  controls your funds.")}`);
+        console.log("");
+        const keyPath = saveKeyFile(acct.address, key);
+        console.log(`  ${ui.dim(`Key saved to: ${keyPath}`)}`);
+        console.log(`  ${ui.yellow("Back up this file securely, then delete it.")}`);
+        console.log("");
+        console.log(`  ${ui.dim("Import into Phantom, MetaMask, or any EVM wallet")}`);
+        console.log(`  ${ui.dim("to view your AGENT tokens and Mining Rig NFT.")}`);
+        console.log("");
+    });
+    walletCmd
+        .command("show")
+        .description("Show wallet address from current .env PRIVATE_KEY")
+        .action(async () => {
+        if (!wallet_1.account) {
+            ui.error("No wallet configured. Set PRIVATE_KEY in .env or run: apow wallet new");
+            return;
+        }
+        console.log("");
+        console.log(`  Address: ${wallet_1.account.address}`);
+        console.log("");
+    });
+    walletCmd
+        .command("export")
+        .description("Export wallet private key (with confirmation)")
+        .action(async () => {
+        if (!wallet_1.account || !config_1.config.privateKey) {
+            ui.error("No wallet configured. Set PRIVATE_KEY in .env or run: apow wallet new");
+            return;
+        }
+        const proceed = await ui.confirm("This will display your private key. Continue?");
+        if (!proceed) {
+            console.log("  Cancelled.");
+            return;
+        }
+        console.log("");
+        console.log(`  Address:     ${wallet_1.account.address}`);
+        console.log(`  Private Key: ${config_1.config.privateKey}`);
+        console.log("");
+        const filename = `wallet-${wallet_1.account.address}.txt`;
+        const filepath = (0, node_path_1.join)(process.cwd(), filename);
+        if (!(0, node_fs_1.existsSync)(filepath)) {
+            const save = await ui.confirm("Save to file?");
+            if (save) {
+                const keyPath = saveKeyFile(wallet_1.account.address, config_1.config.privateKey);
+                console.log(`  ${ui.dim(`Saved to: ${keyPath}`)}`);
+                console.log(`  ${ui.yellow("Back up this file securely, then delete it.")}`);
+                console.log("");
+            }
+        }
+    });
+    walletCmd
+        .command("fund")
+        .description("Send ETH from your wallet to another address")
+        .argument("<address>", "Destination address (0x-prefixed)")
+        .argument("[amount]", "ETH amount to send (default: mint price + 0.003 ETH gas buffer)")
+        .hook("preAction", async () => {
+        await (0, preflight_1.runPreflight)("wallet");
+    })
+        .action(async (address, amountArg) => {
+        if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+            ui.error("Invalid address format. Must be 0x + 40 hex characters.");
+            return;
+        }
+        const { account: senderAccount, walletClient } = (0, wallet_1.requireWallet)();
+        const destAddress = address;
+        // Determine amount
+        let amount;
+        if (amountArg) {
+            try {
+                amount = (0, viem_1.parseEther)(amountArg);
+            }
+            catch {
+                ui.error(`Invalid amount: ${amountArg}. Use decimal ETH (e.g., 0.005).`);
+                return;
+            }
+        }
+        else {
+            // Default: current mint price + 0.003 ETH gas buffer
+            const mintPrice = (await wallet_1.publicClient.readContract({
+                address: config_1.config.miningAgentAddress,
+                abi: miningAgentAbi,
+                functionName: "getMintPrice",
+            }));
+            const gasBuffer = (0, viem_1.parseEther)("0.003");
+            amount = mintPrice + gasBuffer;
+        }
+        const senderBalance = await (0, wallet_1.getEthBalance)();
+        console.log("");
+        ui.table([
+            ["From", `${senderAccount.address.slice(0, 6)}...${senderAccount.address.slice(-4)}`],
+            ["To", `${destAddress.slice(0, 6)}...${destAddress.slice(-4)}`],
+            ["Amount", `${(0, viem_1.formatEther)(amount)} ETH`],
+            ["Balance", `${Number((0, viem_1.formatEther)(senderBalance)).toFixed(6)} ETH`],
+        ]);
+        console.log("");
+        if (senderBalance < amount) {
+            ui.error("Insufficient ETH balance.");
+            ui.hint(`Need ${(0, viem_1.formatEther)(amount)} ETH, have ${Number((0, viem_1.formatEther)(senderBalance)).toFixed(6)} ETH`);
+            return;
+        }
+        const proceed = await ui.confirm("Send ETH?");
+        if (!proceed) {
+            console.log("  Cancelled.");
+            return;
+        }
+        const sendSpinner = ui.spinner("Sending ETH...");
+        const txHash = await walletClient.sendTransaction({
+            account: senderAccount,
+            to: destAddress,
+            value: amount,
+        });
+        sendSpinner.update("Waiting for confirmation...");
+        const receipt = await wallet_1.publicClient.waitForTransactionReceipt({ hash: txHash });
+        if (receipt.status === "reverted") {
+            sendSpinner.fail("Transaction reverted");
+            return;
+        }
+        sendSpinner.stop("Sending ETH... confirmed");
+        console.log(`  ${ui.green("Sent")} ${(0, viem_1.formatEther)(amount)} ETH to ${destAddress.slice(0, 6)}...${destAddress.slice(-4)}`);
+        console.log(`  Tx: ${ui.dim((0, explorer_1.txUrl)(receipt.transactionHash))}`);
+        console.log("");
+    });
+    await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    ui.error(message);
+    process.exitCode = 1;
+});