openbroker 1.0.67 → 1.0.69

package/scripts/strategies/dca.ts

@@ -1,292 +0,0 @@
-#!/usr/bin/env npx tsx
-// DCA (Dollar Cost Averaging) Strategy - Buy fixed amounts at regular intervals
-
-import { getClient } from '../core/client.js';
-import { formatUsd, parseArgs, sleep } from '../core/utils.js';
-
-function printUsage() {
-  console.log(`
-Open Broker - DCA (Dollar Cost Average)
-=======================================
-
-Automatically buy a fixed USD amount at regular intervals to average into
-a position over time, reducing the impact of volatility.
-
-Usage:
-  npx tsx scripts/strategies/dca.ts --coin <COIN> --amount <USD> --interval <PERIOD> --count <N>
-
-Options:
-  --coin          Asset to accumulate (e.g., ETH, BTC)
-  --amount        USD amount per purchase
-  --interval      Time between purchases (e.g., 1h, 4h, 1d, 1w)
-  --count         Number of purchases to make
-  --total         OR total USD to invest (calculates amount per interval)
-  --slippage      Slippage tolerance in bps (default: 50)
-  --dry           Dry run - show DCA plan without executing
-
-Interval Format:
-  Xm = X minutes (e.g., 30m)
-  Xh = X hours (e.g., 4h, 24h)
-  Xd = X days (e.g., 1d, 7d)
-  Xw = X weeks (e.g., 1w)
-
-Examples:
-  # Buy $100 of ETH every hour for 24 purchases
-  npx tsx scripts/strategies/dca.ts --coin ETH --amount 100 --interval 1h --count 24
-
-  # Invest $5000 in BTC over 30 days with daily purchases
-  npx tsx scripts/strategies/dca.ts --coin BTC --total 5000 --interval 1d --count 30
-
-  # Preview DCA plan
-  npx tsx scripts/strategies/dca.ts --coin SOL --amount 50 --interval 4h --count 42 --dry
-
-DCA Benefits:
-  - Removes emotion from buying decisions
-  - Averages out entry price over time
-  - Reduces risk of buying at local tops
-  - Disciplined long-term accumulation strategy
-`);
-}
-
-interface DcaPurchase {
-  number: number;
-  timestamp: Date;
-  targetAmount: number;
-  actualAmount: number;
-  size: number;
-  price: number;
-  status: 'completed' | 'partial' | 'failed' | 'pending';
-  error?: string;
-}
-
-function parseInterval(interval: string): number {
-  const match = interval.match(/^(\d+)(m|h|d|w)$/i);
-  if (!match) {
-    throw new Error(`Invalid interval format: ${interval}. Use Xm, Xh, Xd, or Xw`);
-  }
-
-  const value = parseInt(match[1]);
-  const unit = match[2].toLowerCase();
-
-  switch (unit) {
-    case 'm':
-      return value * 60 * 1000;
-    case 'h':
-      return value * 60 * 60 * 1000;
-    case 'd':
-      return value * 24 * 60 * 60 * 1000;
-    case 'w':
-      return value * 7 * 24 * 60 * 60 * 1000;
-    default:
-      throw new Error(`Unknown interval unit: ${unit}`);
-  }
-}
-
-function formatInterval(ms: number): string {
-  const minutes = ms / 60000;
-  if (minutes < 60) return `${minutes}m`;
-  const hours = minutes / 60;
-  if (hours < 24) return `${hours}h`;
-  const days = hours / 24;
-  if (days < 7) return `${days}d`;
-  return `${days / 7}w`;
-}
-
-function formatDuration(ms: number): string {
-  const seconds = Math.floor(ms / 1000);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
-  const hours = Math.floor(minutes / 60);
-  if (hours < 24) return `${hours}h ${minutes % 60}m`;
-  const days = Math.floor(hours / 24);
-  return `${days}d ${hours % 24}h`;
-}
-
-async function main() {
-  const args = parseArgs(process.argv.slice(2));
-
-  const coin = args.coin as string;
-  const intervalStr = args.interval as string;
-  const count = args.count ? parseInt(args.count as string) : undefined;
-  const amountPerPurchase = args.amount ? parseFloat(args.amount as string) : undefined;
-  const totalAmount = args.total ? parseFloat(args.total as string) : undefined;
-  const slippage = args.slippage ? parseInt(args.slippage as string) : undefined;
-  const dryRun = args.dry as boolean;
-
-  if (!coin || !intervalStr || !count) {
-    printUsage();
-    process.exit(1);
-  }
-
-  if (!amountPerPurchase && !totalAmount) {
-    console.error('Error: Must specify either --amount or --total');
-    process.exit(1);
-  }
-
-  const amount = amountPerPurchase || (totalAmount! / count);
-  const total = totalAmount || (amountPerPurchase! * count);
-
-  let intervalMs: number;
-  try {
-    intervalMs = parseInterval(intervalStr);
-  } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-  }
-
-  const client = getClient();
-
-  if (args.verbose) {
-    client.verbose = true;
-  }
-
-  console.log('Open Broker - DCA Strategy');
-  console.log('==========================\n');
-
-  try {
-    const mids = await client.getAllMids();
-    const currentPrice = parseFloat(mids[coin]);
-    if (!currentPrice) {
-      console.error(`Error: No market data for ${coin}`);
-      process.exit(1);
-    }
-
-    const totalDuration = intervalMs * (count - 1);
-    const sizePerPurchase = amount / currentPrice;
-    const totalSize = sizePerPurchase * count;
-
-    console.log('DCA Plan');
-    console.log('--------');
-    console.log(`Coin:              ${coin}`);
-    console.log(`Current Price:     ${formatUsd(currentPrice)}`);
-    console.log(`Amount/Purchase:   ${formatUsd(amount)}`);
-    console.log(`Purchases:         ${count}`);
-    console.log(`Interval:          ${formatInterval(intervalMs)}`);
-    console.log(`Total Investment:  ${formatUsd(total)}`);
-    console.log(`Total Duration:    ${formatDuration(totalDuration)}`);
-    console.log(`\nAt Current Price:`);
-    console.log(`  Size/Purchase:   ${sizePerPurchase.toFixed(6)} ${coin}`);
-    console.log(`  Total Size:      ${totalSize.toFixed(6)} ${coin}`);
-
-    // Show schedule
-    console.log('\nSchedule Preview');
-    console.log('----------------');
-    const now = new Date();
-    const previewCount = Math.min(5, count);
-    for (let i = 0; i < previewCount; i++) {
-      const time = new Date(now.getTime() + intervalMs * i);
-      console.log(`  #${i + 1}: ${time.toLocaleString()} - ${formatUsd(amount)}`);
-    }
-    if (count > 5) {
-      console.log(`  ... ${count - 5} more purchases`);
-      const lastTime = new Date(now.getTime() + intervalMs * (count - 1));
-      console.log(`  #${count}: ${lastTime.toLocaleString()} - ${formatUsd(amount)}`);
-    }
-
-    if (dryRun) {
-      console.log('\n--- Dry run complete ---');
-      return;
-    }
-
-    console.log('\nStarting DCA execution...\n');
-
-    const purchases: DcaPurchase[] = [];
-    let totalSpent = 0;
-    let totalAcquired = 0;
-
-    for (let i = 0; i < count; i++) {
-      const purchaseNum = i + 1;
-      console.log(`[${purchaseNum}/${count}] Executing purchase of ${formatUsd(amount)} ${coin}...`);
-
-      const purchase: DcaPurchase = {
-        number: purchaseNum,
-        timestamp: new Date(),
-        targetAmount: amount,
-        actualAmount: 0,
-        size: 0,
-        price: 0,
-        status: 'pending',
-      };
-
-      try {
-        // Get current price and calculate size
-        const newMids = await client.getAllMids();
-        const newPrice = parseFloat(newMids[coin]);
-        const size = amount / newPrice;
-
-        const response = await client.marketOrder(coin, true, size, slippage);
-
-        if (response.status === 'ok' && response.response && typeof response.response === 'object') {
-          const status = response.response.data.statuses[0];
-          if (status?.filled) {
-            purchase.size = parseFloat(status.filled.totalSz);
-            purchase.price = parseFloat(status.filled.avgPx);
-            purchase.actualAmount = purchase.size * purchase.price;
-            purchase.status = purchase.actualAmount >= amount * 0.95 ? 'completed' : 'partial';
-
-            totalSpent += purchase.actualAmount;
-            totalAcquired += purchase.size;
-
-            const avgPrice = totalSpent / totalAcquired;
-            console.log(`  Filled: ${purchase.size.toFixed(6)} ${coin} @ ${formatUsd(purchase.price)}`);
-            console.log(`  Running: ${totalAcquired.toFixed(6)} ${coin} | Avg: ${formatUsd(avgPrice)} | Spent: ${formatUsd(totalSpent)}`);
-          } else if (status?.error) {
-            purchase.status = 'failed';
-            purchase.error = status.error;
-            console.log(`  Failed: ${status.error}`);
-          }
-        } else {
-          purchase.status = 'failed';
-          purchase.error = typeof response.response === 'string' ? response.response : 'Unknown error';
-          console.log(`  Failed: ${purchase.error}`);
-        }
-      } catch (err) {
-        purchase.status = 'failed';
-        purchase.error = err instanceof Error ? err.message : String(err);
-        console.log(`  Error: ${purchase.error}`);
-      }
-
-      purchases.push(purchase);
-
-      // Wait for next interval (unless last purchase)
-      if (i < count - 1) {
-        const nextTime = new Date(Date.now() + intervalMs);
-        console.log(`  Next purchase: ${nextTime.toLocaleString()}\n`);
-        await sleep(intervalMs);
-      }
-    }
-
-    // Summary
-    const avgPrice = totalSpent / totalAcquired;
-    const currentMid = parseFloat((await client.getAllMids())[coin]);
-    const unrealizedPnl = (currentMid - avgPrice) * totalAcquired;
-    const successful = purchases.filter(p => p.status === 'completed' || p.status === 'partial').length;
-    const failed = purchases.filter(p => p.status === 'failed').length;
-
-    console.log('\n========== DCA Summary ==========');
-    console.log(`Purchases:       ${successful}/${count} successful${failed > 0 ? ` (${failed} failed)` : ''}`);
-    console.log(`Total Spent:     ${formatUsd(totalSpent)} / ${formatUsd(total)} target`);
-    console.log(`Total Acquired:  ${totalAcquired.toFixed(6)} ${coin}`);
-    console.log(`Average Price:   ${formatUsd(avgPrice)}`);
-    console.log(`Current Price:   ${formatUsd(currentMid)}`);
-    console.log(`Unrealized PnL:  ${formatUsd(unrealizedPnl)} (${((unrealizedPnl / totalSpent) * 100).toFixed(2)}%)`);
-
-    // Show price history
-    if (purchases.length > 1) {
-      const prices = purchases.filter(p => p.price > 0).map(p => p.price);
-      const minPrice = Math.min(...prices);
-      const maxPrice = Math.max(...prices);
-      console.log(`\nPrice Range:`);
-      console.log(`  Lowest:  ${formatUsd(minPrice)}`);
-      console.log(`  Highest: ${formatUsd(maxPrice)}`);
-      console.log(`  Your Avg: ${formatUsd(avgPrice)} (${((avgPrice - minPrice) / (maxPrice - minPrice) * 100).toFixed(0)}% of range)`);
-    }
-
-  } catch (error) {
-    console.error('Error:', error);
-    process.exit(1);
-  }
-}
-
-main();

package/scripts/strategies/funding-arb.ts

@@ -1,352 +0,0 @@
-#!/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 - loads main + HIP-3 assets
-    await client.getMetaAndAssetCtxs();
-
-    // For HIP-3 assets, we need to fetch funding from the dex-specific metadata
-    let hourlyFunding: number;
-    let openInterestVal: number;
-
-    if (client.isHip3(coin)) {
-      const allPerps = await client.getAllPerpMetas();
-      const dexName = client.getCoinDex(coin);
-      const dexData = allPerps.find(d => d.dexName === dexName);
-      if (!dexData) {
-        console.error(`Error: No market data for HIP-3 dex ${dexName}`);
-        process.exit(1);
-      }
-      // API returns universe names already prefixed (e.g., "xyz:CL")
-      const assetIdx = dexData.meta.universe.findIndex(a => a.name === coin);
-      if (assetIdx === -1 || !dexData.assetCtxs[assetIdx]) {
-        console.error(`Error: No market data for ${coin}`);
-        process.exit(1);
-      }
-      hourlyFunding = parseFloat(dexData.assetCtxs[assetIdx].funding);
-      openInterestVal = parseFloat(dexData.assetCtxs[assetIdx].openInterest);
-    } else {
-      const meta = await client.getMetaAndAssetCtxs();
-      const assetIndex = client.getAssetIndex(coin);
-      const assetCtx = meta.assetCtxs[assetIndex];
-      hourlyFunding = parseFloat(assetCtx.funding);
-      openInterestVal = parseFloat(assetCtx.openInterest);
-    }
-
-    const mids = await client.getAllMids();
-    const midPrice = parseFloat(mids[coin]);
-    if (!midPrice) {
-      console.error(`Error: No market data for ${coin}`);
-      process.exit(1);
-    }
-
-    const annualizedFunding = annualizeFundingRate(hourlyFunding) * 100; // as percentage
-    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(openInterestVal)}`);
-    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
-        let newHourlyFunding: number;
-        if (client.isHip3(coin)) {
-          const freshPerps = await client.getAllPerpMetas();
-          const dexName = client.getCoinDex(coin);
-          const dexData = freshPerps.find(d => d.dexName === dexName);
-          // API returns universe names already prefixed (e.g., "xyz:CL")
-          const idx = dexData?.meta.universe.findIndex(a => a.name === coin) ?? -1;
-          newHourlyFunding = idx >= 0 && dexData?.assetCtxs[idx] ? parseFloat(dexData.assetCtxs[idx].funding) : 0;
-        } else {
-          const newMeta = await client.getMetaAndAssetCtxs();
-          const assetIndex = client.getAssetIndex(coin);
-          newHourlyFunding = parseFloat(newMeta.assetCtxs[assetIndex].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();