hedgequantx 2.6.163 → 2.7.1

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

@@ -1,407 +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 { calculateSignal, buildSignal } = require('./hft-signal-calc');
-
-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) {
-    if (this.tickCount < 50) return;
-    
-    const now = Date.now();
-    if (now - this.lastSignalTime < this.cooldownMs) return;
-    
-    const state = {
-      ofiValue: this.ofiValue,
-      zscore: this.zscore,
-      momentum: this.momentum,
-      buyVolume: this.buyVolume,
-      sellVolume: this.sellVolume,
-      cumulativeDelta: this.cumulativeDelta,
-    };
-    
-    const config = {
-      ofiThreshold: this.ofiThreshold,
-      zscoreThreshold: this.zscoreThreshold,
-      momentumThreshold: this.momentumThreshold,
-      minConfidence: this.minConfidence,
-    };
-    
-    const { direction, confidence, scores } = calculateSignal(state, config);
-    
-    if (direction === 'none' || confidence < this.minConfidence) return;
-    
-    this.signalCount++;
-    this.lastSignalTime = now;
-    
-    const signalState = {
-      ...state,
-      std: this.std,
-      tickCount: this.tickCount,
-      signalCount: this.signalCount,
-      contractId: this.contractId,
-      tickSize: this.tickSize,
-    };
-    
-    const signalConfig = {
-      baseStopTicks: this.baseStopTicks,
-      baseTargetTicks: this.baseTargetTicks,
-    };
-    
-    const signal = buildSignal(direction, confidence, scores, tick, signalState, signalConfig);
-    
-    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);
-  }
-
-  /**
-   * 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 };