apow-cli 0.1.0

package/dist/miner.js

@@ -0,0 +1,327 @@
+"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.startMining = startMining;
+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 errors_1 = require("./errors");
+const explorer_1 = require("./explorer");
+const smhl_1 = require("./smhl");
+const ui = __importStar(require("./ui"));
+const wallet_1 = require("./wallet");
+const agentCoinAbi = AgentCoin_json_1.default;
+const miningAgentAbi = MiningAgent_json_1.default;
+const MAX_CONSECUTIVE_FAILURES = 10;
+const BASE_BACKOFF_MS = 2_000;
+const MAX_BACKOFF_MS = 60_000;
+const BASE_REWARD = 3n * 10n ** 18n;
+const REWARD_DECAY_NUM = 90n;
+const REWARD_DECAY_DEN = 100n;
+function elapsedSeconds(start) {
+    const [seconds, nanoseconds] = process.hrtime(start);
+    return seconds + nanoseconds / 1_000_000_000;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function backoffMs(failures) {
+    const base = Math.min(BASE_BACKOFF_MS * 2 ** (failures - 1), MAX_BACKOFF_MS);
+    const jitter = Math.random() * base * 0.3;
+    return base + jitter;
+}
+function estimateReward(totalMines, eraInterval, hashpower) {
+    const era = totalMines / eraInterval;
+    let reward = BASE_REWARD;
+    for (let i = 0n; i < era; i++) {
+        reward = (reward * REWARD_DECAY_NUM) / REWARD_DECAY_DEN;
+    }
+    return (reward * hashpower) / 100n;
+}
+function formatBaseReward(era) {
+    let reward = 3;
+    for (let i = 0n; i < era; i++) {
+        reward *= 0.9;
+    }
+    return reward.toFixed(2);
+}
+async function waitForNextBlock(lastMineBlock) {
+    const deadline = Date.now() + 60_000; // 60 seconds
+    while (Date.now() < deadline) {
+        const currentBlock = await wallet_1.publicClient.getBlockNumber();
+        if (currentBlock > lastMineBlock) {
+            return;
+        }
+        await sleep(500);
+    }
+    throw new Error("Timed out waiting for next block (60s)");
+}
+async function grindNonce(challengeNumber, target, minerAddress, onProgress) {
+    let nonce = 0n;
+    let attempts = 0n;
+    const start = process.hrtime();
+    while (true) {
+        const digest = BigInt((0, viem_1.keccak256)((0, viem_1.encodePacked)(["bytes32", "address", "uint256"], [challengeNumber, minerAddress, nonce])));
+        attempts += 1n;
+        if (digest < target) {
+            const elapsed = elapsedSeconds(start);
+            const hashrate = elapsed > 0 ? Number(attempts) / elapsed : Number(attempts);
+            return { nonce, attempts, hashrate, elapsed };
+        }
+        if (onProgress && attempts % 50000n === 0n) {
+            const elapsed = elapsedSeconds(start);
+            const hashrate = elapsed > 0 ? Number(attempts) / elapsed : Number(attempts);
+            onProgress(attempts, hashrate);
+        }
+        nonce += 1n;
+    }
+}
+async function showStartupBanner(tokenId) {
+    const { account } = (0, wallet_1.requireWallet)();
+    const [ethBalance, totalMines, totalMinted, mineableSupply, eraInterval, hashpowerRaw, rarityRaw] = await Promise.all([
+        (0, wallet_1.getEthBalance)(),
+        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: "MINEABLE_SUPPLY",
+        }),
+        wallet_1.publicClient.readContract({
+            address: config_1.config.agentCoinAddress,
+            abi: agentCoinAbi,
+            functionName: "ERA_INTERVAL",
+        }),
+        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: "rarity",
+            args: [tokenId],
+        }),
+    ]);
+    const rarity = Number(rarityRaw);
+    const hashpower = Number(hashpowerRaw);
+    const era = totalMines / eraInterval;
+    const supplyPct = Number(totalMinted * 10000n / mineableSupply) / 100;
+    console.log("");
+    ui.banner([`AgentCoin Miner v${config_1.config.chainName === "baseSepolia" ? "0.1.0-testnet" : "0.1.0"}`]);
+    ui.table([
+        ["Wallet", `${account.address.slice(0, 6)}...${account.address.slice(-4)} (${Number((0, viem_1.formatEther)(ethBalance)).toFixed(4)} ETH)`],
+        ["Miner", `#${tokenId} (${detect_1.rarityLabels[rarity] ?? `Tier ${rarity}`}, ${(0, detect_1.formatHashpower)(hashpower)})`],
+        ["Network", config_1.config.chain.name],
+        ["Era", `${era} — reward: ${formatBaseReward(era)} AGENT/mine`],
+        ["Supply", `${supplyPct.toFixed(2)}% mined (${Number((0, viem_1.formatEther)(totalMinted)).toLocaleString()} / ${Number((0, viem_1.formatEther)(mineableSupply)).toLocaleString()} AGENT)`],
+    ]);
+    console.log("");
+}
+async function startMining(tokenId) {
+    const { account, walletClient } = (0, wallet_1.requireWallet)();
+    let consecutiveFailures = 0;
+    let mineCount = 0;
+    let runningTotal = 0n;
+    await showStartupBanner(tokenId);
+    while (true) {
+        try {
+            // Pre-flight ownership check
+            const owner = (await wallet_1.publicClient.readContract({
+                address: config_1.config.miningAgentAddress,
+                abi: miningAgentAbi,
+                functionName: "ownerOf",
+                args: [tokenId],
+            }));
+            if (owner.toLowerCase() !== account.address.toLowerCase()) {
+                ui.error(`Miner #${tokenId} is owned by ${owner}, not your wallet.`);
+                ui.hint("Check token ID or verify ownership on Basescan");
+                return;
+            }
+            // Supply exhaustion pre-check
+            const [totalMines, totalMinted, mineableSupply, eraInterval, hashpower] = 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: "MINEABLE_SUPPLY",
+                }),
+                wallet_1.publicClient.readContract({
+                    address: config_1.config.agentCoinAddress,
+                    abi: agentCoinAbi,
+                    functionName: "ERA_INTERVAL",
+                }),
+                wallet_1.publicClient.readContract({
+                    address: config_1.config.miningAgentAddress,
+                    abi: miningAgentAbi,
+                    functionName: "hashpower",
+                    args: [tokenId],
+                }),
+            ]);
+            const estimatedReward = estimateReward(totalMines, eraInterval, BigInt(hashpower));
+            if (totalMinted + estimatedReward > mineableSupply) {
+                ui.error(`Supply nearly exhausted. Remaining: ${(0, viem_1.formatEther)(mineableSupply - totalMinted)} AGENT.`);
+                return;
+            }
+            // Era transition alert
+            const currentEra = totalMines / eraInterval;
+            const minesUntilNextEra = eraInterval - (totalMines % eraInterval);
+            if (minesUntilNextEra <= 10n) {
+                ui.warn(`Era transition in ${minesUntilNextEra} mines! Reward will decrease.`);
+            }
+            mineCount++;
+            console.log(`  ${ui.bold(`[Mine #${mineCount}]`)}`);
+            const miningChallenge = (await wallet_1.publicClient.readContract({
+                address: config_1.config.agentCoinAddress,
+                abi: agentCoinAbi,
+                functionName: "getMiningChallenge",
+            }));
+            const [challengeNumber, target, rawSmhl] = miningChallenge;
+            const smhl = (0, smhl_1.normalizeSmhlChallenge)(rawSmhl);
+            // Solve SMHL with spinner
+            const smhlSpinner = ui.spinner("Solving SMHL challenge...");
+            const smhlStart = process.hrtime();
+            const smhlSolution = await (0, smhl_1.solveSmhlChallenge)(smhl, (attempt) => {
+                smhlSpinner.update(`Solving SMHL challenge... attempt ${attempt}/5`);
+            });
+            const smhlElapsed = elapsedSeconds(smhlStart);
+            smhlSpinner.stop(`Solving SMHL challenge... done (${smhlElapsed.toFixed(1)}s)`);
+            // Grind nonce with spinner
+            const nonceSpinner = ui.spinner("Grinding nonce...");
+            const grind = await grindNonce(challengeNumber, target, account.address, (attempts, hashrate) => {
+                const khs = (hashrate / 1000).toFixed(0);
+                nonceSpinner.update(`Grinding nonce... ${khs}k H/s (${attempts.toLocaleString()} attempts)`);
+            });
+            const khs = (grind.hashrate / 1000).toFixed(0);
+            nonceSpinner.stop(`Grinding nonce... done (${grind.elapsed.toFixed(1)}s, ${khs}k H/s)`);
+            // Submit transaction with spinner
+            const txSpinner = ui.spinner("Submitting transaction...");
+            const txHash = await walletClient.writeContract({
+                address: config_1.config.agentCoinAddress,
+                abi: agentCoinAbi,
+                account,
+                functionName: "mine",
+                args: [grind.nonce, smhlSolution, tokenId],
+            });
+            txSpinner.update("Waiting for confirmation...");
+            const receipt = await wallet_1.publicClient.waitForTransactionReceipt({ hash: txHash });
+            if (receipt.status === "reverted") {
+                throw new Error("Mine transaction reverted on-chain");
+            }
+            txSpinner.stop("Submitting transaction... confirmed");
+            // Fetch post-mine stats
+            const [tokenMineCount, earnings] = 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],
+                }),
+            ]);
+            const delta = earnings - runningTotal;
+            runningTotal = earnings;
+            console.log(`  ${ui.green("+")} ${(0, viem_1.formatEther)(delta)} AGENT | Total: ${(0, viem_1.formatEther)(earnings)} AGENT | Tx: ${ui.dim((0, explorer_1.txUrl)(txHash))}`);
+            console.log("");
+            // Wait for block advancement before next iteration
+            const lastMineBlock = (await wallet_1.publicClient.readContract({
+                address: config_1.config.agentCoinAddress,
+                abi: agentCoinAbi,
+                functionName: "lastMineBlockNumber",
+            }));
+            await waitForNextBlock(lastMineBlock);
+            consecutiveFailures = 0;
+        }
+        catch (error) {
+            const classified = (0, errors_1.classifyError)(error);
+            if (classified.category === "fatal") {
+                ui.error(classified.userMessage);
+                if (classified.recovery)
+                    ui.hint(classified.recovery);
+                return;
+            }
+            if (classified.userMessage.includes("One mine per block")) {
+                console.log(`  ${ui.dim("Waiting for next block...")}`);
+                const lastMineBlock = (await wallet_1.publicClient.readContract({
+                    address: config_1.config.agentCoinAddress,
+                    abi: agentCoinAbi,
+                    functionName: "lastMineBlockNumber",
+                }));
+                await waitForNextBlock(lastMineBlock);
+                continue;
+            }
+            consecutiveFailures += 1;
+            if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                ui.error(`${MAX_CONSECUTIVE_FAILURES} consecutive failures. Last: ${classified.userMessage}`);
+                return;
+            }
+            const delay = backoffMs(consecutiveFailures);
+            ui.error(`${classified.userMessage} (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES})`);
+            if (classified.recovery)
+                ui.hint(classified.recovery);
+            console.log(`  ${ui.dim(`Retrying in ${(delay / 1000).toFixed(1)}s...`)}`);
+            await sleep(delay);
+        }
+    }
+}

package/dist/mint.js

@@ -0,0 +1,256 @@
+"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.runMintFlow = runMintFlow;
+const viem_1 = require("viem");
+const MiningAgent_json_1 = __importDefault(require("./abi/MiningAgent.json"));
+const config_1 = require("./config");
+const explorer_1 = require("./explorer");
+const smhl_1 = require("./smhl");
+const detect_1 = require("./detect");
+const miner_1 = require("./miner");
+const ui = __importStar(require("./ui"));
+const wallet_1 = require("./wallet");
+const miningAgentAbi = MiningAgent_json_1.default;
+const ZERO_SEED = `0x${"0".repeat(64)}`;
+function deriveChallengeFromSeed(seed) {
+    const bytes = (0, viem_1.hexToBytes)(seed);
+    const firstNChars = 5 + (bytes[0] % 6);
+    const wordCount = 3 + (bytes[2] % 5);
+    const totalLength = 20 + (bytes[5] % 31);
+    const charPosition = bytes[3] % totalLength;
+    const charValue = 97 + (bytes[4] % 26);
+    let targetAsciiSum = 400 + (bytes[1] * 3);
+    let maxAsciiSum = firstNChars * 126;
+    if (charPosition < firstNChars) {
+        maxAsciiSum = maxAsciiSum - 126 + charValue;
+    }
+    if (targetAsciiSum > maxAsciiSum) {
+        targetAsciiSum = 400 + ((targetAsciiSum - 400) % (maxAsciiSum - 399));
+    }
+    return (0, smhl_1.normalizeSmhlChallenge)([
+        targetAsciiSum,
+        firstNChars,
+        wordCount,
+        charPosition,
+        charValue,
+        totalLength,
+    ]);
+}
+async function findMintedTokenId(startTokenId, endTokenIdExclusive, owner, blockNumber) {
+    for (let tokenId = startTokenId; tokenId < endTokenIdExclusive; tokenId += 1n) {
+        try {
+            const [tokenOwner, mintBlock] = await Promise.all([
+                wallet_1.publicClient.readContract({
+                    address: config_1.config.miningAgentAddress,
+                    abi: miningAgentAbi,
+                    functionName: "ownerOf",
+                    args: [tokenId],
+                }),
+                wallet_1.publicClient.readContract({
+                    address: config_1.config.miningAgentAddress,
+                    abi: miningAgentAbi,
+                    functionName: "mintBlock",
+                    args: [tokenId],
+                }),
+            ]);
+            if (tokenOwner.toLowerCase() === owner.toLowerCase() && mintBlock === blockNumber) {
+                return tokenId;
+            }
+        }
+        catch {
+            // Ignore missing token ids while scanning the minted window.
+        }
+    }
+    throw new Error("Unable to determine minted token ID from post-mint contract state.");
+}
+async function runMintFlow() {
+    const { account, walletClient } = (0, wallet_1.requireWallet)();
+    console.log("");
+    // 1-rig-per-wallet enforcement
+    const existingBalance = (await wallet_1.publicClient.readContract({
+        address: config_1.config.miningAgentAddress,
+        abi: miningAgentAbi,
+        functionName: "balanceOf",
+        args: [account.address],
+    }));
+    if (existingBalance > 0n) {
+        const tokenId = (await wallet_1.publicClient.readContract({
+            address: config_1.config.miningAgentAddress,
+            abi: miningAgentAbi,
+            functionName: "tokenOfOwnerByIndex",
+            args: [account.address, 0n],
+        }));
+        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);
+        const hashpower = Number(hashpowerRaw);
+        ui.error("This wallet already owns a mining rig.");
+        console.log(`  Rig #${tokenId} — ${detect_1.rarityLabels[rarity] ?? `Tier ${rarity}`} (${(0, detect_1.formatHashpower)(hashpower)})`);
+        console.log("");
+        ui.hint("One rig per wallet. Only one mine can succeed per block,");
+        ui.hint("so extra rigs in the same wallet waste ETH.");
+        ui.hint("To scale: apow wallet new → fund → apow mint");
+        return;
+    }
+    // Fetch mint price and balance FIRST
+    const priceSpinner = ui.spinner("Fetching mint price...");
+    const [mintPrice, ethBalance] = await Promise.all([
+        wallet_1.publicClient.readContract({
+            address: config_1.config.miningAgentAddress,
+            abi: miningAgentAbi,
+            functionName: "getMintPrice",
+        }),
+        (0, wallet_1.getEthBalance)(),
+    ]);
+    priceSpinner.stop("Fetching mint price... done");
+    // Show price preview
+    console.log("");
+    ui.table([
+        ["Mint price", `${(0, viem_1.formatEther)(mintPrice)} ETH`],
+        ["Balance", `${Number((0, viem_1.formatEther)(ethBalance)).toFixed(6)} ETH`],
+    ]);
+    console.log("");
+    if (ethBalance < mintPrice) {
+        ui.error("Insufficient ETH for mint.");
+        ui.hint(`Send at least ${(0, viem_1.formatEther)(mintPrice)} ETH to ${account.address} on Base`);
+        return;
+    }
+    // Confirm before spending ETH
+    const proceed = await ui.confirm("Proceed with mint?");
+    if (!proceed) {
+        console.log("  Mint cancelled.");
+        return;
+    }
+    console.log("");
+    // Request challenge
+    const challengeSpinner = ui.spinner("Requesting challenge...");
+    const challengeTx = await walletClient.writeContract({
+        address: config_1.config.miningAgentAddress,
+        abi: miningAgentAbi,
+        account,
+        functionName: "getChallenge",
+        args: [account.address],
+    });
+    const challengeReceipt = await wallet_1.publicClient.waitForTransactionReceipt({ hash: challengeTx });
+    if (challengeReceipt.status === "reverted") {
+        throw new Error("Challenge request reverted on-chain");
+    }
+    challengeSpinner.stop("Requesting challenge... done");
+    const challengeSeed = (await wallet_1.publicClient.readContract({
+        address: config_1.config.miningAgentAddress,
+        abi: miningAgentAbi,
+        functionName: "challengeSeeds",
+        args: [account.address],
+    }));
+    if (challengeSeed.toLowerCase() === ZERO_SEED.toLowerCase()) {
+        throw new Error("Challenge seed was not stored on-chain.");
+    }
+    // Solve SMHL
+    const challenge = deriveChallengeFromSeed(challengeSeed);
+    const smhlSpinner = ui.spinner("Solving SMHL...");
+    const solution = await (0, smhl_1.solveSmhlChallenge)(challenge, (attempt) => {
+        smhlSpinner.update(`Solving SMHL... attempt ${attempt}/5`);
+    });
+    smhlSpinner.stop("Solving SMHL... done");
+    const nextTokenIdBefore = (await wallet_1.publicClient.readContract({
+        address: config_1.config.miningAgentAddress,
+        abi: miningAgentAbi,
+        functionName: "nextTokenId",
+    }));
+    // Mint
+    const mintSpinner = ui.spinner("Minting...");
+    const mintTx = await walletClient.writeContract({
+        address: config_1.config.miningAgentAddress,
+        abi: miningAgentAbi,
+        account,
+        functionName: "mint",
+        args: [solution],
+        value: mintPrice,
+    });
+    mintSpinner.update("Waiting for confirmation...");
+    const receipt = await wallet_1.publicClient.waitForTransactionReceipt({ hash: mintTx });
+    if (receipt.status === "reverted") {
+        throw new Error("Mint transaction reverted on-chain");
+    }
+    mintSpinner.stop("Minting... confirmed");
+    const nextTokenIdAfter = (await wallet_1.publicClient.readContract({
+        address: config_1.config.miningAgentAddress,
+        abi: miningAgentAbi,
+        functionName: "nextTokenId",
+    }));
+    const tokenId = await findMintedTokenId(nextTokenIdBefore, nextTokenIdAfter, account.address, receipt.blockNumber);
+    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);
+    const hashpower = Number(hashpowerRaw);
+    console.log("");
+    console.log(`  ${ui.green("Miner #" + tokenId.toString())} — ${detect_1.rarityLabels[rarity] ?? `Tier ${rarity}`} (${(0, detect_1.formatHashpower)(hashpower)})`);
+    console.log(`  Tx: ${ui.dim((0, explorer_1.txUrl)(receipt.transactionHash))}`);
+    console.log(`  NFT: ${ui.dim((0, explorer_1.tokenUrl)(config_1.config.miningAgentAddress, tokenId))}`);
+    console.log("");
+    // Offer to start mining
+    const startMine = await ui.confirm("Start mining?");
+    if (startMine) {
+        await (0, miner_1.startMining)(tokenId);
+    }
+}