paper-trading-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 FootballMeanReversionStrategy from './src/strategies/meanReversionStrategy.js';
import logger from './src/utils/logger.js';

/**
 * Paper Trading Test Runner
 * Runs the football mean reversion strategy with simulated capital
 * to test performance without real money risk
 */
class PaperTradingTest {
  constructor() {
    this.api = new KalshiAPI();
    this.websocket = new KalshiWebSocket();
    this.strategy = new FootballMeanReversionStrategy(config);
    
    // 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();
    
    // Performance tracking
    this.performanceHistory = [];
    this.lastReport = Date.now();
    this.reportInterval = 30000; // Report every 30 seconds
    
    // Strategy tuning for faster testing
    this.strategy.lookbackPeriod = 5; // Very short for fast testing
    this.strategy.deviationThreshold = 1.0; // Lower threshold for more signals
    this.strategy.positionSize = 100; // $100 per position
    
    // Track data collection
    this.dataCollectionStatus = new Map(); // marketId -> data count
    
    // Connect strategy events
    this.websocket.on('ticker', (tickerData) => {
      this.processTicker(tickerData);
    });
    
    console.log('🧪 Paper Trading Test Initialized');
    console.log(`💰 Starting Capital: $${this.startingCapital.toLocaleString()}`);
    console.log(`📊 Lookback Period: ${this.strategy.lookbackPeriod} data points (FAST MODE)`);
    console.log(`📈 Deviation Threshold: ${this.strategy.deviationThreshold} std dev (SENSITIVE)`);
    console.log(`💵 Position Size: $${this.strategy.positionSize} per trade`);
    console.log('⚡ Optimized for fast signal generation');
    console.log('');
  }

  /**
   * Process ticker data and execute paper trades
   */
  processTicker(tickerData) {
    try {
      const { marketId, marketTicker, price, yesBid, yesAsk } = tickerData;
      
      // Get market details
      let marketTitle = marketTicker;
      if (this.strategy.testMarkets && this.strategy.testMarkets.has(marketId)) {
        marketTitle = this.strategy.testMarkets.get(marketId).title;
      }
      
      // Track data collection for this market
      if (!this.dataCollectionStatus.has(marketId)) {
        this.dataCollectionStatus.set(marketId, 0);
      }
      const dataCount = this.dataCollectionStatus.get(marketId) + 1;
      this.dataCollectionStatus.set(marketId, dataCount);
      
      // Show progress occasionally
      if (dataCount <= this.strategy.lookbackPeriod && Math.random() < 0.05) {
        console.log(`📊 Collecting data for ${marketTicker}: ${dataCount}/${this.strategy.lookbackPeriod} data points`);
      }
      
      // Check if we should trade this market (accept ANY market for testing)
      const shouldTrade = this.strategy.shouldTradeMarket(marketId, marketTicker, marketTitle) || 
                         (this.strategy.testMarkets && this.strategy.testMarkets.has(marketId));
      
      if (!shouldTrade) {
        return;
      }
      
      // Generate trading signals
      const signal = this.strategy.generateSignals(marketId, marketTicker, marketTitle, tickerData);
      
      // Execute paper trade if signal present
      if (signal) {
        this.executePaperTrade(signal);
      }
      
      // Update performance tracking
      this.updatePerformance();
      
    } catch (error) {
      logger.error('Error processing ticker in paper trading test', { error: error.message });
    }
  }

  /**
   * Execute a paper trade based on signal
   */
  executePaperTrade(signal) {
    const { action, reason, marketId, marketTicker, price, yesBid, yesAsk } = signal;
    
    if (action === 'BUY') {
      // Check if we have enough capital
      const requiredCapital = this.strategy.positionSize;
      if (this.currentCapital >= requiredCapital) {
        
        // Execute buy
        this.currentCapital -= requiredCapital;
        this.positionValue += requiredCapital;
        this.totalInvested += requiredCapital;
        this.tradesExecuted++;
        
        // Log the trade
        this.logTrade('BUY', marketTicker, price, requiredCapital, reason);
        
        // Store position details
        if (!this.strategy.activePositions.has(marketId)) {
          this.strategy.activePositions.set(marketId, {
            side: 'LONG',
            entryPrice: price,
            entryTime: new Date(),
            quantity: this.strategy.positionSize,
            marketId,
            marketTicker,
            invested: requiredCapital
          });
        }
      } else {
        console.log(`⚠️  [INSUFFICIENT CAPITAL] Cannot buy ${marketTicker} - Need $${requiredCapital}, Have $${this.currentCapital.toFixed(2)}`);
      }
      
    } else if (action === 'SELL') {
      const position = this.strategy.activePositions.get(marketId);
      if (position) {
        
        // Calculate profit/loss
        const currentValue = (price / position.entryPrice) * position.invested;
        const profit = currentValue - position.invested;
        const profitPercent = (profit / position.invested) * 100;
        
        // Execute sell
        this.currentCapital += currentValue;
        this.positionValue -= position.invested;
        this.tradesExecuted++;
        
        // Log the trade
        this.logTrade('SELL', marketTicker, price, currentValue, reason, profit, profitPercent);
        
        // Remove position
        this.strategy.activePositions.delete(marketId);
        
        // Update strategy stats
        this.strategy.totalTrades++;
        if (profit > 0) this.strategy.winningTrades++;
        this.strategy.totalProfit += profit;
      }
    }
  }

  /**
   * Log a trade execution
   */
  logTrade(action, marketTicker, price, amount, reason, profit = null, profitPercent = null) {
    const timestamp = new Date().toLocaleTimeString();
    
    if (action === 'BUY') {
      console.log(`\n🚀 [${timestamp}] PAPER BUY: ${marketTicker}`);
      console.log(`   💰 Price: $${price} | Amount: $${amount}`);
      console.log(`   📝 Reason: ${reason}`);
      console.log(`   💳 Capital Remaining: $${this.currentCapital.toFixed(2)}`);
      console.log(`   📊 Active Positions: ${this.strategy.activePositions.size}`);
    } else {
      console.log(`\n💰 [${timestamp}] PAPER SELL: ${marketTicker}`);
      console.log(`   💵 Price: $${price} | Amount: $${amount.toFixed(2)}`);
      console.log(`   📈 Profit: $${profit.toFixed(2)} (${profitPercent.toFixed(1)}%)`);
      console.log(`   📝 Reason: ${reason}`);
      console.log(`   💳 Capital: $${this.currentCapital.toFixed(2)}`);
    }
  }

  /**
   * Update performance tracking
   */
  updatePerformance() {
    const now = Date.now();
    if (now - this.lastReport >= this.reportInterval) {
      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);
    
    console.log(`\n📊 === PAPER TRADING 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.activePositions.size}`);
    console.log(`🏆 Win Rate: ${this.strategy.totalTrades > 0 ? ((this.strategy.winningTrades / this.strategy.totalTrades) * 100).toFixed(1) : 0}%`);
    console.log(`════════════════════════════════════════════\n`);
    
    // Store performance snapshot
    this.performanceHistory.push({
      timestamp: new Date(),
      totalValue,
      totalReturn,
      returnPercent,
      tradesExecuted: this.tradesExecuted,
      activePositions: this.strategy.activePositions.size
    });
  }

  /**
   * Initialize and start the paper trading test
   */
  async start() {
    try {
      console.log('🚀 Starting 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');
      
      // Discover and subscribe to markets
      console.log('🔍 Discovering markets...');
      await this.subscribeToMarkets();
      console.log('✅ Subscribed to market data\n');
      
      console.log('🏈 Paper Trading Test is now LIVE!');
      console.log('📊 Watching for mean reversion 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 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) {
        // Find football markets
        const footballMarkets = markets.markets.filter(market => {
          const text = `${market.ticker} ${market.title}`.toUpperCase();
          return ['NFL', 'NFLGAME', 'NFLWINS', 'NFLPLAYOFF', 'NFLMVP', 'NFLAFCCHAMP', 'NFLNFCCHAMP',
                  'SUPERBOWL', 'PLAYOFF', 'CHAMPIONSHIP', 'FOOTBALL'].some(keyword => 
            text.includes(keyword)
          );
        });
        
        // Always use active markets for more data and faster testing
        const testMarkets = markets.markets.filter(market => 
          market.status === 'active'
        ).slice(0, 50); // Use more markets for better signal opportunities
        
        console.log(`📊 Using ${testMarkets.length} active markets for testing`);
        console.log(`🏈 Football markets found: ${footballMarkets.length}`);
        testMarkets.slice(0, 5).forEach(market => {
          console.log(`   • ${market.ticker} - ${market.title}`);
        });
        
        // Add all test markets to strategy
        testMarkets.forEach(market => {
          this.strategy.addTestMarket(market.id, market.ticker, market.title);
        });
        
        // Subscribe to general ticker feed
        this.websocket.subscribe('ticker', {});
      }
      
    } catch (error) {
      console.error('Failed to subscribe to markets:', error.message);
    }
  }

  /**
   * Stop the paper trading test and show final results
   */
  stop() {
    console.log('\n🛑 Stopping Paper Trading Test...\n');
    
    // Disconnect WebSocket
    if (this.websocket) {
      this.websocket.disconnect();
    }
    
    // Generate final report
    this.generateFinalReport();
    
    console.log('👋 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;
    
    console.log('📋 === FINAL PAPER TRADING 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(`🏆 Winning Trades: ${this.strategy.winningTrades}`);
    console.log(`📈 Win Rate: ${this.strategy.totalTrades > 0 ? ((this.strategy.winningTrades / this.strategy.totalTrades) * 100).toFixed(1) : 0}%`);
    console.log(`🎯 Open Positions: ${this.strategy.activePositions.size}`);
    
    if (this.strategy.activePositions.size > 0) {
      console.log('\n📊 Open Positions:');
      for (const [marketId, position] of this.strategy.activePositions) {
        console.log(`   • ${position.marketTicker}: $${position.invested} @ $${position.entryPrice}`);
      }
    }
    
    console.log('\n🎯 Strategy Performance:');
    console.log(`   Lookback Period: ${this.strategy.lookbackPeriod} data points`);
    console.log(`   Deviation Threshold: ${this.strategy.deviationThreshold} std dev`);
    console.log(`   Position Size: $${this.strategy.positionSize}`);
    console.log(`   Total Strategy Profit: $${this.strategy.totalProfit.toFixed(2)}`);
    
    console.log('═══════════════════════════════════════════\n');
  }
}

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