hedgequantx 2.6.162 → 2.7.0

package/src/services/strategy/recovery-math.js

@@ -1,402 +0,0 @@
-/**
- * =============================================================================
- * Recovery Mode - Mathematical Models for Drawdown Recovery
- * =============================================================================
- * 
- * Uses pure math models to adapt strategy during drawdown:
- * 
- * 1. KELLY CRITERION - Optimal position sizing based on win rate & payoff
- *    f* = (bp - q) / b
- *    where: b = win/loss ratio, p = win probability, q = 1-p
- * 
- * 2. VOLATILITY SCALING - Adjust size inversely to recent volatility
- *    size_adj = base_size * (target_vol / current_vol)
- * 
- * 3. ADAPTIVE THRESHOLDS - Dynamic TP/SL based on ATR
- *    TP = entry ± (ATR * tp_multiplier)
- *    SL = entry ± (ATR * sl_multiplier)
- * 
- * 4. EXPECTED VALUE FILTER - Only take trades with positive EV
- *    EV = (win_prob * avg_win) - (loss_prob * avg_loss)
- * 
- * 5. DRAWDOWN-ADJUSTED KELLY - Reduce risk as drawdown deepens
- *    kelly_adj = kelly * (1 - drawdown_pct / max_drawdown)
- */
-
-'use strict';
-
-const { logger } = require('../../utils/logger');
-const log = logger.scope('RecoveryMath');
-
-/**
- * Recovery Math Engine
- * Calculates optimal parameters during drawdown using mathematical models
- */
-class RecoveryMath {
-  constructor() {
-    // Trade history for calculations
-    this.trades = [];
-    this.maxTrades = 100; // Rolling window
-    
-    // Volatility tracking
-    this.priceReturns = [];
-    this.maxReturns = 200;
-    
-    // Session state
-    this.sessionPnL = 0;
-    this.peakPnL = 0;
-    this.drawdown = 0;
-    this.recoveryActive = false;
-    
-    // Default parameters (will be adjusted dynamically)
-    this.baseParams = {
-      targetTicks: 16,
-      stopTicks: 20,
-      kellyFraction: 0.25, // Use 25% of full Kelly (conservative)
-    };
-  }
-
-  /**
-   * Update session P&L and check recovery activation
-   * @param {number} pnl - Current session P&L
-   * @param {number} activationThreshold - e.g., -300
-   * @param {number} deactivationThreshold - e.g., -100
-   */
-  updateSessionPnL(pnl, activationThreshold = -300, deactivationThreshold = -100) {
-    this.sessionPnL = pnl;
-    
-    // Track peak for drawdown calculation
-    if (pnl > this.peakPnL) {
-      this.peakPnL = pnl;
-    }
-    
-    // Calculate current drawdown
-    this.drawdown = this.peakPnL - pnl;
-    
-    // Check recovery activation
-    const wasActive = this.recoveryActive;
-    
-    if (pnl <= activationThreshold && !this.recoveryActive) {
-      this.recoveryActive = true;
-      log.info('RECOVERY MODE ACTIVATED', { pnl, threshold: activationThreshold });
-    } else if (pnl >= deactivationThreshold && this.recoveryActive) {
-      this.recoveryActive = false;
-      log.info('RECOVERY MODE DEACTIVATED', { pnl, threshold: deactivationThreshold });
-    }
-    
-    return {
-      active: this.recoveryActive,
-      justActivated: this.recoveryActive && !wasActive,
-      justDeactivated: !this.recoveryActive && wasActive,
-      drawdown: this.drawdown,
-    };
-  }
-
-  /**
-   * Record a completed trade for statistics
-   * @param {Object} trade - { pnl, ticks, side, duration }
-   */
-  recordTrade(trade) {
-    this.trades.push({
-      pnl: trade.pnl,
-      ticks: trade.ticks,
-      side: trade.side,
-      duration: trade.duration,
-      timestamp: Date.now(),
-    });
-    
-    // Keep rolling window
-    if (this.trades.length > this.maxTrades) {
-      this.trades.shift();
-    }
-  }
-
-  /**
-   * Record price return for volatility calculation
-   * @param {number} price - Current price
-   * @param {number} prevPrice - Previous price
-   */
-  recordPriceReturn(price, prevPrice) {
-    if (prevPrice > 0) {
-      const ret = (price - prevPrice) / prevPrice;
-      this.priceReturns.push(ret);
-      
-      if (this.priceReturns.length > this.maxReturns) {
-        this.priceReturns.shift();
-      }
-    }
-  }
-
-  /**
-   * Calculate win rate from recent trades
-   * @returns {number} Win rate [0, 1]
-   */
-  calcWinRate() {
-    if (this.trades.length < 5) return 0.5; // Default 50% if insufficient data
-    
-    const wins = this.trades.filter(t => t.pnl > 0).length;
-    return wins / this.trades.length;
-  }
-
-  /**
-   * Calculate average win and loss
-   * @returns {{ avgWin: number, avgLoss: number, payoffRatio: number }}
-   */
-  calcPayoff() {
-    const wins = this.trades.filter(t => t.pnl > 0);
-    const losses = this.trades.filter(t => t.pnl < 0);
-    
-    const avgWin = wins.length > 0 
-      ? wins.reduce((s, t) => s + t.pnl, 0) / wins.length 
-      : 80; // Default $80 (16 ticks on NQ)
-    
-    const avgLoss = losses.length > 0 
-      ? Math.abs(losses.reduce((s, t) => s + t.pnl, 0) / losses.length)
-      : 100; // Default $100 (20 ticks on NQ)
-    
-    return {
-      avgWin,
-      avgLoss,
-      payoffRatio: avgWin / avgLoss,
-    };
-  }
-
-  /**
-   * Calculate Kelly Criterion for optimal bet sizing
-   * f* = (bp - q) / b
-   * where: b = win/loss ratio, p = win probability, q = 1-p
-   * 
-   * @returns {number} Kelly fraction [0, 1]
-   */
-  calcKelly() {
-    const winRate = this.calcWinRate();
-    const { payoffRatio } = this.calcPayoff();
-    
-    const p = winRate;
-    const q = 1 - p;
-    const b = payoffRatio;
-    
-    // Kelly formula
-    let kelly = (b * p - q) / b;
-    
-    // Clamp to reasonable range
-    kelly = Math.max(0, Math.min(1, kelly));
-    
-    return kelly;
-  }
-
-  /**
-   * Calculate drawdown-adjusted Kelly
-   * Reduces risk as drawdown deepens
-   * 
-   * @param {number} maxDrawdown - Maximum allowed drawdown (e.g., 500)
-   * @returns {number} Adjusted Kelly fraction
-   */
-  calcDrawdownAdjustedKelly(maxDrawdown = 500) {
-    const kelly = this.calcKelly();
-    
-    // Reduce Kelly based on current drawdown
-    // At 0% drawdown: use full Kelly
-    // At 100% max drawdown: use 0% Kelly
-    const drawdownPct = Math.min(1, this.drawdown / maxDrawdown);
-    const adjustment = 1 - (drawdownPct * 0.5); // Max 50% reduction
-    
-    return kelly * adjustment;
-  }
-
-  /**
-   * Calculate current volatility (standard deviation of returns)
-   * @returns {number} Volatility (annualized)
-   */
-  calcVolatility() {
-    if (this.priceReturns.length < 20) return 0.02; // Default 2%
-    
-    const mean = this.priceReturns.reduce((s, r) => s + r, 0) / this.priceReturns.length;
-    const variance = this.priceReturns.reduce((s, r) => s + Math.pow(r - mean, 2), 0) / this.priceReturns.length;
-    const stdDev = Math.sqrt(variance);
-    
-    return stdDev;
-  }
-
-  /**
-   * Calculate ATR-based thresholds
-   * @param {number} atr - Average True Range in ticks
-   * @returns {{ targetTicks: number, stopTicks: number }}
-   */
-  calcATRThresholds(atr) {
-    if (!atr || atr < 1) {
-      return {
-        targetTicks: this.baseParams.targetTicks,
-        stopTicks: this.baseParams.stopTicks,
-      };
-    }
-    
-    // Target = 1.5 * ATR (capture 1.5 average moves)
-    // Stop = 2 * ATR (allow 2 average moves against)
-    const targetTicks = Math.round(atr * 1.5);
-    const stopTicks = Math.round(atr * 2);
-    
-    // Clamp to reasonable range
-    return {
-      targetTicks: Math.max(8, Math.min(32, targetTicks)),
-      stopTicks: Math.max(10, Math.min(40, stopTicks)),
-    };
-  }
-
-  /**
-   * Calculate Expected Value of a trade setup
-   * EV = (win_prob * avg_win) - (loss_prob * avg_loss)
-   * 
-   * @param {number} confidence - Signal confidence [0, 1]
-   * @returns {number} Expected value in dollars
-   */
-  calcExpectedValue(confidence = 0.5) {
-    const baseWinRate = this.calcWinRate();
-    const { avgWin, avgLoss } = this.calcPayoff();
-    
-    // Adjust win rate by signal confidence
-    // Higher confidence = higher expected win rate
-    const adjustedWinRate = baseWinRate * (0.5 + confidence * 0.5);
-    
-    const ev = (adjustedWinRate * avgWin) - ((1 - adjustedWinRate) * avgLoss);
-    
-    return ev;
-  }
-
-  /**
-   * Get optimal position size using Kelly and volatility scaling
-   * @param {number} baseSize - Normal position size
-   * @param {number} maxSize - Maximum allowed size
-   * @param {number} targetVol - Target volatility (e.g., 0.02)
-   * @returns {number} Optimal position size
-   */
-  calcOptimalSize(baseSize, maxSize, targetVol = 0.02) {
-    // Get drawdown-adjusted Kelly
-    const kelly = this.calcDrawdownAdjustedKelly();
-    
-    // Get current volatility
-    const currentVol = this.calcVolatility();
-    
-    // Volatility scaling: reduce size when vol is high
-    const volScale = currentVol > 0 ? targetVol / currentVol : 1;
-    const volAdjusted = Math.min(2, Math.max(0.5, volScale)); // Clamp 0.5x - 2x
-    
-    // In recovery mode: use half Kelly (more conservative despite "aggressive")
-    // This is counter-intuitive but mathematically sound:
-    // - We want to recover, but not blow up
-    // - Half Kelly gives ~75% of optimal growth with much less variance
-    const kellyMultiplier = this.recoveryActive 
-      ? this.baseParams.kellyFraction * 0.75  // More conservative in recovery
-      : this.baseParams.kellyFraction;
-    
-    // Calculate optimal size
-    let optimalSize = baseSize * kelly * volAdjusted * kellyMultiplier * 4; // 4x because kelly is small
-    
-    // Clamp to max
-    optimalSize = Math.max(1, Math.min(maxSize, Math.round(optimalSize)));
-    
-    return optimalSize;
-  }
-
-  /**
-   * Get recovery parameters (thresholds, size, filter)
-   * All based on mathematical models
-   * 
-   * @param {Object} context - { baseSize, maxSize, atr, confidence, tickValue }
-   * @returns {Object} Recovery parameters
-   */
-  getRecoveryParams(context) {
-    const { baseSize = 1, maxSize = 5, atr = 12, confidence = 0.5, tickValue = 5 } = context;
-    
-    // Calculate all math-based values
-    const winRate = this.calcWinRate();
-    const { avgWin, avgLoss, payoffRatio } = this.calcPayoff();
-    const kelly = this.calcKelly();
-    const drawdownKelly = this.calcDrawdownAdjustedKelly();
-    const volatility = this.calcVolatility();
-    const ev = this.calcExpectedValue(confidence);
-    const { targetTicks, stopTicks } = this.calcATRThresholds(atr);
-    const optimalSize = this.calcOptimalSize(baseSize, maxSize);
-    
-    // Should we take this trade?
-    // In recovery: only take positive EV trades with high confidence
-    const minEV = this.recoveryActive ? 10 : 0; // Require $10 EV in recovery
-    const shouldTrade = ev >= minEV;
-    
-    return {
-      // Mode status
-      recoveryActive: this.recoveryActive,
-      sessionPnL: this.sessionPnL,
-      drawdown: this.drawdown,
-      
-      // Statistics
-      winRate,
-      avgWin,
-      avgLoss,
-      payoffRatio,
-      
-      // Kelly
-      kelly,
-      drawdownKelly,
-      
-      // Volatility
-      volatility,
-      
-      // Expected Value
-      expectedValue: ev,
-      shouldTrade,
-      
-      // Optimal parameters
-      optimalSize,
-      targetTicks,
-      stopTicks,
-      
-      // Breakeven (based on payoff ratio)
-      // If payoff > 1: early BE (lock small profit)
-      // If payoff < 1: late BE (need bigger moves)
-      breakevenTicks: payoffRatio >= 1 
-        ? Math.max(3, Math.round(targetTicks * 0.3))
-        : Math.max(4, Math.round(targetTicks * 0.4)),
-      
-      // Trailing (based on volatility)
-      // High vol: wider trail
-      // Low vol: tighter trail
-      trailingActivation: Math.round(targetTicks * 0.5),
-      trailingDistance: Math.max(2, Math.round(atr * 0.5)),
-    };
-  }
-
-  /**
-   * Get summary for logging
-   */
-  getSummary() {
-    return {
-      active: this.recoveryActive,
-      sessionPnL: this.sessionPnL,
-      drawdown: this.drawdown,
-      trades: this.trades.length,
-      winRate: (this.calcWinRate() * 100).toFixed(1) + '%',
-      kelly: (this.calcKelly() * 100).toFixed(1) + '%',
-      ev: '$' + this.calcExpectedValue().toFixed(2),
-    };
-  }
-
-  /**
-   * Reset state (new session)
-   */
-  reset() {
-    this.sessionPnL = 0;
-    this.peakPnL = 0;
-    this.drawdown = 0;
-    this.recoveryActive = false;
-    // Keep trade history for learning
-  }
-}
-
-// Singleton instance
-const recoveryMath = new RecoveryMath();
-
-module.exports = {
-  RecoveryMath,
-  recoveryMath,
-};

package/src/services/tradovate/constants.js

@@ -1,109 +0,0 @@
-/**
- * Tradovate Constants
- */
-
-// Base URLs
-const TRADOVATE_URLS = {
-  // Live Trading
-  LIVE_API: 'https://live.tradovateapi.com/v1',
-  LIVE_MD_WS: 'wss://md.tradovateapi.com/v1/websocket',
-  LIVE_TRADING_WS: 'wss://live.tradovateapi.com/v1/websocket',
-
-  // Demo/Simulation Trading
-  DEMO_API: 'https://demo.tradovateapi.com/v1',
-  DEMO_MD_WS: 'wss://md-demo.tradovateapi.com/v1/websocket',
-  DEMO_TRADING_WS: 'wss://demo.tradovateapi.com/v1/websocket',
-};
-
-// API Paths
-const API_PATHS = {
-  // Authentication
-  AUTH_TOKEN_REQUEST: '/auth/accesstokenrequest',
-  AUTH_RENEW_TOKEN: '/auth/renewaccesstoken',
-  AUTH_ME: '/auth/me',
-
-  // Account
-  ACCOUNT_LIST: '/account/list',
-  ACCOUNT_FIND: '/account/find',
-  ACCOUNT_ITEM: '/account/item',
-
-  // Cash Balance
-  CASH_BALANCE_LIST: '/cashBalance/list',
-  CASH_BALANCE_SNAPSHOT: '/cashBalance/getcashbalancesnapshot',
-
-  // Contract
-  CONTRACT_FIND: '/contract/find',
-  CONTRACT_ITEM: '/contract/item',
-  CONTRACT_SUGGEST: '/contract/suggest',
-
-  // Product
-  PRODUCT_LIST: '/product/list',
-  PRODUCT_FIND: '/product/find',
-
-  // Order
-  ORDER_LIST: '/order/list',
-  ORDER_PLACE: '/order/placeorder',
-  ORDER_MODIFY: '/order/modifyorder',
-  ORDER_CANCEL: '/order/cancelorder',
-  ORDER_LIQUIDATE_POSITION: '/order/liquidateposition',
-
-  // Position
-  POSITION_LIST: '/position/list',
-  POSITION_DEPS: '/position/deps',
-
-  // Fill
-  FILL_LIST: '/fill/list',
-  FILL_DEPS: '/fill/deps',
-};
-
-// WebSocket Events
-const WS_EVENTS = {
-  CONNECTED: 'connected',
-  DISCONNECTED: 'disconnected',
-  ERROR: 'error',
-  QUOTE: 'md/quote',
-  DOM: 'md/dom',
-  ORDER: 'order',
-  FILL: 'fill',
-  POSITION: 'position',
-  ACCOUNT: 'account',
-  CASH_BALANCE: 'cashBalance',
-  HEARTBEAT: 'heartbeat',
-};
-
-// Token config
-const TOKEN_CONFIG = {
-  EXPIRATION_MINUTES: 90,
-  RENEW_BEFORE_MINUTES: 15,
-};
-
-/**
- * Get base URL for Tradovate API
- */
-function getBaseUrl(isDemo = true) {
-  return isDemo ? TRADOVATE_URLS.DEMO_API : TRADOVATE_URLS.LIVE_API;
-}
-
-/**
- * Get WebSocket URL for trading
- */
-function getTradingWebSocketUrl(isDemo = true) {
-  return isDemo ? TRADOVATE_URLS.DEMO_TRADING_WS : TRADOVATE_URLS.LIVE_TRADING_WS;
-}
-
-/**
- * Get WebSocket URL for market data
- */
-function getMdWebSocketUrl(isDemo = true) {
-  return isDemo ? TRADOVATE_URLS.DEMO_MD_WS : TRADOVATE_URLS.LIVE_MD_WS;
-}
-
-module.exports = {
-  TRADOVATE_URLS,
-  API_PATHS,
-  WS_EVENTS,
-  TOKEN_CONFIG,
-  getBaseUrl,
-  getTradingWebSocketUrl,
-  getMdWebSocketUrl,
-};