@lightspeed-cli/speed-cli 0.1.0

package/dist/commands/swap.js

@@ -0,0 +1,177 @@
+import { Command } from "commander";
+import { createInterface } from "readline";
+import ora from "ora";
+import { ethers } from "ethers";
+import { getSigner } from "../wallet.js";
+import { get0xQuote } from "../lib/zerox.js";
+import { executeSwapWithQuote } from "../lib/swap-execute.js";
+import { getEthUsdPriceNumber, getSpeedUsdPriceNumber } from "../lib/oracle.js";
+import { recordXpAction } from "../lib/xp.js";
+import { parseTokenAmountToWei } from "../lib/parse-amount.js";
+import { EXPLORER_URLS, resolveChainId, getChainOptionsHint, SPEED_TOKEN_ADDRESS, NATIVE_ETH_0X, CHAIN_NAMES, NATIVE_SYMBOL, } from "../constants.js";
+import { getDefaultChainInput } from "./config.js";
+import { out, exitWithError, setJsonMode, isJsonMode, success, usageHint } from "../output.js";
+function askConfirm(prompt) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(/^y|yes$/i.test(answer.trim()));
+        });
+    });
+}
+function tokenSymbol(addr, chainId) {
+    if (addr.toLowerCase() === NATIVE_ETH_0X.toLowerCase())
+        return NATIVE_SYMBOL[chainId] ?? "ETH";
+    if (addr.toLowerCase() === SPEED_TOKEN_ADDRESS.toLowerCase())
+        return "SPEED";
+    return "token";
+}
+function chainDisplayName(chainId) {
+    const name = CHAIN_NAMES[chainId] ?? String(chainId);
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+/** Format wei as human string (assumes 18 decimals). */
+function formatAmount(wei) {
+    try {
+        const n = ethers.formatEther(wei);
+        return parseFloat(n).toLocaleString(undefined, { maximumFractionDigits: 6 });
+    }
+    catch {
+        return wei;
+    }
+}
+export function swapCmd() {
+    return new Command("swap")
+        .description("One-shot swap: get quote → confirm → approve (if needed) → execute. No need to run quote or approve separately.")
+        .option("-c, --chain <id|name>", "Chain ID or name (e.g. 8453, base)", "8453")
+        .option("--sell <address>", "Sell token (default: Speed)")
+        .option("--buy <address>", "Buy token (default: Speed)")
+        .option("-a, --amount <amount>", "Sell amount in token units (e.g. 0.002, 10000, or 0.002 eth / 100 speed)")
+        .option("--go", "Skip confirmation and execute swap")
+        .option("--dry-run", "Only fetch and print quote; no approval or swap tx")
+        .action(async function (opts) {
+        setJsonMode(this.parent?.opts().json ?? false);
+        const yes = this.parent?.opts().yes ?? opts.go ?? false;
+        const chainId = resolveChainId(opts.chain ?? getDefaultChainInput());
+        if (chainId === null) {
+            exitWithError(`Unknown chain "${opts.chain}". Use one of: ${getChainOptionsHint()}.${usageHint("swap")}`, "INVALID_CHAIN");
+        }
+        if (!opts.amount) {
+            exitWithError("--amount is required. Example: speed swap -c base -a 0.002", "MISSING_ARGS");
+        }
+        const toToken = (v, defaultVal) => {
+            if (!v)
+                return defaultVal;
+            const t = v.trim().toLowerCase();
+            if (t === "speed")
+                return SPEED_TOKEN_ADDRESS;
+            if (t === "eth" || t === "ether" || t === "native")
+                return NATIVE_ETH_0X;
+            return v.trim();
+        };
+        // Default: sell native ETH, buy Speed (so "swap -a 0.002" = sell 0.002 ETH for Speed)
+        const sellToken = toToken(opts.sell, NATIVE_ETH_0X);
+        const buyToken = toToken(opts.buy, SPEED_TOKEN_ADDRESS);
+        if (sellToken.toLowerCase() === buyToken.toLowerCase()) {
+            exitWithError("Sell and buy token must be different. Use --sell and/or --buy to specify.", "SAME_TOKEN");
+        }
+        const amount = parseTokenAmountToWei(opts.amount.trim());
+        try {
+            const signer = getSigner(chainId);
+            const taker = await signer.getAddress();
+            const spinner = isJsonMode() ? null : ora("Fetching quote...").start();
+            const quote = await get0xQuote(chainId, sellToken, buyToken, amount, taker);
+            if (spinner)
+                spinner.succeed("Quote received");
+            if (!quote.transaction?.to || !quote.transaction?.data) {
+                exitWithError("No transaction in quote (0x returned no fill). Try a different amount or token." + usageHint("swap"), "QUOTE_ERROR");
+            }
+            let gasEth = "0";
+            let gasUsd = "0";
+            let gasCostWei = 0n;
+            try {
+                const gasLimit = quote.gas ? BigInt(quote.gas) : 200000n;
+                const feeData = await signer.provider.getFeeData();
+                const gasPrice = feeData.gasPrice ?? 0n;
+                gasCostWei = gasLimit * gasPrice;
+                gasEth = ethers.formatEther(gasCostWei);
+                const ethUsd = await getEthUsdPriceNumber(chainId);
+                gasUsd = (parseFloat(gasEth) * ethUsd).toFixed(2);
+            }
+            catch (_) { }
+            const isSellingNativeEth = sellToken.toLowerCase() === NATIVE_ETH_0X.toLowerCase();
+            if (isSellingNativeEth) {
+                const balance = await signer.provider.getBalance(taker);
+                const amountWei = BigInt(amount);
+                const valueWei = quote.transaction.value ? BigInt(quote.transaction.value) : 0n;
+                const totalNeeded = valueWei + gasCostWei;
+                if (balance < totalNeeded) {
+                    const balanceEth = formatAmount(balance.toString());
+                    const gasEthShort = formatAmount(gasCostWei.toString());
+                    exitWithError(`Insufficient ETH for swap + gas. Balance: ${balanceEth} ETH. This swap needs ${formatAmount(valueWei.toString())} ETH + ~${gasEthShort} ETH gas. Try a smaller amount (e.g. -a 0.0015) or add more ETH.`, "INSUFFICIENT_FUNDS");
+                }
+            }
+            const sellSym = tokenSymbol(sellToken, chainId);
+            const buySym = tokenSymbol(buyToken, chainId);
+            const chainName = chainDisplayName(chainId);
+            const sellFormatted = formatAmount(amount);
+            const buyFormatted = formatAmount(quote.buyAmount);
+            if (opts.dryRun) {
+                if (isJsonMode()) {
+                    out({ sellAmount: amount, buyAmount: quote.buyAmount, gas: quote.gas, needsAllowance: !!quote.issues?.allowance?.spender });
+                }
+                else {
+                    out(`Swap ${sellFormatted} ${sellSym} → ~${buyFormatted} ${buySym} on ${chainName}`);
+                    out(`Gas estimate: ${gasEth} ETH (~$${gasUsd})`);
+                    if (quote.issues?.allowance?.spender)
+                        out("(Would approve spender first, then swap.)");
+                    out("Re-run without --dry-run to execute.");
+                }
+                return;
+            }
+            if (!yes && !isJsonMode()) {
+                out(`Swap ${sellFormatted} ${sellSym} → ~${buyFormatted} ${buySym} on ${chainName}`);
+                out(`Estimated gas: ${gasEth} ETH (~$${gasUsd})`);
+                if (quote.issues?.allowance?.spender)
+                    out("(Will approve spender, then swap.)");
+                const ok = await askConfirm("Proceed? [y/N] ");
+                if (!ok) {
+                    out("Aborted.");
+                    process.exit(0);
+                }
+            }
+            const execSpinner = isJsonMode() ? null : ora("Executing swap...").start();
+            const txHash = await executeSwapWithQuote(signer, sellToken, quote, amount);
+            if (execSpinner)
+                execSpinner.succeed("Swap confirmed");
+            try {
+                const isSellingNative = sellToken.toLowerCase() === NATIVE_ETH_0X.toLowerCase();
+                const amountNum = parseFloat(ethers.formatEther(amount));
+                const usd = isSellingNative
+                    ? amountNum * (await getEthUsdPriceNumber(chainId))
+                    : amountNum * (await getSpeedUsdPriceNumber(chainId));
+                recordXpAction("swap", usd);
+            }
+            catch (_) { }
+            const explorer = EXPLORER_URLS[chainId];
+            const link = explorer ? `${explorer}/tx/${txHash}` : txHash;
+            if (isJsonMode()) {
+                out({ txHash, explorerLink: link });
+            }
+            else {
+                success(`Tx: ${txHash}`);
+                if (explorer)
+                    out(link);
+            }
+        }
+        catch (e) {
+            const err = e;
+            if (err?.code === "INSUFFICIENT_FUNDS" || (typeof err?.message === "string" && err.message.includes("insufficient funds"))) {
+                exitWithError("Insufficient balance for swap + gas. When selling native ETH, leave some for gas (e.g. use -a 0.0015 instead of 0.002)." + usageHint("swap"), "INSUFFICIENT_FUNDS");
+            }
+            const msg = e instanceof Error ? e.message : String(e);
+            exitWithError(`${msg}.${usageHint("swap")}`, "SWAP_ERROR");
+        }
+    });
+}

package/dist/commands/volume.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function volumeCmd(): Command;

package/dist/commands/volume.js

@@ -0,0 +1,241 @@
+import { Command } from "commander";
+import { ethers } from "ethers";
+import ora from "ora";
+import { getSigner } from "../wallet.js";
+import { executeSwap } from "../lib/swap-execute.js";
+import { getEthUsdPriceNumber } from "../lib/oracle.js";
+import { recordXpAction } from "../lib/xp.js";
+import { parseTokenAmountToWei } from "../lib/parse-amount.js";
+import { resolveChainId, getChainOptionsHint, resolveTokenAddress, NATIVE_ETH_0X, EXPLORER_URLS, } from "../constants.js";
+import { getDefaultChainInput } from "./config.js";
+import { out, exitWithError, setJsonMode, isJsonMode, success, usageHint } from "../output.js";
+const ERC20_BALANCE_ABI = ["function balanceOf(address owner) view returns (uint256)"];
+/** Minimum ETH (wei) per buy so 0x doesn't get dust or revert. 0.0001 ETH */
+const MIN_BUY_WEI = 10n ** 14n;
+/** Minimum SPEED (18 decimals) to sell so 0x/DEX doesn't revert. 0.001 SPEED */
+const MIN_SELL_SPEED_WEI = 10n ** 15n;
+function clampBigInt(value, min, max) {
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return value;
+}
+/** Random walk step: currentWei * (1 + uniform(-drift, +drift)), clamped to [minWei, maxWei], never below MIN_BUY_WEI. */
+function nextAmountWei(currentWei, drift, minWei, maxWei) {
+    const multiplier = 1 + (2 * Math.random() - 1) * drift;
+    const scaled = (currentWei * BigInt(Math.round(1000 * multiplier))) / 1000n;
+    const clamped = clampBigInt(scaled, minWei, maxWei);
+    return clamped < MIN_BUY_WEI ? MIN_BUY_WEI : clamped;
+}
+function jitteredDelaySeconds(centerSec, jitterFraction) {
+    const jitter = (2 * Math.random() - 1) * jitterFraction;
+    const sec = centerSec * (1 + jitter);
+    return Math.max(0, sec);
+}
+function sleepMs(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function volumeCmd() {
+    return new Command("volume")
+        .description("Human-like volume: interleaved buys and sells (native ETH ↔ token). Default token is Speed; use --token for others.")
+        .option("-c, --chain <id|name>", "Chain ID or name", "8453")
+        .option("-t, --token <address|speed>", "Token to buy/sell (default: Speed)", "")
+        .option("--ops <n>", "Total number of operations (buy or sell)", "20")
+        .option("-a, --amount <amount>", "Initial ETH per buy in token units (e.g. 0.001, 0.1)", "")
+        .option("--amount-min <amount>", "Min ETH per buy (e.g. 0.0005)", "")
+        .option("--amount-max <amount>", "Max ETH per buy (e.g. 0.002)", "")
+        .option("--amount-drift <fraction>", "Max relative step per buy (e.g. 0.1 = ±10%)", "0.1")
+        .option("--sell-frequency <0..1>", "Probability next op is a sell (e.g. 0.2 = 1 in 5)", "0.2")
+        .option("--sell-partial-chance <0..1>", "When selling, probability of selling partial balance", "0.3")
+        .option("--delay <seconds>", "Center of delay between ops (seconds)", "0")
+        .option("--delay-jitter <fraction>", "Variance around delay (e.g. 0.5 = ±50%)", "0.5")
+        .option("--dry-run", "Do not send any transactions")
+        .action(async function (opts) {
+        setJsonMode(this.parent?.opts().json ?? false);
+        const chainId = resolveChainId(opts.chain ?? getDefaultChainInput());
+        if (chainId === null) {
+            exitWithError(`Unknown chain "${opts.chain}". Use one of: ${getChainOptionsHint()}.${usageHint("volume")}`, "INVALID_CHAIN");
+        }
+        const ops = parseInt(String(opts.ops ?? "20"), 10);
+        if (!Number.isInteger(ops) || ops < 1) {
+            exitWithError("--ops must be an integer >= 1." + usageHint("volume"), "INVALID_OPS");
+        }
+        if (!opts.amount?.trim()) {
+            exitWithError("--amount is required (initial ETH per buy). Example: speed volume -c base -a 0.001 --ops 20", "MISSING_ARGS");
+        }
+        const tokenAddress = resolveTokenAddress(opts.token);
+        const amountWei = parseTokenAmountToWei(opts.amount.trim());
+        let amountMinWei;
+        let amountMaxWei;
+        if (opts.amountMin?.trim() && opts.amountMax?.trim()) {
+            amountMinWei = BigInt(parseTokenAmountToWei(opts.amountMin.trim()));
+            amountMaxWei = BigInt(parseTokenAmountToWei(opts.amountMax.trim()));
+        }
+        else {
+            const initial = BigInt(amountWei);
+            amountMinWei = (initial * 50n) / 100n;
+            amountMaxWei = (initial * 150n) / 100n;
+        }
+        if (amountMinWei >= amountMaxWei) {
+            exitWithError("--amount-min must be less than --amount-max." + usageHint("volume"), "INVALID_AMOUNT");
+        }
+        if (amountMinWei < MIN_BUY_WEI) {
+            amountMinWei = MIN_BUY_WEI;
+        }
+        if (amountMaxWei < MIN_BUY_WEI) {
+            exitWithError(`Amount bounds must be at least ${ethers.formatEther(MIN_BUY_WEI.toString())} ETH.` + usageHint("volume"), "INVALID_AMOUNT");
+        }
+        const amountDrift = parseFloat(opts.amountDrift ?? "0.1");
+        const sellFrequency = parseFloat(opts.sellFrequency ?? "0.2");
+        const sellPartialChance = parseFloat(opts.sellPartialChance ?? "0.3");
+        const delaySec = parseFloat(opts.delay ?? "0");
+        const delayJitter = parseFloat(opts.delayJitter ?? "0.5");
+        if (opts.dryRun) {
+            if (isJsonMode()) {
+                out({
+                    dryRun: true,
+                    chainId,
+                    token: tokenAddress,
+                    ops,
+                    amountWei,
+                    amountMinWei: amountMinWei.toString(),
+                    amountMaxWei: amountMaxWei.toString(),
+                    amountDrift,
+                    sellFrequency,
+                    sellPartialChance,
+                    delaySec,
+                    delayJitter,
+                });
+            }
+            else {
+                out(`Dry run: ${ops} ops (buys + sells), initial amount ${ethers.formatEther(amountWei)} ETH`);
+                out(`Amount walk: [${ethers.formatEther(amountMinWei.toString())}, ${ethers.formatEther(amountMaxWei.toString())}] ETH, drift ±${amountDrift * 100}%`);
+                out(`Sell frequency: ${sellFrequency * 100}%, partial sell chance: ${sellPartialChance * 100}%`);
+                out(`Delay: ${delaySec}s ± ${delayJitter * 100}% jitter`);
+                out("Re-run without --dry-run to execute.");
+            }
+            return;
+        }
+        const signer = getSigner(chainId);
+        const taker = await signer.getAddress();
+        const tokenContract = new ethers.Contract(tokenAddress, ERC20_BALANCE_ABI, signer);
+        let ethUsd = 0;
+        try {
+            ethUsd = await getEthUsdPriceNumber(chainId);
+        }
+        catch (_) { }
+        let currentAmountWei = BigInt(amountWei);
+        const results = [];
+        const failures = [];
+        let buysDone = 0;
+        let sellsDone = 0;
+        for (let op = 1; op <= ops; op++) {
+            const isSell = Math.random() < sellFrequency;
+            if (isSell) {
+                const balance = await tokenContract.balanceOf(taker);
+                if (balance === 0n || balance < MIN_SELL_SPEED_WEI) {
+                    if (!isJsonMode())
+                        out(`Op ${op}/${ops} sell skipped (token balance below minimum ${ethers.formatUnits(MIN_SELL_SPEED_WEI, 18)})`);
+                    if (op < ops)
+                        await sleepMs(jitteredDelaySeconds(delaySec, delayJitter) * 1000);
+                    continue;
+                }
+                const doPartial = Math.random() < sellPartialChance;
+                let sellAmountWei = doPartial
+                    ? (balance * BigInt(Math.floor(200 + Math.random() * 600))) /* [0.2, 0.8] * 1000 */ / 1000n
+                    : balance;
+                if (sellAmountWei < MIN_SELL_SPEED_WEI) {
+                    sellAmountWei = MIN_SELL_SPEED_WEI;
+                }
+                if (sellAmountWei > balance) {
+                    sellAmountWei = balance;
+                }
+                if (sellAmountWei <= 0n || sellAmountWei < MIN_SELL_SPEED_WEI) {
+                    if (op < ops)
+                        await sleepMs(jitteredDelaySeconds(delaySec, delayJitter) * 1000);
+                    continue;
+                }
+                const spinner = isJsonMode() ? null : ora(`Op ${op}/${ops} sell ${doPartial ? "partial" : "all"}...`).start();
+                try {
+                    const { txHash, quote } = await executeSwap(chainId, signer, tokenAddress, NATIVE_ETH_0X, sellAmountWei.toString());
+                    if (spinner)
+                        spinner.succeed(`Op ${op}/${ops} sell confirmed`);
+                    results.push({ op, phase: "sell", txHash, amountWei: sellAmountWei.toString(), partial: doPartial });
+                    sellsDone++;
+                    try {
+                        // Use executed swap value: ETH received (quote.buyAmount) × ETH price
+                        const ethReceived = parseFloat(ethers.formatEther(quote.buyAmount));
+                        const usd = ethReceived * ethUsd;
+                        recordXpAction("volumeOp", usd);
+                    }
+                    catch (_) { }
+                }
+                catch (e) {
+                    if (spinner)
+                        spinner.fail(`Op ${op}/${ops} sell failed`);
+                    const msg = e instanceof Error ? e.message : String(e);
+                    failures.push({ op, phase: "sell", error: msg });
+                    if (!isJsonMode())
+                        out(`  → ${msg.slice(0, 80)}${msg.length > 80 ? "…" : ""}`);
+                }
+            }
+            else {
+                const buyAmountWei = currentAmountWei < MIN_BUY_WEI ? MIN_BUY_WEI : currentAmountWei;
+                const spinner = isJsonMode() ? null : ora(`Op ${op}/${ops} buy...`).start();
+                try {
+                    const { txHash, quote } = await executeSwap(chainId, signer, NATIVE_ETH_0X, tokenAddress, buyAmountWei.toString());
+                    if (spinner)
+                        spinner.succeed(`Op ${op}/${ops} buy confirmed`);
+                    results.push({ op, phase: "buy", txHash, amountWei: buyAmountWei.toString() });
+                    buysDone++;
+                    currentAmountWei = nextAmountWei(buyAmountWei, amountDrift, amountMinWei, amountMaxWei);
+                    try {
+                        // Use executed swap value: ETH sold (quote.sellAmount) × ETH price
+                        const ethSold = parseFloat(ethers.formatEther(quote.sellAmount));
+                        const usd = ethSold * ethUsd;
+                        recordXpAction("volumeOp", usd);
+                    }
+                    catch (_) { }
+                }
+                catch (e) {
+                    if (spinner)
+                        spinner.fail(`Op ${op}/${ops} buy failed`);
+                    const msg = e instanceof Error ? e.message : String(e);
+                    failures.push({ op, phase: "buy", error: msg });
+                    if (!isJsonMode())
+                        out(`  → ${msg.slice(0, 80)}${msg.length > 80 ? "…" : ""}`);
+                }
+            }
+            if (op < ops) {
+                const waitSec = jitteredDelaySeconds(delaySec, delayJitter);
+                if (waitSec > 0)
+                    await sleepMs(waitSec * 1000);
+            }
+        }
+        const explorer = EXPLORER_URLS[chainId];
+        const failedCount = failures.length;
+        if (isJsonMode()) {
+            out({
+                summary: { buys: buysDone, sells: sellsDone, failed: failedCount, totalOps: ops },
+                results: results.map((r) => ({
+                    ...r,
+                    explorerLink: r.txHash && explorer ? `${explorer}/tx/${r.txHash}` : r.txHash,
+                })),
+                failures: failures.length ? failures : undefined,
+            });
+        }
+        else {
+            success(`Volume complete: ${buysDone} buys, ${sellsDone} sells${failedCount ? `, ${failedCount} failed` : ""} (${ops} ops)`);
+            results.forEach((r) => {
+                if (r.txHash) {
+                    const link = explorer ? `${explorer}/tx/${r.txHash}` : r.txHash;
+                    out(`  ${r.phase} op ${r.op}: ${link}`);
+                }
+            });
+            if (failures.length) {
+                out(`Failed: ${failures.map((f) => `op ${f.op} (${f.phase})`).join(", ")}`);
+            }
+        }
+    });
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function whoamiCmd(): Command;

package/dist/commands/whoami.js

@@ -0,0 +1,23 @@
+import { Command } from "commander";
+import { getAddress } from "../wallet.js";
+import { out, exitWithError, isJsonMode, setJsonMode } from "../output.js";
+export function whoamiCmd() {
+    return new Command("whoami")
+        .description("Print address derived from PRIVATE_KEY (sanity check; no tx)")
+        .action(async function () {
+        setJsonMode(this.parent?.opts().json ?? false);
+        try {
+            const address = getAddress();
+            if (isJsonMode()) {
+                out({ address });
+            }
+            else {
+                out(address);
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            exitWithError(`${msg} Set PRIVATE_KEY in env or run: speed setup`, "PRIVATE_KEY_MISSING");
+        }
+    });
+}

package/dist/commands/xp.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function xpCmd(): Command;

package/dist/commands/xp.js

@@ -0,0 +1,56 @@
+import { Command } from "commander";
+import { loadXpState, resetXpState, getTitleForLevel, getProgressInLevel, getXpForNextLevel, } from "../lib/xp.js";
+import { out, setJsonMode, isJsonMode, success } from "../output.js";
+export function xpCmd() {
+    return new Command("xp")
+        .description("Show XP progress: level, streak, stats. Bots use this to see how they're doing.")
+        .option("--no-title", "Omit the silly level title")
+        .option("--reset", "Clear all XP and stats (back to level 1)")
+        .action(async function (opts) {
+        setJsonMode(this.parent?.opts().json ?? false);
+        if (opts.reset) {
+            resetXpState();
+            if (isJsonMode()) {
+                out({ reset: true });
+            }
+            else {
+                success("XP cleared. You're back to level 1.");
+            }
+            return;
+        }
+        const state = loadXpState();
+        const level = state.level;
+        const progress = getProgressInLevel(state.totalXP);
+        const title = getTitleForLevel(level);
+        const nextXp = getXpForNextLevel(level);
+        if (isJsonMode()) {
+            out({
+                totalXP: state.totalXP,
+                level: state.level,
+                title: opts.title !== false ? title : undefined,
+                streak: state.streak,
+                lastActivity: state.lastActivity || undefined,
+                progress: { current: progress.current, needed: progress.needed, fraction: progress.fraction },
+                stats: state.stats,
+                recentHistory: state.history.slice(-10),
+            });
+            return;
+        }
+        if (opts.title !== false) {
+            out(`\n  ╭─────────────────────────────╮`);
+            out(`  │  Level ${String(level).padStart(3)}  ${title.padEnd(18)}  │`);
+            out(`  ╰─────────────────────────────╯\n`);
+        }
+        out(`  Total XP: ${state.totalXP.toLocaleString()}`);
+        out(`  Progress: ${progress.current} / ${nextXp} XP to level ${level + 1} (${(progress.fraction * 100).toFixed(0)}%)`);
+        out(`  Streak:   ${state.streak} day(s)  │  Last activity: ${state.lastActivity || "—"}`);
+        out("");
+        out("  Stats:");
+        out(`    Swaps:      ${state.stats.swaps.count}  ($${state.stats.swaps.totalUSD.toFixed(0)} total)`);
+        out(`    Bridges:    ${state.stats.bridges.count}  ($${state.stats.bridges.totalUSD.toFixed(0)} total)`);
+        out(`    Volume ops: ${state.stats.volumeOps.count}  ($${state.stats.volumeOps.totalUSD.toFixed(0)} total)`);
+        out(`    DCA buys:   ${state.stats.dcaBuys.count}  ($${state.stats.dcaBuys.totalUSD.toFixed(0)} total)`);
+        out(`    Gas refuel: ${state.stats.gasRefuels.count}  ($${state.stats.gasRefuels.totalUSD.toFixed(0)} total)`);
+        out("");
+    });
+}

package/dist/constants.d.ts

@@ -0,0 +1,66 @@
+/** Speed Token address (same on supported chains where applicable) */
+export declare const SPEED_TOKEN_ADDRESS = "0xB01CF1bE9568f09449382a47Cd5bF58e2A9D5922";
+/** 0x API uses this address for native ETH (sell-token in quotes) */
+export declare const NATIVE_ETH_0X = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+/** Supported chain IDs: Ethereum, Base, OP, Arbitrum, Polygon, BNB */
+export declare const SUPPORTED_CHAIN_IDS: readonly [1, 8453, 10, 42161, 137, 56];
+export type SupportedChainId = (typeof SUPPORTED_CHAIN_IDS)[number];
+/** Chain ID to primary display name */
+export declare const CHAIN_NAMES: Record<number, string>;
+/** Name/alias (lowercase) to chain ID. Use resolveChainId() for parsing. */
+export declare const CHAIN_NAME_TO_ID: Record<string, number>;
+/**
+ * Resolve chain from ID number or name (e.g. "8453", "base", "ethereum").
+ * Returns the chain ID if supported, otherwise null.
+ */
+export declare function resolveChainId(input: string): SupportedChainId | null;
+/** Resolve token option: empty or "speed" → SPEED_TOKEN_ADDRESS, else return trimmed address. */
+export declare function resolveTokenAddress(input: string | undefined): string;
+/** Human-readable list of supported chains for error messages (e.g. "1 (ethereum), 8453 (base), ...") */
+export declare function getChainOptionsHint(): string;
+/** Alchemy chain prefix for RPC URL */
+export declare const ALCHEMY_CHAIN_PREFIX: Record<number, string>;
+/** One public fallback RPC per chain when Alchemy is not set */
+export declare const PUBLIC_RPC_FALLBACKS: Record<number, string>;
+/** Lightspeed price oracle addresses by chain (same ABI on all) */
+export declare const ORACLE_ADDRESSES: Record<number, string>;
+/** Minimal ABI for oracle reads: getLatestSpeedEthPrice, getLatestSpeedUsdPrice, getEthUsdPrice */
+export declare const ORACLE_ABI: readonly [{
+    readonly inputs: readonly [];
+    readonly name: "getLatestSpeedEthPrice";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getLatestSpeedUsdPrice";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getEthUsdPrice";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+export declare const ZEROX_API_BASE = "https://api.0x.org";
+export declare const SQUID_BASE_URL = "https://v2.api.squidrouter.com";
+/** Native token symbol per chain (for balance display) */
+export declare const NATIVE_SYMBOL: Record<number, string>;
+/** Block explorer base URLs by chain for tx links */
+export declare const EXPLORER_URLS: Record<number, string>;
+/** Wrapped native token address per chain (for gas command: swap Speed → native) */
+export declare const WRAPPED_NATIVE_ADDRESS: Record<number, string>;