openbroker 1.0.33

package/scripts/strategies/funding-arb.ts

@@ -0,0 +1,319 @@
+#!/usr/bin/env npx tsx
+// Funding Arbitrage Strategy - Collect funding by being on the paying side
+
+import { getClient } from '../core/client.js';
+import { formatUsd, formatPercent, parseArgs, sleep, annualizeFundingRate } from '../core/utils.js';
+
+function printUsage() {
+  console.log(`
+Open Broker - Funding Arbitrage
+===============================
+
+Collect funding payments by taking positions opposite to the majority.
+When funding is positive (longs pay shorts), go short to collect.
+When funding is negative (shorts pay longs), go long to collect.
+
+Usage:
+  npx tsx scripts/strategies/funding-arb.ts --coin <COIN> --size <SIZE> [options]
+
+Options:
+  --coin          Asset to trade (e.g., ETH, BTC)
+  --size          Position size in USD notional
+  --min-funding   Minimum annualized funding rate to enter (default: 20%)
+  --max-funding   Maximum funding rate - avoid extreme rates (default: 200%)
+  --duration      How long to run in hours (default: runs until stopped)
+  --check         Interval to check funding in minutes (default: 60)
+  --close-at      Close position when funding drops below X% (default: 5%)
+  --dry           Dry run - show opportunities without trading
+
+Modes:
+  --mode perp     Perp only - directional exposure to funding (default)
+  --mode hedge    Open opposite spot position for delta neutral (requires spot)
+
+Examples:
+  # Monitor ETH funding, enter $5000 short if funding > 25% annualized
+  npx tsx scripts/strategies/funding-arb.ts --coin ETH --size 5000 --min-funding 25
+
+  # Run for 24 hours, check every 30 minutes
+  npx tsx scripts/strategies/funding-arb.ts --coin BTC --size 10000 --duration 24 --check 30
+
+  # Preview current opportunities
+  npx tsx scripts/strategies/funding-arb.ts --coin ETH --size 5000 --dry
+
+Funding Info:
+  - Hyperliquid funding is paid HOURLY (not 8h like CEXs)
+  - Positive rate: longs pay shorts (go short to collect)
+  - Negative rate: shorts pay longs (go long to collect)
+  - Annualized = hourly rate × 8760
+`);
+}
+
+interface FundingPosition {
+  coin: string;
+  side: 'long' | 'short';
+  size: number;
+  entryPrice: number;
+  entryFunding: number;
+  entryTime: Date;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  const coin = args.coin as string;
+  const notionalSize = parseFloat(args.size as string);
+  const minFunding = args['min-funding'] ? parseFloat(args['min-funding'] as string) : 20;
+  const maxFunding = args['max-funding'] ? parseFloat(args['max-funding'] as string) : 200;
+  const durationHours = args.duration ? parseFloat(args.duration as string) : Infinity;
+  const checkIntervalMins = args.check ? parseFloat(args.check as string) : 60;
+  const closeAt = args['close-at'] ? parseFloat(args['close-at'] as string) : 5;
+  const mode = (args.mode as string) || 'perp';
+  const dryRun = args.dry as boolean;
+
+  if (!coin || isNaN(notionalSize)) {
+    printUsage();
+    process.exit(1);
+  }
+
+  if (mode !== 'perp' && mode !== 'hedge') {
+    console.error('Error: --mode must be "perp" or "hedge"');
+    process.exit(1);
+  }
+
+  if (mode === 'hedge') {
+    console.error('Error: Hedge mode (perp + spot) not yet implemented');
+    process.exit(1);
+  }
+
+  const client = getClient();
+
+  if (args.verbose) {
+    client.verbose = true;
+  }
+
+  console.log('Open Broker - Funding Arbitrage');
+  console.log('===============================\n');
+
+  try {
+    // Initial funding check
+    await client.getMetaAndAssetCtxs();
+    const meta = await client.getMetaAndAssetCtxs();
+    const assetIndex = client.getAssetIndex(coin);
+    const assetCtx = meta.assetCtxs[assetIndex];
+
+    const mids = await client.getAllMids();
+    const midPrice = parseFloat(mids[coin]);
+    if (!midPrice) {
+      console.error(`Error: No market data for ${coin}`);
+      process.exit(1);
+    }
+
+    const hourlyFunding = parseFloat(assetCtx.funding);
+    const annualizedFunding = annualizeFundingRate(hourlyFunding) * 100; // as percentage
+    const openInterest = parseFloat(assetCtx.openInterest);
+    const positionSize = notionalSize / midPrice;
+
+    console.log('Current Market State');
+    console.log('--------------------');
+    console.log(`Coin:              ${coin}`);
+    console.log(`Mid Price:         ${formatUsd(midPrice)}`);
+    console.log(`Hourly Funding:    ${(hourlyFunding * 100).toFixed(4)}%`);
+    console.log(`Annualized:        ${annualizedFunding.toFixed(2)}%`);
+    console.log(`Open Interest:     ${formatUsd(openInterest)}`);
+    console.log(`\nStrategy Config`);
+    console.log('---------------');
+    console.log(`Target Notional:   ${formatUsd(notionalSize)}`);
+    console.log(`Position Size:     ${positionSize.toFixed(6)} ${coin}`);
+    console.log(`Min Funding:       ${minFunding}% annualized`);
+    console.log(`Max Funding:       ${maxFunding}% annualized`);
+    console.log(`Close At:          ${closeAt}% annualized`);
+    console.log(`Check Interval:    ${checkIntervalMins} minutes`);
+    console.log(`Mode:              ${mode.toUpperCase()}`);
+
+    // Determine action based on funding
+    const absAnnualized = Math.abs(annualizedFunding);
+    const shouldGoShort = annualizedFunding > 0; // Positive funding = longs pay shorts
+    const suggestedSide = shouldGoShort ? 'SHORT' : 'LONG';
+
+    console.log(`\nFunding Analysis`);
+    console.log('----------------');
+    if (absAnnualized >= minFunding && absAnnualized <= maxFunding) {
+      console.log(`Status:            OPPORTUNITY FOUND`);
+      console.log(`Suggested:         ${suggestedSide} to collect ${absAnnualized.toFixed(2)}% APR`);
+
+      const hourlyPayment = Math.abs(hourlyFunding) * notionalSize;
+      const dailyPayment = hourlyPayment * 24;
+      const monthlyPayment = dailyPayment * 30;
+      console.log(`\nEstimated Funding Income:`);
+      console.log(`  Hourly:          ${formatUsd(hourlyPayment)}`);
+      console.log(`  Daily:           ${formatUsd(dailyPayment)}`);
+      console.log(`  Monthly:         ${formatUsd(monthlyPayment)}`);
+    } else if (absAnnualized < minFunding) {
+      console.log(`Status:            FUNDING TOO LOW (${absAnnualized.toFixed(2)}% < ${minFunding}%)`);
+      console.log(`Action:            Wait for higher funding rates`);
+    } else {
+      console.log(`Status:            FUNDING TOO HIGH (${absAnnualized.toFixed(2)}% > ${maxFunding}%)`);
+      console.log(`Action:            Risk of squeeze, skip this opportunity`);
+    }
+
+    if (dryRun) {
+      console.log('\n--- Dry run complete ---');
+      return;
+    }
+
+    // Check if we should enter
+    if (absAnnualized < minFunding || absAnnualized > maxFunding) {
+      console.log('\nNo action taken - funding outside target range.');
+
+      if (durationHours === Infinity) {
+        console.log('Exiting. Use --duration to run continuous monitoring.');
+        return;
+      }
+    }
+
+    // Execute entry if conditions met
+    let position: FundingPosition | null = null;
+
+    if (absAnnualized >= minFunding && absAnnualized <= maxFunding) {
+      console.log(`\nOpening ${suggestedSide} position...`);
+
+      const isBuy = !shouldGoShort;
+      const response = await client.marketOrder(coin, isBuy, positionSize);
+
+      if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+        const status = response.response.data.statuses[0];
+        if (status?.filled) {
+          const avgPrice = parseFloat(status.filled.avgPx);
+          const filledSize = parseFloat(status.filled.totalSz);
+          console.log(`  Entry filled: ${filledSize} ${coin} @ ${formatUsd(avgPrice)}`);
+
+          position = {
+            coin,
+            side: shouldGoShort ? 'short' : 'long',
+            size: filledSize,
+            entryPrice: avgPrice,
+            entryFunding: annualizedFunding,
+            entryTime: new Date(),
+          };
+        } else if (status?.error) {
+          console.log(`  Entry failed: ${status.error}`);
+        }
+      } else {
+        console.log(`  Entry failed: ${typeof response.response === 'string' ? response.response : 'Unknown error'}`);
+      }
+    }
+
+    // Monitoring loop
+    if (durationHours !== Infinity || position) {
+      const endTime = durationHours === Infinity ? Infinity : Date.now() + durationHours * 3600 * 1000;
+      const checkInterval = checkIntervalMins * 60 * 1000;
+
+      console.log(`\nMonitoring funding rates...`);
+      console.log(`(Press Ctrl+C to exit)\n`);
+
+      let totalFundingCollected = 0;
+      let lastCheck = Date.now();
+
+      while (Date.now() < endTime) {
+        await sleep(checkInterval);
+
+        // Get updated funding
+        const newMeta = await client.getMetaAndAssetCtxs();
+        const newAssetCtx = newMeta.assetCtxs[assetIndex];
+        const newHourlyFunding = parseFloat(newAssetCtx.funding);
+        const newAnnualized = annualizeFundingRate(newHourlyFunding) * 100;
+        const newMids = await client.getAllMids();
+        const newPrice = parseFloat(newMids[coin]);
+
+        const timeElapsed = (Date.now() - lastCheck) / 3600000; // hours
+        lastCheck = Date.now();
+
+        console.log(`[${new Date().toLocaleTimeString()}] ${coin}: ${newAnnualized.toFixed(2)}% APR, Price: ${formatUsd(newPrice)}`);
+
+        if (position) {
+          // Calculate funding collected
+          const fundingCollected = Math.abs(newHourlyFunding) * position.size * newPrice * timeElapsed;
+          totalFundingCollected += fundingCollected;
+
+          // Calculate PnL
+          const pricePnl = position.side === 'long'
+            ? (newPrice - position.entryPrice) * position.size
+            : (position.entryPrice - newPrice) * position.size;
+          const totalPnl = pricePnl + totalFundingCollected;
+
+          console.log(`  Position: ${position.side.toUpperCase()} ${position.size.toFixed(6)} @ ${formatUsd(position.entryPrice)}`);
+          console.log(`  Price PnL: ${formatUsd(pricePnl)}, Funding: ${formatUsd(totalFundingCollected)}, Total: ${formatUsd(totalPnl)}`);
+
+          // Check if we should close
+          const shouldClose =
+            (position.side === 'short' && newAnnualized < closeAt) ||
+            (position.side === 'long' && newAnnualized > -closeAt);
+
+          if (shouldClose) {
+            console.log(`\n  Funding dropped below ${closeAt}%, closing position...`);
+
+            const closeIsBuy = position.side === 'short';
+            const closeResponse = await client.marketOrder(coin, closeIsBuy, position.size);
+
+            if (closeResponse.status === 'ok' && closeResponse.response && typeof closeResponse.response === 'object') {
+              const closeStatus = closeResponse.response.data.statuses[0];
+              if (closeStatus?.filled) {
+                const exitPrice = parseFloat(closeStatus.filled.avgPx);
+                console.log(`  Closed @ ${formatUsd(exitPrice)}`);
+                console.log(`\n  === Position Summary ===`);
+                console.log(`  Entry:    ${formatUsd(position.entryPrice)}`);
+                console.log(`  Exit:     ${formatUsd(exitPrice)}`);
+                console.log(`  Price PnL: ${formatUsd(pricePnl)}`);
+                console.log(`  Funding:   ${formatUsd(totalFundingCollected)}`);
+                console.log(`  Total PnL: ${formatUsd(totalPnl)}`);
+                position = null;
+              }
+            }
+          }
+        } else {
+          // No position - check if we should enter
+          const absNewAnnualized = Math.abs(newAnnualized);
+          if (absNewAnnualized >= minFunding && absNewAnnualized <= maxFunding) {
+            const enterShort = newAnnualized > 0;
+            const enterSide = enterShort ? 'SHORT' : 'LONG';
+            console.log(`  Funding opportunity: ${enterSide} at ${absNewAnnualized.toFixed(2)}% APR`);
+
+            const enterIsBuy = !enterShort;
+            const currentSize = notionalSize / newPrice;
+            const response = await client.marketOrder(coin, enterIsBuy, currentSize);
+
+            if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+              const status = response.response.data.statuses[0];
+              if (status?.filled) {
+                position = {
+                  coin,
+                  side: enterShort ? 'short' : 'long',
+                  size: parseFloat(status.filled.totalSz),
+                  entryPrice: parseFloat(status.filled.avgPx),
+                  entryFunding: newAnnualized,
+                  entryTime: new Date(),
+                };
+                console.log(`  Entered ${enterSide} ${position.size.toFixed(6)} @ ${formatUsd(position.entryPrice)}`);
+              }
+            }
+          }
+        }
+
+        console.log('');
+      }
+
+      // Close any remaining position at end of duration
+      if (position) {
+        console.log(`\nDuration ended. Closing position...`);
+        const closeIsBuy = position.side === 'short';
+        await client.marketOrder(coin, closeIsBuy, position.size);
+      }
+    }
+
+  } catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+main();