@lightspeed-cli/speed-cli 0.1.0

package/dist/commands/pending.js

@@ -0,0 +1,125 @@
+import { Command } from "commander";
+import { getSquid } from "../lib/squid.js";
+import { listPendingBridges, removePendingBridges } from "../lib/pending-bridges.js";
+import { getPendingTxList } from "../lib/alchemy-history.js";
+import { getAddress } from "../wallet.js";
+import { CHAIN_NAMES, SUPPORTED_CHAIN_IDS, EXPLORER_URLS, resolveChainId, getChainOptionsHint } from "../constants.js";
+import { out, exitWithError, setJsonMode, isJsonMode, usageHint } from "../output.js";
+export function pendingCmd() {
+    return new Command("pending")
+        .description("Show in-flight bridge transfers and pending txs")
+        .option("-c, --chain <id|name>", "Chain for pending txs only (omit = all chains)")
+        .option("--no-bridges", "Skip bridge status")
+        .option("--no-txs", "Skip pending tx list")
+        .option("--clear-done", "Remove completed/failed bridges from stored list")
+        .action(async function (opts) {
+        setJsonMode(this.parent?.opts().json ?? false);
+        const showBridges = opts.bridges !== false;
+        const showTxs = opts.txs !== false;
+        const clearDone = opts.clearDone === true;
+        const address = getAddress();
+        const result = {};
+        if (showBridges) {
+            const entries = listPendingBridges();
+            const integratorId = process.env.SQUID_INTEGRATOR_ID?.trim();
+            const bridgeStatuses = [];
+            const toRemove = [];
+            if (integratorId && entries.length > 0) {
+                try {
+                    const squid = await getSquid();
+                    const statusResults = await Promise.allSettled(entries.map((e) => squid.getStatus({
+                        transactionId: e.txHash,
+                        requestId: e.requestId,
+                        integratorId,
+                        quoteId: e.quoteId ?? "",
+                    })));
+                    for (let i = 0; i < entries.length; i++) {
+                        const e = entries[i];
+                        const r = statusResults[i];
+                        if (r?.status === "fulfilled") {
+                            const s = (r.value.squidTransactionStatus ?? "").toLowerCase();
+                            bridgeStatuses.push({
+                                requestId: e.requestId,
+                                status: r.value.squidTransactionStatus,
+                                fromChain: e.fromChain,
+                                toChain: e.toChain,
+                                txHash: e.txHash,
+                            });
+                            if (clearDone && (s.includes("success") || s.includes("complete") || s.includes("failed") || s.includes("error"))) {
+                                toRemove.push(e.requestId);
+                            }
+                        }
+                        else {
+                            bridgeStatuses.push({
+                                requestId: e.requestId,
+                                status: "unknown",
+                                fromChain: e.fromChain,
+                                toChain: e.toChain,
+                                txHash: e.txHash,
+                            });
+                        }
+                    }
+                    if (clearDone && toRemove.length > 0) {
+                        removePendingBridges(toRemove);
+                    }
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    if (!isJsonMode())
+                        out(`Bridge status error: ${msg}`);
+                }
+            }
+            result.bridges = bridgeStatuses;
+            if (!isJsonMode()) {
+                if (bridgeStatuses.length === 0) {
+                    out("No in-flight bridges (or none stored). Run 'speed bridge' to add one.");
+                }
+                else {
+                    out("Bridges:");
+                    for (const b of bridgeStatuses) {
+                        out(`  ${b.fromChain} → ${b.toChain}  ${b.status}  ${b.txHash.slice(0, 10)}...  requestId: ${b.requestId}`);
+                    }
+                }
+            }
+        }
+        if (showTxs) {
+            const resolvedChain = opts.chain !== undefined ? resolveChainId(opts.chain) : null;
+            const chainsToQuery = opts.chain !== undefined
+                ? resolvedChain !== null
+                    ? [resolvedChain]
+                    : []
+                : [...SUPPORTED_CHAIN_IDS];
+            if (opts.chain !== undefined && chainsToQuery.length === 0) {
+                exitWithError(`Unknown chain "${opts.chain}". Use one of: ${getChainOptionsHint()}.${usageHint("pending")}`, "INVALID_CHAIN");
+            }
+            const txLists = await Promise.allSettled(chainsToQuery.map((chainId) => getPendingTxList(chainId, address)));
+            const pendingTxs = [];
+            for (let i = 0; i < chainsToQuery.length; i++) {
+                const chainId = chainsToQuery[i];
+                const result = txLists[i];
+                const list = result?.status === "fulfilled" ? result.value : [];
+                for (const tx of list) {
+                    pendingTxs.push({ chainId, hash: tx.hash, from: tx.from, to: tx.to, value: tx.value });
+                }
+            }
+            result.pendingTxs = pendingTxs;
+            if (!isJsonMode()) {
+                if (showBridges)
+                    out("");
+                if (pendingTxs.length === 0) {
+                    out("No pending txs (Alchemy pending is WebSocket-only).");
+                }
+                else {
+                    out("Pending txs:");
+                    for (const t of pendingTxs) {
+                        const link = EXPLORER_URLS[t.chainId] ? `${EXPLORER_URLS[t.chainId]}/tx/${t.hash}` : t.hash;
+                        out(`  ${CHAIN_NAMES[t.chainId] ?? t.chainId}  ${t.hash.slice(0, 10)}...  ${link}`);
+                    }
+                }
+            }
+        }
+        if (isJsonMode()) {
+            out(result);
+        }
+    });
+}

package/dist/commands/price.d.ts

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

package/dist/commands/price.js

@@ -0,0 +1,35 @@
+import { Command } from "commander";
+import { getOraclePrices, parseEthUsdRaw } from "../lib/oracle.js";
+import { resolveChainId, getChainOptionsHint } from "../constants.js";
+import { getDefaultChainInput } from "./config.js";
+import { out, exitWithError, setJsonMode, isJsonMode, usageHint } from "../output.js";
+export function priceCmd() {
+    return new Command("price")
+        .description("Speed/ETH, Speed/USD, native USD via Lightspeed oracles")
+        .option("-c, --chain <id|name>", "Chain ID or name", "8453")
+        .action(async function (opts) {
+        setJsonMode(this.parent?.opts().json ?? false);
+        const chainId = resolveChainId(opts.chain ?? getDefaultChainInput());
+        if (chainId === null) {
+            exitWithError(`Unknown or unsupported chain: ${opts.chain}. Use: ${getChainOptionsHint()}`, "INVALID_CHAIN");
+        }
+        try {
+            const { speedEth: speedEthRaw, speedUsd: speedUsdRaw, ethUsd: ethUsdRaw } = await getOraclePrices(chainId);
+            const speedEth = Number(speedEthRaw) / 1e18;
+            const speedUsd = Number(speedUsdRaw) / 1e8;
+            const ethUsd = parseEthUsdRaw(ethUsdRaw);
+            if (isJsonMode()) {
+                out({ chainId, speedPerNative: speedEth, speedUsd, nativeUsd: ethUsd });
+            }
+            else {
+                out(`Speed/Native: ${speedEth}`);
+                out(`Speed/USD: $${speedUsd}`);
+                out(`Native/USD: $${ethUsd}`);
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            exitWithError(`${msg}.${usageHint("price")}`, "PRICE_ERROR");
+        }
+    });
+}

package/dist/commands/quote.d.ts

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

package/dist/commands/quote.js

@@ -0,0 +1,54 @@
+import { Command } from "commander";
+import ora from "ora";
+import { getAddress } from "../wallet.js";
+import { get0xQuote } from "../lib/zerox.js";
+import { parseTokenAmountToWei } from "../lib/parse-amount.js";
+import { resolveChainId, getChainOptionsHint } from "../constants.js";
+import { getDefaultChainInput } from "./config.js";
+import { out, exitWithError, setJsonMode, isJsonMode, usageHint } from "../output.js";
+export function quoteCmd() {
+    return new Command("quote")
+        .description("Preview swap (no tx). To execute, use: speed swap --buy <addr> -a <amount> (approve is automatic)")
+        .option("-c, --chain <id|name>", "Chain ID or name", "8453")
+        .option("--sell <address>", "Sell token address (default: Speed)")
+        .option("--buy <address>", "Buy token address")
+        .option("-a, --amount <amount>", "Sell amount in token units (e.g. 0.002, 10000)")
+        .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("quote")}`, "INVALID_CHAIN");
+        }
+        if (!opts.buy || !opts.amount) {
+            exitWithError("--buy and --amount are required", "MISSING_ARGS");
+        }
+        const sellToken = opts.sell?.trim() ?? "0xB01CF1bE9568f09449382a47Cd5bF58e2A9D5922";
+        const buyToken = opts.buy.trim();
+        const amount = parseTokenAmountToWei(opts.amount.trim());
+        try {
+            const spinner = isJsonMode() ? null : ora("Fetching quote...").start();
+            const taker = getAddress();
+            const quote = await get0xQuote(chainId, sellToken, buyToken, amount, taker);
+            if (spinner)
+                spinner.succeed("Quote received");
+            if (isJsonMode()) {
+                out({
+                    sellAmount: quote.sellAmount,
+                    buyAmount: quote.buyAmount,
+                    buyToken: quote.buyToken,
+                    sellToken: quote.sellToken,
+                    gas: quote.gas,
+                    to: quote.transaction?.to,
+                });
+            }
+            else {
+                out(`Buy amount: ${quote.buyAmount}`);
+                out(`Gas estimate: ${quote.gas}`);
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            exitWithError(`${msg}.${usageHint("quote")}`, "QUOTE_ERROR");
+        }
+    });
+}

package/dist/commands/revoke.d.ts

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

package/dist/commands/revoke.js

@@ -0,0 +1,38 @@
+import { Command } from "commander";
+import { ethers } from "ethers";
+import { getSigner } from "../wallet.js";
+import { resolveChainId, getChainOptionsHint } from "../constants.js";
+import { getDefaultChainInput } from "./config.js";
+import { out, exitWithError, setJsonMode, isJsonMode, success, usageHint } from "../output.js";
+const ERC20_ABI = ["function approve(address spender, uint256 amount) returns (bool)"];
+export function revokeCmd() {
+    return new Command("revoke")
+        .description("Set allowance back to 0 for a spender (security hygiene)")
+        .option("-c, --chain <id|name>", "Chain ID or name", "8453")
+        .requiredOption("--token <address>", "Token contract address")
+        .requiredOption("--spender <address>", "Spender address to revoke (e.g. 0x AllowanceHolder)")
+        .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()}. Example: speed revoke -c base --token <addr> --spender <addr>`, "INVALID_CHAIN");
+        }
+        try {
+            const signer = getSigner(chainId);
+            const token = new ethers.Contract(opts.token.trim(), ERC20_ABI, signer);
+            const tx = await token.approve(opts.spender.trim(), 0n);
+            await tx.wait();
+            if (isJsonMode()) {
+                out({ txHash: tx.hash, token: opts.token, spender: opts.spender });
+            }
+            else {
+                success(`Revoked allowance for ${opts.spender} on ${opts.token}`);
+                out(`Tx: ${tx.hash}`);
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            exitWithError(`${msg}.${usageHint("revoke")}`, "REVOKE_ERROR");
+        }
+    });
+}

package/dist/commands/send.d.ts

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

package/dist/commands/send.js

@@ -0,0 +1,43 @@
+import { Command } from "commander";
+import { ethers } from "ethers";
+import { getSigner } from "../wallet.js";
+import { parseTokenAmountToWei } from "../lib/parse-amount.js";
+import { EXPLORER_URLS, SPEED_TOKEN_ADDRESS, resolveChainId, getChainOptionsHint } from "../constants.js";
+import { getDefaultChainInput } from "./config.js";
+import { out, exitWithError, setJsonMode, isJsonMode, success, usageHint } from "../output.js";
+const ERC20_ABI = ["function transfer(address to, uint256 amount) returns (bool)"];
+export function sendCmd() {
+    return new Command("send")
+        .description("Plain ERC-20 transfer of Speed to an address")
+        .option("-c, --chain <id|name>", "Chain ID or name", "8453")
+        .requiredOption("-t, --to <address>", "Recipient address")
+        .requiredOption("-a, --amount <amount>", "Amount of SPEED to send (e.g. 0.1, 1000)")
+        .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()}. Example: speed send -c base -t <to-address> -a 1000`, "INVALID_CHAIN");
+        }
+        try {
+            const signer = getSigner(chainId);
+            const token = new ethers.Contract(SPEED_TOKEN_ADDRESS, ERC20_ABI, signer);
+            const amountWei = parseTokenAmountToWei(opts.amount.trim());
+            const tx = await token.transfer(opts.to.trim(), amountWei);
+            await tx.wait();
+            const explorer = EXPLORER_URLS[chainId];
+            const link = explorer ? `${explorer}/tx/${tx.hash}` : tx.hash;
+            if (isJsonMode()) {
+                out({ txHash: tx.hash, explorerLink: link });
+            }
+            else {
+                success(`Sent. Tx: ${tx.hash}`);
+                if (explorer)
+                    out(link);
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            exitWithError(`${msg}.${usageHint("send")}`, "SEND_ERROR");
+        }
+    });
+}

package/dist/commands/setup.d.ts

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

package/dist/commands/setup.js

@@ -0,0 +1,104 @@
+import { Command } from "commander";
+import { createInterface } from "readline";
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import { ethers } from "ethers";
+import { getEnvPath, getSpeedConfigDir } from "../env.js";
+import { out, exitWithError, setJsonMode, isJsonMode, success } from "../output.js";
+const ENV_KEYS = [
+    { key: "PRIVATE_KEY", label: "Wallet private key (hex, or leave blank to generate a new bot wallet)", required: false },
+    { key: "0X_API_KEY", label: "0x API key (https://dashboard.0x.org/)", required: true },
+    { key: "SQUID_INTEGRATOR_ID", label: "Squid integrator ID (https://docs.squidrouter.com)", required: true },
+    { key: "ALCHEMY_API_KEY", label: "Alchemy API key (https://dashboard.alchemy.com/)", required: true },
+];
+function question(rl, prompt) {
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            resolve((answer ?? "").trim());
+        });
+    });
+}
+function escapeEnvValue(value) {
+    const trimmed = value.replace(/\r?\n/g, "").trim();
+    if (trimmed === "")
+        return '""';
+    if (/[\s#"\\]/.test(trimmed)) {
+        return '"' + trimmed.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
+    }
+    return trimmed;
+}
+export function setupCmd() {
+    return new Command("setup")
+        .description("Interactively set secrets; writes to ~/.speed/.env (run when env is not set)")
+        .option("--force", "Overwrite existing .env (default: prompt to merge)")
+        .action(async function (opts) {
+        setJsonMode(this.parent?.opts().json ?? false);
+        if (isJsonMode()) {
+            exitWithError("Setup is interactive; omit --json. Example: speed setup", "INVALID_MODE");
+        }
+        const envPath = getEnvPath();
+        const dir = getSpeedConfigDir();
+        const existing = {};
+        if (existsSync(envPath)) {
+            const raw = readFileSync(envPath, "utf-8");
+            for (const line of raw.split(/\r?\n/)) {
+                const m = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+                if (m) {
+                    const v = m[2].replace(/^["']|["']$/g, "").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+                    existing[m[1]] = v;
+                }
+            }
+            if (!opts.force) {
+                out(`Found existing ${envPath}`);
+                out("Leave a prompt blank to keep current value.");
+            }
+        }
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const next = { ...existing };
+        for (const { key, label, required } of ENV_KEYS) {
+            const current = existing[key];
+            const hint = current ? ` [current: ${current.slice(0, 8)}...]` : "";
+            const prompt = `${label}${hint}: `;
+            const answer = await question(rl, prompt);
+            if (answer !== "") {
+                next[key] = answer;
+            }
+            else if (current) {
+                next[key] = current;
+            }
+            else if (required) {
+                rl.close();
+                exitWithError(`Missing required value for ${key}. Re-run: speed setup`, "SETUP_INCOMPLETE");
+            }
+        }
+        rl.close();
+        if (!next.PRIVATE_KEY?.trim()) {
+            const wallet = ethers.Wallet.createRandom();
+            const pk = wallet.privateKey;
+            next.PRIVATE_KEY = pk.startsWith("0x") ? pk : `0x${pk}`;
+            if (!isJsonMode()) {
+                success("Created new bot wallet (no private key provided).");
+                out(`Address: ${wallet.address}`);
+                out("Fund this address to use swap/bridge/send.");
+            }
+        }
+        const missing = ENV_KEYS.filter(({ key, required }) => required && !next[key]);
+        if (missing.length > 0) {
+            exitWithError(`Missing required: ${missing.map((m) => m.key).join(", ")}. Re-run: speed setup`, "SETUP_INCOMPLETE");
+        }
+        const apiKey = next["0X_API_KEY"] ?? "";
+        const lines = [
+            "# Generated by speed setup. Do not commit.",
+            "",
+            `PRIVATE_KEY=${escapeEnvValue(next.PRIVATE_KEY ?? "")}`,
+            `0X_API_KEY=${escapeEnvValue(apiKey)}`,
+            `OX_API_KEY=${escapeEnvValue(apiKey)}`,
+            `SQUID_INTEGRATOR_ID=${escapeEnvValue(next.SQUID_INTEGRATOR_ID ?? "")}`,
+            `ALCHEMY_API_KEY=${escapeEnvValue(next.ALCHEMY_API_KEY ?? "")}`,
+            "",
+        ];
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(envPath, lines.join("\n"), "utf-8");
+        success(`Wrote ${envPath}`);
+        out("Run 'speed whoami' or 'speed doctor' to verify.");
+    });
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,64 @@
+import { Command } from "commander";
+import { getSquid } from "../lib/squid.js";
+import { resolveChainId, getChainOptionsHint } from "../constants.js";
+import { getDefaultChainInput } from "./config.js";
+import { out, exitWithError, setJsonMode, isJsonMode, usageHint } from "../output.js";
+export function statusCmd() {
+    return new Command("status")
+        .description("Check tx confirmation; for bridge, poll Squid getStatus")
+        .requiredOption("--tx <hash>", "Transaction hash")
+        .option("-c, --chain <id|name>", "Chain ID or name (for non-bridge tx)")
+        .option("--request-id <id>", "Squid request ID (for bridge)")
+        .option("--quote-id <id>", "Squid quote ID (for bridge)")
+        .action(async function (opts) {
+        setJsonMode(this.parent?.opts().json ?? false);
+        const txHash = opts.tx.trim();
+        const integratorId = process.env.SQUID_INTEGRATOR_ID?.trim();
+        if (opts.requestId && integratorId) {
+            try {
+                const squid = await getSquid();
+                const status = await squid.getStatus({
+                    transactionId: txHash,
+                    requestId: opts.requestId,
+                    integratorId,
+                    quoteId: opts.quoteId ?? "",
+                });
+                if (isJsonMode()) {
+                    out({ status: status.squidTransactionStatus, ...status });
+                }
+                else {
+                    out(`Bridge status: ${status.squidTransactionStatus}`);
+                }
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                exitWithError(`${msg}.${usageHint("status")}`, "STATUS_ERROR");
+            }
+            return;
+        }
+        const chainId = resolveChainId(opts.chain ?? getDefaultChainInput());
+        if (chainId === null) {
+            exitWithError(`Unknown chain "${opts.chain}". Use one of: ${getChainOptionsHint()}. Example: speed status --tx <hash> -c base`, "INVALID_CHAIN");
+        }
+        try {
+            const { getSigner } = await import("../wallet.js");
+            const { getRpcUrl } = await import("../rpc.js");
+            const { ethers } = await import("ethers");
+            const provider = new ethers.JsonRpcProvider(getRpcUrl(chainId));
+            const receipt = await provider.getTransactionReceipt(txHash);
+            if (isJsonMode()) {
+                out({
+                    blockNumber: receipt?.blockNumber?.toString(),
+                    status: receipt?.status === 1 ? "confirmed" : receipt ? "reverted" : "pending",
+                });
+            }
+            else {
+                out(receipt ? `Status: ${receipt.status === 1 ? "confirmed" : "reverted"} Block: ${receipt.blockNumber}` : "Pending or not found");
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            exitWithError(`${msg}.${usageHint("status")}`, "STATUS_ERROR");
+        }
+    });
+}

package/dist/commands/swap.d.ts

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