hedgequantx 2.6.162 → 2.7.0

package/src/services/strategy/hft-tick.js

@@ -1,507 +0,0 @@
-/**
- * =============================================================================
- * HFT TICK-BY-TICK STRATEGY
- * =============================================================================
- * Pure tick-based strategy for high-frequency trading
- * No bars, no candles - every tick counts
- * 
- * MODELS:
- * 1. Order Flow Imbalance (OFI) - Real-time buy/sell pressure
- * 2. Cumulative Delta - Net volume direction
- * 3. Bid/Ask Pressure - Spread and size analysis
- * 4. Momentum - Price velocity and acceleration
- * 5. Mean Reversion - Z-score on tick prices
- * 
- * SIGNALS:
- * - Generated on each tick when conditions align
- * - Sub-second decision making
- * - Designed for <50ms execution
- */
-
-const EventEmitter = require('events');
-const { logger } = require('../../utils/logger');
-
-const log = logger.scope('HFT');
-
-/**
- * Circular buffer for efficient tick storage
- */
-class CircularBuffer {
-  constructor(size) {
-    this.size = size;
-    this.buffer = new Array(size);
-    this.head = 0;
-    this.count = 0;
-  }
-
-  push(item) {
-    this.buffer[this.head] = item;
-    this.head = (this.head + 1) % this.size;
-    if (this.count < this.size) this.count++;
-  }
-
-  get(index) {
-    if (index >= this.count) return null;
-    const actualIndex = (this.head - this.count + index + this.size) % this.size;
-    return this.buffer[actualIndex];
-  }
-
-  getLast(n = 1) {
-    const result = [];
-    const count = Math.min(n, this.count);
-    for (let i = this.count - count; i < this.count; i++) {
-      result.push(this.get(i));
-    }
-    return result;
-  }
-
-  getAll() {
-    return this.getLast(this.count);
-  }
-
-  get length() {
-    return this.count;
-  }
-
-  clear() {
-    this.head = 0;
-    this.count = 0;
-  }
-}
-
-/**
- * HFT Tick Strategy
- */
-class HFTTickStrategy extends EventEmitter {
-  constructor() {
-    super();
-    
-    // Configuration - MUST be set via initialize() with API data
-    this.tickSize = null;
-    this.tickValue = null;
-    this.contractId = null;
-    this.initialized = false;
-    
-    // Tick buffers (circular for memory efficiency)
-    this.tickBuffer = new CircularBuffer(1000);  // Last 1000 ticks
-    this.priceBuffer = new CircularBuffer(500);  // Last 500 prices
-    
-    // Real-time metrics
-    this.cumulativeDelta = 0;
-    this.buyVolume = 0;
-    this.sellVolume = 0;
-    this.lastPrice = 0;
-    this.lastBid = 0;
-    this.lastAsk = 0;
-    
-    // ═══════════════════════════════════════════════════════════════════════
-    // STRATEGY CONFIGURATION PARAMETERS
-    // These are algorithm tuning parameters, NOT trading data
-    // They define HOW the strategy calculates signals from real tick data
-    // ═══════════════════════════════════════════════════════════════════════
-    
-    // OFI calculation windows (algorithm config)
-    this.ofiWindow = 50;  // Number of ticks for OFI calculation
-    this.ofiValue = 0;    // Calculated from real ticks
-    
-    // Momentum windows (algorithm config)
-    this.momentumWindow = 20;  // Number of ticks for momentum
-    this.momentum = 0;         // Calculated from real tick prices
-    this.acceleration = 0;     // Calculated from real tick prices
-    
-    // Mean reversion windows (algorithm config)
-    this.zscoreWindow = 100;  // Number of ticks for z-score
-    this.zscore = 0;          // Calculated from real tick prices
-    this.mean = 0;            // Calculated from real tick prices
-    this.std = 0;             // Calculated from real tick prices
-    
-    // Signal thresholds (algorithm tuning - from backtests)
-    this.ofiThreshold = 0.3;       // |OFI| threshold for signal generation
-    this.zscoreThreshold = 1.5;    // |Z| threshold for mean reversion
-    this.momentumThreshold = 0.5;  // Momentum threshold for confirmation
-    this.minConfidence = 0.6;      // Minimum composite score for signal
-    
-    // Risk parameters in ticks (algorithm config)
-    this.baseStopTicks = 8;     // Base stop distance in ticks
-    this.baseTargetTicks = 12;  // Base target distance in ticks
-    
-    // State tracking
-    this.tickCount = 0;         // Counter from real ticks received
-    this.signalCount = 0;       // Counter of signals generated
-    this.lastSignalTime = 0;    // Timestamp of last signal
-    this.cooldownMs = 5000;     // Cooldown between signals (ms)
-  }
-
-  /**
-   * Initialize strategy for a contract
-   * @param {string} contractId - Contract identifier from API
-   * @param {number} tickSize - Tick size from API (REQUIRED - no default)
-   * @param {number} tickValue - Tick value from API (REQUIRED - no default)
-   */
-  initialize(contractId, tickSize, tickValue) {
-    if (!contractId || tickSize === undefined || tickValue === undefined) {
-      throw new Error('HFT Strategy requires contractId, tickSize, and tickValue from API');
-    }
-    
-    this.contractId = contractId;
-    this.tickSize = tickSize;
-    this.tickValue = tickValue;
-    this.initialized = true;
-    
-    // Reset state
-    this.tickBuffer.clear();
-    this.priceBuffer.clear();
-    this.cumulativeDelta = 0;
-    this.buyVolume = 0;
-    this.sellVolume = 0;
-    this.tickCount = 0;
-    
-    log.info(`Initialized for ${contractId}: tick=${tickSize}, value=${tickValue}`);
-  }
-
-  /**
-   * Process a single tick - CORE HFT FUNCTION
-   * Called on every market tick
-   */
-  processTick(tick) {
-    if (!this.initialized) return;
-    
-    const { price, bid, ask, volume, side, timestamp } = tick;
-    
-    // Store tick
-    this.tickBuffer.push({
-      price,
-      bid: bid || this.lastBid,
-      ask: ask || this.lastAsk,
-      volume: volume || 1,
-      side: side || this.inferSide(price, bid, ask),
-      timestamp: timestamp || Date.now(),
-    });
-    
-    this.priceBuffer.push(price);
-    this.tickCount++;
-    
-    // Update last values
-    this.lastPrice = price;
-    if (bid) this.lastBid = bid;
-    if (ask) this.lastAsk = ask;
-    
-    // Update real-time metrics
-    this._updateDelta(tick);
-    this._updateOFI();
-    this._updateMomentum();
-    this._updateZScore();
-    
-    // Check for signal (every tick!)
-    this._checkSignal(tick);
-  }
-
-  /**
-   * Infer trade side from price position
-   */
-  inferSide(price, bid, ask) {
-    if (!bid || !ask) return 'unknown';
-    const mid = (bid + ask) / 2;
-    return price >= mid ? 'BUY' : 'SELL';
-  }
-
-  /**
-   * Update cumulative delta
-   */
-  _updateDelta(tick) {
-    const vol = tick.volume || 1;
-    const side = tick.side?.toUpperCase() || this.inferSide(tick.price, tick.bid, tick.ask);
-    
-    if (side === 'BUY') {
-      this.buyVolume += vol;
-      this.cumulativeDelta += vol;
-    } else if (side === 'SELL') {
-      this.sellVolume += vol;
-      this.cumulativeDelta -= vol;
-    }
-  }
-
-  /**
-   * Calculate Order Flow Imbalance on recent ticks
-   */
-  _updateOFI() {
-    const ticks = this.tickBuffer.getLast(this.ofiWindow);
-    if (ticks.length < 10) {
-      this.ofiValue = 0;
-      return;
-    }
-    
-    let buyPressure = 0;
-    let sellPressure = 0;
-    
-    for (const tick of ticks) {
-      const vol = tick.volume || 1;
-      const side = (tick.side || '').toUpperCase();
-      
-      if (side === 'BUY') {
-        buyPressure += vol;
-      } else if (side === 'SELL') {
-        sellPressure += vol;
-      }
-    }
-    
-    const total = buyPressure + sellPressure;
-    if (total > 0) {
-      // OFI range: -1 (all sells) to +1 (all buys)
-      this.ofiValue = (buyPressure - sellPressure) / total;
-    }
-  }
-
-  /**
-   * Calculate price momentum
-   */
-  _updateMomentum() {
-    const prices = this.priceBuffer.getLast(this.momentumWindow);
-    if (prices.length < 5) {
-      this.momentum = 0;
-      this.acceleration = 0;
-      return;
-    }
-    
-    // Momentum = price change over window
-    const first = prices[0];
-    const last = prices[prices.length - 1];
-    this.momentum = (last - first) / this.tickSize;
-    
-    // Acceleration = change in momentum
-    if (prices.length >= 10) {
-      const mid = prices[Math.floor(prices.length / 2)];
-      const firstHalf = (mid - first) / this.tickSize;
-      const secondHalf = (last - mid) / this.tickSize;
-      this.acceleration = secondHalf - firstHalf;
-    }
-  }
-
-  /**
-   * Calculate Z-Score for mean reversion
-   */
-  _updateZScore() {
-    const prices = this.priceBuffer.getLast(this.zscoreWindow);
-    if (prices.length < 20) {
-      this.zscore = 0;
-      return;
-    }
-    
-    // Calculate mean
-    this.mean = prices.reduce((a, b) => a + b, 0) / prices.length;
-    
-    // Calculate standard deviation
-    const variance = prices.reduce((sum, p) => sum + Math.pow(p - this.mean, 2), 0) / prices.length;
-    this.std = Math.sqrt(variance);
-    
-    // Z-Score
-    if (this.std > 0.0001) {
-      this.zscore = (this.lastPrice - this.mean) / this.std;
-    } else {
-      this.zscore = 0;
-    }
-  }
-
-  /**
-   * Check for trading signal
-   */
-  _checkSignal(tick) {
-    // Need minimum data
-    if (this.tickCount < 50) return;
-    
-    // Cooldown check
-    const now = Date.now();
-    if (now - this.lastSignalTime < this.cooldownMs) return;
-    
-    // Calculate composite score
-    const { direction, confidence, scores } = this._calculateSignal();
-    
-    if (direction === 'none' || confidence < this.minConfidence) return;
-    
-    // Generate signal
-    this.signalCount++;
-    this.lastSignalTime = now;
-    
-    const signal = this._buildSignal(direction, confidence, scores, tick);
-    
-    log.info(`SIGNAL #${this.signalCount}: ${direction.toUpperCase()} @ ${tick.price} | ` +
-             `OFI=${this.ofiValue.toFixed(2)} Z=${this.zscore.toFixed(2)} Mom=${this.momentum.toFixed(1)} | ` +
-             `Conf=${(confidence * 100).toFixed(0)}%`);
-    
-    this.emit('signal', signal);
-  }
-
-  /**
-   * Calculate trading signal from all models
-   */
-  _calculateSignal() {
-    let direction = 'none';
-    let confidence = 0;
-    
-    const scores = {
-      ofi: 0,
-      zscore: 0,
-      momentum: 0,
-      delta: 0,
-      composite: 0,
-    };
-    
-    // === MODEL 1: OFI ===
-    const absOfi = Math.abs(this.ofiValue);
-    if (absOfi > this.ofiThreshold) {
-      scores.ofi = Math.min(1.0, absOfi / 0.6);
-    }
-    
-    // === MODEL 2: Z-Score Mean Reversion ===
-    const absZ = Math.abs(this.zscore);
-    if (absZ > this.zscoreThreshold) {
-      scores.zscore = Math.min(1.0, absZ / 3.0);
-    }
-    
-    // === MODEL 3: Momentum ===
-    const absMom = Math.abs(this.momentum);
-    if (absMom > this.momentumThreshold) {
-      scores.momentum = Math.min(1.0, absMom / 3.0);
-    }
-    
-    // === MODEL 4: Delta ===
-    const totalVol = this.buyVolume + this.sellVolume;
-    if (totalVol > 0) {
-      const deltaRatio = this.cumulativeDelta / totalVol;
-      scores.delta = Math.min(1.0, Math.abs(deltaRatio) * 2);
-    }
-    
-    // === COMPOSITE SCORE ===
-    scores.composite = 
-      scores.ofi * 0.35 +       // OFI: 35%
-      scores.zscore * 0.25 +    // Z-Score: 25%
-      scores.momentum * 0.20 +  // Momentum: 20%
-      scores.delta * 0.20;      // Delta: 20%
-    
-    confidence = scores.composite;
-    
-    // === DETERMINE DIRECTION ===
-    // Mean reversion: go opposite to z-score
-    // Momentum: confirm with OFI and delta
-    
-    if (scores.composite >= this.minConfidence) {
-      // Primary: Mean reversion
-      if (absZ > this.zscoreThreshold) {
-        direction = this.zscore > 0 ? 'short' : 'long';
-        
-        // Confirm with OFI
-        const ofiConfirms = 
-          (direction === 'long' && this.ofiValue > 0) ||
-          (direction === 'short' && this.ofiValue < 0);
-        
-        if (ofiConfirms) {
-          confidence += 0.1;
-        } else if (Math.abs(this.ofiValue) > 0.2) {
-          // OFI contradicts - reduce confidence
-          confidence -= 0.15;
-        }
-      }
-      // Fallback: Momentum breakout
-      else if (absMom > this.momentumThreshold * 2 && absOfi > this.ofiThreshold) {
-        direction = this.momentum > 0 ? 'long' : 'short';
-        // Must be confirmed by OFI
-        if ((direction === 'long' && this.ofiValue < 0) ||
-            (direction === 'short' && this.ofiValue > 0)) {
-          direction = 'none';
-        }
-      }
-    }
-    
-    confidence = Math.min(1.0, Math.max(0, confidence));
-    
-    return { direction, confidence, scores };
-  }
-
-  /**
-   * Build signal object
-   */
-  _buildSignal(direction, confidence, scores, tick) {
-    const entry = tick.price;
-    const isLong = direction === 'long';
-    
-    // Adaptive stops based on volatility (std dev)
-    const volMult = Math.max(0.5, Math.min(2.0, this.std / this.tickSize / 4));
-    const stopTicks = Math.round(this.baseStopTicks * volMult);
-    const targetTicks = Math.round(this.baseTargetTicks * volMult);
-    
-    const stopLoss = isLong 
-      ? entry - stopTicks * this.tickSize
-      : entry + stopTicks * this.tickSize;
-      
-    const takeProfit = isLong
-      ? entry + targetTicks * this.tickSize
-      : entry - targetTicks * this.tickSize;
-    
-    return {
-      id: `hft-${Date.now()}-${this.signalCount}`,
-      timestamp: Date.now(),
-      contractId: this.contractId,
-      direction,
-      side: isLong ? 0 : 1,
-      entry,
-      stopLoss,
-      takeProfit,
-      confidence,
-      scores,
-      // Model values for logging
-      ofi: this.ofiValue,
-      zscore: this.zscore,
-      momentum: this.momentum,
-      delta: this.cumulativeDelta,
-      // Tick count
-      tickCount: this.tickCount,
-    };
-  }
-
-  /**
-   * Get current model values for monitoring
-   */
-  getModelValues() {
-    return {
-      ofi: this.ofiValue,
-      delta: this.cumulativeDelta,
-      zscore: this.zscore,
-      momentum: this.momentum,
-      mean: this.mean,
-      std: this.std,
-      buyVolume: this.buyVolume,
-      sellVolume: this.sellVolume,
-      tickCount: this.tickCount,
-      signalCount: this.signalCount,
-    };
-  }
-
-  /**
-   * Get state for display
-   */
-  getState() {
-    return this.getModelValues();
-  }
-
-  /**
-   * Reset strategy state
-   */
-  reset() {
-    this.tickBuffer.clear();
-    this.priceBuffer.clear();
-    this.cumulativeDelta = 0;
-    this.buyVolume = 0;
-    this.sellVolume = 0;
-    this.tickCount = 0;
-    this.signalCount = 0;
-    this.ofiValue = 0;
-    this.zscore = 0;
-    this.momentum = 0;
-    log.info('Strategy reset');
-  }
-}
-
-// Singleton instance
-const hftStrategy = new HFTTickStrategy();
-
-module.exports = { HFTTickStrategy, hftStrategy };