@raintree-technology/perps 0.1.0

package/dist/commands/arb/execute.js

@@ -0,0 +1,467 @@
+/**
+ * Arb Execute Command
+ * Execute delta-neutral funding arbitrage across exchanges
+ */
+import { confirm } from "@inquirer/prompts";
+import { getContext, getOutputOptions } from "../../cli/program.js";
+import { output, outputError } from "../../cli/output.js";
+import { getExchangeAdapterById } from "../../lib/exchange.js";
+import { getLatestFundingRates } from "../../lib/db/funding-history.js";
+import { getExchangeIdByName, DEFAULT_ARB_SIZE_USD } from "../../lib/constants.js";
+import { validateAsset, validateSize } from "../../lib/validate.js";
+import { getExchangeCredentials } from "../../lib/config.js";
+import { RiskPolicyMiddleware } from "../../lib/risk/policy-middleware.js";
+import { executeOrderWithSafety } from "../../lib/execution/safety.js";
+import { runWithExecutionJournal } from "../../lib/execution/journal.js";
+import { withJsonContract } from "../../lib/contracts.js";
+import { CLIError, EXIT_CODES, inferExitCode } from "../../lib/exit-codes.js";
+export function registerArbExecuteCommand(arb) {
+    arb
+        .command("execute [asset]")
+        .description("Execute delta-neutral funding arbitrage")
+        .option("-s, --size <usd>", "Position size in USD", String(DEFAULT_ARB_SIZE_USD))
+        .option("--confidence <0-1>", "Signal confidence for risk policy (default: 1.0)")
+        .option("--tp <pct>", "Attach take-profit (% from entry) to each leg")
+        .option("--sl <pct>", "Attach stop-loss (% from entry) to each leg")
+        .option("--no-close-then-flip", "Disable auto close-then-flip behavior")
+        .option("--no-spread-aware", "Disable spread-aware execution pricing")
+        .option("--idempotency-key <key>", "Idempotency key prefix for safe retries (leg keys use :short/:long suffixes)")
+        .option("--dry-run", "Show execution plan without trading")
+        .option("-y, --yes", "Skip confirmation prompts")
+        .action(async function (asset) {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        const emitJson = (data) => {
+            output(withJsonContract("arb.execute.result", data), outputOpts);
+        };
+        const isJson = outputOpts.json;
+        try {
+            if (isJson && !opts.yes && !opts.dryRun) {
+                throw new CLIError("Use --yes with --json for non-interactive arb execution", EXIT_CODES.VALIDATION_ERROR);
+            }
+            const assetName = validateAsset(asset);
+            const market = `${assetName}-PERP`;
+            const requestedSizeUsd = validateSize(opts.size, DEFAULT_ARB_SIZE_USD);
+            const confidence = opts.confidence ? parseFloat(opts.confidence) : 1;
+            if (!Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+                throw new CLIError("Confidence must be a number between 0 and 1", EXIT_CODES.VALIDATION_ERROR);
+            }
+            const rates = getLatestFundingRates(market);
+            if (rates.length < 2) {
+                if (isJson) {
+                    emitJson({
+                        status: "no_data",
+                        reason: "not_enough_exchange_data",
+                        market,
+                        requiredExchanges: 2,
+                        availableExchanges: rates.length,
+                    });
+                }
+                else {
+                    console.log("\n  Not enough exchange data. Run \x1b[36mperps arb track --once\x1b[0m first.\n");
+                }
+                process.exitCode = EXIT_CODES.DATA_UNAVAILABLE;
+                return;
+            }
+            const sorted = [...rates].sort((a, b) => b.rate - a.rate);
+            const highest = sorted[0];
+            const lowest = sorted[sorted.length - 1];
+            const spread = highest.rate - lowest.rate;
+            if (spread <= 0) {
+                if (isJson) {
+                    emitJson({
+                        status: "no_opportunity",
+                        reason: "non_positive_spread",
+                        market,
+                        spread,
+                    });
+                }
+                else {
+                    console.log("\n  No positive spread found. Arbitrage not profitable right now.\n");
+                }
+                process.exitCode = EXIT_CODES.NO_OPPORTUNITY;
+                return;
+            }
+            const shortExchangeId = getExchangeIdByName(highest.exchange);
+            const longExchangeId = getExchangeIdByName(lowest.exchange);
+            if (shortExchangeId === longExchangeId) {
+                if (isJson) {
+                    emitJson({
+                        status: "no_opportunity",
+                        reason: "same_exchange_legs",
+                        market,
+                        exchangeId: shortExchangeId,
+                    });
+                }
+                else {
+                    console.log("\n  Best long/short legs resolved to the same exchange. Skipping.\n");
+                }
+                process.exitCode = EXIT_CODES.NO_OPPORTUNITY;
+                return;
+            }
+            const shortAdapter = getExchangeAdapterById(shortExchangeId);
+            const longAdapter = getExchangeAdapterById(longExchangeId);
+            const shortCredentials = getExchangeCredentials(ctx.config, shortExchangeId, {
+                requireTrading: true,
+            });
+            const longCredentials = getExchangeCredentials(ctx.config, longExchangeId, {
+                requireTrading: true,
+            });
+            await shortAdapter.connect({
+                testnet: ctx.config.testnet,
+                rpcUrl: shortCredentials.fullnodeUrl,
+                wsUrl: shortCredentials.wsUrl,
+                credentials: shortCredentials,
+            });
+            await longAdapter.connect({
+                testnet: ctx.config.testnet,
+                rpcUrl: longCredentials.fullnodeUrl,
+                wsUrl: longCredentials.wsUrl,
+                credentials: longCredentials,
+            });
+            try {
+                const shortTicker = await shortAdapter.getTicker(market);
+                const longTicker = await longAdapter.getTicker(market);
+                const shortPrice = parseFloat(shortTicker.lastPrice);
+                const longPrice = parseFloat(longTicker.lastPrice);
+                if (!Number.isFinite(shortPrice) || !Number.isFinite(longPrice)) {
+                    throw new CLIError("Unable to fetch reliable ticker prices for arb sizing", EXIT_CODES.DATA_UNAVAILABLE);
+                }
+                // Run risk policy independently on both legs and size to the stricter leg.
+                const shortRisk = new RiskPolicyMiddleware(ctx.config, shortExchangeId);
+                const longRisk = new RiskPolicyMiddleware(ctx.config, longExchangeId);
+                const shortEval = await shortRisk.evaluateUsdSignal(shortAdapter, { market, side: "short", confidence, reason: "arb:short", timestamp: Date.now() }, requestedSizeUsd);
+                const longEval = await longRisk.evaluateUsdSignal(longAdapter, { market, side: "long", confidence, reason: "arb:long", timestamp: Date.now() }, requestedSizeUsd);
+                if (!shortEval.allowed) {
+                    throw new CLIError(`Short leg blocked by risk policy: ${shortEval.reason ?? "unknown"}`, EXIT_CODES.EXECUTION_ERROR);
+                }
+                if (!longEval.allowed) {
+                    throw new CLIError(`Long leg blocked by risk policy: ${longEval.reason ?? "unknown"}`, EXIT_CODES.EXECUTION_ERROR);
+                }
+                const sizeUsd = Math.min(requestedSizeUsd, shortEval.sizeUsd, longEval.sizeUsd);
+                if (!Number.isFinite(sizeUsd) || sizeUsd <= 0) {
+                    throw new CLIError("Risk policy reduced arb size to zero", EXIT_CODES.EXECUTION_ERROR);
+                }
+                const annualized = spread * 24 * 365 * 100;
+                const dailyProfit = spread * 24 * sizeUsd;
+                const plan = {
+                    asset: assetName,
+                    size: sizeUsd,
+                    shortExchange: highest.exchange,
+                    shortPrice,
+                    longExchange: lowest.exchange,
+                    longPrice,
+                    spread: spread * 100,
+                    annualized,
+                    dailyProfit,
+                };
+                if (!isJson) {
+                    console.log("\n  \x1b[1m━━━ Delta-Neutral Execution Plan ━━━\x1b[0m\n");
+                    console.log(`  Asset:          ${assetName}`);
+                    console.log(`  Position Size:  $${sizeUsd.toLocaleString()}`);
+                    if (Math.abs(sizeUsd - requestedSizeUsd) > 1e-9) {
+                        console.log(`  Risk Adjusted:  from $${requestedSizeUsd.toLocaleString()}`);
+                    }
+                    console.log("");
+                    console.log(`  \x1b[31m▼ SHORT\x1b[0m ${highest.exchange}`);
+                    console.log(`    Price:        $${shortPrice.toLocaleString()}`);
+                    console.log(`    Funding:      ${(highest.rate * 100).toFixed(4)}%/hr (you receive)`);
+                    console.log("");
+                    console.log(`  \x1b[32m▲ LONG\x1b[0m  ${lowest.exchange}`);
+                    console.log(`    Price:        $${longPrice.toLocaleString()}`);
+                    console.log(`    Funding:      ${(lowest.rate * 100).toFixed(4)}%/hr (you pay)`);
+                    console.log("");
+                    console.log("  " + "─".repeat(45));
+                    console.log(`  Net Spread:     \x1b[32m${plan.spread.toFixed(4)}%/hr\x1b[0m`);
+                    console.log(`  Annualized:     \x1b[32m${annualized.toFixed(2)}%\x1b[0m`);
+                    console.log(`  Est. Daily:     \x1b[32m$${dailyProfit.toFixed(2)}\x1b[0m`);
+                    console.log("  " + "─".repeat(45));
+                    console.log("");
+                }
+                if (opts.dryRun) {
+                    if (isJson) {
+                        emitJson({
+                            status: "dry_run",
+                            market,
+                            asset: assetName,
+                            testnet: ctx.config.testnet,
+                            requestedSizeUsd,
+                            plan,
+                        });
+                    }
+                    else {
+                        console.log("  \x1b[33m[DRY RUN]\x1b[0m Execution skipped.\n");
+                    }
+                    return;
+                }
+                if (!opts.yes) {
+                    const confirmed = await confirm({
+                        message: "Execute this arbitrage trade?",
+                        default: false,
+                    });
+                    if (!confirmed) {
+                        if (isJson) {
+                            emitJson({
+                                status: "cancelled",
+                                reason: "user_declined_confirmation",
+                                market,
+                                asset: assetName,
+                                plan,
+                            });
+                        }
+                        else {
+                            console.log("\n  Execution cancelled.\n");
+                        }
+                        process.exitCode = EXIT_CODES.CANCELLED;
+                        return;
+                    }
+                }
+                const shortSize = (sizeUsd / shortPrice).toFixed(8);
+                const longSize = (sizeUsd / longPrice).toFixed(8);
+                const shouldAttachTpSl = opts.tp !== undefined || opts.sl !== undefined;
+                const tp = opts.tp !== undefined ? parseFloat(opts.tp) : ctx.config.executionSafety.takeProfitPct;
+                const sl = opts.sl !== undefined ? parseFloat(opts.sl) : ctx.config.executionSafety.stopLossPct;
+                const closeThenFlip = opts.closeThenFlip ?? true;
+                const spreadAware = opts.spreadAware ?? true;
+                const idempotencyPrefix = opts.idempotencyKey?.trim() || undefined;
+                if (shouldAttachTpSl) {
+                    if (!Number.isFinite(tp) || tp <= 0) {
+                        throw new CLIError("TP must be a positive number", EXIT_CODES.VALIDATION_ERROR);
+                    }
+                    if (!Number.isFinite(sl) || sl <= 0) {
+                        throw new CLIError("SL must be a positive number", EXIT_CODES.VALIDATION_ERROR);
+                    }
+                }
+                if (!isJson) {
+                    console.log("\n  \x1b[36mExecuting...\x1b[0m\n");
+                }
+                if (!isJson) {
+                    console.log(`  Opening SHORT on ${highest.exchange}...`);
+                }
+                const shortJournal = await runWithExecutionJournal({
+                    idempotencyKey: idempotencyPrefix ? `${idempotencyPrefix}:short` : undefined,
+                    metadata: {
+                        command: "arb.execute.short",
+                        exchange: shortExchangeId,
+                        testnet: ctx.config.testnet,
+                        market,
+                        side: "short",
+                        orderType: "market",
+                    },
+                    request: {
+                        market,
+                        side: "short",
+                        size: shortSize,
+                        closeThenFlip,
+                        spreadAware,
+                        spreadOffset: ctx.config.executionSafety.spreadOffset,
+                        tp: shouldAttachTpSl ? tp : null,
+                        sl: shouldAttachTpSl ? sl : null,
+                        requestedSizeUsd,
+                        adjustedSizeUsd: sizeUsd,
+                        confidence,
+                    },
+                    execute: async () => {
+                        const result = await executeOrderWithSafety(shortAdapter, {
+                            market,
+                            side: "short",
+                            type: "market",
+                            size: shortSize,
+                        }, {
+                            closeThenFlip,
+                            spreadAwarePricing: spreadAware,
+                            spreadOffset: ctx.config.executionSafety.spreadOffset,
+                            attachTpSl: shouldAttachTpSl,
+                            tpSlConfig: shouldAttachTpSl
+                                ? { stopLossPct: sl, takeProfitPct: tp }
+                                : undefined,
+                        });
+                        return {
+                            order: {
+                                id: result.order.id,
+                                market: result.order.market,
+                                side: result.order.side,
+                                size: result.order.size,
+                                status: result.order.status,
+                                price: result.order.price,
+                            },
+                            safety: {
+                                closedOppositePosition: result.closedOppositePosition,
+                                tpSlOrderIds: result.tpSlOrderIds,
+                                pricing: result.pricing,
+                            },
+                        };
+                    },
+                });
+                if (!isJson) {
+                    console.log(`  ✓ Short ${shortJournal.replayed ? "replayed" : "opened"}: ${shortJournal.result.order.id}`);
+                }
+                if (!isJson) {
+                    console.log(`  Opening LONG on ${lowest.exchange}...`);
+                }
+                let longJournal = null;
+                try {
+                    longJournal = await runWithExecutionJournal({
+                        idempotencyKey: idempotencyPrefix ? `${idempotencyPrefix}:long` : undefined,
+                        metadata: {
+                            command: "arb.execute.long",
+                            exchange: longExchangeId,
+                            testnet: ctx.config.testnet,
+                            market,
+                            side: "long",
+                            orderType: "market",
+                        },
+                        request: {
+                            market,
+                            side: "long",
+                            size: longSize,
+                            closeThenFlip,
+                            spreadAware,
+                            spreadOffset: ctx.config.executionSafety.spreadOffset,
+                            tp: shouldAttachTpSl ? tp : null,
+                            sl: shouldAttachTpSl ? sl : null,
+                            requestedSizeUsd,
+                            adjustedSizeUsd: sizeUsd,
+                            confidence,
+                        },
+                        execute: async () => {
+                            const result = await executeOrderWithSafety(longAdapter, {
+                                market,
+                                side: "long",
+                                type: "market",
+                                size: longSize,
+                            }, {
+                                closeThenFlip,
+                                spreadAwarePricing: spreadAware,
+                                spreadOffset: ctx.config.executionSafety.spreadOffset,
+                                attachTpSl: shouldAttachTpSl,
+                                tpSlConfig: shouldAttachTpSl
+                                    ? { stopLossPct: sl, takeProfitPct: tp }
+                                    : undefined,
+                            });
+                            return {
+                                order: {
+                                    id: result.order.id,
+                                    market: result.order.market,
+                                    side: result.order.side,
+                                    size: result.order.size,
+                                    status: result.order.status,
+                                    price: result.order.price,
+                                },
+                                safety: {
+                                    closedOppositePosition: result.closedOppositePosition,
+                                    tpSlOrderIds: result.tpSlOrderIds,
+                                    pricing: result.pricing,
+                                },
+                            };
+                        },
+                    });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (isJson) {
+                        emitJson({
+                            status: "partial_failure",
+                            market,
+                            asset: assetName,
+                            testnet: ctx.config.testnet,
+                            plan,
+                            error: {
+                                message,
+                                exitCode: EXIT_CODES.PARTIAL_EXECUTION,
+                            },
+                            execution: {
+                                short: {
+                                    exchange: highest.exchange,
+                                    exchangeId: shortExchangeId,
+                                    ...shortJournal.result,
+                                    idempotency: {
+                                        key: shortJournal.idempotencyKey,
+                                        replayed: shortJournal.replayed,
+                                        autoGenerated: shortJournal.autoGeneratedKey,
+                                        journalId: shortJournal.journalId,
+                                    },
+                                },
+                            },
+                        });
+                    }
+                    else {
+                        console.error("\n  \x1b[31mExecution failed on long leg:\x1b[0m", message);
+                        console.log("  \x1b[33mWarning:\x1b[0m Short leg may be open. Check positions manually.\n");
+                    }
+                    process.exitCode = EXIT_CODES.PARTIAL_EXECUTION;
+                    return;
+                }
+                if (!longJournal) {
+                    throw new CLIError("Long-leg journal result missing", EXIT_CODES.EXECUTION_ERROR);
+                }
+                if (!isJson) {
+                    console.log(`  ✓ Long ${longJournal.replayed ? "replayed" : "opened"}: ${longJournal.result.order.id}`);
+                    console.log("\n  \x1b[32m━━━ Arbitrage Executed ━━━\x1b[0m");
+                    if (shortJournal.result.safety.tpSlOrderIds.length > 0 ||
+                        longJournal.result.safety.tpSlOrderIds.length > 0) {
+                        console.log("  TP/SL attached on opened legs");
+                    }
+                    console.log(`  Monitor positions with: perps -e ${shortExchangeId} account positions`);
+                    console.log(`                      and: perps -e ${longExchangeId} account positions`);
+                    console.log("");
+                }
+                else {
+                    emitJson({
+                        status: "executed",
+                        market,
+                        asset: assetName,
+                        testnet: ctx.config.testnet,
+                        requestedSizeUsd,
+                        plan,
+                        execution: {
+                            short: {
+                                exchange: highest.exchange,
+                                exchangeId: shortExchangeId,
+                                ...shortJournal.result,
+                                idempotency: {
+                                    key: shortJournal.idempotencyKey,
+                                    replayed: shortJournal.replayed,
+                                    autoGenerated: shortJournal.autoGeneratedKey,
+                                    journalId: shortJournal.journalId,
+                                },
+                            },
+                            long: {
+                                exchange: lowest.exchange,
+                                exchangeId: longExchangeId,
+                                ...longJournal.result,
+                                idempotency: {
+                                    key: longJournal.idempotencyKey,
+                                    replayed: longJournal.replayed,
+                                    autoGenerated: longJournal.autoGeneratedKey,
+                                    journalId: longJournal.journalId,
+                                },
+                            },
+                        },
+                    });
+                }
+            }
+            finally {
+                await Promise.allSettled([shortAdapter.disconnect(), longAdapter.disconnect()]);
+            }
+        }
+        catch (err) {
+            const code = inferExitCode(err);
+            const message = err instanceof Error ? err.message : String(err);
+            if (isJson) {
+                emitJson({
+                    status: "error",
+                    error: {
+                        message,
+                        exitCode: code,
+                    },
+                });
+            }
+            else {
+                outputError(message);
+            }
+            process.exit(code);
+        }
+    });
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Arb Funding Command
+ * Compare funding rates across exchanges
+ */
+import { Command } from "commander";
+export declare function registerArbFundingCommand(arb: Command): void;

package/dist/commands/arb/funding.js

@@ -0,0 +1,201 @@
+/**
+ * Arb Funding Command
+ * Compare funding rates across exchanges
+ */
+import { highlighter } from "../../cli/experience.js";
+import { output, outputError } from "../../cli/output.js";
+import { getContext, getOutputOptions } from "../../cli/program.js";
+import { getAvailableExchanges, getExchangeAdapterById } from "../../lib/exchange.js";
+export function registerArbFundingCommand(arb) {
+    arb
+        .command("funding [asset]")
+        .description("Compare funding rates across exchanges")
+        .option("--all", "Show funding for common assets")
+        .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 (opts.all) {
+                await showAllFunding(exchanges, outputOpts.json, isTestnet);
+            }
+            else {
+                await showFunding(asset?.toUpperCase() || "BTC", exchanges, outputOpts.json, isTestnet);
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+}
+async function fetchFunding(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;
+            const symbol = `${asset}-PERP`;
+            const funding = await adapter.getFundingRate(symbol);
+            const rate = parseFloat(funding.rate) * 100; // Convert to percentage
+            return {
+                exchange: adapter.info.name,
+                symbol: funding.market,
+                rate,
+                annualized: rate * 24 * 365, // Hourly rate * 24 hours * 365 days
+                nextFunding: funding.nextFundingTime,
+            };
+        }
+        catch (err) {
+            return {
+                exchange: adapter.info.name,
+                symbol: `${asset}-PERP`,
+                rate: 0,
+                annualized: 0,
+                nextFunding: 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 showFunding(asset, exchanges, json, isTestnet) {
+    if (!json) {
+        console.log(`\nFetching ${asset} funding rates...\n`);
+    }
+    const rates = await fetchFunding(asset, exchanges, isTestnet);
+    const validRates = rates.filter((r) => !r.error);
+    if (validRates.length === 0) {
+        if (json) {
+            output({
+                status: "no_data",
+                asset,
+                rates: [],
+                exchangesScanned: exchanges.length,
+            }, { json: true });
+            return;
+        }
+        console.log(`No funding data found for ${asset}`);
+        return;
+    }
+    // Find highest and lowest
+    const sorted = [...validRates].sort((a, b) => b.rate - a.rate);
+    const highest = sorted[0];
+    const lowest = sorted[sorted.length - 1];
+    const delta = highest.rate - lowest.rate;
+    const data = {
+        asset,
+        rates: validRates,
+        spread: {
+            high: { exchange: highest.exchange, rate: highest.rate },
+            low: { exchange: lowest.exchange, rate: lowest.rate },
+            delta,
+            annualizedDelta: delta * 24 * 365,
+        },
+        timestamp: Date.now(),
+    };
+    if (json) {
+        output(data, { json: true });
+        return;
+    }
+    // Table output
+    console.log(`  ${asset}-PERP Funding Rate Comparison\n`);
+    console.log("  Exchange".padEnd(18) + "Rate (1h)".padEnd(16) + "Annualized".padEnd(16) + "Next Funding");
+    console.log("  " + "─".repeat(65));
+    const colorRate = (value, text) => value >= 0 ? highlighter.success(text) : highlighter.error(text);
+    for (const r of sorted) {
+        const sign = r.rate >= 0 ? "+" : "";
+        const rateStr = `${sign}${r.rate.toFixed(4)}%`;
+        const annStr = `${sign}${r.annualized.toFixed(2)}%`;
+        const nextFundingStr = r.nextFunding > 0 ? new Date(r.nextFunding).toLocaleTimeString() : "N/A";
+        // Use fixed-width fields before coloring to avoid ANSI padding issues
+        console.log(`  ${r.exchange.padEnd(16)}` +
+            `${colorRate(r.rate, rateStr.padEnd(16))}` +
+            `${colorRate(r.annualized, annStr.padEnd(16))}` +
+            nextFundingStr);
+    }
+    // Show errors
+    const errors = rates.filter((r) => r.error);
+    if (errors.length > 0) {
+        console.log(`\n  ${highlighter.warn("Not available on:")} ${errors.map((e) => e.exchange).join(", ")}`);
+    }
+    // Show arbitrage opportunity
+    console.log("\n  " + "─".repeat(65));
+    if (delta > 0.001) {
+        // Only show if meaningful spread
+        console.log(`\n  ${highlighter.success("Funding Rate Arbitrage Opportunity")}`);
+        console.log(`  Short on ${highest.exchange} (paying ${highest.rate.toFixed(4)}%)`);
+        console.log(`  Long on ${lowest.exchange} (paying ${lowest.rate.toFixed(4)}%)`);
+        console.log(`  Delta: ${delta.toFixed(4)}% per hour (${(delta * 24 * 365).toFixed(2)}% annualized)`);
+        // Calculate daily profit on $10k position
+        const dailyProfit = (delta / 100) * 24 * 10000;
+        console.log(`  ~$${dailyProfit.toFixed(2)}/day on $10k delta-neutral position`);
+    }
+    else {
+        console.log(`\n  No significant funding rate spread (${delta.toFixed(4)}%)`);
+    }
+    console.log("");
+}
+async function showAllFunding(exchanges, json, isTestnet) {
+    const assets = ["BTC", "ETH", "SOL", "DOGE", "ARB", "OP"];
+    const rows = [];
+    if (!json) {
+        console.log("\nFetching funding rates for common assets...\n");
+        console.log("  Asset".padEnd(10) + "Highest".padEnd(28) + "Lowest".padEnd(28) + "Spread (Ann.)");
+        console.log("  " + "─".repeat(80));
+    }
+    for (const asset of assets) {
+        const rates = await fetchFunding(asset, exchanges, isTestnet);
+        const validRates = rates.filter((r) => !r.error);
+        if (validRates.length < 2) {
+            if (!json) {
+                console.log(`  ${asset.padEnd(8)}  Available on <2 exchanges`);
+            }
+            continue;
+        }
+        const sorted = [...validRates].sort((a, b) => b.rate - a.rate);
+        const highest = sorted[0];
+        const lowest = sorted[sorted.length - 1];
+        const delta = highest.rate - lowest.rate;
+        const annDelta = delta * 24 * 365;
+        rows.push({
+            asset,
+            highest: { exchange: highest.exchange, rate: highest.rate },
+            lowest: { exchange: lowest.exchange, rate: lowest.rate },
+            spreadAnnualized: annDelta,
+            timestamp: Date.now(),
+        });
+        if (!json) {
+            const colorRate = (value, text) => value >= 0 ? highlighter.success(text) : highlighter.error(text);
+            const highSign = highest.rate >= 0 ? "+" : "";
+            const lowSign = lowest.rate >= 0 ? "+" : "";
+            const highStr = `${highSign}${highest.rate.toFixed(4)}%`;
+            const lowStr = `${lowSign}${lowest.rate.toFixed(4)}%`;
+            const deltaStr = `${annDelta.toFixed(2)}%`;
+            console.log(`  ${asset.padEnd(8)}` +
+                `${highest.exchange.padEnd(12)} ${colorRate(highest.rate, highStr.padEnd(12))}  ` +
+                `${lowest.exchange.padEnd(12)} ${colorRate(lowest.rate, lowStr.padEnd(12))}  ` +
+                (annDelta > 10 ? highlighter.success(deltaStr) : highlighter.dim(deltaStr)));
+        }
+    }
+    if (json) {
+        output(rows, { json: true });
+        return;
+    }
+    console.log("");
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Arb History Command
+ * View historical funding rate spreads
+ */
+import { Command } from "commander";
+export declare function registerArbHistoryCommand(arb: Command): void;