volatility-paper-test.js

#!/usr/bin/env node

import { config } from './src/config/config.js';
import { KalshiAPI } from './src/api/kalshiApi.js';
import { KalshiWebSocket } from './src/websocket/kalshiWebSocket.js';
import VolatilityStrategy from './src/strategies/volatilityStrategy.js';
import logger from './src/utils/logger.js';

/**
 * Volatility Strategy Paper Trading Test
 * Tests the volatility-based trading strategy with simulated capital
 */
class VolatilityPaperTradingTest {
  constructor() {
    this.api = new KalshiAPI();
    this.websocket = new KalshiWebSocket();
    
    // Create capital checker function
    const capitalChecker = () => this.currentCapital;
    
    this.strategy = new VolatilityStrategy(config, capitalChecker);
    
    // Paper trading simulation settings
    this.startingCapital = 10000; // $10,000 starting capital
    this.currentCapital = this.startingCapital;
    this.positionValue = 0;
    this.totalInvested = 0;
    this.tradesExecuted = 0;
    this.startTime = new Date();
    
    // Market price tracking for position valuation
    this.marketPrices = new Map(); // marketId -> latest price
    
    // Performance tracking
    this.performanceHistory = [];
    this.lastReport = Date.now();
    this.reportInterval = 60000; // Report every 60 seconds instead of 30
    
    // Enhanced performance metrics
    this.peakValue = this.startingCapital;
    this.maxDrawdown = 0;
    this.returns = [];
    
    // Connect strategy events
    this.websocket.on('ticker', (tickerData) => {
      this.processTicker(tickerData);
    });
    
    console.log('🧪 Volatility Strategy Paper Trading Test Initialized');
    console.log(`💰 Starting Capital: $${this.startingCapital.toLocaleString()}`);
    console.log(`📊 Volatility Threshold: ${this.strategy.volatilityThreshold}`);
    console.log(`📈 Price Swing Threshold: ${(this.strategy.priceSwingThreshold * 100).toFixed(1)}%`);
    console.log(`💵 Base Position Size: $${this.strategy.positionSize}`);
    console.log(`🎯 Max Positions: ${this.strategy.maxPositions}`);
    console.log(`🛑 Stop Loss: ${(this.strategy.stopLoss * 100).toFixed(1)}%`);
    console.log(`💰 Take Profit: ${(this.strategy.takeProfit * 100).toFixed(1)}%`);
    console.log('');
  }

  /**
   * Process ticker data and execute volatility trades
   */
  processTicker(tickerData) {
    try {
      const { marketId, marketTicker, price, yesBid, yesAsk } = tickerData;
      
      // Validate data quality
      if (!this.isValidTickerData(tickerData)) {
        return;
      }
      
      // Store latest market price for position valuation
      this.marketPrices.set(marketId, parseFloat(price));
      
      // Update position values with current prices
      this.updatePositionValues();
      
      // Process data through volatility strategy
      this.strategy.processTickerData(tickerData);
      
      // Check for new volatility signals
      const signal = this.strategy.volatilitySignals.get(marketId);
      if (signal && !this.strategy.positions.has(marketId)) {
        // Check daily loss limit before executing trades
        if (!this.checkDailyLossLimit()) {
          return;
        }
        
        // Add a small delay to avoid excessive trading
        setTimeout(() => {
          this.executePaperTrade(signal);
          // Clear the signal after execution to prevent re-execution
          this.strategy.volatilitySignals.delete(marketId);
        }, 1000); // 1 second delay
      }
      
      // Check exit conditions for existing positions
      const exitSignal = this.strategy.checkExitConditions(marketId, parseFloat(price));
      if (exitSignal) {
        this.handlePositionExit(exitSignal);
      }
      
      // Update performance tracking less frequently
      if (Date.now() - this.lastReport >= this.reportInterval) {
        this.updatePerformance();
      }
      
    } catch (error) {
      logger.error('Error processing ticker in volatility paper trading test', { error: error.message });
    }
  }

  /**
   * Execute a paper trade based on volatility signal
   */
  executePaperTrade(signal) {
    const { action, reasoning, marketId, marketTicker, price, yesBid, yesAsk, volatility, regime, regimeMultiplier } = signal;
    
    // Calculate position size based on volatility regime
    const basePositionSize = this.strategy.positionSize;
    const adjustedPositionSize = basePositionSize * regimeMultiplier;
    
    // Check if we have enough capital
    if (this.currentCapital >= adjustedPositionSize) {
      
      // Execute the trade
      if (action === 'BUY') {
        this.currentCapital -= adjustedPositionSize;
        this.positionValue += adjustedPositionSize;
        this.totalInvested += adjustedPositionSize;
        this.tradesExecuted++;
        
        // Log the trade
        this.logTrade('BUY', marketTicker, yesAsk, adjustedPositionSize, reasoning, volatility, regime);
        
        // Execute in strategy (this will create the position)
        if (this.strategy.executeVolatilityTrade(signal)) {
          // Clear the signal after successful execution
          this.strategy.volatilitySignals.delete(signal.marketId);
        }
        
      } else if (action === 'SELL') {
        this.currentCapital -= adjustedPositionSize;
        this.positionValue += adjustedPositionSize;
        this.totalInvested += adjustedPositionSize;
        this.tradesExecuted++;
        
        // Log the trade
        this.logTrade('SELL', marketTicker, yesBid, adjustedPositionSize, reasoning, volatility, regime);
        
        // Execute in strategy (this will create the position)
        if (this.strategy.executeVolatilityTrade(signal)) {
          // Clear the signal after successful execution
          this.strategy.volatilitySignals.delete(signal.marketId);
        }
      }
      
    } else {
      console.log(`⚠️  [INSUFFICIENT CAPITAL] Cannot ${action} ${marketTicker} - Need $${adjustedPositionSize}, Have $${this.currentCapital.toFixed(2)}`);
    }
  }

  /**
   * Handle position exit (stop loss, take profit, etc.)
   */
  handlePositionExit(exitSignal) {
    const { action, price, reason, pnl, position } = exitSignal;
    
    // Calculate actual exit value
    const exitValue = position.quantity;
    
    // Update capital
    if (pnl > 0) {
      this.currentCapital += exitValue + pnl;
    } else {
      this.currentCapital += exitValue + pnl;
    }
    
    this.positionValue -= position.quantity;
    
    // Log the exit
    this.logTradeExit(action, position.marketTicker, price, exitValue, reason, pnl);
  }

  /**
   * Update position values based on current market prices
   */
  updatePositionValues() {
    let totalValue = 0;
    for (const [marketId, position] of this.strategy.positions) {
      const currentPrice = this.marketPrices.get(marketId);
      if (currentPrice) {
        if (position.side === 'LONG') {
          const currentValue = position.quantity * (currentPrice / position.entryPrice);
          totalValue += currentValue;
        } else if (position.side === 'SHORT') {
          const currentValue = position.quantity * (2 - currentPrice / position.entryPrice);
          totalValue += currentValue;
        }
      } else {
        // If no current price, use entry value
        totalValue += position.quantity;
      }
    }
    this.positionValue = totalValue;
  }

  /**
   * Log a trade execution
   */
  logTrade(action, marketTicker, price, amount, reasoning, volatility, regime) {
    const timestamp = new Date().toLocaleTimeString();
    
    console.log(`\n🚀 [${timestamp}] VOLATILITY ${action}: ${marketTicker}`);
    console.log(`   💰 Price: $${price} | Amount: $${amount}`);
    console.log(`   📊 Volatility: ${volatility.toFixed(4)} (${regime} regime)`);
    console.log(`   📝 Reason: ${reasoning}`);
    console.log(`   💳 Capital Remaining: $${this.currentCapital.toFixed(2)}`);
    console.log(`   📊 Active Positions: ${this.strategy.positions.size}`);
    console.log(`   🏷️  Market Type: ${this.classifyMarket(marketTicker)}`);
  }

  /**
   * Log a trade exit
   */
  logTradeExit(action, marketTicker, price, amount, reason, pnl) {
    const timestamp = new Date().toLocaleTimeString();
    
    console.log(`\n�� [${timestamp}] VOLATILITY EXIT: ${marketTicker}`);
    console.log(`   💵 Price: $${price} | Amount: $${amount.toFixed(2)}`);
    console.log(`   📈 P&L: $${pnl.toFixed(2)}`);
    console.log(`   📝 Reason: ${reason}`);
    console.log(`   💳 Capital: $${this.currentCapital.toFixed(2)}`);
  }

  /**
   * Check daily loss limit to prevent excessive losses
   */
  checkDailyLossLimit() {
    const todayStart = new Date();
    todayStart.setHours(0, 0, 0, 0);
    
    const todayTrades = this.performanceHistory.filter(p => 
      p.timestamp >= todayStart
    );
    
    if (todayTrades.length > 0) {
      const dayStartValue = todayTrades[0].totalValue;
      const currentValue = this.currentCapital + this.positionValue;
      const dailyPnL = currentValue - dayStartValue;
      
      // Stop trading if down more than 5%
      if (dailyPnL < -this.startingCapital * 0.05) {
        console.log('🚨 Daily loss limit reached. Stopping new trades.');
        return false;
      }
    }
    return true;
  }

  /**
   * Update performance tracking
   */
  updatePerformance() {
    const now = Date.now();
    if (now - this.lastReport >= this.reportInterval) {
      // Update position values before performance calculation
      this.updatePositionValues();
      
      const totalValue = this.currentCapital + this.positionValue;
      
      // Track drawdown
      if (!this.peakValue || totalValue > this.peakValue) {
        this.peakValue = totalValue;
      }
      const currentDrawdown = (this.peakValue - totalValue) / this.peakValue;
      if (!this.maxDrawdown || currentDrawdown > this.maxDrawdown) {
        this.maxDrawdown = currentDrawdown;
      }
      
      // Store returns for Sharpe calculation
      if (this.performanceHistory.length > 0) {
        const lastValue = this.performanceHistory[this.performanceHistory.length - 1].totalValue;
        const returnRate = (totalValue - lastValue) / lastValue;
        this.returns.push(returnRate);
        
        // Keep only last 100 returns
        if (this.returns.length > 100) this.returns.shift();
      }
      
      this.generatePerformanceReport();
      this.lastReport = now;
    }
  }

  /**
   * Generate performance report
   */
  generatePerformanceReport() {
    const totalValue = this.currentCapital + this.positionValue;
    const totalReturn = totalValue - this.startingCapital;
    const returnPercent = (totalReturn / this.startingCapital) * 100;
    const elapsed = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
    
    // Get strategy performance stats
    const strategyStats = this.strategy.getPerformanceStats();
    
    // Only show detailed report every 2 minutes to reduce noise
    const showDetailed = elapsed % 120 === 0;
    
    if (showDetailed) {
      console.log(`\n📊 === VOLATILITY STRATEGY PERFORMANCE (${elapsed}s) ===`);
      console.log(`💰 Starting Capital: $${this.startingCapital.toLocaleString()}`);
      console.log(`💳 Available Cash: $${this.currentCapital.toFixed(2)}`);
      console.log(`📈 Position Value: $${this.positionValue.toFixed(2)}`);
      console.log(`💎 Total Portfolio: $${totalValue.toFixed(2)}`);
      console.log(`📊 Total Return: $${totalReturn.toFixed(2)} (${returnPercent.toFixed(2)}%)`);
      console.log(`🔄 Trades Executed: ${this.tradesExecuted}`);
      console.log(`🎯 Active Positions: ${this.strategy.positions.size}`);
      console.log(`\n🎯 Strategy Performance:`);
      console.log(`   Total Trades: ${strategyStats.totalTrades}`);
      console.log(`   Win Rate: ${strategyStats.winRate}%`);
      console.log(`   Total Profit: $${strategyStats.totalProfit}`);
      console.log(`   Strategy: ${strategyStats.strategy}`);
      console.log(`════════════════════════════════════════════\n`);
    } else {
      // Simple status update
      console.log(`📊 [${elapsed}s] Portfolio: $${totalValue.toFixed(0)} | Return: ${returnPercent.toFixed(1)}% | Positions: ${this.strategy.positions.size}`);
    }
    
    // Store performance snapshot
    this.performanceHistory.push({
      timestamp: new Date(),
      totalValue,
      totalReturn,
      returnPercent,
      tradesExecuted: this.tradesExecuted,
      activePositions: this.strategy.positions.size,
      strategyStats
    });
  }

  /**
   * Initialize and start the volatility paper trading test
   */
  async start() {
    try {
      console.log('🚀 Starting Volatility Strategy Paper Trading Test...\n');
      
      // Test API connection
      console.log('📡 Connecting to Kalshi API...');
      await this.api.testConnection();
      console.log('✅ API connected successfully\n');
      
      // Connect WebSocket
      console.log('🔌 Connecting to Kalshi WebSocket...');
      await this.websocket.connect();
      console.log('✅ WebSocket connected successfully\n');
      
      // Subscribe to markets
      console.log('🔍 Discovering and subscribing to markets...');
      await this.subscribeToMarkets();
      console.log('✅ Subscribed to market data\n');
      
      console.log('📊 Volatility Strategy is now LIVE!');
      console.log('🎯 Watching for high volatility opportunities...');
      console.log('💡 Press Ctrl+C to stop and see final results\n');
      
      // Set up graceful shutdown
      process.on('SIGINT', () => {
        this.stop();
      });
      
    } catch (error) {
      console.error('❌ Failed to start volatility paper trading test:', error.message);
      process.exit(1);
    }
  }

  /**
   * Subscribe to markets for testing
   */
  async subscribeToMarkets() {
    try {
      const markets = await this.api.getMarkets(1000);
      
      if (markets.markets) {
        const activeMarkets = markets.markets.filter(market => 
          market.status === 'active'
        ).slice(0, 100); // Use top 100 active markets
        
        console.log(`📊 Found ${activeMarkets.length} active markets for volatility analysis`);
        console.log(`🏈 Football markets: ${activeMarkets.filter(m => m.ticker.includes('NFL')).length}`);
        console.log(`💰 Crypto markets: ${activeMarkets.filter(m => m.ticker.includes('BTC') || m.ticker.includes('ETH')).length}`);
        console.log(`📈 Financial markets: ${activeMarkets.filter(m => m.ticker.includes('FED') || m.ticker.includes('NASDAQ')).length}\n`);
        
        // Subscribe to general ticker feed
        this.websocket.subscribe('ticker', {});
      }
      
    } catch (error) {
      console.error('Failed to subscribe to markets:', error.message);
    }
  }

  /**
   * Stop the test and show final results
   */
  stop() {
    console.log('\n🛑 Stopping Volatility Strategy Paper Trading Test...\n');
    
    // Disconnect WebSocket
    if (this.websocket) {
      this.websocket.disconnect();
    }
    
    // Generate final report
    this.generateFinalReport();
    
    console.log('👋 Volatility Strategy Paper Trading Test completed. Goodbye!');
    process.exit(0);
  }

  /**
   * Generate final comprehensive report
   */
  generateFinalReport() {
    const totalValue = this.currentCapital + this.positionValue;
    const totalReturn = totalValue - this.startingCapital;
    const returnPercent = (totalReturn / this.startingCapital) * 100;
    const elapsed = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
    const minutes = Math.floor(elapsed / 60);
    const seconds = elapsed % 60;
    
    const strategyStats = this.strategy.getPerformanceStats();
    
    console.log('📋 === FINAL VOLATILITY STRATEGY RESULTS ===');
    console.log(`⏱️  Test Duration: ${minutes}m ${seconds}s`);
    console.log(`💰 Starting Capital: $${this.startingCapital.toLocaleString()}`);
    console.log(`💳 Final Cash: $${this.currentCapital.toFixed(2)}`);
    console.log(`📈 Position Value: $${this.positionValue.toFixed(2)}`);
    console.log(`💎 Final Portfolio: $${totalValue.toFixed(2)}`);
    console.log(`📊 Total Return: $${totalReturn.toFixed(2)} (${returnPercent.toFixed(2)}%)`);
    console.log(`🔄 Total Trades: ${this.tradesExecuted}`);
    console.log(`🎯 Open Positions: ${this.strategy.positions.size}`);
    
    console.log('\n🎯 Volatility Strategy Performance:');
    console.log(`   Total Trades: ${strategyStats.totalTrades}`);
    console.log(`   Winning Trades: ${strategyStats.winningTrades}`);
    console.log(`   Win Rate: ${strategyStats.winRate}%`);
    console.log(`   Total Strategy Profit: $${strategyStats.totalProfit}`);
    
    if (this.strategy.positions.size > 0) {
      console.log('\n📊 Open Positions:');
      for (const [marketId, position] of this.strategy.positions) {
        console.log(`   • ${position.marketTicker}: $${position.quantity} @ $${position.entryPrice} (${position.side})`);
      }
    }
    
    console.log('\n💡 Strategy Insights:');
    console.log(`   Volatility Threshold: ${this.strategy.volatilityThreshold}`);
    console.log(`   Price Swing Threshold: ${(this.strategy.priceSwingThreshold * 100).toFixed(1)}%`);
    console.log(`   Position Size: $${this.strategy.positionSize}`);
    console.log(`   Stop Loss: ${(this.strategy.stopLoss * 100).toFixed(1)}%`);
    console.log(`   Take Profit: ${(this.strategy.takeProfit * 100).toFixed(1)}%`);
    
    console.log('═══════════════════════════════════════════\n');
  }

  /**
   * Classify market type based on ticker
   */
  classifyMarket(ticker) {
    if (ticker.includes('NFL') || ticker.includes('NBA') || ticker.includes('MLB')) return 'Sports';
    if (ticker.includes('BTC') || ticker.includes('ETH') || ticker.includes('CRYPTO')) return 'Crypto';
    if (ticker.includes('FED') || ticker.includes('NASDAQ') || ticker.includes('NYSE')) return 'Finance';
    if (ticker.includes('POLITICS') || ticker.includes('ELECTION')) return 'Politics';
    return 'Other';
  }

  /**
   * Validate ticker data for processing
   */
  isValidTickerData(tickerData) {
    const { marketId, marketTicker, price, yesBid, yesAsk } = tickerData;
    if (!marketId || !marketTicker || !price || !yesBid || !yesAsk) {
      logger.warn('Received invalid ticker data, skipping processing', { tickerData });
      return false;
    }
    
    // Check if market is still active
    if (!this.isMarketActive(marketId)) {
      this.handleInactiveMarket(marketId);
      return false;
    }
    
    return true;
  }

  /**
   * Check if market is still active
   */
  isMarketActive(marketId) {
    // For now, assume all markets are active
    // In production, you'd check against a list of active markets
    return true;
  }

  /**
   * Handle inactive market
   */
  handleInactiveMarket(marketId) {
    // Close any open positions in this market
    const position = this.strategy.positions.get(marketId);
    if (position) {
      console.log(`⚠️  Market ${position.marketTicker} is no longer active, closing position`);
      // Force close position at current market price
      this.strategy.positions.delete(marketId);
      this.positionValue -= position.quantity;
    }
  }

  /**
   * Get latest price for a market
   */
  getLatestPrice(marketId) {
    return this.marketPrices.get(marketId);
  }
}

// Run the volatility paper trading test
const test = new VolatilityPaperTradingTest();
test.start().catch((error) => {
  console.error('❌ Volatility paper trading test failed:', error.message);
  process.exit(1);
});