apow-cli 0.1.4 → 0.3.0

package/dist/fund.js

@@ -0,0 +1,313 @@
+"use strict";
+// Fund command — bridge SOL → ETH on Base so Solana users can start mining.
+// Three paths:
+//   Option A: Direct Solana signing via deBridge DLN (~20s)
+//   Option B: Deposit address + QR via Squid Router (~1-3 min)
+//   Option C: Manual send (just show Base address)
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFundFlow = runFundFlow;
+const viem_1 = require("viem");
+const wallet_1 = require("./wallet");
+const ui = __importStar(require("./ui"));
+async function fetchPrices() {
+    const res = await fetch("https://api.coingecko.com/api/v3/simple/price?ids=solana,ethereum&vs_currencies=usd");
+    if (!res.ok)
+        throw new Error("Failed to fetch prices from CoinGecko");
+    const data = (await res.json());
+    const ethUsd = data.ethereum.usd;
+    const solUsd = data.solana.usd;
+    return { solPerEth: ethUsd / solUsd, ethPriceUsd: ethUsd, solPriceUsd: solUsd };
+}
+/** SOL needed for target ETH, with 10% buffer for bridge fees + slippage. */
+function solNeededForEth(targetEth, solPerEth) {
+    return targetEth * solPerEth * 1.1;
+}
+// ---------------------------------------------------------------------------
+// QR code helper
+// ---------------------------------------------------------------------------
+async function showQrCode(text) {
+    try {
+        const mod = await Promise.resolve().then(() => __importStar(require("qrcode-terminal")));
+        const qrcode = mod.default || mod;
+        await new Promise((resolve) => {
+            qrcode.generate(text, { small: true }, (qr) => {
+                for (const line of qr.split("\n")) {
+                    if (line)
+                        console.log(`    ${line}`);
+                }
+                resolve();
+            });
+        });
+    }
+    catch {
+        // QR is nice-to-have, not critical
+    }
+}
+// ---------------------------------------------------------------------------
+// Option A — Direct signing via deBridge
+// ---------------------------------------------------------------------------
+async function runDirectBridge(solanaKeyInput, baseAddress, targetEth) {
+    const solanaSpinner = ui.spinner("Checking Solana balance...");
+    const solana = await Promise.resolve().then(() => __importStar(require("./bridge/solana")));
+    const debridge = await Promise.resolve().then(() => __importStar(require("./bridge/debridge")));
+    let kp;
+    try {
+        kp = await solana.parseSolanaKey(solanaKeyInput);
+    }
+    catch (err) {
+        solanaSpinner.fail("Invalid Solana key");
+        throw err;
+    }
+    const balance = await solana.getSolanaBalance(kp.publicKey);
+    solanaSpinner.stop(`Solana balance: ${balance.toFixed(4)} SOL`);
+    // Prices
+    const priceSpinner = ui.spinner("Fetching prices...");
+    const prices = await fetchPrices();
+    const solAmount = solNeededForEth(targetEth, prices.solPerEth);
+    priceSpinner.stop(`SOL/ETH rate: ${prices.solPerEth.toFixed(1)} SOL = 1 ETH`);
+    if (balance < solAmount) {
+        ui.error(`Insufficient SOL. Need ~${solAmount.toFixed(4)} SOL, have ${balance.toFixed(4)} SOL.`);
+        return;
+    }
+    console.log("");
+    ui.table([
+        ["Bridging", `${solAmount.toFixed(4)} SOL → ~${targetEth.toFixed(4)} ETH on Base`],
+        ["Via", "deBridge DLN (~20 seconds)"],
+        [
+            "From",
+            `${kp.publicKey.slice(0, 4)}...${kp.publicKey.slice(-4)}`,
+        ],
+        ["To", `${baseAddress.slice(0, 6)}...${baseAddress.slice(-4)}`],
+    ]);
+    console.log("");
+    const proceed = await ui.confirm("Confirm bridge?");
+    if (!proceed) {
+        console.log("  Cancelled.");
+        return;
+    }
+    const bridgeSpinner = ui.spinner("Signing bridge transaction...");
+    const result = await debridge.bridgeViaDeBridge(kp.keypair, baseAddress, solAmount);
+    bridgeSpinner.stop(`Submitted! Order: ${result.orderId.slice(0, 12)}...`);
+    const pollSpinner = ui.spinner("Waiting for bridge fulfillment... (~20s)");
+    const fulfillment = await debridge.pollOrderStatus(result.orderId, (status) => pollSpinner.update(`Bridge status: ${status}`));
+    const received = fulfillment.ethReceived || `~${targetEth.toFixed(4)}`;
+    pollSpinner.stop(`Bridge complete! ${received} ETH arrived on Base`);
+    console.log("");
+    console.log(`  ${ui.green("Your wallet is funded!")} Next: ${ui.cyan("apow mint")}`);
+    console.log("");
+}
+// ---------------------------------------------------------------------------
+// Options B+C — Deposit address via Squid
+// ---------------------------------------------------------------------------
+async function runDepositBridge(baseAddress, targetEth) {
+    const priceSpinner = ui.spinner("Fetching prices...");
+    const prices = await fetchPrices();
+    const solAmount = solNeededForEth(targetEth, prices.solPerEth);
+    priceSpinner.stop(`SOL/ETH rate: ${prices.solPerEth.toFixed(1)} SOL = 1 ETH`);
+    const addrSpinner = ui.spinner("Generating deposit address...");
+    const squid = await Promise.resolve().then(() => __importStar(require("./bridge/squid")));
+    const solana = await Promise.resolve().then(() => __importStar(require("./bridge/solana")));
+    let deposit;
+    try {
+        deposit = await squid.getDepositAddress(baseAddress, solAmount);
+    }
+    catch (err) {
+        addrSpinner.fail("Failed to get deposit address");
+        throw err;
+    }
+    addrSpinner.stop("Deposit address ready");
+    // Display deposit info
+    console.log("");
+    console.log(`  ${ui.bold("Send SOL to this address:")}`);
+    console.log("");
+    console.log(`  ${ui.cyan(deposit.depositAddress)}`);
+    console.log("");
+    await showQrCode(deposit.depositAddress);
+    console.log("");
+    ui.table([
+        [
+            "Amount",
+            `~${solAmount.toFixed(4)} SOL (~$${(solAmount * prices.solPriceUsd).toFixed(2)})`,
+        ],
+        ["You'll receive", `~${deposit.expectedReceive} ETH on Base`],
+        ["Bridge", "Squid Router (Chainflip)"],
+        ["Time", "~1-3 minutes"],
+    ]);
+    console.log("");
+    if (deposit.expiresAt) {
+        ui.warn(`Deposit address expires: ${deposit.expiresAt}`);
+        console.log("");
+    }
+    // Poll for SOL deposit
+    const depositSpinner = ui.spinner("Waiting for SOL deposit... (Ctrl+C to cancel)");
+    const initialBalance = await solana.getAddressBalance(deposit.depositAddress);
+    let depositDetected = false;
+    const depositDeadline = Date.now() + 600_000; // 10 min
+    while (!depositDetected && Date.now() < depositDeadline) {
+        await new Promise((r) => setTimeout(r, 3000));
+        try {
+            const currentBalance = await solana.getAddressBalance(deposit.depositAddress);
+            if (currentBalance > initialBalance + 0.001) {
+                depositDetected = true;
+                depositSpinner.stop(`Deposit received! ${(currentBalance - initialBalance).toFixed(4)} SOL`);
+            }
+        }
+        catch {
+            // Transient RPC error — keep polling
+        }
+    }
+    if (!depositDetected) {
+        depositSpinner.fail("No deposit detected after 10 minutes");
+        ui.hint("If you sent SOL, check: https://explorer.squidrouter.com");
+        return;
+    }
+    // Poll for bridge completion
+    const bridgeSpinner = ui.spinner("Bridging SOL → ETH on Base... (~1-3 min)");
+    const result = await squid.pollBridgeStatus(deposit.requestId, (status) => bridgeSpinner.update(`Bridge status: ${status}`));
+    const received = result.ethReceived || deposit.expectedReceive;
+    bridgeSpinner.stop(`Bridge complete! ${received} ETH arrived`);
+    console.log("");
+    console.log(`  ${ui.green("Your wallet is funded!")} Next: ${ui.cyan("apow mint")}`);
+    console.log("");
+}
+// ---------------------------------------------------------------------------
+// Option C — Manual Base address
+// ---------------------------------------------------------------------------
+async function runManualFund(baseAddress) {
+    console.log("");
+    console.log(`  ${ui.bold("Send ETH on Base to this address:")}`);
+    console.log("");
+    console.log(`  ${ui.cyan(baseAddress)}`);
+    console.log("");
+    await showQrCode(baseAddress);
+    console.log("");
+    console.log(`  ${ui.dim("Send from any wallet — Coinbase, MetaMask, Phantom, etc.")}`);
+    console.log(`  ${ui.dim("Need ~0.005 ETH to start mining.")}`);
+    console.log(`  ${ui.dim("After sending, run:")} ${ui.cyan("apow mint")}`);
+    console.log("");
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+async function runFundFlow(options) {
+    if (!wallet_1.account) {
+        ui.error("No wallet configured. Run `apow setup` first.");
+        process.exit(1);
+    }
+    const baseAddress = wallet_1.account.address;
+    const balance = await (0, wallet_1.getEthBalance)();
+    const ethBalance = Number((0, viem_1.formatEther)(balance));
+    console.log("");
+    ui.banner(["Fund Your Mining Wallet"]);
+    console.log("");
+    ui.table([
+        [
+            "Your Base wallet",
+            `${baseAddress.slice(0, 6)}...${baseAddress.slice(-4)}`,
+        ],
+        [
+            "Balance",
+            `${ethBalance.toFixed(6)} ETH${ethBalance < 0.005 ? " (need ~0.005 ETH to start)" : ""}`,
+        ],
+    ]);
+    console.log("");
+    // Parse target ETH
+    const targetEth = options.amount ? parseFloat(options.amount) : 0.005;
+    if (isNaN(targetEth) || targetEth <= 0) {
+        ui.error("Invalid amount. Specify ETH target (e.g., --amount 0.005).");
+        return;
+    }
+    // --key flag: direct bridge immediately
+    if (options.key) {
+        await runDirectBridge(options.key, baseAddress, targetEth);
+        return;
+    }
+    // --solana flag: ask about key, then bridge
+    if (options.solana) {
+        const hasKey = await ui.confirm("Do you have your Solana private key?");
+        if (hasKey) {
+            const key = await ui.promptSecret("Solana private key (base58)");
+            if (!key) {
+                ui.error("No key provided.");
+                return;
+            }
+            await runDirectBridge(key, baseAddress, targetEth);
+        }
+        else {
+            await runDepositBridge(baseAddress, targetEth);
+        }
+        return;
+    }
+    // Interactive menu
+    console.log("  How do you want to fund?");
+    console.log(`    ${ui.cyan("1.")} Bridge from Solana (SOL → ETH on Base)`);
+    console.log(`    ${ui.cyan("2.")} Send ETH on Base directly (from another wallet)`);
+    console.log(`    ${ui.cyan("3.")} Copy address and fund manually`);
+    console.log("");
+    const choice = await ui.prompt("Choice", "1");
+    switch (choice) {
+        case "1": {
+            const hasKey = await ui.confirm("Do you have your Solana private key?");
+            if (hasKey) {
+                const key = await ui.promptSecret("Solana private key (base58)");
+                if (!key) {
+                    ui.error("No key provided.");
+                    return;
+                }
+                await runDirectBridge(key, baseAddress, targetEth);
+            }
+            else {
+                await runDepositBridge(baseAddress, targetEth);
+            }
+            break;
+        }
+        case "2": {
+            console.log("");
+            console.log(`  ${ui.bold("Send ETH on Base to:")}`);
+            console.log(`  ${ui.cyan(baseAddress)}`);
+            console.log("");
+            console.log(`  ${ui.dim("Need ~0.005 ETH to start mining.")}`);
+            console.log(`  ${ui.dim("After sending, run:")} ${ui.cyan("apow mint")}`);
+            console.log("");
+            break;
+        }
+        case "3":
+        default: {
+            await runManualFund(baseAddress);
+            break;
+        }
+    }
+}

package/dist/index.js

@@ -39,12 +39,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
 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 fund_1 = require("./fund");
 const mint_1 = require("./mint");
 const miner_1 = require("./miner");
 const preflight_1 = require("./preflight");
@@ -271,6 +273,18 @@ async function main() {
         .action(async () => {
         await setupWizard();
     });
+    program
+        .command("fund")
+        .description("Fund your wallet — bridge SOL → ETH on Base, or show deposit address")
+        .option("--solana", "Bridge from Solana")
+        .option("--key <base58>", "Solana private key for direct signing")
+        .option("--amount <eth>", "Target ETH amount (default: 0.005)")
+        .hook("preAction", async () => {
+        await (0, preflight_1.runPreflight)("readonly");
+    })
+        .action(async (opts) => {
+        await (0, fund_1.runFundFlow)(opts);
+    });
     program
         .command("mint")
         .description("Mint a new miner NFT")
@@ -457,8 +471,198 @@ async function main() {
         console.log(`  Tx: ${ui.dim((0, explorer_1.txUrl)(receipt.transactionHash))}`);
         console.log("");
     });
+    // --- Dashboard commands ---
+    const dashboardCmd = program
+        .command("dashboard")
+        .description("Multi-wallet mining dashboard");
+    dashboardCmd
+        .command("start", { isDefault: true })
+        .description("Launch the dashboard web UI")
+        .action(async () => {
+        const walletsPath = getWalletsPath();
+        // Seed wallets.json if it doesn't exist
+        if (!(0, node_fs_1.existsSync)(walletsPath)) {
+            const walletsDir = (0, node_path_1.join)(process.env.HOME ?? "", ".apow");
+            if (!(0, node_fs_1.existsSync)(walletsDir))
+                (0, node_fs_1.mkdirSync)(walletsDir, { recursive: true });
+            const initial = wallet_1.account ? [wallet_1.account.address] : [];
+            (0, node_fs_1.writeFileSync)(walletsPath, JSON.stringify(initial, null, 2), "utf8");
+            if (wallet_1.account) {
+                ui.ok(`Seeded ${walletsPath} with ${wallet_1.account.address.slice(0, 6)}...${wallet_1.account.address.slice(-4)}`);
+            }
+            else {
+                ui.ok(`Created ${walletsPath} (empty — add wallets with: apow dashboard add <address>)`);
+            }
+        }
+        // Auto-detect wallets from CWD
+        const { addresses, newCount } = detectWallets(process.cwd());
+        if (newCount > 0) {
+            ui.ok(`Detected ${addresses.length} wallets (${newCount} new)`);
+        }
+        else if (addresses.length > 0) {
+            console.log(`  ${ui.dim(`${addresses.length} wallets loaded`)}`);
+        }
+        const { startDashboardServer } = await Promise.resolve().then(() => __importStar(require("./dashboard")));
+        console.log("");
+        console.log(`  ${ui.bold("APoW Dashboard")} starting on http://localhost:3847`);
+        console.log(`  ${ui.dim("Press Ctrl+C to stop")}`);
+        console.log("");
+        const server = startDashboardServer({
+            port: 3847,
+            walletsPath,
+            rpcUrl: config_1.config.rpcUrl,
+            miningAgentAddress: config_1.config.miningAgentAddress,
+            agentCoinAddress: config_1.config.agentCoinAddress,
+        });
+        // Open browser after short delay (server starts instantly)
+        setTimeout(() => {
+            const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+            (0, node_child_process_1.spawn)(openCmd, ["http://localhost:3847"], { stdio: "ignore" });
+        }, 500);
+        // Wait for SIGINT
+        await new Promise((resolve) => {
+            process.on("SIGINT", () => {
+                server.close();
+                resolve();
+            });
+        });
+    });
+    dashboardCmd
+        .command("add <address>")
+        .description("Add a wallet address to monitor")
+        .action((address) => {
+        if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+            ui.error("Invalid address. Must be 0x + 40 hex characters.");
+            return;
+        }
+        const walletsPath = getWalletsPath();
+        const wallets = loadWallets(walletsPath);
+        const lower = address.toLowerCase();
+        if (wallets.some((w) => w.toLowerCase() === lower)) {
+            ui.warn("Address already monitored.");
+            return;
+        }
+        wallets.push(address);
+        saveWallets(walletsPath, wallets);
+        ui.ok(`Added ${address.slice(0, 6)}...${address.slice(-4)} (${wallets.length} wallets total)`);
+    });
+    dashboardCmd
+        .command("remove <address>")
+        .description("Remove a wallet address from monitoring")
+        .action((address) => {
+        const walletsPath = getWalletsPath();
+        const wallets = loadWallets(walletsPath);
+        const lower = address.toLowerCase();
+        const filtered = wallets.filter((w) => w.toLowerCase() !== lower);
+        if (filtered.length === wallets.length) {
+            ui.warn("Address not found in wallet list.");
+            return;
+        }
+        saveWallets(walletsPath, filtered);
+        ui.ok(`Removed ${address.slice(0, 6)}...${address.slice(-4)} (${filtered.length} wallets remaining)`);
+    });
+    dashboardCmd
+        .command("scan [dir]")
+        .description("Auto-detect wallets from wallet-0x*.txt files in a directory")
+        .action((dir) => {
+        const scanDir = dir ?? process.cwd();
+        const { addresses, newCount } = detectWallets(scanDir);
+        console.log("");
+        if (addresses.length === 0) {
+            console.log(`  No wallets found in ${scanDir}`);
+            console.log(`  ${ui.dim("Expected files named wallet-0x<address>.txt")}`);
+        }
+        else {
+            console.log(`  ${ui.bold("Detected Wallets")} (${newCount} new, ${addresses.length} total)`);
+            console.log("");
+            for (const addr of addresses) {
+                console.log(`  ${addr}`);
+            }
+        }
+        console.log("");
+    });
+    dashboardCmd
+        .command("wallets")
+        .description("List monitored wallet addresses")
+        .action(() => {
+        const walletsPath = getWalletsPath();
+        const wallets = loadWallets(walletsPath);
+        if (wallets.length === 0) {
+            console.log("  No wallets configured. Run: apow dashboard add <address>");
+            return;
+        }
+        console.log("");
+        console.log(`  ${ui.bold("Monitored Wallets")} (${wallets.length})`);
+        console.log("");
+        for (const w of wallets) {
+            console.log(`  ${w}`);
+        }
+        console.log("");
+    });
     await program.parseAsync(process.argv);
 }
+function getWalletsPath() {
+    return (0, node_path_1.join)(process.env.HOME ?? "", ".apow", "wallets.json");
+}
+function loadWallets(path) {
+    try {
+        const raw = (0, node_fs_1.readFileSync)(path, "utf8");
+        const data = JSON.parse(raw);
+        return Array.isArray(data) ? data.filter((a) => typeof a === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+function saveWallets(path, wallets) {
+    const dir = (0, node_path_1.join)(process.env.HOME ?? "", ".apow");
+    if (!(0, node_fs_1.existsSync)(dir))
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    (0, node_fs_1.writeFileSync)(path, JSON.stringify(wallets, null, 2), "utf8");
+}
+function detectWallets(scanDir) {
+    const walletsPath = getWalletsPath();
+    const existing = loadWallets(walletsPath);
+    const seen = new Set(existing.map((a) => a.toLowerCase()));
+    const detected = [];
+    // Scan scanDir for wallet-0x*.txt files
+    try {
+        const entries = (0, node_fs_1.readdirSync)(scanDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile()) {
+                const match = entry.name.match(/^wallet-(0x[0-9a-fA-F]{40})\.txt$/);
+                if (match && !seen.has(match[1].toLowerCase())) {
+                    detected.push(match[1]);
+                    seen.add(match[1].toLowerCase());
+                }
+            }
+            // Scan rig*/wallet-0x*.txt subdirectories
+            if (entry.isDirectory() && entry.name.startsWith("rig")) {
+                try {
+                    const rigFiles = (0, node_fs_1.readdirSync)((0, node_path_1.join)(scanDir, entry.name));
+                    for (const file of rigFiles) {
+                        const m = file.match(/^wallet-(0x[0-9a-fA-F]{40})\.txt$/);
+                        if (m && !seen.has(m[1].toLowerCase())) {
+                            detected.push(m[1]);
+                            seen.add(m[1].toLowerCase());
+                        }
+                    }
+                }
+                catch {
+                    // rig dir not readable — skip
+                }
+            }
+        }
+    }
+    catch {
+        // scanDir not readable
+    }
+    const merged = [...existing, ...detected];
+    if (detected.length > 0) {
+        saveWallets(walletsPath, merged);
+    }
+    return { addresses: merged, newCount: detected.length };
+}
 main().catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
     ui.error(message);

package/dist/smhl.js

@@ -234,7 +234,7 @@ async function requestGeminiSolution(prompt) {
                 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 },
+            generationConfig: { temperature: 0.7, thinkingConfig: { thinkingBudget: 0 } },
         }),
     });
     if (response.status === 429) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apow-cli",
-  "version": "0.1.4",
+  "version": "0.3.0",
   "description": "Mine AGENT tokens on Base L2 with AI-powered proof of work",
   "keywords": [
     "apow",
@@ -39,9 +39,11 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@solana/web3.js": "^1.98.0",
     "commander": "^14.0.0",
     "dotenv": "^17.2.3",
     "openai": "^6.6.0",
+    "qrcode-terminal": "^0.12.0",
     "viem": "^2.38.2"
   },
   "devDependencies": {