apow-cli 0.1.4 → 0.3.0

package/dist/dashboard.js

@@ -0,0 +1,424 @@
+"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.startDashboardServer = startDashboardServer;
+const http = __importStar(require("node:http"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const dashboard_html_1 = require("./dashboard-html");
+const AgentCoin_json_1 = __importDefault(require("./abi/AgentCoin.json"));
+const MiningAgent_json_1 = __importDefault(require("./abi/MiningAgent.json"));
+const AgentCoinAbi = AgentCoin_json_1.default;
+const MiningAgentAbi = MiningAgent_json_1.default;
+const RARITY_LABELS = ["Common", "Uncommon", "Rare", "Epic", "Mythic"];
+const ADDR_RE = /^0x[0-9a-fA-F]{40}$/;
+const DEFAULT_RPC = "https://mainnet.base.org";
+const FLEETS_PATH = (0, node_path_1.join)(process.env.HOME ?? "", ".apow", "fleets.json");
+// --- Wallet / Fleet loading ---
+function isAddress(s) {
+    return ADDR_RE.test(s);
+}
+function extractArray(path) {
+    const raw = (0, node_fs_1.readFileSync)(path, "utf8");
+    const data = JSON.parse(raw);
+    if (!Array.isArray(data))
+        return [];
+    return data.filter((a) => typeof a === "string" && isAddress(a));
+}
+function extractSolkek(path) {
+    const raw = (0, node_fs_1.readFileSync)(path, "utf8");
+    const data = JSON.parse(raw);
+    const addrs = [];
+    if (data.master?.address && isAddress(data.master.address)) {
+        addrs.push(data.master.address);
+    }
+    if (Array.isArray(data.miners)) {
+        for (const m of data.miners) {
+            if (m.address && isAddress(m.address)) {
+                addrs.push(m.address);
+            }
+        }
+    }
+    return addrs;
+}
+function extractRigdirs(dir) {
+    const addrs = [];
+    const entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.startsWith("rig"))
+            continue;
+        const rigFiles = (0, node_fs_1.readdirSync)((0, node_path_1.join)(dir, entry.name));
+        for (const file of rigFiles) {
+            const match = file.match(/^wallet-(0x[0-9a-fA-F]{40})\.txt$/);
+            if (match && isAddress(match[1])) {
+                addrs.push(match[1]);
+            }
+        }
+    }
+    return addrs;
+}
+function extractWalletfiles(dir) {
+    const addrs = [];
+    const files = (0, node_fs_1.readdirSync)(dir);
+    for (const file of files) {
+        const match = file.match(/^wallet-(0x[0-9a-fA-F]{40})\.txt$/);
+        if (match && isAddress(match[1])) {
+            addrs.push(match[1]);
+        }
+    }
+    return addrs;
+}
+function getFleets(walletsPath) {
+    try {
+        const raw = (0, node_fs_1.readFileSync)(FLEETS_PATH, "utf8");
+        const configs = JSON.parse(raw);
+        return configs.map((cfg) => {
+            let addresses = [];
+            try {
+                switch (cfg.type) {
+                    case "array":
+                        addresses = extractArray(cfg.path);
+                        break;
+                    case "solkek":
+                        addresses = extractSolkek(cfg.path);
+                        break;
+                    case "rigdirs":
+                        addresses = extractRigdirs(cfg.path);
+                        break;
+                    case "walletfiles":
+                        addresses = extractWalletfiles(cfg.path);
+                        break;
+                }
+            }
+            catch {
+                // Skip broken fleet sources silently
+            }
+            return { name: cfg.name, addresses };
+        });
+    }
+    catch {
+        return [{ name: "Main", addresses: getWalletAddresses(walletsPath) }];
+    }
+}
+function getWalletAddresses(walletsPath) {
+    try {
+        const raw = (0, node_fs_1.readFileSync)(walletsPath, "utf8");
+        const data = JSON.parse(raw);
+        if (Array.isArray(data)) {
+            return data.filter((addr) => typeof addr === "string" && ADDR_RE.test(addr));
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+function getAddressesForFleet(fleetName, walletsPath) {
+    if (!fleetName || fleetName === "All") {
+        const fleets = getFleets(walletsPath);
+        const seen = new Set();
+        const all = [];
+        for (const f of fleets) {
+            for (const addr of f.addresses) {
+                const lower = addr.toLowerCase();
+                if (!seen.has(lower)) {
+                    seen.add(lower);
+                    all.push(addr);
+                }
+            }
+        }
+        return all;
+    }
+    const fleets = getFleets(walletsPath);
+    const fleet = fleets.find((f) => f.name === fleetName);
+    if (fleet)
+        return fleet.addresses;
+    return getWalletAddresses(walletsPath);
+}
+// --- Art parsing ---
+function parseArtFromTokenUri(raw) {
+    if (!raw?.startsWith("data:application/json;base64,"))
+        return "";
+    try {
+        const json = JSON.parse(Buffer.from(raw.slice(29), "base64").toString("utf8"));
+        return json.image ?? "";
+    }
+    catch {
+        return "";
+    }
+}
+// --- Server ---
+function startDashboardServer(opts) {
+    const { port, walletsPath, rpcUrl, miningAgentAddress, agentCoinAddress } = opts;
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain: chains_1.base,
+        transport: (0, viem_1.http)(rpcUrl),
+    });
+    const artCache = new Map();
+    const htmlPage = (0, dashboard_html_1.getDashboardHtml)();
+    async function handleWallets(fleetParam) {
+        const addresses = getAddressesForFleet(fleetParam, walletsPath);
+        if (addresses.length === 0)
+            return "[]";
+        // Phase 1: ETH balance + AGENT balance + NFT count
+        const phase1Contracts = addresses.flatMap((addr) => [
+            { address: agentCoinAddress, abi: AgentCoinAbi, functionName: "balanceOf", args: [addr] },
+            { address: miningAgentAddress, abi: MiningAgentAbi, functionName: "balanceOf", args: [addr] },
+        ]);
+        const [balances, multicallResults] = await Promise.all([
+            Promise.all(addresses.map((addr) => publicClient.getBalance({ address: addr }).catch(() => 0n))),
+            publicClient.multicall({ contracts: phase1Contracts }),
+        ]);
+        const walletInfos = addresses.map((addr, i) => ({
+            address: addr,
+            ethBalance: balances[i],
+            agentBalance: multicallResults[i * 2].result ?? 0n,
+            nftCount: Number(multicallResults[i * 2 + 1].result ?? 0n),
+        }));
+        // Phase 2: token IDs
+        const tokenIdContracts = [];
+        const tokenIdMap = [];
+        for (let wi = 0; wi < walletInfos.length; wi++) {
+            const info = walletInfos[wi];
+            for (let mi = 0; mi < info.nftCount; mi++) {
+                tokenIdContracts.push({
+                    address: miningAgentAddress,
+                    abi: MiningAgentAbi,
+                    functionName: "tokenOfOwnerByIndex",
+                    args: [info.address, BigInt(mi)],
+                });
+                tokenIdMap.push({ walletIdx: wi });
+            }
+        }
+        const tokenIds = [];
+        const validTokenMap = [];
+        if (tokenIdContracts.length > 0) {
+            const tokenIdResults = await publicClient.multicall({ contracts: tokenIdContracts });
+            for (let i = 0; i < tokenIdResults.length; i++) {
+                const r = tokenIdResults[i];
+                if (r.status === "success" && r.result != null) {
+                    validTokenMap.push(i);
+                    tokenIds.push(r.result);
+                }
+            }
+        }
+        // No miners — return early
+        if (tokenIds.length === 0) {
+            const wallets = walletInfos.map((info) => ({
+                address: info.address,
+                ethBalance: (0, viem_1.formatEther)(info.ethBalance),
+                agentBalance: (0, viem_1.formatEther)(info.agentBalance),
+                miners: [],
+            }));
+            return JSON.stringify(wallets);
+        }
+        // Phase 3: miner stats + art
+        const uncachedTokenIds = tokenIds.filter((id) => !artCache.has(id.toString()));
+        const FIELDS_PER_TOKEN = 5;
+        const detailContracts = tokenIds.flatMap((tokenId) => [
+            { address: miningAgentAddress, abi: MiningAgentAbi, functionName: "rarity", args: [tokenId] },
+            { address: miningAgentAddress, abi: MiningAgentAbi, functionName: "hashpower", args: [tokenId] },
+            { address: agentCoinAddress, abi: AgentCoinAbi, functionName: "tokenMineCount", args: [tokenId] },
+            { address: agentCoinAddress, abi: AgentCoinAbi, functionName: "tokenEarnings", args: [tokenId] },
+            { address: miningAgentAddress, abi: MiningAgentAbi, functionName: "mintBlock", args: [tokenId] },
+        ]);
+        const detailResults = await publicClient.multicall({ contracts: detailContracts });
+        // Batch art URI calls for uncached tokens — use small chunks to avoid RPC response size limits
+        const ART_CHUNK_SIZE = 2;
+        const artResults = [];
+        for (let i = 0; i < uncachedTokenIds.length; i += ART_CHUNK_SIZE) {
+            const chunk = uncachedTokenIds.slice(i, i + ART_CHUNK_SIZE);
+            const artContracts = chunk.map((tokenId) => ({
+                address: miningAgentAddress,
+                abi: MiningAgentAbi,
+                functionName: "tokenURI",
+                args: [tokenId],
+            }));
+            try {
+                const chunkResults = await publicClient.multicall({ contracts: artContracts });
+                artResults.push(...chunkResults);
+            }
+            catch {
+                // Push failure entries so indexing stays aligned
+                for (let j = 0; j < chunk.length; j++) {
+                    artResults.push({ status: "failure" });
+                }
+            }
+        }
+        // Populate art cache
+        for (let i = 0; i < uncachedTokenIds.length; i++) {
+            const r = artResults[i];
+            if (r && r.status === "success" && r.result) {
+                const imageUri = parseArtFromTokenUri(r.result);
+                if (imageUri)
+                    artCache.set(uncachedTokenIds[i].toString(), imageUri);
+            }
+        }
+        // Build wallet data
+        const minersByWallet = new Map();
+        for (let ti = 0; ti < tokenIds.length; ti++) {
+            const originalIdx = validTokenMap[ti];
+            const { walletIdx } = tokenIdMap[originalIdx];
+            const b = ti * FIELDS_PER_TOKEN;
+            const rarity = Number(detailResults[b].result ?? 0n);
+            const hashpower = Number(detailResults[b + 1].result ?? 100n);
+            const mineCount = detailResults[b + 2].result ?? 0n;
+            const earnings = detailResults[b + 3].result ?? 0n;
+            const mintBlock = detailResults[b + 4].result ?? 0n;
+            const tid = tokenIds[ti].toString();
+            const miner = {
+                tokenId: tid,
+                rarity,
+                rarityLabel: RARITY_LABELS[rarity] ?? `Tier ${rarity}`,
+                hashpower,
+                mineCount: mineCount.toString(),
+                earnings: (0, viem_1.formatEther)(earnings),
+                mintBlock: mintBlock.toString(),
+                imageUri: artCache.get(tid),
+            };
+            if (!minersByWallet.has(walletIdx))
+                minersByWallet.set(walletIdx, []);
+            minersByWallet.get(walletIdx).push(miner);
+        }
+        const wallets = walletInfos.map((info, i) => ({
+            address: info.address,
+            ethBalance: (0, viem_1.formatEther)(info.ethBalance),
+            agentBalance: (0, viem_1.formatEther)(info.agentBalance),
+            miners: minersByWallet.get(i) ?? [],
+        }));
+        return JSON.stringify(wallets);
+    }
+    async function handleNetwork() {
+        const results = await publicClient.multicall({
+            contracts: [
+                { address: agentCoinAddress, abi: AgentCoinAbi, functionName: "totalMines" },
+                { address: agentCoinAddress, abi: AgentCoinAbi, functionName: "totalMinted" },
+                { address: agentCoinAddress, abi: AgentCoinAbi, functionName: "miningTarget" },
+                { address: agentCoinAddress, abi: AgentCoinAbi, functionName: "MINEABLE_SUPPLY" },
+                { address: agentCoinAddress, abi: AgentCoinAbi, functionName: "ERA_INTERVAL" },
+            ],
+        });
+        const totalMines = results[0].result;
+        const totalMinted = results[1].result;
+        const miningTarget = results[2].result;
+        const mineableSupply = results[3].result;
+        const eraInterval = results[4].result;
+        const era = totalMines / eraInterval;
+        const minesUntilNextEra = eraInterval - (totalMines % eraInterval);
+        const supplyPct = Number((totalMinted * 10000n) / mineableSupply) / 100;
+        let baseReward = 3;
+        for (let i = 0n; i < era; i++) {
+            baseReward *= 0.9;
+        }
+        const nextEraReward = baseReward * 0.9;
+        const targetLog = Math.log2(Number(miningTarget));
+        const difficulty = targetLog > 250 ? "very easy" :
+            targetLog > 240 ? "easy" :
+                targetLog > 220 ? "moderate" :
+                    targetLog > 200 ? "hard" : "very hard";
+        return JSON.stringify({
+            totalMines: totalMines.toString(),
+            totalMinted: (0, viem_1.formatEther)(totalMinted),
+            mineableSupply: (0, viem_1.formatEther)(mineableSupply),
+            era: Number(era),
+            minesUntilNextEra: minesUntilNextEra.toString(),
+            baseReward,
+            nextEraReward,
+            difficulty,
+            supplyPct,
+        });
+    }
+    function handleFleets() {
+        const fleets = getFleets(walletsPath);
+        return JSON.stringify(fleets.map((f) => ({ name: f.name, walletCount: f.addresses.length })));
+    }
+    function handleConfig() {
+        const rpcIsDefault = rpcUrl === DEFAULT_RPC;
+        const walletCount = getWalletAddresses(walletsPath).length;
+        return JSON.stringify({ rpcIsDefault, walletCount });
+    }
+    function jsonResponse(res, body, status = 200) {
+        res.writeHead(status, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+        res.end(body);
+    }
+    function errorResponse(res, message, status = 500) {
+        jsonResponse(res, JSON.stringify({ error: message }), status);
+    }
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+        const pathname = url.pathname;
+        try {
+            if (pathname === "/" || pathname === "") {
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.end(htmlPage);
+                return;
+            }
+            if (pathname === "/api/wallets") {
+                const fleet = url.searchParams.get("fleet");
+                const body = await handleWallets(fleet);
+                jsonResponse(res, body);
+                return;
+            }
+            if (pathname === "/api/network") {
+                const body = await handleNetwork();
+                jsonResponse(res, body);
+                return;
+            }
+            if (pathname === "/api/fleets") {
+                const body = handleFleets();
+                jsonResponse(res, body);
+                return;
+            }
+            if (pathname === "/api/config") {
+                const body = handleConfig();
+                jsonResponse(res, body);
+                return;
+            }
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end("Not Found");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Unknown error";
+            errorResponse(res, message);
+        }
+    });
+    server.listen(port);
+    return server;
+}