hedgequantx 2.6.163 → 2.7.1

package/src/services/position-manager.js

@@ -1,438 +0,0 @@
-/**
- * @fileoverview Position Manager for Fast Scalping
- * @module services/position-manager
- * 
- * Manages position lifecycle with:
- * - 10 second minimum hold (prop firm rule - NON-NEGOTIABLE)
- * - Intelligent exit based on momentum (OFI 50%, Kalman 25%, Z-Score 25%)
- * - Trailing stop after profit threshold
- * - 60 second failsafe exit (NON-NEGOTIABLE)
- * - VPIN protection filter
- * 
- * Data source: Rithmic ORDER_PLANT (fills), PNL_PLANT (positions), TICKER_PLANT (prices)
- */
-
-const EventEmitter = require('events');
-const { FAST_SCALPING } = require('../config/settings');
-const { logger } = require('../utils/logger');
-const { MOMENTUM, WEIGHTS } = require('./position-constants');
-const { checkExitConditions, checkBreakevenActivation, calculatePnlTicks } = require('./position-exit-logic');
-
-const log = logger.scope('PositionMgr');
-
-/**
- * Position Manager Service
- * Handles position lifecycle for fast scalping strategy
- */
-class PositionManager extends EventEmitter {
-  constructor(rithmicService, strategy = null) {
-    super();
-    this.rithmic = rithmicService;
-    this.strategy = strategy;
-    
-    this.positions = new Map();
-    this.latestPrices = new Map();
-    this.contractInfo = new Map();
-    
-    this._monitorInterval = null;
-    this._isRunning = false;
-    
-    this._onOrderFilled = this._onOrderFilled.bind(this);
-    this._onPriceUpdate = this._onPriceUpdate.bind(this);
-    this._onPositionUpdate = this._onPositionUpdate.bind(this);
-  }
-
-  setStrategy(strategy) {
-    this.strategy = strategy;
-    log.debug('Strategy reference set');
-  }
-
-  setContractInfo(symbol, info) {
-    this.contractInfo.set(symbol, {
-      tickSize: info.tickSize,
-      tickValue: info.tickValue,
-      contractId: info.contractId,
-    });
-    log.debug('Contract info set', { symbol, tickSize: info.tickSize, tickValue: info.tickValue });
-  }
-
-  start() {
-    if (this._isRunning) return;
-    
-    log.info('Starting position manager', {
-      minHoldMs: FAST_SCALPING.MIN_HOLD_MS,
-      maxHoldMs: FAST_SCALPING.MAX_HOLD_MS,
-      targetTicks: FAST_SCALPING.TARGET_TICKS,
-      stopTicks: FAST_SCALPING.STOP_TICKS,
-      momentumWeights: WEIGHTS,
-    });
-    
-    this.rithmic.on('orderFilled', this._onOrderFilled);
-    this.rithmic.on('priceUpdate', this._onPriceUpdate);
-    this.rithmic.on('positionUpdate', this._onPositionUpdate);
-    
-    this._monitorInterval = setInterval(() => {
-      this._monitorPositions();
-    }, FAST_SCALPING.MONITOR_INTERVAL_MS);
-    
-    this._isRunning = true;
-    log.debug('Position manager started');
-  }
-
-  stop() {
-    if (!this._isRunning) return;
-    
-    log.info('Stopping position manager');
-    
-    this.rithmic.off('orderFilled', this._onOrderFilled);
-    this.rithmic.off('priceUpdate', this._onPriceUpdate);
-    this.rithmic.off('positionUpdate', this._onPositionUpdate);
-    
-    if (this._monitorInterval) {
-      clearInterval(this._monitorInterval);
-      this._monitorInterval = null;
-    }
-    
-    this._isRunning = false;
-    log.debug('Position manager stopped');
-  }
-
-  registerEntry(entryResult, orderData, contractInfo = null) {
-    if (!entryResult.success) {
-      log.warn('Cannot register failed entry', { error: entryResult.error });
-      return null;
-    }
-    
-    const { orderTag, entryTime, latencyMs } = entryResult;
-    
-    const info = contractInfo || this.contractInfo.get(orderData.symbol) || {
-      tickSize: null,
-      tickValue: null,
-      contractId: orderData.contractId || orderData.symbol,
-    };
-    
-    const position = {
-      orderTag,
-      accountId: orderData.accountId,
-      symbol: orderData.symbol,
-      exchange: orderData.exchange || 'CME',
-      side: orderData.side,
-      size: orderData.size,
-      entryPrice: null,
-      entryTime,
-      fillTime: null,
-      highWaterMark: null,
-      lowWaterMark: null,
-      status: 'pending',
-      holdComplete: false,
-      breakevenActive: false,
-      breakevenPrice: null,
-      exitReason: null,
-      latencyMs,
-      tickSize: info.tickSize,
-      tickValue: info.tickValue,
-      contractId: info.contractId,
-    };
-    
-    this.positions.set(orderTag, position);
-    
-    log.debug('Registered entry', {
-      orderTag,
-      symbol: orderData.symbol,
-      side: orderData.side === 0 ? 'LONG' : 'SHORT',
-      size: orderData.size,
-      latencyMs,
-      tickSize: info.tickSize,
-    });
-    
-    return orderTag;
-  }
-
-  _onOrderFilled(fillInfo) {
-    const { orderTag, avgFillPrice, symbol } = fillInfo;
-    
-    if (!orderTag) return;
-    
-    const position = this.positions.get(orderTag);
-    if (!position) {
-      // Check if this is an exit fill
-      for (const [tag, pos] of this.positions) {
-        if (pos.status === 'exiting' && pos.symbol === symbol) {
-          this._handleExitFill(tag, pos, avgFillPrice);
-          return;
-        }
-      }
-      log.debug('Fill for untracked order', { orderTag });
-      return;
-    }
-    
-    if (position.status === 'pending') {
-      this._handleEntryFill(orderTag, position, avgFillPrice);
-    } else if (position.status === 'exiting') {
-      this._handleExitFill(orderTag, position, avgFillPrice);
-    }
-  }
-
-  _handleEntryFill(orderTag, position, avgFillPrice) {
-    position.entryPrice = avgFillPrice;
-    position.fillTime = Date.now();
-    position.highWaterMark = avgFillPrice;
-    position.lowWaterMark = avgFillPrice;
-    position.status = 'holding';
-    
-    const fillLatency = position.fillTime - position.entryTime;
-    
-    log.info('ENTRY FILLED', {
-      orderTag,
-      symbol: position.symbol,
-      side: position.side === 0 ? 'LONG' : 'SHORT',
-      size: position.size,
-      price: avgFillPrice,
-      entryLatencyMs: position.latencyMs,
-      fillLatencyMs: fillLatency,
-    });
-    
-    this.emit('entryFilled', { orderTag, position, fillLatencyMs: fillLatency });
-    
-    setTimeout(() => this._onHoldComplete(orderTag), FAST_SCALPING.MIN_HOLD_MS);
-    setTimeout(() => this._failsafeExit(orderTag), FAST_SCALPING.MAX_HOLD_MS);
-  }
-
-  _handleExitFill(orderTag, position, avgFillPrice) {
-    position.status = 'closed';
-    const holdDuration = Date.now() - position.fillTime;
-    const pnlTicks = this._calculatePnlTicks(position, avgFillPrice);
-    
-    log.info('EXIT FILLED', {
-      orderTag,
-      symbol: position.symbol,
-      exitPrice: avgFillPrice,
-      entryPrice: position.entryPrice,
-      pnlTicks,
-      holdDurationMs: holdDuration,
-      reason: position.exitReason,
-    });
-    
-    this.emit('exitFilled', {
-      orderTag,
-      position,
-      exitPrice: avgFillPrice,
-      pnlTicks,
-      holdDurationMs: holdDuration,
-    });
-    
-    this.positions.delete(orderTag);
-  }
-
-  _failsafeExit(orderTag) {
-    const position = this.positions.get(orderTag);
-    if (!position) return;
-    
-    if (position.status === 'holding' || position.status === 'active') {
-      const currentPrice = this.latestPrices.get(position.symbol);
-      const pnlTicks = currentPrice ? this._calculatePnlTicks(position, currentPrice) : 0;
-      
-      log.warn('FAILSAFE EXIT - 60s max hold exceeded', { orderTag, symbol: position.symbol, pnlTicks });
-      
-      this._executeExit(orderTag, {
-        type: 'failsafe',
-        reason: '60s max hold exceeded (NON-NEGOTIABLE)',
-        pnlTicks,
-      });
-    }
-  }
-
-  _onPriceUpdate(priceData) {
-    const { symbol, price } = priceData;
-    
-    this.latestPrices.set(symbol, price);
-    
-    for (const [, position] of this.positions) {
-      if (position.symbol === symbol && (position.status === 'holding' || position.status === 'active') && position.entryPrice) {
-        if (position.side === 0) {
-          position.highWaterMark = Math.max(position.highWaterMark, price);
-        } else {
-          position.lowWaterMark = Math.min(position.lowWaterMark, price);
-        }
-      }
-    }
-  }
-
-  _onPositionUpdate(posData) {
-    log.debug('Position update from PNL_PLANT', { symbol: posData?.symbol, qty: posData?.quantity });
-  }
-
-  _onHoldComplete(orderTag) {
-    const position = this.positions.get(orderTag);
-    if (!position) return;
-    
-    if (position.status === 'holding') {
-      position.holdComplete = true;
-      position.status = 'active';
-      
-      log.info('Hold complete - now monitoring for exit', {
-        orderTag,
-        symbol: position.symbol,
-        entryPrice: position.entryPrice,
-      });
-      
-      this.emit('holdComplete', { orderTag, position });
-    }
-  }
-
-  _monitorPositions() {
-    const now = Date.now();
-    
-    for (const [orderTag, position] of this.positions) {
-      if (position.status !== 'active') continue;
-      
-      const currentPrice = this.latestPrices.get(position.symbol);
-      if (!currentPrice) continue;
-      
-      const holdDuration = now - position.fillTime;
-      const pnlTicks = this._calculatePnlTicks(position, currentPrice);
-      
-      // Check for breakeven activation
-      const beActivation = checkBreakevenActivation(position, pnlTicks, (p) => this._getTickSize(p));
-      if (beActivation) {
-        position.breakevenPrice = beActivation.breakevenPrice;
-        position.breakevenActive = true;
-        
-        log.info('BREAKEVEN ACTIVATED', {
-          symbol: position.symbol,
-          entryPrice: position.entryPrice,
-          bePrice: position.breakevenPrice,
-          pnlTicks,
-        });
-        
-        this.emit('breakevenActivated', {
-          orderTag: position.orderTag,
-          position,
-          breakevenPrice: position.breakevenPrice,
-          pnlTicks,
-        });
-      }
-      
-      // Check exit conditions
-      const exitReason = checkExitConditions({
-        position,
-        currentPrice,
-        pnlTicks,
-        holdDuration,
-        strategy: this.strategy,
-        getTickSize: (p) => this._getTickSize(p),
-        latestPrices: this.latestPrices,
-      });
-      
-      if (exitReason) {
-        this._executeExit(orderTag, exitReason);
-      }
-    }
-  }
-
-  _executeExit(orderTag, exitReason) {
-    const position = this.positions.get(orderTag);
-    if (!position || position.status === 'exiting' || position.status === 'closed') return;
-    
-    position.status = 'exiting';
-    position.exitReason = exitReason;
-    
-    log.info('Executing EXIT', {
-      orderTag,
-      symbol: position.symbol,
-      reason: exitReason.reason,
-      pnlTicks: exitReason.pnlTicks,
-      momentum: exitReason.momentum,
-    });
-    
-    const exitSide = position.side === 0 ? 1 : 0;
-    
-    const exitResult = this.rithmic.fastExit({
-      accountId: position.accountId,
-      symbol: position.symbol,
-      exchange: position.exchange,
-      size: position.size,
-      side: exitSide,
-    });
-    
-    if (exitResult.success) {
-      log.debug('Exit order fired', {
-        orderTag: position.orderTag,
-        exitOrderTag: exitResult.orderTag,
-        latencyMs: exitResult.latencyMs,
-      });
-      
-      this.emit('exitOrderFired', {
-        orderTag,
-        exitOrderTag: exitResult.orderTag,
-        exitReason,
-        latencyMs: exitResult.latencyMs,
-      });
-    } else {
-      log.error('Exit order FAILED', { orderTag, error: exitResult.error });
-      position.status = 'active';
-      position.exitReason = null;
-    }
-  }
-
-  _getTickSize(position) {
-    if (position.tickSize !== null && position.tickSize !== undefined) {
-      return position.tickSize;
-    }
-    
-    const info = this.contractInfo.get(position.symbol);
-    if (info && info.tickSize) {
-      return info.tickSize;
-    }
-    
-    log.warn('No tick size available for symbol', { symbol: position.symbol });
-    return null;
-  }
-
-  _getTickValue(position) {
-    if (position.tickValue !== null && position.tickValue !== undefined) {
-      return position.tickValue;
-    }
-    
-    const info = this.contractInfo.get(position.symbol);
-    if (info && info.tickValue) {
-      return info.tickValue;
-    }
-    
-    log.warn('No tick value available for symbol', { symbol: position.symbol });
-    return null;
-  }
-
-  _calculatePnlTicks(position, currentPrice) {
-    return calculatePnlTicks(position, currentPrice, (p) => this._getTickSize(p));
-  }
-
-  getActivePositions() {
-    return Array.from(this.positions.values()).filter(
-      p => p.status === 'holding' || p.status === 'active'
-    );
-  }
-
-  getPosition(orderTag) {
-    return this.positions.get(orderTag) || null;
-  }
-
-  canEnter(symbol) {
-    for (const position of this.positions.values()) {
-      if (position.symbol === symbol && position.status !== 'closed') {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  getMomentumThresholds() {
-    return { ...MOMENTUM };
-  }
-
-  getMomentumWeights() {
-    return { ...WEIGHTS };
-  }
-}
-
-module.exports = { PositionManager };

package/src/services/position-momentum.js

@@ -1,206 +0,0 @@
-/**
- * @fileoverview Position Momentum Calculator
- * Calculates momentum using strategy's math models (OFI, Kalman, Z-Score)
- * 
- * Data sources:
- * - OFI: Strategy's computeOrderFlowImbalance()
- * - Kalman: Strategy's kalmanStates
- * - Z-Score: Strategy's computeZScore()
- * - VPIN: Strategy's computeVPIN()
- */
-
-const { logger } = require('../utils/logger');
-const { WEIGHTS } = require('./position-constants');
-
-const log = logger.scope('PositionMomentum');
-
-/**
- * Get OFI (Order Flow Imbalance) from strategy
- * @param {Object} strategy - Strategy instance
- * @param {string} contractId - Contract identifier
- * @returns {number|null} OFI value [-1, 1] or null if unavailable
- */
-const getOFI = (strategy, contractId) => {
-  if (!strategy) return null;
-  
-  // Try strategy's computeOrderFlowImbalance (direct calculation from bars)
-  if (typeof strategy.computeOrderFlowImbalance === 'function') {
-    const bars = strategy.getBarHistory?.(contractId);
-    if (bars && bars.length >= 20) {
-      try {
-        return strategy.computeOrderFlowImbalance(bars);
-      } catch (error) {
-        log.debug('OFI calculation failed', { error: error.message });
-      }
-    }
-  }
-  
-  // Try getModelValues (pre-calculated values)
-  const modelValues = strategy.getModelValues?.(contractId);
-  if (modelValues && modelValues.rawOfi !== undefined) {
-    return modelValues.rawOfi;
-  }
-  
-  return null;
-};
-
-/**
- * Get Kalman velocity from strategy's Kalman filter
- * @param {Object} strategy - Strategy instance
- * @param {string} contractId - Contract identifier
- * @param {number} currentPrice - Latest price
- * @returns {number|null} Velocity value or null if unavailable
- */
-const getKalmanVelocity = (strategy, contractId, currentPrice) => {
-  if (!strategy) return null;
-  
-  // Try to access kalmanStates from strategy
-  if (strategy.kalmanStates) {
-    const state = strategy.kalmanStates.get(contractId);
-    if (state && typeof state.estimate === 'number') {
-      if (currentPrice !== undefined && currentPrice !== null) {
-        return currentPrice - state.estimate;
-      }
-    }
-  }
-  
-  return null;
-};
-
-/**
- * Get Z-Score from strategy
- * @param {Object} strategy - Strategy instance
- * @param {string} contractId - Contract identifier
- * @returns {number|null} Z-Score value or null if unavailable
- */
-const getZScore = (strategy, contractId) => {
-  if (!strategy) return null;
-  
-  // Try strategy's computeZScore (direct calculation from price buffer)
-  if (typeof strategy.computeZScore === 'function') {
-    const prices = strategy.priceBuffer?.get(contractId);
-    if (prices && prices.length >= 50) {
-      try {
-        return strategy.computeZScore(prices);
-      } catch (error) {
-        log.debug('Z-Score calculation failed', { error: error.message });
-      }
-    }
-  }
-  
-  return null;
-};
-
-/**
- * Get VPIN from strategy
- * @param {Object} strategy - Strategy instance
- * @param {string} contractId - Contract identifier
- * @returns {number|null} VPIN value [0, 1] or null if unavailable
- */
-const getVPIN = (strategy, contractId) => {
-  if (!strategy) return null;
-  
-  // Try strategy's computeVPIN (direct calculation from volume buffer)
-  if (typeof strategy.computeVPIN === 'function') {
-    const volumes = strategy.volumeBuffer?.get(contractId);
-    if (volumes && volumes.length >= 50) {
-      try {
-        return strategy.computeVPIN(volumes);
-      } catch (error) {
-        log.debug('VPIN calculation failed', { error: error.message });
-      }
-    }
-  }
-  
-  // Try getModelValues (pre-calculated, stored as 1 - vpin for scoring)
-  const modelValues = strategy.getModelValues?.(contractId);
-  if (modelValues && typeof modelValues.vpin === 'number') {
-    return 1 - modelValues.vpin;
-  }
-  
-  return null;
-};
-
-/**
- * Calculate momentum score using strategy's existing math models
- * Weighted: OFI (50%) + Kalman Velocity (25%) + Z-Score (25%)
- * 
- * @param {Object} params - Parameters
- * @param {Object} params.strategy - Strategy instance
- * @param {string} params.contractId - Contract identifier
- * @param {number} params.side - Position side (0=Long, 1=Short)
- * @param {number} params.currentPrice - Latest price
- * @param {number|null} params.tickSize - Tick size from API
- * @returns {number|null} Momentum score [-1 to 1], positive = favorable, null if insufficient data
- */
-const calculateMomentum = ({ strategy, contractId, side, currentPrice, tickSize }) => {
-  if (!strategy) {
-    return null;
-  }
-  
-  // Get individual model values (all from API/strategy, not invented)
-  const ofi = getOFI(strategy, contractId);
-  const velocity = getKalmanVelocity(strategy, contractId, currentPrice);
-  const zscore = getZScore(strategy, contractId);
-  
-  // Count how many models have data
-  let availableModels = 0;
-  let totalWeight = 0;
-  let weightedSum = 0;
-  
-  // 1. OFI (50%) - Order Flow Imbalance
-  if (ofi !== null) {
-    // For long: positive OFI = favorable, For short: negative OFI = favorable
-    const favorableOfi = side === 0 ? ofi : -ofi;
-    const ofiScore = Math.min(1, Math.max(-1, favorableOfi));
-    weightedSum += ofiScore * WEIGHTS.OFI;
-    totalWeight += WEIGHTS.OFI;
-    availableModels++;
-  }
-  
-  // 2. Kalman Velocity (25%)
-  if (velocity !== null && tickSize !== null) {
-    // Normalize velocity: favorable direction = positive
-    const favorableVelocity = side === 0 ? velocity : -velocity;
-    // Normalize to [-1, 1]: 4 ticks of velocity = 1.0 score
-    const normalizedVelocity = favorableVelocity / (tickSize * 4);
-    const velocityScore = Math.min(1, Math.max(-1, normalizedVelocity));
-    weightedSum += velocityScore * WEIGHTS.KALMAN;
-    totalWeight += WEIGHTS.KALMAN;
-    availableModels++;
-  }
-  
-  // 3. Z-Score (25%) - Progression toward mean
-  if (zscore !== null) {
-    let zscoreScore;
-    if (side === 0) {
-      // Long: entered when Z < -threshold, improving = Z moving toward 0
-      zscoreScore = zscore > -0.5 ? 0.5 : -0.5;
-    } else {
-      // Short: entered when Z > threshold, improving = Z moving toward 0
-      zscoreScore = zscore < 0.5 ? 0.5 : -0.5;
-    }
-    weightedSum += zscoreScore * WEIGHTS.ZSCORE;
-    totalWeight += WEIGHTS.ZSCORE;
-    availableModels++;
-  }
-  
-  // Need at least 1 model with data to calculate momentum
-  if (availableModels === 0 || totalWeight === 0) {
-    return null;
-  }
-  
-  // Normalize by actual total weight (in case some models unavailable)
-  const momentum = weightedSum / totalWeight;
-  
-  // Clamp to [-1, 1]
-  return Math.min(1, Math.max(-1, momentum));
-};
-
-module.exports = {
-  getOFI,
-  getKalmanVelocity,
-  getZScore,
-  getVPIN,
-  calculateMomentum,
-};