@raintree-technology/perps 0.1.0

package/dist/commands/arb/history.js

@@ -0,0 +1,153 @@
+/**
+ * Arb History Command
+ * View historical funding rate spreads
+ */
+import { getOutputOptions } from "../../cli/program.js";
+import { output, outputError } from "../../cli/output.js";
+import { getFundingHistory, getLatestFundingRates, getSpreadStats, getFundingSpreads, getRecordCount, } from "../../lib/db/funding-history.js";
+import { DEFAULT_HISTORY_HOURS } from "../../lib/constants.js";
+import { validateAsset, parsePositiveInt } from "../../lib/validate.js";
+export function registerArbHistoryCommand(arb) {
+    arb
+        .command("history [asset]")
+        .description("View historical funding rate data")
+        .option("-h, --hours <hours>", "Hours of history to show", String(DEFAULT_HISTORY_HOURS))
+        .option("--stats", "Show statistics summary")
+        .option("--spreads", "Show hourly spread history")
+        .action(async function (asset) {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        const hours = parsePositiveInt(opts.hours, "hours", DEFAULT_HISTORY_HOURS);
+        const market = `${validateAsset(asset)}-PERP`;
+        try {
+            const recordCount = getRecordCount();
+            if (recordCount === 0) {
+                if (outputOpts.json) {
+                    output({
+                        status: "no_data",
+                        market,
+                        hours,
+                        history: [],
+                        latestRates: [],
+                        message: "No funding history recorded yet. Run `perps arb track` first.",
+                    }, outputOpts);
+                    return;
+                }
+                console.log("\n  No funding history recorded yet.");
+                console.log("  Run \x1b[36mperps arb track\x1b[0m to start collecting data.\n");
+                return;
+            }
+            if (opts.stats) {
+                showStats(market, hours, outputOpts.json);
+            }
+            else if (opts.spreads) {
+                showSpreads(market, hours, outputOpts.json);
+            }
+            else {
+                showHistory(market, hours, outputOpts.json);
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+}
+function showHistory(market, hours, json) {
+    const rates = getLatestFundingRates(market);
+    const history = getFundingHistory(market, { hours });
+    if (json) {
+        output({ market, hours, latestRates: rates, history }, { json: true });
+        return;
+    }
+    console.log(`\n  ${market} Funding History (last ${hours}h)\n`);
+    if (rates.length === 0) {
+        console.log(`  No data for ${market}`);
+        return;
+    }
+    // Show latest rates
+    console.log("  \x1b[1mLatest Rates:\x1b[0m");
+    console.log("  " + "Exchange".padEnd(18) + "Rate (1h)".padEnd(14) + "Annualized".padEnd(14) + "Last Updated");
+    console.log("  " + "─".repeat(70));
+    for (const r of rates) {
+        const rateColor = r.rate >= 0 ? "\x1b[32m" : "\x1b[31m";
+        const sign = r.rate >= 0 ? "+" : "";
+        const annPercent = r.annualized;
+        const timeAgo = formatTimeAgo(r.recordedAt);
+        console.log(`  ${r.exchange.padEnd(16)}` +
+            `${rateColor}${sign}${(r.rate * 100).toFixed(4)}%\x1b[0m`.padEnd(23) +
+            `${rateColor}${sign}${annPercent.toFixed(2)}%\x1b[0m`.padEnd(23) +
+            timeAgo);
+    }
+    // Show sample count
+    console.log(`\n  \x1b[90m${history.length} samples in last ${hours}h\x1b[0m\n`);
+}
+function showStats(market, hours, json) {
+    const stats = getSpreadStats(market, hours);
+    if (json) {
+        output({ market, hours, stats }, { json: true });
+        return;
+    }
+    console.log(`\n  ${market} Spread Statistics (last ${hours}h)\n`);
+    if (stats.samples === 0) {
+        console.log(`  No spread data for ${market}`);
+        console.log(`  Run \x1b[36mperps arb track\x1b[0m to start collecting data.\n`);
+        return;
+    }
+    console.log("  " + "─".repeat(50));
+    const annualizedPct = stats.avgAnnualized * 100; // Convert decimal to percentage
+    const spreadColor = annualizedPct > 10 ? "\x1b[32m" : "\x1b[33m";
+    const consistColor = stats.consistency > 80 ? "\x1b[32m" : stats.consistency > 50 ? "\x1b[33m" : "\x1b[31m";
+    console.log(`  Avg Spread:       ${spreadColor}${(stats.avgSpread * 100).toFixed(4)}%\x1b[0m per hour`);
+    console.log(`  Avg Annualized:   ${spreadColor}${annualizedPct.toFixed(2)}%\x1b[0m`);
+    console.log(`  Min Spread:       ${(stats.minSpread * 100).toFixed(4)}%`);
+    console.log(`  Max Spread:       ${(stats.maxSpread * 100).toFixed(4)}%`);
+    console.log(`  Consistency:      ${consistColor}${stats.consistency.toFixed(1)}%\x1b[0m of samples have positive spread`);
+    console.log(`  Samples:          ${stats.samples}`);
+    if (stats.bestPair) {
+        console.log(`\n  Best Pair:        Short ${stats.bestPair.high} / Long ${stats.bestPair.low}`);
+    }
+    // Profitability estimate
+    if (stats.avgAnnualized > 0) {
+        // avgSpread is decimal (e.g., 0.0001 = 0.01%), so multiply by position size
+        const dailyOnTenK = stats.avgSpread * 24 * 10000;
+        console.log(`\n  \x1b[36mEstimated Daily Profit:\x1b[0m $${dailyOnTenK.toFixed(2)} on $10k delta-neutral`);
+        console.log(`  \x1b[90m(Based on average spread, actual results vary)\x1b[0m`);
+    }
+    console.log("\n  " + "─".repeat(50) + "\n");
+}
+function showSpreads(market, hours, json) {
+    const spreads = getFundingSpreads(market, hours);
+    if (json) {
+        output({ market, hours, spreads }, { json: true });
+        return;
+    }
+    console.log(`\n  ${market} Hourly Spreads (last ${hours}h)\n`);
+    if (spreads.length === 0) {
+        console.log(`  No spread data for ${market}`);
+        return;
+    }
+    console.log("  " + "Time".padEnd(14) + "High".padEnd(20) + "Low".padEnd(20) + "Spread".padEnd(14) + "Ann.");
+    console.log("  " + "─".repeat(75));
+    for (const s of spreads.slice(0, 24)) { // Last 24 entries
+        const time = new Date(s.recordedAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+        const annPct = s.annualizedSpread * 100; // Convert decimal to percentage
+        const spreadColor = annPct > 10 ? "\x1b[32m" : "\x1b[33m";
+        console.log(`  ${time.padEnd(12)}` +
+            `${s.highExchange.padEnd(10)} ${(s.highRate * 100).toFixed(4)}%`.padEnd(20) +
+            `${s.lowExchange.padEnd(10)} ${(s.lowRate * 100).toFixed(4)}%`.padEnd(20) +
+            `${(s.spread * 100).toFixed(4)}%`.padEnd(14) +
+            `${spreadColor}${annPct.toFixed(1)}%\x1b[0m`);
+    }
+    console.log("");
+}
+function formatTimeAgo(timestamp) {
+    const seconds = Math.floor((Date.now() - timestamp) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86400)}d ago`;
+}

package/dist/commands/arb/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Arbitrage Commands
+ * Cross-exchange price and funding comparisons
+ */
+import type { Command } from "commander";
+export declare function registerArbCommands(program: Command): void;

package/dist/commands/arb/index.js

@@ -0,0 +1,29 @@
+/**
+ * Arbitrage Commands
+ * Cross-exchange price and funding comparisons
+ */
+import { registerArbSpreadCommand } from "./spread.js";
+import { registerArbFundingCommand } from "./funding.js";
+import { registerArbHistoryCommand } from "./history.js";
+import { registerArbTrackCommand } from "./track.js";
+import { registerArbExecuteCommand } from "./execute.js";
+import { registerArbAlertCommand } from "./alert.js";
+import { registerArbPositionsCommand } from "./positions.js";
+import { registerArbCompareCommand } from "./compare.js";
+import { registerArbBasisCommand } from "./basis.js";
+import { registerArbBasisExecuteCommand } from "./basis-execute.js";
+export function registerArbCommands(program) {
+    const arb = program
+        .command("arb")
+        .description("Cross-exchange arbitrage tools");
+    registerArbSpreadCommand(arb);
+    registerArbFundingCommand(arb);
+    registerArbHistoryCommand(arb);
+    registerArbTrackCommand(arb);
+    registerArbExecuteCommand(arb);
+    registerArbAlertCommand(arb);
+    registerArbPositionsCommand(arb);
+    registerArbCompareCommand(arb);
+    registerArbBasisCommand(arb);
+    registerArbBasisExecuteCommand(arb);
+}

package/dist/commands/arb/positions.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Arb Positions Command
+ * View all open positions across exchanges
+ */
+import { Command } from "commander";
+export declare function registerArbPositionsCommand(arb: Command): void;

package/dist/commands/arb/positions.js

@@ -0,0 +1,158 @@
+/**
+ * Arb Positions Command
+ * View all open positions across exchanges
+ */
+import { getContext, getOutputOptions } from "../../cli/program.js";
+import { output, outputError } from "../../cli/output.js";
+import { getExchangeAdapterById, getAvailableExchanges } from "../../lib/exchange.js";
+export function registerArbPositionsCommand(arb) {
+    arb
+        .command("positions")
+        .description("View all open positions across exchanges")
+        .option("--exchange <exchanges>", "Comma-separated exchanges to check (default: all)")
+        .action(async function () {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        const isTestnet = ctx.config.testnet;
+        const exchanges = opts.exchange
+            ? opts.exchange.split(",").map(e => e.trim().toLowerCase())
+            : getAvailableExchanges();
+        try {
+            if (!outputOpts.json) {
+                console.log("\n  Fetching positions across exchanges...\n");
+            }
+            const allPositions = [];
+            const errors = [];
+            for (const exchangeId of exchanges) {
+                let adapter = null;
+                let connected = false;
+                try {
+                    adapter = getExchangeAdapterById(exchangeId);
+                    await adapter.connect({ testnet: isTestnet });
+                    connected = true;
+                    const positions = await adapter.getPositions();
+                    for (const pos of positions) {
+                        if (parseFloat(pos.size) === 0)
+                            continue;
+                        allPositions.push({
+                            exchange: adapter.info.name,
+                            market: pos.market,
+                            side: pos.side,
+                            size: pos.size,
+                            entryPrice: pos.entryPrice,
+                            markPrice: pos.markPrice,
+                            unrealizedPnl: pos.unrealizedPnl,
+                            leverage: pos.leverage,
+                        });
+                    }
+                }
+                catch (err) {
+                    errors.push({
+                        exchange: adapter?.info.name ?? exchangeId,
+                        error: err instanceof Error ? err.message : "Unknown error",
+                    });
+                }
+                finally {
+                    if (connected && adapter) {
+                        await adapter.disconnect().catch(() => undefined);
+                    }
+                }
+            }
+            if (outputOpts.json) {
+                output({ positions: allPositions, errors }, { json: true });
+                return;
+            }
+            if (allPositions.length === 0) {
+                console.log("  No open positions found.\n");
+                if (errors.length > 0) {
+                    console.log("  \x1b[33mNote:\x1b[0m Some exchanges require authentication:");
+                    for (const e of errors) {
+                        console.log(`    ${e.exchange}: ${e.error}`);
+                    }
+                    console.log("");
+                }
+                return;
+            }
+            // Display positions
+            console.log("  \x1b[1mOpen Positions\x1b[0m\n");
+            console.log("  " +
+                "Exchange".padEnd(14) +
+                "Market".padEnd(12) +
+                "Side".padEnd(8) +
+                "Size".padEnd(14) +
+                "Entry".padEnd(12) +
+                "Mark".padEnd(12) +
+                "PnL");
+            console.log("  " + "─".repeat(85));
+            let totalPnl = 0;
+            for (const pos of allPositions) {
+                const sideColor = pos.side === "long" ? "\x1b[32m" : "\x1b[31m";
+                const pnl = parseFloat(pos.unrealizedPnl);
+                const pnlColor = pnl >= 0 ? "\x1b[32m" : "\x1b[31m";
+                const pnlSign = pnl >= 0 ? "+" : "";
+                totalPnl += pnl;
+                console.log(`  ${pos.exchange.padEnd(12)}` +
+                    `${pos.market.padEnd(12)}` +
+                    `${sideColor}${pos.side.toUpperCase().padEnd(8)}\x1b[0m` +
+                    `${pos.size.padEnd(14)}` +
+                    `$${parseFloat(pos.entryPrice).toFixed(2).padEnd(11)}` +
+                    `$${parseFloat(pos.markPrice).toFixed(2).padEnd(11)}` +
+                    `${pnlColor}${pnlSign}$${pnl.toFixed(2)}\x1b[0m`);
+            }
+            console.log("  " + "─".repeat(85));
+            const totalPnlColor = totalPnl >= 0 ? "\x1b[32m" : "\x1b[31m";
+            const totalPnlSign = totalPnl >= 0 ? "+" : "";
+            console.log(`  ${"Total PnL:".padEnd(66)}${totalPnlColor}${totalPnlSign}$${totalPnl.toFixed(2)}\x1b[0m`);
+            // Calculate net exposure per market
+            console.log("\n  \x1b[1mNet Exposure\x1b[0m\n");
+            const exposureByMarket = new Map();
+            for (const pos of allPositions) {
+                const existing = exposureByMarket.get(pos.market) || {
+                    market: pos.market,
+                    long: 0,
+                    short: 0,
+                    net: 0,
+                    value: 0,
+                };
+                const size = parseFloat(pos.size);
+                const price = parseFloat(pos.markPrice);
+                if (pos.side === "long") {
+                    existing.long += size;
+                }
+                else {
+                    existing.short += size;
+                }
+                existing.net = existing.long - existing.short;
+                existing.value = existing.net * price;
+                exposureByMarket.set(pos.market, existing);
+            }
+            console.log("  " + "Market".padEnd(12) + "Long".padEnd(14) + "Short".padEnd(14) + "Net".padEnd(14) + "Value");
+            console.log("  " + "─".repeat(60));
+            for (const exposure of exposureByMarket.values()) {
+                const netColor = Math.abs(exposure.net) < 0.0001
+                    ? "\x1b[32m"
+                    : exposure.net > 0
+                        ? "\x1b[33m"
+                        : "\x1b[31m";
+                const netStr = Math.abs(exposure.net) < 0.0001
+                    ? "HEDGED"
+                    : exposure.net.toFixed(6);
+                console.log(`  ${exposure.market.padEnd(12)}` +
+                    `${exposure.long.toFixed(6).padEnd(14)}` +
+                    `${exposure.short.toFixed(6).padEnd(14)}` +
+                    `${netColor}${netStr.padEnd(14)}\x1b[0m` +
+                    `$${exposure.value.toFixed(2)}`);
+            }
+            console.log("");
+            if (errors.length > 0) {
+                console.log("  \x1b[33mCould not check:\x1b[0m " + errors.map(e => e.exchange).join(", "));
+                console.log("");
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/arb/spread.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Arb Spread Command
+ * Compare prices across all exchanges for arbitrage opportunities
+ */
+import { Command } from "commander";
+export declare function registerArbSpreadCommand(arb: Command): void;

package/dist/commands/arb/spread.js

@@ -0,0 +1,253 @@
+/**
+ * Arb Spread Command
+ * Compare prices across all exchanges for arbitrage opportunities
+ */
+import { getContext, getOutputOptions } from "../../cli/program.js";
+import { output, outputError } from "../../cli/output.js";
+import { getExchangeAdapterById, getAvailableExchanges } from "../../lib/exchange.js";
+export function registerArbSpreadCommand(arb) {
+    arb
+        .command("spread [asset]")
+        .description("Compare prices across exchanges")
+        .option("-w, --watch", "Watch mode - continuously update")
+        .option("--all", "Show all common markets")
+        .action(async function (asset) {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        const isTestnet = ctx.config.testnet;
+        try {
+            const exchanges = getAvailableExchanges();
+            if (outputOpts.json && opts.watch) {
+                throw new Error("Watch mode is not supported with --json");
+            }
+            if (opts.all) {
+                await showAllSpreads(exchanges, outputOpts.json, isTestnet);
+            }
+            else if (asset) {
+                if (opts.watch) {
+                    await watchSpread(asset.toUpperCase(), exchanges, isTestnet);
+                }
+                else {
+                    await showSpread(asset.toUpperCase(), exchanges, outputOpts.json, isTestnet);
+                }
+            }
+            else {
+                // Default: show BTC spread
+                await showSpread("BTC", exchanges, outputOpts.json, isTestnet);
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+}
+async function fetchPrices(asset, exchanges, isTestnet) {
+    const results = [];
+    const promises = exchanges.map(async (exchangeId) => {
+        const adapter = getExchangeAdapterById(exchangeId);
+        let connected = false;
+        try {
+            await adapter.connect({ testnet: isTestnet });
+            connected = true;
+            // Try to get ticker for this asset
+            const symbol = `${asset}-PERP`;
+            const ticker = await adapter.getTicker(symbol);
+            return {
+                exchange: adapter.info.name,
+                symbol: ticker.market,
+                markPrice: parseFloat(ticker.markPrice),
+                indexPrice: parseFloat(ticker.indexPrice),
+                bid: parseFloat(ticker.bid),
+                ask: parseFloat(ticker.ask),
+                fundingRate: parseFloat(ticker.fundingRate) * 100, // Convert to percentage
+            };
+        }
+        catch (err) {
+            return {
+                exchange: adapter.info.name,
+                symbol: `${asset}-PERP`,
+                markPrice: 0,
+                indexPrice: 0,
+                bid: 0,
+                ask: 0,
+                fundingRate: 0,
+                error: err instanceof Error ? err.message : "Unknown error",
+            };
+        }
+        finally {
+            if (connected) {
+                await adapter.disconnect().catch(() => undefined);
+            }
+        }
+    });
+    const settled = await Promise.allSettled(promises);
+    for (const result of settled) {
+        if (result.status === "fulfilled") {
+            results.push(result.value);
+        }
+    }
+    return results;
+}
+async function showSpread(asset, exchanges, json, isTestnet) {
+    if (!json) {
+        console.log(`\nFetching ${asset} prices across ${exchanges.length} exchanges...\n`);
+    }
+    const prices = await fetchPrices(asset, exchanges, isTestnet);
+    const validPrices = prices.filter(p => p.markPrice > 0);
+    if (validPrices.length === 0) {
+        if (json) {
+            output({
+                status: "no_data",
+                asset,
+                prices: [],
+                exchangesScanned: exchanges.length,
+            }, { json: true });
+            return;
+        }
+        console.log(`No prices found for ${asset} on any exchange`);
+        return;
+    }
+    // Find best bid (highest) and best ask (lowest)
+    const bestBid = validPrices.reduce((best, p) => p.bid > best.bid ? p : best, validPrices[0]);
+    const bestAsk = validPrices.reduce((best, p) => p.ask < best.ask || best.ask === 0 ? p : best, validPrices[0]);
+    // Calculate spread
+    const spreadPct = ((bestBid.bid - bestAsk.ask) / bestAsk.ask) * 100;
+    const data = {
+        asset,
+        prices: validPrices,
+        bestBid: { exchange: bestBid.exchange, price: bestBid.bid },
+        bestAsk: { exchange: bestAsk.exchange, price: bestAsk.ask },
+        spreadPct,
+        timestamp: Date.now(),
+    };
+    if (json) {
+        output(data, { json: true });
+        return;
+    }
+    // Table output
+    console.log(`  ${asset}-PERP Price Comparison\n`);
+    console.log("  Exchange".padEnd(18) + "Mark Price".padEnd(14) + "Bid".padEnd(14) + "Ask".padEnd(14) + "Funding");
+    console.log("  " + "─".repeat(70));
+    // Sort by mark price descending
+    validPrices.sort((a, b) => b.markPrice - a.markPrice);
+    for (const p of validPrices) {
+        const isBestBid = p.exchange === bestBid.exchange;
+        const isBestAsk = p.exchange === bestAsk.exchange;
+        const bidStr = isBestBid ? `\x1b[32m${p.bid.toFixed(2)}\x1b[0m` : p.bid.toFixed(2);
+        const askStr = isBestAsk ? `\x1b[31m${p.ask.toFixed(2)}\x1b[0m` : p.ask.toFixed(2);
+        const fundingStr = p.fundingRate >= 0
+            ? `\x1b[32m+${p.fundingRate.toFixed(4)}%\x1b[0m`
+            : `\x1b[31m${p.fundingRate.toFixed(4)}%\x1b[0m`;
+        console.log(`  ${p.exchange.padEnd(16)}` +
+            `$${p.markPrice.toFixed(2).padEnd(13)}` +
+            `${bidStr.padEnd(14 + (isBestBid ? 9 : 0))}` + // Account for ANSI codes
+            `${askStr.padEnd(14 + (isBestAsk ? 9 : 0))}` +
+            fundingStr);
+    }
+    // Show errors
+    const errors = prices.filter(p => p.error);
+    if (errors.length > 0) {
+        console.log("\n  \x1b[33mNot available on:\x1b[0m " + errors.map(e => e.exchange).join(", "));
+    }
+    // Show spread summary
+    console.log("\n  " + "─".repeat(70));
+    if (spreadPct > 0) {
+        console.log(`\n  \x1b[32mArbitrage Opportunity: ${spreadPct.toFixed(4)}%\x1b[0m`);
+        console.log(`  Buy on ${bestAsk.exchange} @ $${bestAsk.ask.toFixed(2)}`);
+        console.log(`  Sell on ${bestBid.exchange} @ $${bestBid.bid.toFixed(2)}`);
+        console.log(`  Profit: $${(bestBid.bid - bestAsk.ask).toFixed(2)} per unit`);
+    }
+    else {
+        console.log(`\n  No arbitrage opportunity (spread: ${spreadPct.toFixed(4)}%)`);
+    }
+    console.log("");
+}
+async function showAllSpreads(exchanges, json, isTestnet) {
+    // Common assets across exchanges
+    const assets = ["BTC", "ETH", "SOL", "DOGE", "ARB", "OP", "WIF", "TIA"];
+    const rows = [];
+    if (!json) {
+        console.log("\nFetching prices for common assets...\n");
+        console.log("  Asset".padEnd(10) + "Best Bid".padEnd(24) + "Best Ask".padEnd(24) + "Spread");
+        console.log("  " + "─".repeat(70));
+    }
+    for (const asset of assets) {
+        const prices = await fetchPrices(asset, exchanges, isTestnet);
+        const validPrices = prices.filter(p => p.markPrice > 0);
+        if (validPrices.length < 2) {
+            if (!json) {
+                console.log(`  ${asset.padEnd(8)}  Available on <2 exchanges`);
+            }
+            continue;
+        }
+        const bestBid = validPrices.reduce((best, p) => p.bid > best.bid ? p : best, validPrices[0]);
+        const bestAsk = validPrices.reduce((best, p) => p.ask < best.ask || best.ask === 0 ? p : best, validPrices[0]);
+        const spreadPct = ((bestBid.bid - bestAsk.ask) / bestAsk.ask) * 100;
+        rows.push({
+            asset,
+            bestBid: { exchange: bestBid.exchange, price: bestBid.bid },
+            bestAsk: { exchange: bestAsk.exchange, price: bestAsk.ask },
+            spreadPct,
+            timestamp: Date.now(),
+        });
+        if (!json) {
+            const spreadColor = spreadPct > 0 ? "\x1b[32m" : "\x1b[90m";
+            console.log(`  ${asset.padEnd(8)}` +
+                `${bestBid.exchange.padEnd(12)} $${bestBid.bid.toFixed(2).padEnd(10)}` +
+                `${bestAsk.exchange.padEnd(12)} $${bestAsk.ask.toFixed(2).padEnd(10)}` +
+                `${spreadColor}${spreadPct.toFixed(4)}%\x1b[0m`);
+        }
+    }
+    if (json) {
+        output(rows, { json: true });
+        return;
+    }
+    console.log("");
+}
+async function watchSpread(asset, exchanges, isTestnet) {
+    console.log(`\nWatching ${asset} spread (Ctrl+C to exit)...\n`);
+    const refresh = async () => {
+        // Clear screen
+        process.stdout.write("\x1B[2J\x1B[0f");
+        console.log(`\n  ${asset}-PERP Spread Monitor (${new Date().toLocaleTimeString()})\n`);
+        const prices = await fetchPrices(asset, exchanges, isTestnet);
+        const validPrices = prices.filter(p => p.markPrice > 0);
+        if (validPrices.length === 0) {
+            console.log(`  No prices available`);
+            return;
+        }
+        console.log("  Exchange".padEnd(18) + "Mark".padEnd(14) + "Bid".padEnd(14) + "Ask".padEnd(14) + "Funding");
+        console.log("  " + "─".repeat(65));
+        validPrices.sort((a, b) => b.markPrice - a.markPrice);
+        for (const p of validPrices) {
+            const fundingColor = p.fundingRate >= 0 ? "\x1b[32m" : "\x1b[31m";
+            console.log(`  ${p.exchange.padEnd(16)}` +
+                `$${p.markPrice.toFixed(2).padEnd(13)}` +
+                `$${p.bid.toFixed(2).padEnd(13)}` +
+                `$${p.ask.toFixed(2).padEnd(13)}` +
+                `${fundingColor}${p.fundingRate.toFixed(4)}%\x1b[0m`);
+        }
+        // Calculate spread
+        const bestBid = validPrices.reduce((best, p) => p.bid > best.bid ? p : best, validPrices[0]);
+        const bestAsk = validPrices.reduce((best, p) => p.ask < best.ask ? p : best, validPrices[0]);
+        const spread = ((bestBid.bid - bestAsk.ask) / bestAsk.ask) * 100;
+        console.log("\n  " + "─".repeat(65));
+        console.log(`\n  Spread: ${spread >= 0 ? "\x1b[32m" : "\x1b[90m"}${spread.toFixed(4)}%\x1b[0m`);
+        console.log(`  Best bid: ${bestBid.exchange} @ $${bestBid.bid.toFixed(2)}`);
+        console.log(`  Best ask: ${bestAsk.exchange} @ $${bestAsk.ask.toFixed(2)}`);
+        console.log("\n  Press Ctrl+C to exit");
+    };
+    // Initial refresh
+    await refresh();
+    // Refresh every 5 seconds
+    const interval = setInterval(refresh, 5000);
+    process.once("SIGINT", () => {
+        clearInterval(interval);
+        console.log("\n");
+        process.exit(0);
+    });
+    // Keep alive
+    await new Promise(() => { });
+}

package/dist/commands/arb/track.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Arb Track Command
+ * Start background funding rate tracking with live UI
+ */
+import { Command } from "commander";
+export declare function registerArbTrackCommand(arb: Command): void;