hedgequantx 2.6.161 → 2.6.163

package/src/services/rithmic/trade-history.js

@@ -0,0 +1,254 @@
+/**
+ * @fileoverview Rithmic Trade History
+ * Handles trade history fetching and P&L calculation
+ * 
+ * NO FAKE DATA - Only real values from Rithmic API
+ */
+
+const { logger } = require('../../utils/logger');
+const { getTickMultiplier } = require('./specs');
+
+const log = logger.scope('RithmicTradeHistory');
+
+/**
+ * Get trade history from Rithmic API
+ * Uses RequestShowOrderHistory to fetch historical fills
+ * @param {Object} service - RithmicService instance
+ * @param {string} accountId - Optional account filter
+ * @param {number} days - Number of days to fetch (default: 30)
+ * @returns {Promise<{success: boolean, trades: Array}>}
+ */
+const getTradeHistory = async (service, accountId, days = 30) => {
+  if (!service.orderConn || !service.loginInfo) {
+    return { success: true, trades: service.completedTrades || [] };
+  }
+
+  return new Promise((resolve) => {
+    const historyOrders = [];
+    let resolved = false;
+    
+    // Timeout after 5 seconds
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        // Combine API history with session trades
+        const allTrades = [...processHistoryToTrades(historyOrders, service), ...service.completedTrades];
+        resolve({ success: true, trades: allTrades });
+      }
+    }, 5000);
+    
+    // Listen for order history snapshots
+    const onOrderNotification = (data) => {
+      try {
+        if (data.isSnapshot || data.status === 'complete' || data.status === 'Complete') {
+          const order = {
+            orderId: data.orderId || data.orderTag,
+            accountId: data.accountId,
+            symbol: data.symbol,
+            exchange: data.exchange,
+            side: data.transactionType === 1 ? 0 : 1,
+            quantity: data.quantity || data.totalFillQuantity || 0,
+            fillPrice: data.avgFillPrice || data.lastFillPrice || 0,
+            timestamp: data.ssboe ? data.ssboe * 1000 : Date.now(),
+            status: data.status,
+          };
+          
+          if (order.quantity > 0 && order.fillPrice > 0) {
+            historyOrders.push(order);
+          }
+        }
+      } catch (e) {
+        // Ignore parse errors
+      }
+    };
+    
+    const onHistoryComplete = () => {
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        const allTrades = [...processHistoryToTrades(historyOrders, service), ...service.completedTrades];
+        resolve({ success: true, trades: allTrades });
+      }
+    };
+    
+    const cleanup = () => {
+      clearTimeout(timeout);
+      service.removeListener('orderNotification', onOrderNotification);
+      service.removeListener('orderHistoryComplete', onHistoryComplete);
+    };
+    
+    service.on('orderNotification', onOrderNotification);
+    service.on('orderHistoryComplete', onHistoryComplete);
+    
+    // Request order history for each account
+    try {
+      const accounts = accountId 
+        ? service.accounts.filter(a => a.accountId === accountId)
+        : service.accounts;
+      
+      for (const acc of accounts) {
+        service.orderConn.send('RequestShowOrderHistory', {
+          templateId: 324,
+          userMsg: ['HQX-HISTORY'],
+          fcmId: acc.fcmId || service.loginInfo.fcmId,
+          ibId: acc.ibId || service.loginInfo.ibId,
+          accountId: acc.accountId,
+        });
+      }
+    } catch (e) {
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        resolve({ success: false, error: e.message, trades: service.completedTrades || [] });
+      }
+    }
+  });
+};
+
+/**
+ * Process historical orders into trades with P&L
+ * Matches entries and exits to calculate P&L
+ * @param {Array} orders - Historical orders
+ * @param {Object} service - RithmicService instance (for _getTickMultiplier)
+ * @returns {Array} Processed trades
+ */
+const processHistoryToTrades = (orders, service) => {
+  const trades = [];
+  const openPositions = new Map();
+  
+  // Sort by timestamp (oldest first)
+  const sorted = [...orders].sort((a, b) => a.timestamp - b.timestamp);
+  
+  for (const order of sorted) {
+    const key = `${order.accountId}:${order.symbol}`;
+    const open = openPositions.get(key);
+    
+    if (open && open.side !== order.side) {
+      // Closing trade - calculate P&L
+      const closeQty = Math.min(order.quantity, open.quantity);
+      let pnl;
+      
+      if (open.side === 0) {
+        pnl = (order.fillPrice - open.price) * closeQty;
+      } else {
+        pnl = (open.price - order.fillPrice) * closeQty;
+      }
+      
+      const tickMultiplier = getTickMultiplier(order.symbol);
+      pnl = pnl * tickMultiplier;
+      
+      trades.push({
+        id: order.orderId,
+        accountId: order.accountId,
+        symbol: order.symbol,
+        exchange: order.exchange,
+        side: open.side,
+        size: closeQty,
+        entryPrice: open.price,
+        exitPrice: order.fillPrice,
+        price: order.fillPrice,
+        timestamp: order.timestamp,
+        creationTimestamp: new Date(order.timestamp).toISOString(),
+        status: 'CLOSED',
+        profitAndLoss: pnl,
+        pnl: pnl,
+        fees: 0,
+      });
+      
+      const remaining = open.quantity - closeQty;
+      if (remaining <= 0) {
+        openPositions.delete(key);
+      } else {
+        open.quantity = remaining;
+      }
+    } else if (open && open.side === order.side) {
+      // Adding to position
+      const totalQty = open.quantity + order.quantity;
+      open.price = ((open.price * open.quantity) + (order.fillPrice * order.quantity)) / totalQty;
+      open.quantity = totalQty;
+    } else {
+      // Opening new position
+      openPositions.set(key, {
+        side: order.side,
+        quantity: order.quantity,
+        price: order.fillPrice,
+        timestamp: order.timestamp,
+      });
+    }
+  }
+  
+  return trades;
+};
+
+/**
+ * Setup order fill listener for real-time P&L tracking
+ * @param {Object} service - RithmicService instance
+ */
+const setupOrderFillListener = (service) => {
+  service._openEntries = new Map();
+  
+  service.on('orderFilled', (fillInfo) => {
+    const key = `${fillInfo.accountId}:${fillInfo.symbol}`;
+    const side = fillInfo.transactionType === 1 ? 0 : 1;
+    const qty = fillInfo.fillQuantity || fillInfo.totalFillQuantity || 0;
+    const price = fillInfo.avgFillPrice || fillInfo.lastFillPrice || 0;
+    
+    const openEntry = service._openEntries.get(key);
+    let pnl = null;
+    
+    if (openEntry && openEntry.side !== side) {
+      // Closing trade
+      const closeQty = Math.min(qty, openEntry.qty);
+      
+      if (openEntry.side === 0) {
+        pnl = (price - openEntry.price) * closeQty;
+      } else {
+        pnl = (openEntry.price - price) * closeQty;
+      }
+      
+      const remainingQty = openEntry.qty - closeQty;
+      if (remainingQty <= 0) {
+        service._openEntries.delete(key);
+      } else {
+        openEntry.qty = remainingQty;
+      }
+      
+      service.completedTrades.push({
+        id: fillInfo.orderId || fillInfo.orderTag,
+        orderTag: fillInfo.orderTag,
+        accountId: fillInfo.accountId,
+        symbol: fillInfo.symbol,
+        exchange: fillInfo.exchange,
+        side: openEntry.side,
+        size: closeQty,
+        entryPrice: openEntry.price,
+        exitPrice: price,
+        price: price,
+        timestamp: fillInfo.localTimestamp || Date.now(),
+        creationTimestamp: new Date().toISOString(),
+        status: 'CLOSED',
+        profitAndLoss: pnl,
+        pnl: pnl,
+        fees: 0,
+      });
+      log.debug('Trade closed', { symbol: fillInfo.symbol, pnl, trades: service.completedTrades.length });
+    } else {
+      // Opening or adding to position
+      if (openEntry && openEntry.side === side) {
+        const totalQty = openEntry.qty + qty;
+        openEntry.price = ((openEntry.price * openEntry.qty) + (price * qty)) / totalQty;
+        openEntry.qty = totalQty;
+      } else {
+        service._openEntries.set(key, { side, qty, price, timestamp: Date.now() });
+      }
+      log.debug('Position opened/added', { symbol: fillInfo.symbol, side, qty, price });
+    }
+  });
+};
+
+module.exports = {
+  getTradeHistory,
+  processHistoryToTrades,
+  setupOrderFillListener,
+};

package/src/services/strategy/hft-signal-calc.js

@@ -0,0 +1,147 @@
+/**
+ * HFT Signal Calculation
+ * @module services/strategy/hft-signal-calc
+ * 
+ * Signal generation and building logic for HFT strategy
+ */
+
+/**
+ * Calculate trading signal from all models
+ * @param {Object} state - Strategy state
+ * @param {Object} config - Strategy config
+ * @returns {Object} {direction, confidence, scores}
+ */
+function calculateSignal(state, config) {
+  let direction = 'none';
+  let confidence = 0;
+  
+  const { ofiValue, zscore, momentum, buyVolume, sellVolume, cumulativeDelta } = state;
+  const { ofiThreshold, zscoreThreshold, momentumThreshold, minConfidence } = config;
+  
+  const scores = {
+    ofi: 0,
+    zscore: 0,
+    momentum: 0,
+    delta: 0,
+    composite: 0,
+  };
+  
+  // === MODEL 1: OFI ===
+  const absOfi = Math.abs(ofiValue);
+  if (absOfi > ofiThreshold) {
+    scores.ofi = Math.min(1.0, absOfi / 0.6);
+  }
+  
+  // === MODEL 2: Z-Score Mean Reversion ===
+  const absZ = Math.abs(zscore);
+  if (absZ > zscoreThreshold) {
+    scores.zscore = Math.min(1.0, absZ / 3.0);
+  }
+  
+  // === MODEL 3: Momentum ===
+  const absMom = Math.abs(momentum);
+  if (absMom > momentumThreshold) {
+    scores.momentum = Math.min(1.0, absMom / 3.0);
+  }
+  
+  // === MODEL 4: Delta ===
+  const totalVol = buyVolume + sellVolume;
+  if (totalVol > 0) {
+    const deltaRatio = 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 ===
+  if (scores.composite >= minConfidence) {
+    // Primary: Mean reversion
+    if (absZ > zscoreThreshold) {
+      direction = zscore > 0 ? 'short' : 'long';
+      
+      // Confirm with OFI
+      const ofiConfirms = 
+        (direction === 'long' && ofiValue > 0) ||
+        (direction === 'short' && ofiValue < 0);
+      
+      if (ofiConfirms) {
+        confidence += 0.1;
+      } else if (Math.abs(ofiValue) > 0.2) {
+        confidence -= 0.15;
+      }
+    }
+    // Fallback: Momentum breakout
+    else if (absMom > momentumThreshold * 2 && absOfi > ofiThreshold) {
+      direction = momentum > 0 ? 'long' : 'short';
+      if ((direction === 'long' && ofiValue < 0) ||
+          (direction === 'short' && ofiValue > 0)) {
+        direction = 'none';
+      }
+    }
+  }
+  
+  confidence = Math.min(1.0, Math.max(0, confidence));
+  
+  return { direction, confidence, scores };
+}
+
+/**
+ * Build signal object
+ * @param {string} direction
+ * @param {number} confidence
+ * @param {Object} scores
+ * @param {Object} tick
+ * @param {Object} state
+ * @param {Object} config
+ * @returns {Object} Signal object
+ */
+function buildSignal(direction, confidence, scores, tick, state, config) {
+  const entry = tick.price;
+  const isLong = direction === 'long';
+  
+  const { std, ofiValue, zscore, momentum, cumulativeDelta, tickCount, signalCount, contractId, tickSize } = state;
+  const { baseStopTicks, baseTargetTicks } = config;
+  
+  // Adaptive stops based on volatility
+  const volMult = Math.max(0.5, Math.min(2.0, std / tickSize / 4));
+  const stopTicks = Math.round(baseStopTicks * volMult);
+  const targetTicks = Math.round(baseTargetTicks * volMult);
+  
+  const stopLoss = isLong 
+    ? entry - stopTicks * tickSize
+    : entry + stopTicks * tickSize;
+    
+  const takeProfit = isLong
+    ? entry + targetTicks * tickSize
+    : entry - targetTicks * tickSize;
+  
+  return {
+    id: `hft-${Date.now()}-${signalCount}`,
+    timestamp: Date.now(),
+    contractId,
+    direction,
+    side: isLong ? 0 : 1,
+    entry,
+    stopLoss,
+    takeProfit,
+    confidence,
+    scores,
+    ofi: ofiValue,
+    zscore,
+    momentum,
+    delta: cumulativeDelta,
+    tickCount,
+  };
+}
+
+module.exports = {
+  calculateSignal,
+  buildSignal,
+};

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

@@ -20,6 +20,7 @@
 
 const EventEmitter = require('events');
 const { logger } = require('../../utils/logger');
+const { calculateSignal, buildSignal } = require('./hft-signal-calc');
 
 const log = logger.scope('HFT');
 
@@ -306,23 +307,49 @@ class HFTTickStrategy extends EventEmitter {
    * 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();
+    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;
     
-    // Generate signal
     this.signalCount++;
     this.lastSignalTime = now;
     
-    const signal = this._buildSignal(direction, confidence, scores, tick);
+    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)} | ` +
@@ -331,133 +358,6 @@ class HFTTickStrategy extends EventEmitter {
     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
    */