apow-cli 0.1.0

package/dist/preflight.js

@@ -0,0 +1,183 @@
+"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 });
+exports.runPreflight = runPreflight;
+const viem_1 = require("viem");
+const AgentCoin_json_1 = __importDefault(require("./abi/AgentCoin.json"));
+const config_1 = require("./config");
+const wallet_1 = require("./wallet");
+const ui = __importStar(require("./ui"));
+const agentCoinAbi = AgentCoin_json_1.default;
+async function runPreflight(level) {
+    const results = [];
+    // Check 1: Contract addresses set
+    const zeroAddr = "0x0000000000000000000000000000000000000000";
+    if (config_1.config.miningAgentAddress === zeroAddr || config_1.config.agentCoinAddress === zeroAddr) {
+        results.push({
+            label: "Contract addresses not configured",
+            passed: false,
+            fix: "Set MINING_AGENT_ADDRESS and AGENT_COIN_ADDRESS in .env",
+        });
+    }
+    else {
+        results.push({ label: "Contract addresses configured", passed: true });
+    }
+    // Check 2: RPC reachable + chain ID
+    try {
+        const chainId = await wallet_1.publicClient.getChainId();
+        const expectedId = config_1.config.chain.id;
+        if (chainId !== expectedId) {
+            results.push({
+                label: `RPC chain mismatch — expected ${expectedId}, got ${chainId}`,
+                passed: false,
+                fix: "Update RPC_URL to point to the correct network",
+            });
+        }
+        else {
+            results.push({ label: `RPC connected — ${config_1.config.chain.name}`, passed: true });
+        }
+    }
+    catch {
+        results.push({
+            label: `RPC unreachable — could not connect to ${config_1.config.rpcUrl}`,
+            passed: false,
+            fix: "Check internet connection or update RPC_URL in .env",
+        });
+    }
+    if (level === "wallet" || level === "mining") {
+        // Check 3: Private key valid
+        if (wallet_1.account) {
+            results.push({
+                label: `Private key valid (${wallet_1.account.address.slice(0, 6)}...${wallet_1.account.address.slice(-4)})`,
+                passed: true,
+            });
+        }
+        else {
+            results.push({
+                label: "Private key not configured",
+                passed: false,
+                fix: "Set PRIVATE_KEY in .env (0x-prefixed 32-byte hex)",
+            });
+        }
+        // Check 4: Wallet has ETH
+        if (wallet_1.account) {
+            try {
+                const balance = await wallet_1.publicClient.getBalance({ address: wallet_1.account.address });
+                const ethBalance = Number((0, viem_1.formatEther)(balance));
+                if (ethBalance < 0.001) {
+                    results.push({
+                        label: `Low ETH balance (${ethBalance.toFixed(6)} ETH)`,
+                        passed: false,
+                        fix: `Send ETH to ${wallet_1.account.address} on Base`,
+                    });
+                }
+                else {
+                    results.push({ label: `ETH balance: ${ethBalance.toFixed(6)} ETH`, passed: true });
+                }
+            }
+            catch {
+                results.push({
+                    label: "Could not check ETH balance",
+                    passed: false,
+                    fix: "Verify RPC connection",
+                });
+            }
+        }
+        // Check 5: LLM key set
+        if (config_1.config.llmProvider === "ollama") {
+            results.push({ label: `LLM provider: ollama (${config_1.config.ollamaUrl})`, passed: true });
+        }
+        else if (config_1.config.llmProvider === "claude-code" || config_1.config.llmProvider === "codex") {
+            results.push({ label: `LLM provider: ${config_1.config.llmProvider} (local CLI)`, passed: true });
+        }
+        else if (config_1.config.llmApiKey) {
+            results.push({ label: `LLM provider: ${config_1.config.llmProvider} (key set)`, passed: true });
+        }
+        else {
+            results.push({
+                label: `LLM API key not set for ${config_1.config.llmProvider}`,
+                passed: false,
+                fix: "Set LLM_API_KEY (or OPENAI_API_KEY / ANTHROPIC_API_KEY / GEMINI_API_KEY) in .env, or run `apow setup`",
+            });
+        }
+    }
+    // Check 6: Contracts exist on-chain (bytecode check)
+    try {
+        const [miningAgentCode, agentCoinCode] = await Promise.all([
+            wallet_1.publicClient.getCode({ address: config_1.config.miningAgentAddress }),
+            wallet_1.publicClient.getCode({ address: config_1.config.agentCoinAddress }),
+        ]);
+        if (!miningAgentCode || miningAgentCode === "0x") {
+            results.push({
+                label: "MiningAgent contract not found on-chain",
+                passed: false,
+                fix: "Verify MINING_AGENT_ADDRESS is correct for this network",
+            });
+        }
+        else if (!agentCoinCode || agentCoinCode === "0x") {
+            results.push({
+                label: "AgentCoin contract not found on-chain",
+                passed: false,
+                fix: "Verify AGENT_COIN_ADDRESS is correct for this network",
+            });
+        }
+        else {
+            results.push({ label: "Contracts verified on-chain", passed: true });
+        }
+    }
+    catch {
+        // Skip if contract addresses not configured (already caught above)
+    }
+    const failures = results.filter((r) => !r.passed);
+    if (failures.length > 0) {
+        console.log("");
+        console.log(`  ${ui.red("Pre-flight failed:")}`);
+        for (const r of results) {
+            if (r.passed) {
+                ui.ok(r.label);
+            }
+            else {
+                ui.fail(r.label);
+                if (r.fix)
+                    ui.hint(`Fix: ${r.fix}`);
+            }
+        }
+        console.log("");
+        process.exit(1);
+    }
+}

package/dist/smhl.js

@@ -0,0 +1,317 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSmhlChallenge = normalizeSmhlChallenge;
+exports.buildSmhlPrompt = buildSmhlPrompt;
+exports.validateSmhlSolution = validateSmhlSolution;
+exports.solveSmhlChallenge = solveSmhlChallenge;
+const node_child_process_1 = require("node:child_process");
+const openai_1 = __importDefault(require("openai"));
+const config_1 = require("./config");
+function normalizeSmhlChallenge(raw) {
+    if (Array.isArray(raw)) {
+        const [targetAsciiSum, firstNChars, wordCount, charPosition, charValue, totalLength] = raw;
+        return {
+            targetAsciiSum: Number(targetAsciiSum),
+            firstNChars: Number(firstNChars),
+            wordCount: Number(wordCount),
+            charPosition: Number(charPosition),
+            charValue: Number(charValue),
+            totalLength: Number(totalLength),
+        };
+    }
+    if (raw && typeof raw === "object") {
+        const challenge = raw;
+        return {
+            targetAsciiSum: Number(challenge.targetAsciiSum),
+            firstNChars: Number(challenge.firstNChars),
+            wordCount: Number(challenge.wordCount),
+            charPosition: Number(challenge.charPosition),
+            charValue: Number(challenge.charValue),
+            totalLength: Number(challenge.totalLength),
+        };
+    }
+    throw new Error("Unable to normalize SMHL challenge.");
+}
+function buildSmhlPrompt(challenge, feedback) {
+    const requiredChar = String.fromCharCode(challenge.charValue);
+    const spaces = Math.max(0, challenge.wordCount - 1);
+    const avgWordLen = Math.round((challenge.totalLength - spaces) / challenge.wordCount);
+    const minWordLen = Math.max(2, avgWordLen - 2);
+    const maxWordLen = avgWordLen + 2;
+    const lines = [
+        `Write exactly ${challenge.wordCount} lowercase English words separated by single spaces.`,
+        `Each word should be ${minWordLen} to ${maxWordLen} letters long.`,
+        `At least one word must contain the letter '${requiredChar}'.`,
+        `No punctuation, no quotes, no explanation — just the words.`,
+    ];
+    if (feedback) {
+        lines.push("", `Previous attempt was rejected: ${feedback}. Try completely different words.`);
+    }
+    return lines.join("\n");
+}
+function validateSmhlSolution(solution, challenge) {
+    const issues = [];
+    if (!solution) {
+        issues.push("empty response");
+        return issues;
+    }
+    const len = Buffer.byteLength(solution, "utf8");
+    if (Math.abs(len - challenge.totalLength) > 5) {
+        issues.push(`length ${len} not within ±5 of ${challenge.totalLength}`);
+    }
+    if (!/^[\x20-\x7E]+$/.test(solution)) {
+        issues.push("solution must use printable ASCII only");
+    }
+    const requiredChar = String.fromCharCode(challenge.charValue);
+    if (!solution.includes(requiredChar)) {
+        issues.push(`missing required char '${requiredChar}'`);
+    }
+    const words = solution.split(" ").filter(Boolean);
+    if (Math.abs(words.length - challenge.wordCount) > 2) {
+        issues.push(`word count ${words.length} not within ±2 of ${challenge.wordCount}`);
+    }
+    return issues;
+}
+/**
+ * Post-process LLM output to fit within SMHL constraints.
+ * The LLM generates roughly-correct text; this adjusts length, word count,
+ * and ensures the required character is present.
+ */
+function adjustSolution(raw, challenge) {
+    const requiredChar = String.fromCharCode(challenge.charValue);
+    const minLen = challenge.totalLength - 5;
+    const maxLen = challenge.totalLength + 5;
+    const maxWords = challenge.wordCount + 2;
+    // Clean: lowercase, letters and spaces only, collapse whitespace
+    let words = raw
+        .toLowerCase()
+        .replace(/[^a-z ]/g, "")
+        .split(/\s+/)
+        .filter((w) => w.length > 0);
+    if (words.length === 0)
+        return raw;
+    // Trim excess words (prefer keeping words with the required char)
+    while (words.length > maxWords) {
+        let removeIdx = -1;
+        for (let i = words.length - 1; i >= 0; i--) {
+            if (!words[i].includes(requiredChar)) {
+                removeIdx = i;
+                break;
+            }
+        }
+        words.splice(removeIdx >= 0 ? removeIdx : words.length - 1, 1);
+    }
+    let result = words.join(" ");
+    let len = Buffer.byteLength(result, "utf8");
+    // Too long: trim at word boundary, then trim characters
+    if (len > maxLen) {
+        result = result.slice(0, maxLen);
+        const lastSpace = result.lastIndexOf(" ");
+        if (lastSpace >= minLen)
+            result = result.slice(0, lastSpace);
+        words = result.split(" ").filter(Boolean);
+        len = Buffer.byteLength(result, "utf8");
+    }
+    // Too short: add filler words
+    const fillers = ["and", "the", "not", "can", "run", "now", "old", "new"];
+    let fi = 0;
+    while (len < minLen && words.length < maxWords) {
+        words.push(fillers[fi % fillers.length]);
+        result = words.join(" ");
+        len = Buffer.byteLength(result, "utf8");
+        fi++;
+    }
+    // Still too short but can't add more words: extend last word
+    while (len < minLen && words.length > 0) {
+        words[words.length - 1] += "s";
+        result = words.join(" ");
+        len = Buffer.byteLength(result, "utf8");
+    }
+    // Ensure required char is present
+    if (!result.includes(requiredChar)) {
+        const last = words[words.length - 1];
+        words[words.length - 1] = last.slice(0, -1) + requiredChar;
+        result = words.join(" ");
+    }
+    return result;
+}
+function sanitizeResponse(text) {
+    let cleaned = text.replace(/\r/g, "").trim();
+    const fenceMatch = cleaned.match(/^```(?:text)?\n([\s\S]*?)\n```$/);
+    if (fenceMatch) {
+        cleaned = fenceMatch[1];
+    }
+    if ((cleaned.startsWith('"') && cleaned.endsWith('"')) ||
+        (cleaned.startsWith("'") && cleaned.endsWith("'"))) {
+        cleaned = cleaned.slice(1, -1);
+    }
+    return cleaned;
+}
+async function requestOpenAiSolution(prompt) {
+    const client = new openai_1.default({ apiKey: (0, config_1.requireLlmApiKey)() });
+    const response = await client.chat.completions.create({
+        model: config_1.config.llmModel,
+        temperature: 0.7,
+        messages: [
+            {
+                role: "system",
+                content: "You generate short lowercase word sequences that match exact constraints. Return only the words separated by spaces. Nothing else.",
+            },
+            { role: "user", content: prompt },
+        ],
+    }, { timeout: 15_000 });
+    return response.choices[0]?.message.content ?? "";
+}
+async function requestAnthropicSolution(prompt) {
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        signal: AbortSignal.timeout(15_000),
+        headers: {
+            "content-type": "application/json",
+            "x-api-key": (0, config_1.requireLlmApiKey)(),
+            "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify({
+            model: config_1.config.llmModel,
+            max_tokens: 200,
+            temperature: 0.7,
+            system: "You generate short lowercase word sequences that match exact constraints. Return only the words separated by spaces. Nothing else.",
+            messages: [{ role: "user", content: prompt }],
+        }),
+    });
+    if (response.status === 429) {
+        const retryAfter = response.headers.get("retry-after");
+        const waitMs = retryAfter ? parseInt(retryAfter) * 1000 : 5000;
+        await new Promise((r) => setTimeout(r, waitMs));
+        throw new Error(`Rate limited by Anthropic — retrying`);
+    }
+    if (!response.ok) {
+        throw new Error(`Anthropic request failed: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data.content?.find((item) => item.type === "text")?.text ?? "";
+}
+async function requestOllamaSolution(prompt) {
+    const response = await fetch(`${config_1.config.ollamaUrl}/api/generate`, {
+        method: "POST",
+        signal: AbortSignal.timeout(15_000),
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            model: config_1.config.llmModel,
+            prompt: [
+                "You generate short lowercase word sequences that match exact constraints.",
+                "Return only the words separated by spaces. Nothing else.",
+                "",
+                prompt,
+            ].join("\n"),
+            stream: false,
+            options: { temperature: 0.7 },
+        }),
+    });
+    if (response.status === 429) {
+        const retryAfter = response.headers.get("retry-after");
+        const waitMs = retryAfter ? parseInt(retryAfter) * 1000 : 5000;
+        await new Promise((r) => setTimeout(r, waitMs));
+        throw new Error(`Rate limited by Ollama — retrying`);
+    }
+    if (!response.ok) {
+        throw new Error(`Ollama request failed: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data.response ?? "";
+}
+async function requestGeminiSolution(prompt) {
+    const model = config_1.config.llmModel || "gemini-2.5-flash";
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${(0, config_1.requireLlmApiKey)()}`, {
+        method: "POST",
+        signal: AbortSignal.timeout(15_000),
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            systemInstruction: {
+                parts: [{ text: "You generate short lowercase word sequences that match exact constraints. Return only the words separated by spaces. Nothing else." }],
+            },
+            contents: [{ parts: [{ text: prompt }] }],
+            generationConfig: { temperature: 0.7 },
+        }),
+    });
+    if (response.status === 429) {
+        const retryAfter = response.headers.get("retry-after");
+        const waitMs = retryAfter ? parseInt(retryAfter) * 1000 : 5000;
+        await new Promise((r) => setTimeout(r, waitMs));
+        throw new Error(`Rate limited by Gemini — retrying`);
+    }
+    if (!response.ok) {
+        throw new Error(`Gemini request failed: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data.candidates?.[0]?.content?.parts?.[0]?.text ?? "";
+}
+async function requestClaudeCodeSolution(prompt) {
+    return new Promise((resolve, reject) => {
+        const escaped = prompt.replace(/'/g, "'\\''");
+        (0, node_child_process_1.exec)(`claude -p '${escaped}'`, { timeout: 120_000 }, (error, stdout, stderr) => {
+            if (error) {
+                reject(new Error(`Claude Code error: ${error.message}${stderr ? `\nstderr: ${stderr}` : ""}${stdout ? `\nstdout: ${stdout}` : ""}`));
+                return;
+            }
+            resolve(stdout.trim());
+        });
+    });
+}
+async function requestCodexSolution(prompt) {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)("codex", ["exec", prompt, "--full-auto"], { timeout: 15_000 }, (error, stdout, stderr) => {
+            if (error) {
+                reject(new Error(`Codex error: ${error.message}`));
+                return;
+            }
+            resolve(stdout.trim());
+        });
+    });
+}
+async function requestProviderSolution(prompt) {
+    switch (config_1.config.llmProvider) {
+        case "anthropic":
+            return requestAnthropicSolution(prompt);
+        case "gemini":
+            return requestGeminiSolution(prompt);
+        case "ollama":
+            return requestOllamaSolution(prompt);
+        case "claude-code":
+            return requestClaudeCodeSolution(prompt);
+        case "codex":
+            return requestCodexSolution(prompt);
+        case "openai":
+        default:
+            return requestOpenAiSolution(prompt);
+    }
+}
+async function solveSmhlChallenge(challenge, onAttempt) {
+    let feedback;
+    let lastIssues = "provider did not return a valid response";
+    for (let attempt = 1; attempt <= 5; attempt += 1) {
+        if (onAttempt)
+            onAttempt(attempt);
+        try {
+            const prompt = buildSmhlPrompt(challenge, feedback);
+            const raw = await requestProviderSolution(prompt);
+            const sanitized = sanitizeResponse(raw);
+            const adjusted = adjustSolution(sanitized, challenge);
+            const issues = validateSmhlSolution(adjusted, challenge);
+            if (issues.length === 0) {
+                return adjusted;
+            }
+            feedback = issues.join(", ");
+            lastIssues = `attempt ${attempt}: ${feedback}`;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            feedback = msg;
+            lastIssues = `attempt ${attempt}: ${msg}`;
+        }
+    }
+    throw new Error(`SMHL solve failed after 5 attempts: ${lastIssues}`);
+}

package/dist/stats.js

@@ -0,0 +1,166 @@
+"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 });
+exports.displayStats = displayStats;
+const viem_1 = require("viem");
+const AgentCoin_json_1 = __importDefault(require("./abi/AgentCoin.json"));
+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 ui = __importStar(require("./ui"));
+const wallet_1 = require("./wallet");
+const miningAgentAbi = MiningAgent_json_1.default;
+const agentCoinAbi = AgentCoin_json_1.default;
+async function displayStats(tokenId) {
+    const [totalMines, totalMinted, miningTarget, mineableSupply, eraInterval, walletBalance] = await Promise.all([
+        wallet_1.publicClient.readContract({
+            address: config_1.config.agentCoinAddress,
+            abi: agentCoinAbi,
+            functionName: "totalMines",
+        }),
+        wallet_1.publicClient.readContract({
+            address: config_1.config.agentCoinAddress,
+            abi: agentCoinAbi,
+            functionName: "totalMinted",
+        }),
+        wallet_1.publicClient.readContract({
+            address: config_1.config.agentCoinAddress,
+            abi: agentCoinAbi,
+            functionName: "miningTarget",
+        }),
+        wallet_1.publicClient.readContract({
+            address: config_1.config.agentCoinAddress,
+            abi: agentCoinAbi,
+            functionName: "MINEABLE_SUPPLY",
+        }),
+        wallet_1.publicClient.readContract({
+            address: config_1.config.agentCoinAddress,
+            abi: agentCoinAbi,
+            functionName: "ERA_INTERVAL",
+        }),
+        wallet_1.account
+            ? wallet_1.publicClient.readContract({
+                address: config_1.config.agentCoinAddress,
+                abi: agentCoinAbi,
+                functionName: "balanceOf",
+                args: [wallet_1.account.address],
+            })
+            : Promise.resolve(0n),
+    ]);
+    const era = totalMines / eraInterval;
+    const minesUntilNextEra = eraInterval - (totalMines % eraInterval);
+    const supplyPct = Number(totalMinted * 10000n / mineableSupply) / 100;
+    const remainingSupply = mineableSupply - totalMinted;
+    // Base reward calculation (3 * 0.9^era)
+    let baseReward = 3;
+    for (let i = 0n; i < era; i++) {
+        baseReward *= 0.9;
+    }
+    let nextEraReward = baseReward * 0.9;
+    // Difficulty interpretation
+    const targetLog = Math.log2(Number(miningTarget));
+    const difficultyDesc = targetLog > 250 ? "very easy" : targetLog > 240 ? "easy" : targetLog > 220 ? "moderate" : targetLog > 200 ? "hard" : "very hard";
+    console.log("");
+    console.log(`  ${ui.bold("Network")}`);
+    ui.table([
+        ["Total mines", totalMines.toLocaleString()],
+        ["Supply mined", `${Number((0, viem_1.formatEther)(totalMinted)).toLocaleString()} / ${Number((0, viem_1.formatEther)(mineableSupply)).toLocaleString()} AGENT (${supplyPct.toFixed(2)}%)`],
+        ["Remaining", `${Number((0, viem_1.formatEther)(remainingSupply)).toLocaleString()} AGENT`],
+        ["Era", `${era} (${minesUntilNextEra.toLocaleString()} mines until era ${(era + 1n).toString()})`],
+        ["Base reward", `${baseReward.toFixed(2)} AGENT (next era: ${nextEraReward.toFixed(2)})`],
+        ["Difficulty", `${difficultyDesc} (target: 2^${targetLog.toFixed(0)})`],
+    ]);
+    if (wallet_1.account && walletBalance > 0n) {
+        console.log("");
+        console.log(`  ${ui.bold("Wallet")}`);
+        ui.table([
+            ["Address", `${wallet_1.account.address.slice(0, 6)}...${wallet_1.account.address.slice(-4)}`],
+            ["AGENT balance", `${Number((0, viem_1.formatEther)(walletBalance)).toLocaleString()} AGENT`],
+        ]);
+    }
+    if (tokenId === undefined) {
+        console.log("");
+        return;
+    }
+    const [tokenMineCount, tokenEarnings, rarityRaw, hashpowerRaw, mintBlock] = await Promise.all([
+        wallet_1.publicClient.readContract({
+            address: config_1.config.agentCoinAddress,
+            abi: agentCoinAbi,
+            functionName: "tokenMineCount",
+            args: [tokenId],
+        }),
+        wallet_1.publicClient.readContract({
+            address: config_1.config.agentCoinAddress,
+            abi: agentCoinAbi,
+            functionName: "tokenEarnings",
+            args: [tokenId],
+        }),
+        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],
+        }),
+        wallet_1.publicClient.readContract({
+            address: config_1.config.miningAgentAddress,
+            abi: miningAgentAbi,
+            functionName: "mintBlock",
+            args: [tokenId],
+        }),
+    ]);
+    const rarity = Number(rarityRaw);
+    const hashpower = Number(hashpowerRaw);
+    const rewardPerMine = baseReward * (hashpower / 100);
+    console.log("");
+    console.log(`  ${ui.bold(`Miner #${tokenId} (${detect_1.rarityLabels[rarity] ?? `Tier ${rarity}`}, ${(0, detect_1.formatHashpower)(hashpower)})`)}`);
+    ui.table([
+        ["Mine count", tokenMineCount.toLocaleString()],
+        ["Earnings", `${Number((0, viem_1.formatEther)(tokenEarnings)).toLocaleString()} AGENT`],
+        ["Reward/mine", `${rewardPerMine.toFixed(2)} AGENT`],
+        ["Mint block", mintBlock.toLocaleString()],
+        ["Basescan", (0, explorer_1.tokenUrl)(config_1.config.miningAgentAddress, tokenId)],
+    ]);
+    console.log("");
+}