@raintree-technology/perps 0.1.0

package/dist/commands/arb/compare.js

@@ -0,0 +1,216 @@
+/**
+ * Arb Compare Command
+ * Compare arbitrage opportunities across all assets
+ */
+import { getContext, getOutputOptions } from "../../cli/program.js";
+import { output, outputError } from "../../cli/output.js";
+import { getExchangeAdapterById, getAvailableExchanges } from "../../lib/exchange.js";
+import { getSpreadStats, storeFundingRates } from "../../lib/db/funding-history.js";
+import { COMMON_ASSETS, DEFAULT_WATCH_INTERVAL_SEC } from "../../lib/constants.js";
+import { pLimit } from "../../lib/rate-limit.js";
+import { parseAssetList, parsePositiveInt } from "../../lib/validate.js";
+export function registerArbCompareCommand(arb) {
+    arb
+        .command("compare")
+        .description("Compare arbitrage opportunities across all assets")
+        .option("-a, --assets <assets>", "Comma-separated assets", COMMON_ASSETS.join(","))
+        .option("--min-spread <percent>", "Minimum annualized spread to show", "0")
+        .option("--sort <field>", "Sort by: spread, consistency, daily", "spread")
+        .option("-w, --watch", "Continuous monitoring mode")
+        .option("-i, --interval <seconds>", "Refresh interval for watch mode", String(DEFAULT_WATCH_INTERVAL_SEC))
+        .option("--store", "Store funding data to database while watching")
+        .action(async function () {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        const assets = parseAssetList(opts.assets, COMMON_ASSETS);
+        const minSpread = parseFloat(opts.minSpread) || 0;
+        const exchanges = getAvailableExchanges();
+        const intervalSec = parsePositiveInt(opts.interval, "interval", DEFAULT_WATCH_INTERVAL_SEC);
+        const isTestnet = ctx.config.testnet;
+        if (opts.watch) {
+            // Watch mode - continuous monitoring
+            console.clear();
+            console.log("  \x1b[1mFunding Rate Monitor\x1b[0m - Refreshing every " + intervalSec + "s (Ctrl+C to stop)\n");
+            const runOnce = async () => {
+                try {
+                    const startTime = Date.now();
+                    const opportunities = await fetchAllOpportunities(assets, exchanges, minSpread, isTestnet, opts.store ?? false);
+                    sortOpportunities(opportunities, opts.sort);
+                    // Clear and redraw
+                    console.clear();
+                    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                    console.log(`  \x1b[1mFunding Rate Monitor\x1b[0m - Updated ${new Date().toLocaleTimeString()} (${elapsed}s) | Refresh: ${intervalSec}s\n`);
+                    displayOpportunities(opportunities, opts.store ?? false);
+                }
+                catch (err) {
+                    console.error(`  \x1b[31mError:\x1b[0m ${err instanceof Error ? err.message : err}`);
+                }
+            };
+            // Run immediately
+            await runOnce();
+            // Then on interval
+            const interval = setInterval(runOnce, intervalSec * 1000);
+            // Handle Ctrl+C
+            process.once("SIGINT", () => {
+                clearInterval(interval);
+                console.log("\n\n  Monitor stopped.\n");
+                process.exit(0);
+            });
+            // Keep running
+            await new Promise(() => { });
+        }
+        else {
+            // One-shot mode
+            try {
+                if (!outputOpts.json) {
+                    console.log("\n  Fetching funding rates across all exchanges...\n");
+                }
+                const opportunities = await fetchAllOpportunities(assets, exchanges, minSpread, isTestnet, false);
+                sortOpportunities(opportunities, opts.sort);
+                if (outputOpts.json) {
+                    output({ opportunities }, { json: true });
+                    return;
+                }
+                displayOpportunities(opportunities, false);
+            }
+            catch (err) {
+                outputError(err instanceof Error ? err.message : String(err));
+                process.exit(1);
+            }
+        }
+    });
+}
+async function fetchAllOpportunities(assets, exchanges, minSpread, isTestnet, storeData = false) {
+    const opportunities = [];
+    const now = Date.now();
+    for (const asset of assets) {
+        try {
+            const rates = await fetchFundingForAsset(asset, exchanges, isTestnet);
+            if (rates.length < 2)
+                continue;
+            // Store to database if requested
+            if (storeData) {
+                const records = rates.map(r => ({
+                    exchange: r.exchange,
+                    market: `${asset}-PERP`,
+                    rate: r.rate,
+                    annualized: r.rate * 24 * 365 * 100,
+                    recordedAt: now,
+                }));
+                storeFundingRates(records);
+            }
+            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) * 100; // Convert to percentage
+            const annualized = spread * 24 * 365;
+            if (annualized < minSpread)
+                continue;
+            // Get historical stats if available
+            const stats = getSpreadStats(`${asset}-PERP`, 24);
+            opportunities.push({
+                asset,
+                spread,
+                annualized,
+                shortExchange: highest.exchange,
+                shortRate: highest.rate * 100,
+                longExchange: lowest.exchange,
+                longRate: lowest.rate * 100,
+                dailyOn10k: (spread / 100) * 24 * 10000,
+                consistency: stats.samples > 0 ? stats.consistency : undefined,
+                samples: stats.samples > 0 ? stats.samples : undefined,
+            });
+        }
+        catch {
+            // Skip assets that fail
+        }
+    }
+    return opportunities;
+}
+function sortOpportunities(opportunities, sortField) {
+    if (sortField === "consistency") {
+        opportunities.sort((a, b) => (b.consistency || 0) - (a.consistency || 0));
+    }
+    else if (sortField === "daily") {
+        opportunities.sort((a, b) => b.dailyOn10k - a.dailyOn10k);
+    }
+    else {
+        opportunities.sort((a, b) => b.annualized - a.annualized);
+    }
+}
+function displayOpportunities(opportunities, showStored) {
+    if (opportunities.length === 0) {
+        console.log("  No opportunities found above threshold.\n");
+        return;
+    }
+    // Display table
+    console.log("  " +
+        "Asset".padEnd(8) +
+        "Spread".padEnd(10) +
+        "Annual".padEnd(10) +
+        "$/day".padEnd(10) +
+        "Short".padEnd(16) +
+        "Long".padEnd(16) +
+        "Consistency");
+    console.log("  " + "─".repeat(85));
+    for (const opp of opportunities) {
+        const spreadColor = opp.annualized >= 50 ? "\x1b[32m" : opp.annualized >= 20 ? "\x1b[33m" : "\x1b[90m";
+        const consistColor = opp.consistency !== undefined
+            ? opp.consistency >= 80 ? "\x1b[32m" : opp.consistency >= 50 ? "\x1b[33m" : "\x1b[31m"
+            : "\x1b[90m";
+        const consistStr = opp.consistency !== undefined
+            ? `${opp.consistency.toFixed(0)}% (${opp.samples})`
+            : "no data";
+        console.log(`  ${opp.asset.padEnd(8)}` +
+            `${spreadColor}${opp.spread.toFixed(4)}%\x1b[0m`.padEnd(19) +
+            `${spreadColor}${opp.annualized.toFixed(1)}%\x1b[0m`.padEnd(19) +
+            `${spreadColor}$${opp.dailyOn10k.toFixed(2)}\x1b[0m`.padEnd(19) +
+            `${opp.shortExchange.substring(0, 12).padEnd(16)}` +
+            `${opp.longExchange.substring(0, 12).padEnd(16)}` +
+            `${consistColor}${consistStr}\x1b[0m`);
+    }
+    console.log("  " + "─".repeat(85));
+    // Summary
+    const bestOpp = opportunities[0];
+    if (bestOpp && bestOpp.annualized >= 20) {
+        console.log(`\n  \x1b[32mBest:\x1b[0m ${bestOpp.asset} ${bestOpp.annualized.toFixed(1)}% | Short ${bestOpp.shortExchange} / Long ${bestOpp.longExchange}`);
+    }
+    if (showStored) {
+        console.log(`  \x1b[90mData stored to database\x1b[0m`);
+    }
+    console.log("");
+}
+async function fetchFundingForAsset(asset, exchanges, isTestnet) {
+    const results = [];
+    const market = `${asset}-PERP`;
+    // Use rate-limited parallel execution
+    const tasks = exchanges.map((exchangeId) => async () => {
+        const adapter = getExchangeAdapterById(exchangeId);
+        let connected = false;
+        try {
+            await adapter.connect({ testnet: isTestnet });
+            connected = true;
+            const funding = await adapter.getFundingRate(market);
+            return {
+                exchange: adapter.info.name,
+                rate: parseFloat(funding.rate),
+            };
+        }
+        catch {
+            return null;
+        }
+        finally {
+            if (connected) {
+                await adapter.disconnect().catch(() => undefined);
+            }
+        }
+    });
+    const settled = await pLimit(tasks, 3); // Max 3 concurrent requests
+    for (const result of settled) {
+        if (result.status === "fulfilled" && result.value) {
+            results.push(result.value);
+        }
+    }
+    return results;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Arb Execute Command
+ * Execute delta-neutral funding arbitrage across exchanges
+ */
+import { Command } from "commander";
+export declare function registerArbExecuteCommand(arb: Command): void;