hedgequantx 2.6.28 → 2.6.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.6.28",
+  "version": "2.6.30",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/pages/algo/one-account.js

@@ -16,12 +16,16 @@ const { checkMarketHours } = require('../../services/projectx/market');
 const { FAST_SCALPING } = require('../../config/settings');
 const { PositionManager } = require('../../services/position-manager');
 
-// Strategy & Market Data (obfuscated)
+// Strategy & Market Data
 const { M1 } = require('../../../dist/lib/m/s1');
+const { hftStrategy } = require('../../services/strategy/hft-tick');
 const { MarketDataFeed } = require('../../../dist/lib/data');
 const { RithmicMarketDataFeed } = require('../../services/rithmic/market-data');
 const { algoLogger } = require('./logger');
 
+// Use HFT tick-based strategy for Rithmic (fast path), M1 for ProjectX
+const USE_HFT_STRATEGY = true;
+
 // AI Strategy Supervisor - observes, learns, and optimizes the strategy
 const aiService = require('../../services/ai');
 const StrategySupervisor = require('../../services/ai/strategy-supervisor');
@@ -263,13 +267,15 @@ const launchAlgo = async (service, account, contract, config) => {
   let lastTradeCount = 0; // Track number of trades from API
   let lastPositionQty = 0; // Track position changes
   
-  // Initialize Strategy FIRST (M1 is singleton instance)
-  // Strategy needs to be initialized before PositionManager so it can access math models
-  const strategy = M1;
+  // Initialize Strategy
+  // Use HFT tick-based strategy for Rithmic (fast path), M1 for ProjectX
+  const strategy = (USE_HFT_STRATEGY && useFastPath) ? hftStrategy : M1;
+  const strategyName = (USE_HFT_STRATEGY && useFastPath) ? 'HFT-TICK' : 'M1';
   
-  // Only initialize strategy if we have tick data from API
+  // Initialize strategy with tick specs
   if (tickSize !== null && tickValue !== null) {
     strategy.initialize(contractId, tickSize, tickValue);
+    algoLogger.info(ui, 'STRATEGY', `${strategyName} initialized | tick=${tickSize} value=$${tickValue}`);
   } else {
     algoLogger.warning(ui, 'WARNING', 'Tick size/value not available from API');
   }
@@ -588,15 +594,19 @@ const launchAlgo = async (service, account, contract, config) => {
     // Heartbeat every 30 seconds - show strategy model values
     if (Date.now() - lastHeartbeat > 30000) {
       // Try to get model values from strategy
-      const modelValues = strategy.getModelValues?.(contractId) || strategy.getState?.() || null;
-      if (modelValues && (modelValues.ofi !== undefined || modelValues.delta !== undefined)) {
-        const ofi = (modelValues.ofi || 0).toFixed(1);
-        const delta = (modelValues.delta || 0).toFixed(1);
-        const zscore = (modelValues.zscore || modelValues.zScore || 0).toFixed(2);
-        const momentum = modelValues.momentum ? (modelValues.momentum > 0 ? 'BULL' : 'BEAR') : 'FLAT';
-        algoLogger.info(ui, 'M1 STATUS', `OFI=${ofi} Delta=${delta} Z=${zscore} ${momentum} | ${tps} ticks/30s`);
+      const modelValues = strategy.getModelValues?.() || strategy.getModelValues?.(contractId) || null;
+      
+      if (modelValues && modelValues.ofi !== undefined) {
+        // HFT Strategy - pure tick values
+        const ofi = (modelValues.ofi || 0).toFixed(2);
+        const delta = modelValues.delta || 0;
+        const zscore = (modelValues.zscore || 0).toFixed(2);
+        const mom = (modelValues.momentum || 0).toFixed(1);
+        const signals = modelValues.signalCount || 0;
+        const deltaStr = delta >= 0 ? `+${delta}` : `${delta}`;
+        algoLogger.info(ui, strategyName, `OFI=${ofi} Z=${zscore} Mom=${mom} Δ=${deltaStr} | ${signals} signals | ${tps} t/30s`);
       } else {
-        // Show tick count and price to confirm data is flowing
+        // Fallback
         algoLogger.info(ui, 'SCANNING', `${tps} ticks/30s | ${tickCount} total | price=${tickData.price}`);
       }
       lastHeartbeat = Date.now();

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

@@ -0,0 +1,507 @@
+/**
+ * =============================================================================
+ * 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 };