@bankr/cli 0.1.0-beta.6 → 0.1.0

package/dist/commands/fees.js

@@ -0,0 +1,793 @@
+import chalk from "chalk";
+import { confirm, password, checkbox } from "@inquirer/prompts";
+import { isAddress } from "viem";
+import { getCreatorFees, getBeneficiaryFeesStreaming, getTokenCreatorFees, getUserInfo, buildDopplerClaimTx, submit, } from "../lib/api.js";
+import { emitCESP } from "../lib/cesp/engine.js";
+import { requireApiKey } from "../lib/config.js";
+import * as output from "../lib/output.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const BRAND = chalk.hex("#FF613D");
+const BRAND_BOLD = BRAND.bold;
+const GREEN = chalk.green;
+const BRIGHT_GREEN = chalk.greenBright;
+const CYAN = chalk.cyan;
+const BRIGHT_CYAN = chalk.cyanBright;
+const YELLOW = chalk.yellowBright;
+const MAGENTA = chalk.magentaBright;
+const DIM = chalk.dim;
+const BOLD = chalk.bold;
+const WHITE = chalk.whiteBright;
+const CHART_HEIGHT = 16;
+const CHART_WIDTH = 58;
+const MIN_DAYS = 1;
+const MAX_DAYS = 90;
+const DEFAULT_DAYS = 30;
+// ---------------------------------------------------------------------------
+// Chart helpers (ported from development/scripts/daily-usdc-earnings.ts)
+// ---------------------------------------------------------------------------
+const SPARK_CHARS = [
+    "\u2581",
+    "\u2582",
+    "\u2583",
+    "\u2584",
+    "\u2585",
+    "\u2586",
+    "\u2587",
+    "\u2588",
+];
+function sparkline(values) {
+    if (values.length === 0)
+        return "";
+    const max = Math.max(...values);
+    const min = Math.min(...values);
+    const range = max - min || 1;
+    return values
+        .map((v) => {
+        const idx = Math.round(((v - min) / range) * (SPARK_CHARS.length - 1));
+        return SPARK_CHARS[idx];
+    })
+        .join("");
+}
+function colorForValue(value, max) {
+    const ratio = max > 0 ? value / max : 0;
+    if (ratio >= 0.75)
+        return BRIGHT_GREEN;
+    if (ratio >= 0.5)
+        return GREEN;
+    if (ratio >= 0.25)
+        return CYAN;
+    return DIM;
+}
+function sectionBox(title, boxWidth) {
+    const top = BRAND_BOLD("\u2554" + "\u2550".repeat(boxWidth) + "\u2557");
+    const pad = Math.max(0, boxWidth - 2 - title.length);
+    const mid = `${BRAND_BOLD("\u2551")} ${BOLD(WHITE(title))}${" ".repeat(pad)} ${BRAND_BOLD("\u2551")}`;
+    const bot = BRAND_BOLD("\u255a" + "\u2550".repeat(boxWidth) + "\u255d");
+    return [top, mid, bot];
+}
+function drawChart(dailyData) {
+    if (dailyData.length === 0)
+        return "  No data to chart.";
+    const values = dailyData.map((d) => d.amount);
+    const max = Math.max(...values);
+    const lines = [];
+    const boxWidth = CHART_WIDTH + 14;
+    lines.push("");
+    for (const l of sectionBox("DAILY FEE EARNINGS (WETH)", boxWidth)) {
+        lines.push(`  ${l}`);
+    }
+    lines.push("");
+    const chartRows = [];
+    for (let row = CHART_HEIGHT; row >= 0; row--) {
+        const label = row === CHART_HEIGHT
+            ? max.toFixed(4)
+            : row === 0
+                ? "0"
+                : row === Math.floor(CHART_HEIGHT / 2)
+                    ? (max / 2).toFixed(4)
+                    : "";
+        const paddedLabel = label.padStart(12);
+        // Sample data to fit chart width
+        const step = Math.max(1, Math.floor(dailyData.length / CHART_WIDTH));
+        const sampledValues = [];
+        for (let i = 0; i < dailyData.length; i += step) {
+            sampledValues.push(values[i]);
+        }
+        while (sampledValues.length < CHART_WIDTH) {
+            sampledValues.push(0);
+        }
+        let rowStr = "";
+        for (let col = 0; col < Math.min(sampledValues.length, CHART_WIDTH); col++) {
+            const val = sampledValues[col];
+            const barHeight = max > 0 ? (val / max) * CHART_HEIGHT : 0;
+            const color = colorForValue(val, max);
+            if (barHeight >= row && row > 0) {
+                if (barHeight - row < 1 && barHeight >= row) {
+                    rowStr += color("\u2584");
+                }
+                else {
+                    rowStr += color("\u2588");
+                }
+            }
+            else if (row === 0) {
+                rowStr += DIM("\u2500");
+            }
+            else {
+                rowStr += " ";
+            }
+        }
+        const yLabel = DIM(paddedLabel);
+        const separator = row === 0 ? DIM("\u253c") : DIM("\u2502");
+        chartRows.push(`  ${yLabel} ${separator}${rowStr}`);
+    }
+    lines.push(...chartRows);
+    // X-axis labels
+    const xAxisPadding = " ".repeat(14);
+    if (dailyData.length > 0) {
+        const first = dailyData[0].date.slice(5);
+        const last = dailyData[dailyData.length - 1].date.slice(5);
+        const mid = dailyData[Math.floor(dailyData.length / 2)].date.slice(5);
+        const gap1 = Math.floor(CHART_WIDTH / 2) - first.length;
+        const gap2 = CHART_WIDTH - Math.floor(CHART_WIDTH / 2) - mid.length;
+        lines.push(`  ${xAxisPadding} ${DIM(first)}${" ".repeat(Math.max(1, gap1))}${DIM(mid)}${" ".repeat(Math.max(1, gap2))}${DIM(last)}`);
+    }
+    return lines.join("\n");
+}
+function drawTable(dailyData, total) {
+    const lines = [];
+    const nonZero = dailyData.filter((d) => d.amount > 0);
+    if (nonZero.length === 0)
+        return "";
+    const max = Math.max(...nonZero.map((d) => d.amount));
+    // Column inner widths (content between │ borders, including padding spaces)
+    const col1 = 14; // " YYYY-MM-DD   "
+    const col2 = 16; // " XX.XXXXXX       "
+    const barMax = 30;
+    const pctWidth = 6; // "XX.X%" padded
+    const col3 = 1 + barMax + 1 + pctWidth + 1; // " bar pct% " = 39
+    const hr = (l, m, r) => YELLOW(l +
+        "\u2500".repeat(col1) +
+        m +
+        "\u2500".repeat(col2) +
+        m +
+        "\u2500".repeat(col3) +
+        r);
+    lines.push("");
+    lines.push(`  ${hr("\u250c", "\u252c", "\u2510")}`);
+    // Header row — pad each cell to its column width
+    const h1 = (" Date" + " ".repeat(col1)).slice(0, col1);
+    const h2 = (" WETH Earned" + " ".repeat(col2)).slice(0, col2);
+    const h3 = (" Distribution" + " ".repeat(col3)).slice(0, col3);
+    lines.push(`  ${YELLOW("\u2502")}${BOLD(WHITE(h1))}${YELLOW("\u2502")}${BOLD(WHITE(h2))}${YELLOW("\u2502")}${BOLD(WHITE(h3))}${YELLOW("\u2502")}`);
+    lines.push(`  ${hr("\u251c", "\u253c", "\u2524")}`);
+    for (const { date, amount } of nonZero) {
+        const barWidth = max > 0 ? Math.max(1, Math.round((amount / max) * barMax)) : 0;
+        const color = colorForValue(amount, max);
+        const bar = color("\u2588".repeat(barWidth));
+        const pctStr = (total > 0 ? ((amount / total) * 100).toFixed(1) : "0.0") + "%";
+        const amountStr = amount.toFixed(6);
+        // Col1: " date    " (14 chars)
+        const c1 = ` ${date}` + " ".repeat(Math.max(0, col1 - 1 - date.length));
+        // Col2: " amountPadded " (16 chars)
+        const c2 = ` ${amountStr.padStart(14)} `;
+        // Col3: " bar spaces pct% " (col3 chars)
+        const barArea = barWidth + Math.max(0, barMax - barWidth); // always barMax
+        const c3Pad = Math.max(0, col3 - 1 - barArea - 1 - pctStr.length - 1);
+        const c3 = ` ${bar}${" ".repeat(Math.max(0, barMax - barWidth))} ${DIM(pctStr)}${" ".repeat(c3Pad)} `;
+        lines.push(`  ${YELLOW("\u2502")}${CYAN(c1)}${YELLOW("\u2502")}${BRIGHT_GREEN(c2)}${YELLOW("\u2502")}${c3}${YELLOW("\u2502")}`);
+    }
+    lines.push(`  ${hr("\u2514", "\u2534", "\u2518")}`);
+    return lines.join("\n");
+}
+function statCard(title, value, subtitle, color) {
+    const inner = 22;
+    const top = color("\u250c" + "\u2500".repeat(inner) + "\u2510");
+    const titlePad = Math.max(0, inner - 1 - title.length);
+    const titleLine = `${color("\u2502")} ${DIM(title)}${" ".repeat(titlePad)}${color("\u2502")}`;
+    const valuePad = Math.max(0, inner - 1 - value.length);
+    const valueLine = `${color("\u2502")} ${BOLD(WHITE(value))}${" ".repeat(valuePad)}${color("\u2502")}`;
+    const subPad = Math.max(0, inner - 1 - subtitle.length);
+    const subLine = `${color("\u2502")} ${DIM(subtitle)}${" ".repeat(subPad)}${color("\u2502")}`;
+    const bottom = color("\u2514" + "\u2500".repeat(inner) + "\u2518");
+    return [top, titleLine, valueLine, subLine, bottom];
+}
+function renderStatRow(cards) {
+    const lines = [];
+    const height = cards[0].length;
+    for (let i = 0; i < height; i++) {
+        lines.push("  " + cards.map((c) => c[i]).join("  "));
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Rendering
+// ---------------------------------------------------------------------------
+function renderDashboard(data) {
+    // Banner
+    const bannerTitle = "B A N K R   \u00b7   F E E   D A S H B O A R D";
+    const bannerBox = sectionBox(bannerTitle, bannerTitle.length + 4);
+    for (const l of bannerBox) {
+        console.log(`  ${l}`);
+    }
+    console.log(`${DIM(`  Wallet: ${data.address}`)}`);
+    console.log(`${DIM(`  Chain:  Base \u00b7 Tokens: ${data.tokens.length} \u00b7 Period: ${data.days} days`)}`);
+    if (data.tokens.length === 0) {
+        console.log(`\n  ${DIM("No tokens found where this wallet is a creator beneficiary.")}`);
+        console.log("");
+        return;
+    }
+    // Claimable summary cards
+    console.log("");
+    console.log(renderStatRow([
+        statCard("CLAIMABLE WETH", data.totals.claimableWeth, "pending", MAGENTA),
+        statCard("CLAIMED WETH", data.totals.claimedWeth, `${data.totals.claimCount} claims (${data.days}d)`, BRIGHT_CYAN),
+    ]));
+    // Daily chart
+    const dailyData = data.dailyEarnings.map((d) => ({
+        date: d.date,
+        amount: Number(d.weth),
+    }));
+    const amounts = dailyData.map((d) => d.amount);
+    const total = amounts.reduce((a, b) => a + b, 0);
+    if (total > 0) {
+        console.log(drawChart(dailyData));
+        // Stats row
+        const avg = amounts.length > 0 ? total / amounts.length : 0;
+        const maxDay = dailyData.reduce((best, d) => (d.amount > best.amount ? d : best), dailyData[0]);
+        const activeDays = amounts.filter((a) => a > 0).length;
+        const streak = (() => {
+            let s = 0;
+            for (let i = amounts.length - 1; i >= 0; i--) {
+                if (amounts[i] > 0)
+                    s++;
+                else
+                    break;
+            }
+            return s;
+        })();
+        console.log("");
+        console.log(renderStatRow([
+            statCard("TOTAL EARNED", total.toFixed(6), `${data.days} days`, MAGENTA),
+            statCard("DAILY AVERAGE", avg.toFixed(6), "per day", BRIGHT_CYAN),
+            statCard("BEST DAY", maxDay.amount.toFixed(6), maxDay.date, YELLOW),
+        ]));
+        console.log("");
+        console.log(renderStatRow([
+            statCard("ACTIVE DAYS", `${activeDays} / ${data.days}`, "with earnings", GREEN),
+            statCard("CURRENT STREAK", `${streak} day${streak !== 1 ? "s" : ""}`, "consecutive", MAGENTA),
+        ]));
+        // Sparkline
+        console.log("");
+        console.log(`  ${DIM("Sparkline:")} ${BRIGHT_GREEN(sparkline(amounts))}`);
+        // Table
+        console.log(drawTable(dailyData, total));
+        // Projections
+        const projectedMonthly = avg * 30;
+        const projectedYearly = avg * 365;
+        console.log("");
+        console.log(`  ${BRAND_BOLD("Projections (based on daily avg):")}`);
+        console.log(`     ${DIM("Monthly:")}  ${BOLD(BRIGHT_GREEN(projectedMonthly.toFixed(6) + " WETH"))}`);
+        console.log(`     ${DIM("Yearly:")}   ${BOLD(BRIGHT_GREEN(projectedYearly.toFixed(4) + " WETH"))}`);
+    }
+    // Per-token breakdown
+    console.log("");
+    console.log(`  ${BRAND_BOLD("\u2550".repeat(62))}`);
+    console.log(`  ${BRAND_BOLD("PER-TOKEN BREAKDOWN")}`);
+    console.log(`  ${BRAND_BOLD("\u2550".repeat(62))}`);
+    console.log("");
+    for (const token of data.tokens) {
+        const wethIsToken0 = token.token0Label === "WETH";
+        const claimableWeth = wethIsToken0
+            ? token.claimable.token0
+            : token.claimable.token1;
+        const claimableToken = wethIsToken0
+            ? token.claimable.token1
+            : token.claimable.token0;
+        const claimedWeth = wethIsToken0
+            ? token.claimed.token0
+            : token.claimed.token1;
+        const claimedToken = wethIsToken0
+            ? token.claimed.token1
+            : token.claimed.token0;
+        const tokenSymbol = wethIsToken0 ? token.token1Label : token.token0Label;
+        const sourceLabel = token.source === "clanker" ? DIM(" [Clanker]") : DIM(" [Doppler]");
+        console.log(`  ${BOLD(WHITE(token.name))} ${DIM("($" + token.symbol + ")")}${sourceLabel}`);
+        const shareInfo = token.source === "clanker"
+            ? `${DIM("Creator")} ${DIM("\u00b7 Token:")} ${DIM(token.tokenAddress)}`
+            : `${DIM("Share:")} ${token.share} ${DIM("\u00b7 Token:")} ${DIM(token.tokenAddress)}`;
+        console.log(`  ${shareInfo}`);
+        console.log(`  ${DIM("Claimable:")}  ${BRIGHT_GREEN(claimableWeth.padStart(12))} WETH  ${DIM("|")}  ${BRIGHT_GREEN(claimableToken.padStart(18))} ${tokenSymbol}`);
+        console.log(`  ${DIM("Claimed:")}    ${WHITE(claimedWeth.padStart(12))} WETH  ${DIM("|")}  ${WHITE(claimedToken.padStart(18))} ${tokenSymbol}  ${DIM(`(${token.claimed.count} claims)`)}`);
+        console.log("");
+    }
+    console.log(`  ${BRAND_BOLD("\u2550".repeat(62))}`);
+    console.log("");
+}
+// Subcommand names that Commander may accidentally pass as the address arg
+const FEES_SUBCOMMANDS = ["claim", "claim-wallet"];
+export async function feesCommand(address, opts) {
+    // Commander may route "bankr fees claim-wallet" here with address="claim-wallet"
+    // instead of to the subcommand. Bail out and let Commander re-route.
+    if (address && FEES_SUBCOMMANDS.includes(address)) {
+        return;
+    }
+    // Validate days
+    let days;
+    if (opts.days) {
+        days = parseInt(opts.days, 10);
+        if (isNaN(days) || days < MIN_DAYS || days > MAX_DAYS) {
+            output.error(`Days must be between ${MIN_DAYS} and ${MAX_DAYS}`);
+            process.exit(1);
+        }
+    }
+    // --token flag: look up fees by token address (no wallet needed)
+    if (opts.token) {
+        const spin = output.spinner("Fetching token creator fee data...");
+        try {
+            const data = await getTokenCreatorFees(opts.token, days);
+            spin.succeed("Fee data loaded");
+            emitCESP("task.complete");
+            if (opts.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            renderDashboard(data);
+        }
+        catch (err) {
+            spin.fail("Failed to fetch token fee data");
+            emitCESP("task.error");
+            output.error(err.message);
+            process.exit(1);
+        }
+        return;
+    }
+    // Resolve wallet address
+    let walletAddress = address;
+    if (!walletAddress) {
+        requireApiKey();
+        const spin = output.spinner("Fetching wallet info...");
+        try {
+            const info = await getUserInfo();
+            const evmWallet = info.wallets.find((w) => w.chain === "evm");
+            if (!evmWallet) {
+                spin.fail("No EVM wallet found for this account");
+                process.exit(1);
+            }
+            walletAddress = evmWallet.address;
+            spin.succeed(`Wallet: ${walletAddress}`);
+        }
+        catch (err) {
+            spin.fail("Failed to fetch wallet info");
+            output.error(err.message);
+            process.exit(1);
+        }
+    }
+    // Fetch data
+    const spin = output.spinner("Fetching creator fee data...");
+    try {
+        const data = await getCreatorFees(walletAddress, days);
+        spin.succeed("Fee data loaded");
+        emitCESP("task.complete");
+        if (opts.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        renderDashboard(data);
+    }
+    catch (err) {
+        spin.fail("Failed to fetch fee data");
+        emitCESP("task.error");
+        output.error(err.message);
+        process.exit(1);
+    }
+}
+export async function feesClaimCommand(tokenAddress, opts) {
+    requireApiKey();
+    // Step 1: Build claim transaction
+    const buildSpin = output.spinner("Building claim transaction...");
+    let claimTx;
+    try {
+        claimTx = await buildDopplerClaimTx(tokenAddress);
+        buildSpin.succeed(claimTx.description);
+    }
+    catch (err) {
+        buildSpin.fail("Failed to build claim transaction");
+        emitCESP("task.error");
+        output.error(err.message);
+        process.exit(1);
+    }
+    // Step 2: Confirm
+    if (!opts.yes) {
+        console.log();
+        output.keyValue("To", claimTx.to);
+        output.keyValue("Chain ID", String(claimTx.chainId));
+        output.keyValue("Action", claimTx.description);
+        console.log();
+        const proceed = await confirm({
+            message: "Submit this claim transaction?",
+            default: true,
+            theme: output.bankrTheme,
+        });
+        if (!proceed) {
+            output.dim("Claim cancelled.");
+            return;
+        }
+    }
+    // Step 3: Submit via /agent/submit
+    const submitSpin = output.spinner("Submitting claim transaction...");
+    const startTime = Date.now();
+    try {
+        const result = await submit({
+            transaction: {
+                to: claimTx.to,
+                chainId: claimTx.chainId,
+                data: claimTx.data,
+            },
+            description: claimTx.description,
+            waitForConfirmation: true,
+        });
+        const elapsed = output.formatDuration(Date.now() - startTime);
+        if (result.success) {
+            submitSpin.succeed(`Fees claimed in ${elapsed}`);
+            emitCESP("task.complete");
+            console.log();
+            if (result.transactionHash) {
+                output.keyValue("Transaction", result.transactionHash);
+            }
+            if (result.status) {
+                output.keyValue("Status", output.formatStatus(result.status === "success" ? "completed" : result.status));
+            }
+            output.keyValue("Signer", result.signer);
+            console.log();
+            output.dim(`View on Basescan: https://basescan.org/tx/${result.transactionHash}`);
+        }
+        else {
+            submitSpin.fail(`Claim failed after ${elapsed}`);
+            emitCESP("task.error");
+            output.error(result.error || "Transaction failed");
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        submitSpin.fail("Claim submission failed");
+        emitCESP("task.error");
+        output.error(err.message);
+        process.exit(1);
+    }
+}
+// ---------------------------------------------------------------------------
+// claim-wallet: Claim fees using an external private key (no Bankr account)
+// ---------------------------------------------------------------------------
+const DEFAULT_BASE_RPC = "https://mainnet.base.org";
+export async function feesClaimWalletCommand(address, opts) {
+    // Commander may pass the subcommand name as the address arg — discard it
+    if (address && !isAddress(address)) {
+        address = undefined;
+    }
+    // Load .env from cwd if present (no dependency needed)
+    try {
+        const { readFileSync, existsSync } = await import("node:fs");
+        const { resolve } = await import("node:path");
+        const envPath = resolve(process.cwd(), ".env");
+        if (existsSync(envPath)) {
+            const envContent = readFileSync(envPath, "utf-8");
+            for (const line of envContent.split("\n")) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith("#"))
+                    continue;
+                const eqIdx = trimmed.indexOf("=");
+                if (eqIdx === -1)
+                    continue;
+                const key = trimmed.slice(0, eqIdx).trim();
+                const raw = trimmed.slice(eqIdx + 1).trim();
+                // Strip surrounding quotes
+                const val = raw.replace(/^["']|["']$/g, "");
+                if (!process.env[key]) {
+                    process.env[key] = val;
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore .env read errors
+    }
+    // Step 1: Get private key (flag > env var > .env > interactive prompt)
+    let privateKey;
+    if (opts.privateKey) {
+        privateKey = opts.privateKey;
+    }
+    else if (process.env.BANKR_PRIVATE_KEY) {
+        privateKey = process.env.BANKR_PRIVATE_KEY.trim();
+    }
+    else if (!address) {
+        output.error("Address required when no private key is available. Provide an address argument or set BANKR_PRIVATE_KEY in .env");
+        process.exit(1);
+    }
+    else {
+        privateKey = await password({
+            message: "Enter private key for this wallet (0x...):",
+            mask: "*",
+            theme: output.bankrTheme,
+        });
+    }
+    privateKey = privateKey.trim();
+    if (!privateKey.startsWith("0x")) {
+        privateKey = `0x${privateKey}`;
+    }
+    // Step 2: Derive account from key
+    const { privateKeyToAccount } = await import("viem/accounts");
+    let account;
+    try {
+        account = privateKeyToAccount(privateKey);
+    }
+    catch {
+        output.error("Invalid private key format");
+        process.exit(1);
+    }
+    // Step 3: Resolve address — derive from key if not provided, verify match if provided
+    if (!address) {
+        address = account.address;
+        output.dim(`Using address from private key: ${address}`);
+    }
+    else {
+        if (!isAddress(address)) {
+            output.error("Invalid EVM address");
+            process.exit(1);
+        }
+        if (account.address.toLowerCase() !== address.toLowerCase()) {
+            output.error(`Private key does not match address ${address}. Derived: ${account.address}`);
+            process.exit(1);
+        }
+    }
+    console.log();
+    output.keyValue("Wallet", account.address);
+    // Step 4: Fetch claimable fees with streaming progress
+    const fetchSpin = output.spinner("Scanning launches for claimable fees...");
+    let allTokens;
+    try {
+        const result = await getBeneficiaryFeesStreaming(address, (progress) => {
+            fetchSpin.text = `Scanning pools... ${progress.scanned}/${progress.total} (${progress.found ?? 0} with claimable fees)`;
+        });
+        fetchSpin.succeed(`Scanned ${result.totalLaunches} launches — ${result.poolsWithShares} pools with shares, ${result.tokens.length} with claimable fees`);
+        allTokens = result.tokens;
+    }
+    catch (err) {
+        fetchSpin.fail("Failed to fetch fee data");
+        output.error(err.message);
+        process.exit(1);
+    }
+    // Step 5: Filter to tokens with claimable fees (API already filters, but
+    // double-check for any rounding edge cases)
+    const parseAmount = (s) => parseFloat(s.replace(/^[<>]/, "")) || 0;
+    const claimableTokens = allTokens.filter((token) => {
+        const wethIsToken0 = token.token0Label === "WETH";
+        const claimableWeth = wethIsToken0
+            ? token.claimable.token0
+            : token.claimable.token1;
+        const claimableToken = wethIsToken0
+            ? token.claimable.token1
+            : token.claimable.token0;
+        return parseAmount(claimableWeth) > 0 || parseAmount(claimableToken) > 0;
+    });
+    if (claimableTokens.length === 0) {
+        console.log();
+        output.dim("No claimable fees found for this wallet.");
+        return;
+    }
+    // Show total claimable WETH
+    const totalWeth = claimableTokens.reduce((sum, token) => {
+        const wethIsToken0 = token.token0Label === "WETH";
+        const wethStr = wethIsToken0
+            ? token.claimable.token0
+            : token.claimable.token1;
+        return sum + parseAmount(wethStr);
+    }, 0);
+    console.log();
+    output.keyValue("Total claimable", `${totalWeth.toFixed(6)} WETH across ${claimableTokens.length} token${claimableTokens.length !== 1 ? "s" : ""}`);
+    // Step 6: Select tokens
+    let selectedTokens;
+    if (opts.all) {
+        selectedTokens = claimableTokens;
+    }
+    else {
+        const choices = claimableTokens.map((token) => {
+            const wethIsToken0 = token.token0Label === "WETH";
+            const claimableWeth = wethIsToken0
+                ? token.claimable.token0
+                : token.claimable.token1;
+            return {
+                name: `${token.name} ($${token.symbol}) - ${claimableWeth} WETH`,
+                value: token.tokenAddress,
+                checked: true,
+            };
+        });
+        const selectedAddresses = await checkbox({
+            message: "Select tokens to claim fees for:",
+            choices,
+            theme: output.bankrTheme,
+        });
+        if (selectedAddresses.length === 0) {
+            output.dim("No tokens selected.");
+            return;
+        }
+        selectedTokens = claimableTokens.filter((t) => selectedAddresses.includes(t.tokenAddress));
+    }
+    // Step 7: Build transactions locally (like claim-doppler-fees.ts script)
+    const { createPublicClient, createWalletClient, http, encodeFunctionData } = await import("viem");
+    const { base } = await import("viem/chains");
+    const rpcUrl = opts.rpc || DEFAULT_BASE_RPC;
+    const transport = http(rpcUrl);
+    const publicClient = createPublicClient({ chain: base, transport });
+    const walletClient = createWalletClient({
+        account,
+        chain: base,
+        transport,
+    });
+    const collectFeesAbi = [
+        {
+            type: "function",
+            name: "collectFees",
+            stateMutability: "nonpayable",
+            inputs: [{ name: "poolId", type: "bytes32" }],
+            outputs: [
+                { name: "fees0", type: "uint128" },
+                { name: "fees1", type: "uint128" },
+            ],
+        },
+    ];
+    // Filter to tokens with initializer (required for local tx building)
+    const buildableTokens = selectedTokens.filter((t) => t.initializer);
+    if (buildableTokens.length < selectedTokens.length) {
+        output.warn(`${selectedTokens.length - buildableTokens.length} token(s) missing initializer data — skipped`);
+    }
+    if (buildableTokens.length === 0) {
+        output.error("No transactions could be built");
+        process.exit(1);
+    }
+    // Encode calldata locally (instant, no RPC)
+    const txData = buildableTokens.map((t) => ({
+        token: t,
+        to: t.initializer,
+        data: encodeFunctionData({
+            abi: collectFeesAbi,
+            functionName: "collectFees",
+            args: [t.poolId],
+        }),
+    }));
+    // Estimate gas for ALL tokens in parallel
+    const buildSpin = output.spinner(`Estimating gas for ${txData.length} transaction${txData.length !== 1 ? "s" : ""}...`);
+    const GAS_BUFFER = 130n; // 30% buffer
+    const gasEstimates = await Promise.all(txData.map(async ({ token, to, data }) => {
+        try {
+            const gas = await publicClient.estimateGas({
+                account: account.address,
+                to,
+                data,
+            });
+            return (gas * GAS_BUFFER) / 100n;
+        }
+        catch (err) {
+            output.warn(`${token.symbol}: gas estimate failed — ${err.message}`);
+            return null;
+        }
+    }));
+    // Filter out failed gas estimates
+    const readyTxs = txData
+        .map((td, i) => ({ ...td, gas: gasEstimates[i] }))
+        .filter((td) => td.gas !== null);
+    if (readyTxs.length === 0) {
+        buildSpin.fail("All gas estimates failed");
+        process.exit(1);
+    }
+    buildSpin.succeed(`Prepared ${readyTxs.length} transaction${readyTxs.length !== 1 ? "s" : ""}`);
+    // Step 8: Show summary and confirm
+    const [feeData] = await Promise.all([publicClient.estimateFeesPerGas()]);
+    console.log();
+    console.log(`  ${BRAND_BOLD("Transactions to submit:")}`);
+    console.log();
+    for (const tx of readyTxs) {
+        const gasWei = tx.gas * (feeData.maxFeePerGas ?? 0n);
+        const gasCostEth = Number(gasWei) / 1e18;
+        console.log(`  ${BOLD(WHITE(tx.token.name))} ${DIM(`($${tx.token.symbol})`)}`);
+        console.log(`  ${DIM("To:")} ${tx.to}  ${DIM("Gas:")} ~${gasCostEth.toFixed(6)} ETH`);
+        console.log();
+    }
+    if (!opts.yes) {
+        const proceed = await confirm({
+            message: `Submit ${readyTxs.length} claim transaction${readyTxs.length !== 1 ? "s" : ""}?`,
+            default: true,
+            theme: output.bankrTheme,
+        });
+        if (!proceed) {
+            output.dim("Cancelled.");
+            return;
+        }
+    }
+    // Step 9: Fire all txs with explicit nonce, then confirm in parallel
+    const startTime = Date.now();
+    let successCount = 0;
+    let failCount = 0;
+    const sendSpin = output.spinner("Preparing transactions...");
+    const baseNonce = await publicClient.getTransactionCount({
+        address: account.address,
+        blockTag: "pending",
+    });
+    let nonce = baseNonce;
+    const pendingTxs = [];
+    for (const tx of readyTxs) {
+        sendSpin.text = `Sending ${pendingTxs.length + 1}/${readyTxs.length}: ${tx.token.symbol}...`;
+        try {
+            const hash = await walletClient.sendTransaction({
+                to: tx.to,
+                data: tx.data,
+                gas: tx.gas,
+                maxFeePerGas: feeData.maxFeePerGas,
+                maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+                nonce: nonce++,
+            });
+            pendingTxs.push({ token: tx.token, hash });
+        }
+        catch (err) {
+            sendSpin.fail(`${tx.token.symbol}: Send failed — ${err.message}`);
+            emitCESP("task.error");
+            failCount++;
+            if (readyTxs.indexOf(tx) < readyTxs.length - 1) {
+                output.warn("Stopping remaining sends to avoid nonce gaps.");
+            }
+            break;
+        }
+    }
+    if (pendingTxs.length > 0) {
+        sendSpin.succeed(`Sent ${pendingTxs.length} transaction${pendingTxs.length !== 1 ? "s" : ""}`);
+    }
+    else {
+        sendSpin.fail("No transactions were sent.");
+    }
+    // Wait for all receipts in parallel
+    if (pendingTxs.length > 0) {
+        const confirmSpin = output.spinner(`Waiting for ${pendingTxs.length} confirmation${pendingTxs.length !== 1 ? "s" : ""}...`);
+        const results = await Promise.all(pendingTxs.map(async ({ token, hash }) => {
+            try {
+                const receipt = await publicClient.waitForTransactionReceipt({
+                    hash,
+                });
+                return { token, hash, status: receipt.status };
+            }
+            catch (err) {
+                return {
+                    token,
+                    hash,
+                    status: "failed",
+                    error: err.message,
+                };
+            }
+        }));
+        confirmSpin.stop();
+        for (const r of results) {
+            if (r.status === "success") {
+                output.success(`${r.token.symbol}: Claimed ${DIM(`tx: ${r.hash.slice(0, 10)}...${r.hash.slice(-8)}`)}`);
+                output.dim(`  https://basescan.org/tx/${r.hash}`);
+                successCount++;
+            }
+            else {
+                const reason = "error" in r ? r.error : "Transaction reverted";
+                output.error(`${r.token.symbol}: ${reason}`);
+                output.dim(`  https://basescan.org/tx/${r.hash}`);
+                failCount++;
+            }
+        }
+    }
+    // Step 10: Summary
+    const elapsed = output.formatDuration(Date.now() - startTime);
+    console.log();
+    if (successCount > 0) {
+        emitCESP("task.complete");
+        output.success(`Claimed fees for ${successCount} token${successCount !== 1 ? "s" : ""} in ${elapsed}`);
+    }
+    if (failCount > 0) {
+        output.error(`${failCount} claim${failCount !== 1 ? "s" : ""} failed`);
+    }
+}
+//# sourceMappingURL=fees.js.map