@lightspeed-cli/speed-cli 0.1.0

package/dist/constants.js

@@ -0,0 +1,135 @@
+/** Speed Token address (same on supported chains where applicable) */
+export const SPEED_TOKEN_ADDRESS = "0xB01CF1bE9568f09449382a47Cd5bF58e2A9D5922";
+/** 0x API uses this address for native ETH (sell-token in quotes) */
+export const NATIVE_ETH_0X = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+/** Supported chain IDs: Ethereum, Base, OP, Arbitrum, Polygon, BNB */
+export const SUPPORTED_CHAIN_IDS = [1, 8453, 10, 42161, 137, 56];
+/** Chain ID to primary display name */
+export const CHAIN_NAMES = {
+    1: "ethereum",
+    8453: "base",
+    10: "optimism",
+    42161: "arbitrum",
+    137: "polygon",
+    56: "bnb",
+};
+/** Name/alias (lowercase) to chain ID. Use resolveChainId() for parsing. */
+export const CHAIN_NAME_TO_ID = {
+    ethereum: 1,
+    eth: 1,
+    mainnet: 1,
+    base: 8453,
+    optimism: 10,
+    op: 10,
+    arbitrum: 42161,
+    arb: 42161,
+    polygon: 137,
+    matic: 137,
+    bnb: 56,
+    bsc: 56,
+};
+/**
+ * Resolve chain from ID number or name (e.g. "8453", "base", "ethereum").
+ * Returns the chain ID if supported, otherwise null.
+ */
+export function resolveChainId(input) {
+    const s = input.trim();
+    if (/^\d+$/.test(s)) {
+        const id = parseInt(s, 10);
+        return SUPPORTED_CHAIN_IDS.includes(id) ? id : null;
+    }
+    const id = CHAIN_NAME_TO_ID[s.toLowerCase()];
+    return id != null && SUPPORTED_CHAIN_IDS.includes(id) ? id : null;
+}
+/** Resolve token option: empty or "speed" → SPEED_TOKEN_ADDRESS, else return trimmed address. */
+export function resolveTokenAddress(input) {
+    if (!input?.trim())
+        return SPEED_TOKEN_ADDRESS;
+    if (input.trim().toLowerCase() === "speed")
+        return SPEED_TOKEN_ADDRESS;
+    return input.trim();
+}
+/** Human-readable list of supported chains for error messages (e.g. "1 (ethereum), 8453 (base), ...") */
+export function getChainOptionsHint() {
+    return SUPPORTED_CHAIN_IDS.map((id) => `${id} (${CHAIN_NAMES[id]})`).join(", ");
+}
+/** Alchemy chain prefix for RPC URL */
+export const ALCHEMY_CHAIN_PREFIX = {
+    1: "eth",
+    10: "opt",
+    137: "polygon",
+    42161: "arb",
+    56: "bnb",
+    8453: "base",
+};
+/** One public fallback RPC per chain when Alchemy is not set */
+export const PUBLIC_RPC_FALLBACKS = {
+    1: "https://eth.llamarpc.com",
+    10: "https://mainnet.optimism.io",
+    137: "https://polygon.llamarpc.com",
+    42161: "https://arb1.arbitrum.io/rpc",
+    56: "https://bsc-dataseed.binance.org",
+    8453: "https://mainnet.base.org",
+};
+/** Lightspeed price oracle addresses by chain (same ABI on all) */
+export const ORACLE_ADDRESSES = {
+    8453: "0xFc89e7541339499a3c3e0030825DaaD67a52CBd4",
+    1: "0x73f7a22c2fa57c09d292c20627a6e01c791b95ea",
+    56: "0x2529107fdb6d2dee755540653e538ccb99641d55",
+    10: "0x8c584569fcbfbd0b57c991973b92a981a23deaf9",
+    42161: "0x11a1ad1d0d83cd85cc37b7be9b98d37ec07bf66c",
+    137: "0x3e3b0dCdF39F5D9D2179eB72fE1E71D303523941",
+};
+/** Minimal ABI for oracle reads: getLatestSpeedEthPrice, getLatestSpeedUsdPrice, getEthUsdPrice */
+export const ORACLE_ABI = [
+    {
+        inputs: [],
+        name: "getLatestSpeedEthPrice",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getLatestSpeedUsdPrice",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getEthUsdPrice",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+export const ZEROX_API_BASE = "https://api.0x.org";
+export const SQUID_BASE_URL = "https://v2.api.squidrouter.com";
+/** Native token symbol per chain (for balance display) */
+export const NATIVE_SYMBOL = {
+    1: "ETH",
+    8453: "ETH",
+    10: "ETH",
+    42161: "ETH",
+    137: "MATIC",
+    56: "BNB",
+};
+/** Block explorer base URLs by chain for tx links */
+export const EXPLORER_URLS = {
+    1: "https://etherscan.io",
+    8453: "https://basescan.org",
+    10: "https://optimistic.etherscan.io",
+    42161: "https://arbiscan.io",
+    137: "https://polygonscan.com",
+    56: "https://bscscan.com",
+};
+/** Wrapped native token address per chain (for gas command: swap Speed → native) */
+export const WRAPPED_NATIVE_ADDRESS = {
+    1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    8453: "0x4200000000000000000000000000000000000006",
+    10: "0x4200000000000000000000000000000000000006",
+    42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    137: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+    56: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+};

package/dist/env.d.ts

@@ -0,0 +1,10 @@
+/** Path to ~/.speed (or SPEED_CONFIG_DIR). */
+export declare function getSpeedConfigDir(): string;
+/** Path to ~/.speed/.env (secrets from `speed setup`). */
+export declare function getEnvPath(): string;
+/**
+ * Load env: first ~/.speed/.env (from speed setup), then .env in cwd.
+ * Cwd .env overrides. Call once at CLI startup.
+ * Keys like 0X_API_KEY are applied manually because dotenv does not load names starting with a digit.
+ */
+export declare function loadEnv(): void;

package/dist/env.js

@@ -0,0 +1,58 @@
+import { config as dotenvConfig } from "dotenv";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const SPEED_CONFIG_DIR = process.env.SPEED_CONFIG_DIR ?? join(homedir(), ".speed");
+/** Path to ~/.speed (or SPEED_CONFIG_DIR). */
+export function getSpeedConfigDir() {
+    return SPEED_CONFIG_DIR;
+}
+/** Path to ~/.speed/.env (secrets from `speed setup`). */
+export function getEnvPath() {
+    return join(SPEED_CONFIG_DIR, ".env");
+}
+/** Dotenv skips keys that start with a digit (e.g. 0X_API_KEY). Apply from file manually. */
+function applyNumericPrefixedKeys(envPath) {
+    try {
+        let raw = readFileSync(envPath, "utf-8");
+        raw = raw.replace(/^\uFEFF/, ""); // strip BOM (Windows can add it)
+        for (const line of raw.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("#"))
+                continue;
+            const idx = trimmed.indexOf("0X_API_KEY=");
+            const idxAlt = trimmed.indexOf("OX_API_KEY=");
+            const keyStart = idx >= 0 ? idx : idxAlt >= 0 ? idxAlt : -1;
+            if (keyStart >= 0) {
+                const eq = trimmed.indexOf("=", keyStart);
+                const rest = trimmed.slice(eq + 1).trim();
+                const v = rest.replace(/^["']|["']$/g, "").replace(/\\"/g, '"').replace(/\\\\/g, "\\").trim();
+                if (v !== "") {
+                    process.env["0X_API_KEY"] = v;
+                    process.env["OX_API_KEY"] = v;
+                }
+                break;
+            }
+        }
+    }
+    catch {
+        // ignore read errors (e.g. missing file, permissions)
+    }
+}
+/**
+ * Load env: first ~/.speed/.env (from speed setup), then .env in cwd.
+ * Cwd .env overrides. Call once at CLI startup.
+ * Keys like 0X_API_KEY are applied manually because dotenv does not load names starting with a digit.
+ */
+export function loadEnv() {
+    const globalPath = getEnvPath();
+    applyNumericPrefixedKeys(globalPath); // always try (dotenv skips 0X_API_KEY; file may exist even if path differs)
+    if (existsSync(globalPath)) {
+        dotenvConfig({ path: globalPath });
+    }
+    dotenvConfig(); // cwd .env
+    const cwdEnv = join(process.cwd(), ".env");
+    if (existsSync(cwdEnv)) {
+        applyNumericPrefixedKeys(cwdEnv); // cwd can override (empty values do not override)
+    }
+}

package/dist/lib/alchemy-history.d.ts

@@ -0,0 +1,24 @@
+/** Normalized transfer/tx for history display (Alchemy getAssetTransfers shape). */
+export interface TransferEntry {
+    hash: string;
+    from: string;
+    to: string;
+    value: string;
+    blockNumber: string;
+    timeStamp: string;
+    category?: string;
+    /** "in" | "out" relative to the queried address */
+    direction?: "in" | "out";
+    /** Display symbol: ETH, SPEED, or token address slice */
+    symbol?: string;
+}
+/** Fetch transfer history for address via Alchemy getAssetTransfers (uses ALCHEMY_API_KEY / getRpcUrl). */
+export declare function getTransfers(chainId: number, address: string, options?: {
+    limit?: number;
+    pageKey?: string;
+}): Promise<{
+    transfers: TransferEntry[];
+    pageKey?: string;
+}>;
+/** Pending txs for address: Alchemy exposes this only via WebSocket (alchemy_pendingTransactions). Return empty for REST. */
+export declare function getPendingTxList(_chainId: number, _address: string): Promise<TransferEntry[]>;

package/dist/lib/alchemy-history.js

@@ -0,0 +1,75 @@
+import { getRpcUrl } from "../rpc.js";
+import { SPEED_TOKEN_ADDRESS } from "../constants.js";
+/** Fetch transfer history for address via Alchemy getAssetTransfers (uses ALCHEMY_API_KEY / getRpcUrl). */
+export async function getTransfers(chainId, address, options = {}) {
+    const url = getRpcUrl(chainId);
+    const maxCount = Math.min(options.limit ?? 20, 100);
+    // Alchemy: 'internal' category only supported for ETH (1) and MATIC (137)
+    const categories = chainId === 1 || chainId === 137
+        ? ["external", "internal", "erc20", "erc721", "erc1155"]
+        : ["external", "erc20", "erc721", "erc1155"];
+    const params = {
+        fromAddress: address,
+        fromBlock: "0x0",
+        toBlock: "latest",
+        maxCount: "0x" + maxCount.toString(16),
+        category: categories,
+        order: "desc",
+        withMetadata: true,
+    };
+    if (options.pageKey)
+        params.pageKey = options.pageKey;
+    const body = {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "alchemy_getAssetTransfers",
+        params: [params],
+    };
+    const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Alchemy API error: ${res.status}`);
+    const data = (await res.json());
+    if (data.error)
+        throw new Error(`Alchemy: ${data.error.message}`);
+    const result = data.result;
+    if (!result?.transfers)
+        return { transfers: [] };
+    const addrLower = address.toLowerCase();
+    const transfers = result.transfers.map((t) => {
+        const from = (t.from ?? "").toLowerCase();
+        const to = (t.to ?? "").toLowerCase();
+        const direction = to === addrLower ? "in" : from === addrLower ? "out" : "in";
+        let symbol = t.asset ?? "";
+        if (!symbol && t.category) {
+            if (t.category === "external" || t.category === "internal")
+                symbol = "ETH";
+            else if (t.category === "erc20" && t.rawContract?.address) {
+                symbol = t.rawContract.address.toLowerCase() === SPEED_TOKEN_ADDRESS.toLowerCase() ? "SPEED" : `${t.rawContract.address.slice(0, 6)}…${t.rawContract.address.slice(-4)}`;
+            }
+            else if (t.category === "erc20")
+                symbol = "ERC20";
+            else
+                symbol = t.category.toUpperCase();
+        }
+        return {
+            hash: t.hash ?? "",
+            from: t.from ?? "",
+            to: t.to ?? "",
+            value: t.value != null ? String(t.value) : "0",
+            blockNumber: t.blockNum ?? "0",
+            timeStamp: t.metadata?.blockTimestamp ?? "",
+            category: t.category,
+            direction,
+            symbol: symbol || undefined,
+        };
+    });
+    return { transfers, pageKey: result.pageKey };
+}
+/** Pending txs for address: Alchemy exposes this only via WebSocket (alchemy_pendingTransactions). Return empty for REST. */
+export async function getPendingTxList(_chainId, _address) {
+    return [];
+}

package/dist/lib/explorer.d.ts

@@ -0,0 +1,24 @@
+export interface ExplorerTx {
+    hash: string;
+    from: string;
+    to: string;
+    value: string;
+    gasUsed: string;
+    gasPrice: string;
+    blockNumber: string;
+    timeStamp: string;
+    txreceipt_status?: string;
+    isError?: string;
+}
+export interface ExplorerTxListResponse {
+    status: string;
+    message: string;
+    result: ExplorerTx[] | string;
+}
+/** Fetch normal transaction list for address (Etherscan-compatible API). */
+export declare function getTxList(chainId: number, address: string, options?: {
+    limit?: number;
+    page?: number;
+}): Promise<ExplorerTx[]>;
+/** Fetch pending transactions for address (if supported by explorer). */
+export declare function getPendingTxList(chainId: number, address: string): Promise<ExplorerTx[]>;

package/dist/lib/explorer.js

@@ -0,0 +1,59 @@
+import { EXPLORER_API_BASES } from "../constants.js";
+const API_KEY = process.env.EXPLORER_API_KEY ?? process.env.ETHERSCAN_API_KEY;
+/** Fetch normal transaction list for address (Etherscan-compatible API). */
+export async function getTxList(chainId, address, options = {}) {
+    const base = EXPLORER_API_BASES[chainId];
+    if (!base)
+        throw new Error(`No explorer API for chain ${chainId}`);
+    const limit = Math.min(options.limit ?? 20, 100);
+    const page = options.page ?? 1;
+    const params = new URLSearchParams({
+        module: "account",
+        action: "txlist",
+        address,
+        startblock: "0",
+        endblock: "99999999",
+        sort: "desc",
+        page: String(page),
+        offset: String(limit),
+    });
+    if (API_KEY?.trim())
+        params.set("apikey", API_KEY.trim());
+    const url = `${base}/api?${params}`;
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`Explorer API error: ${res.status}`);
+    const data = (await res.json());
+    if (data.message !== "OK" && data.message !== "No transactions found") {
+        throw new Error(`Explorer API: ${data.message}`);
+    }
+    const result = data.result;
+    if (typeof result === "string")
+        return [];
+    return Array.isArray(result) ? result : [];
+}
+/** Fetch pending transactions for address (if supported by explorer). */
+export async function getPendingTxList(chainId, address) {
+    const base = EXPLORER_API_BASES[chainId];
+    if (!base)
+        throw new Error(`No explorer API for chain ${chainId}`);
+    const params = new URLSearchParams({
+        module: "account",
+        action: "pendingtxlist",
+        address,
+    });
+    if (API_KEY?.trim())
+        params.set("apikey", API_KEY.trim());
+    const url = `${base}/api?${params}`;
+    const res = await fetch(url);
+    if (!res.ok)
+        return [];
+    const data = (await res.json());
+    if (data.message !== "OK" && data.message !== "No transactions found") {
+        return [];
+    }
+    const result = data.result;
+    if (typeof result === "string")
+        return [];
+    return Array.isArray(result) ? result : [];
+}

package/dist/lib/oracle.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Oracle USD prices may use 8 or 18 decimals. Normalize to a plain USD number.
+ * - raw >= 1e15: treat as 18 decimals (e.g. 2000e18 = $2000).
+ * - Else try 8 decimals; if result > MAX_PLAUSIBLE_PRICE, assume 18 decimals (e.g. low-priced token stored in 18 decimals).
+ */
+export declare function parseEthUsdRaw(raw: bigint): number;
+/** Get native token (ETH/BNB/POL) price in USD from Lightspeed oracle (raw uint256). */
+export declare function getEthUsdPrice(chainId: number): Promise<bigint>;
+/** Get ETH/USD price as a number (handles 8 or 18 decimals from oracle). */
+export declare function getEthUsdPriceNumber(chainId: number): Promise<number>;
+/** Get Speed/USD price (raw) */
+export declare function getSpeedUsdPrice(chainId: number): Promise<bigint>;
+/** Get Speed/USD price as a number (handles 8 or 18 decimals). */
+export declare function getSpeedUsdPriceNumber(chainId: number): Promise<number>;
+/** Get Speed/native price (raw) */
+export declare function getSpeedEthPrice(chainId: number): Promise<bigint>;
+/** All three oracle prices in one shot (one provider, parallel reads). Use for price command. */
+export declare function getOraclePrices(chainId: number): Promise<{
+    ethUsd: bigint;
+    speedUsd: bigint;
+    speedEth: bigint;
+}>;

package/dist/lib/oracle.js

@@ -0,0 +1,70 @@
+import { ethers } from "ethers";
+import { getRpcUrl } from "../rpc.js";
+import { ORACLE_ADDRESSES, ORACLE_ABI } from "../constants.js";
+/** Max plausible USD per unit (ETH/token); above this we assume wrong decimals. */
+const MAX_PLAUSIBLE_PRICE = 1e6;
+/**
+ * Oracle USD prices may use 8 or 18 decimals. Normalize to a plain USD number.
+ * - raw >= 1e15: treat as 18 decimals (e.g. 2000e18 = $2000).
+ * - Else try 8 decimals; if result > MAX_PLAUSIBLE_PRICE, assume 18 decimals (e.g. low-priced token stored in 18 decimals).
+ */
+export function parseEthUsdRaw(raw) {
+    const n = Number(raw);
+    if (n >= 1e15)
+        return n / 1e18;
+    const as8 = n / 1e8;
+    if (as8 > MAX_PLAUSIBLE_PRICE)
+        return n / 1e18; // low-priced token in 18 decimals (e.g. 1e13 → 0.00001)
+    return as8;
+}
+/** Get native token (ETH/BNB/POL) price in USD from Lightspeed oracle (raw uint256). */
+export async function getEthUsdPrice(chainId) {
+    const addr = ORACLE_ADDRESSES[chainId];
+    if (!addr)
+        throw new Error(`No oracle for chain ${chainId}`);
+    const provider = new ethers.JsonRpcProvider(getRpcUrl(chainId));
+    const contract = new ethers.Contract(addr, ORACLE_ABI, provider);
+    return contract.getEthUsdPrice();
+}
+/** Get ETH/USD price as a number (handles 8 or 18 decimals from oracle). */
+export async function getEthUsdPriceNumber(chainId) {
+    const raw = await getEthUsdPrice(chainId);
+    return parseEthUsdRaw(raw);
+}
+/** Get Speed/USD price (raw) */
+export async function getSpeedUsdPrice(chainId) {
+    const addr = ORACLE_ADDRESSES[chainId];
+    if (!addr)
+        throw new Error(`No oracle for chain ${chainId}`);
+    const provider = new ethers.JsonRpcProvider(getRpcUrl(chainId));
+    const contract = new ethers.Contract(addr, ORACLE_ABI, provider);
+    return contract.getLatestSpeedUsdPrice();
+}
+/** Get Speed/USD price as a number (handles 8 or 18 decimals). */
+export async function getSpeedUsdPriceNumber(chainId) {
+    const raw = await getSpeedUsdPrice(chainId);
+    return parseEthUsdRaw(raw);
+}
+/** Get Speed/native price (raw) */
+export async function getSpeedEthPrice(chainId) {
+    const addr = ORACLE_ADDRESSES[chainId];
+    if (!addr)
+        throw new Error(`No oracle for chain ${chainId}`);
+    const provider = new ethers.JsonRpcProvider(getRpcUrl(chainId));
+    const contract = new ethers.Contract(addr, ORACLE_ABI, provider);
+    return contract.getLatestSpeedEthPrice();
+}
+/** All three oracle prices in one shot (one provider, parallel reads). Use for price command. */
+export async function getOraclePrices(chainId) {
+    const addr = ORACLE_ADDRESSES[chainId];
+    if (!addr)
+        throw new Error(`No oracle for chain ${chainId}`);
+    const provider = new ethers.JsonRpcProvider(getRpcUrl(chainId));
+    const contract = new ethers.Contract(addr, ORACLE_ABI, provider);
+    const [ethUsd, speedUsd, speedEth] = await Promise.all([
+        contract.getEthUsdPrice(),
+        contract.getLatestSpeedUsdPrice(),
+        contract.getLatestSpeedEthPrice(),
+    ]);
+    return { ethUsd, speedUsd, speedEth };
+}

package/dist/lib/parse-amount.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parse a human token amount to wei (18 decimals).
+ * - Decimal (e.g. 0.1, 1.5) → token amount
+ * - Optional suffix "eth", "ether", "speed", "token" → token amount
+ * - Short integer (e.g. 10000, 1) → token amount
+ * - 18+ digit integer → raw wei (for power users)
+ */
+export declare function parseTokenAmountToWei(amountRaw: string): string;

package/dist/lib/parse-amount.js

@@ -0,0 +1,19 @@
+import { ethers } from "ethers";
+/**
+ * Parse a human token amount to wei (18 decimals).
+ * - Decimal (e.g. 0.1, 1.5) → token amount
+ * - Optional suffix "eth", "ether", "speed", "token" → token amount
+ * - Short integer (e.g. 10000, 1) → token amount
+ * - 18+ digit integer → raw wei (for power users)
+ */
+export function parseTokenAmountToWei(amountRaw) {
+    const trimmed = amountRaw.replace(/\s*(eth|ether|speed|token)\s*$/i, "").trim();
+    const hasDecimal = /\.\d/.test(amountRaw);
+    const hasSuffix = /\s*(eth|ether|speed|token)\s*$/i.test(amountRaw);
+    const allDigits = /^\d+$/.test(trimmed);
+    const looksLikeWei = allDigits && trimmed.length >= 18;
+    if (hasDecimal || hasSuffix || !looksLikeWei) {
+        return ethers.parseEther(trimmed).toString();
+    }
+    return trimmed;
+}

package/dist/lib/pending-bridges.d.ts

@@ -0,0 +1,12 @@
+export interface PendingBridgeEntry {
+    requestId: string;
+    quoteId: string;
+    txHash: string;
+    fromChain: number;
+    toChain: number;
+    startedAt: string;
+}
+export declare function addPendingBridge(entry: PendingBridgeEntry): void;
+export declare function listPendingBridges(): PendingBridgeEntry[];
+/** Remove entries by requestId; returns new list. */
+export declare function removePendingBridges(requestIds: string[]): PendingBridgeEntry[];

package/dist/lib/pending-bridges.js

@@ -0,0 +1,34 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { getSpeedConfigDir } from "../env.js";
+const PENDING_BRIDGES_PATH = join(getSpeedConfigDir(), "pending-bridges.json");
+function load() {
+    try {
+        if (existsSync(PENDING_BRIDGES_PATH)) {
+            const raw = readFileSync(PENDING_BRIDGES_PATH, "utf-8");
+            const data = JSON.parse(raw);
+            return Array.isArray(data) ? data : [];
+        }
+    }
+    catch (_) { }
+    return [];
+}
+function save(entries) {
+    mkdirSync(getSpeedConfigDir(), { recursive: true });
+    writeFileSync(PENDING_BRIDGES_PATH, JSON.stringify(entries, null, 2));
+}
+export function addPendingBridge(entry) {
+    const entries = load();
+    entries.unshift(entry);
+    save(entries);
+}
+export function listPendingBridges() {
+    return load();
+}
+/** Remove entries by requestId; returns new list. */
+export function removePendingBridges(requestIds) {
+    const set = new Set(requestIds);
+    const entries = load().filter((e) => !set.has(e.requestId));
+    save(entries);
+    return entries;
+}

package/dist/lib/squid.d.ts

@@ -0,0 +1,28 @@
+export interface ISquid {
+    getRoute(params: SquidRouteParams): Promise<{
+        route: unknown;
+        requestId: string;
+    }>;
+    executeRoute(opts: {
+        signer: unknown;
+        route: unknown;
+    }): Promise<unknown>;
+    getStatus(params: {
+        transactionId: string;
+        requestId: string;
+        integratorId: string;
+        quoteId: string;
+    }): Promise<{
+        squidTransactionStatus: string;
+    }>;
+}
+export declare function getSquid(): Promise<ISquid>;
+export interface SquidRouteParams {
+    fromAddress: string;
+    fromChain: string;
+    fromToken: string;
+    fromAmount: string;
+    toChain: string;
+    toToken: string;
+    toAddress: string;
+}

package/dist/lib/squid.js

@@ -0,0 +1,23 @@
+import { SQUID_BASE_URL } from "../constants.js";
+let squidInstance = null;
+function getIntegratorId() {
+    const id = process.env.SQUID_INTEGRATOR_ID?.trim();
+    if (!id)
+        throw new Error("SQUID_INTEGRATOR_ID must be set");
+    return id;
+}
+async function initSquid() {
+    const { Squid } = await import("@0xsquid/sdk");
+    const squid = new Squid({
+        baseUrl: SQUID_BASE_URL,
+        integratorId: getIntegratorId(),
+    });
+    await squid.init();
+    return squid;
+}
+export async function getSquid() {
+    if (squidInstance)
+        return squidInstance;
+    squidInstance = await initSquid();
+    return squidInstance;
+}

package/dist/lib/swap-execute.d.ts

@@ -0,0 +1,16 @@
+import { ethers } from "ethers";
+import { type ZeroXQuoteResult } from "./zerox.js";
+/**
+ * Execute swap from an existing quote: approve if needed → send transaction → wait.
+ * Used by swap command after it has already fetched the quote for display/prechecks.
+ */
+export declare function executeSwapWithQuote(signer: ethers.Signer, sellToken: string, quote: ZeroXQuoteResult, amountWei: string): Promise<string>;
+/**
+ * Execute one swap: get quote → approve if needed → send transaction → wait.
+ * Used by volume command. No confirmation, no dry-run.
+ * @returns { txHash, quote }
+ */
+export declare function executeSwap(chainId: number, signer: ethers.Signer, sellToken: string, buyToken: string, amountWei: string): Promise<{
+    txHash: string;
+    quote: ZeroXQuoteResult;
+}>;