hedgequantx 2.6.162 → 2.7.0

package/src/services/position-manager.js

@@ -1,528 +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 { calculateMomentum, getVPIN } = require('./position-momentum');
-
-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);
-      
-      const exitReason = this._checkExitConditions(position, currentPrice, pnlTicks, holdDuration);
-      
-      if (exitReason) {
-        this._executeExit(orderTag, exitReason);
-      }
-    }
-  }
-
-  _checkExitConditions(position, currentPrice, pnlTicks) {
-    if (pnlTicks === null) return null;
-    
-    const targetTicks = FAST_SCALPING.TARGET_TICKS;
-    const stopTicks = FAST_SCALPING.STOP_TICKS;
-    
-    // 1. TARGET HIT
-    if (pnlTicks >= targetTicks) {
-      return { type: 'target', reason: 'Target reached', pnlTicks };
-    }
-    
-    // 2. BREAKEVEN CHECK
-    if (position.breakevenActive && position.breakevenPrice !== null) {
-      const tickSize = this._getTickSize(position);
-      if (tickSize) {
-        if (position.side === 0 && currentPrice <= position.breakevenPrice) {
-          return { type: 'breakeven', reason: 'Breakeven stop hit', pnlTicks };
-        } else if (position.side === 1 && currentPrice >= position.breakevenPrice) {
-          return { type: 'breakeven', reason: 'Breakeven stop hit', pnlTicks };
-        }
-      }
-    }
-    
-    // 3. STOP HIT (only if BE not active)
-    if (!position.breakevenActive && pnlTicks <= -stopTicks) {
-      return { type: 'stop', reason: 'Stop loss hit', pnlTicks };
-    }
-    
-    // 4. ACTIVATE BREAKEVEN
-    if (!position.breakevenActive && pnlTicks >= FAST_SCALPING.BREAKEVEN_ACTIVATION_TICKS) {
-      const tickSize = this._getTickSize(position);
-      if (tickSize && position.entryPrice) {
-        const offset = FAST_SCALPING.BREAKEVEN_OFFSET_TICKS * tickSize;
-        position.breakevenPrice = position.side === 0 
-          ? position.entryPrice + offset 
-          : position.entryPrice - offset;
-        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,
-        });
-      }
-    }
-    
-    // 5. VPIN DANGER
-    const vpin = getVPIN(this.strategy, position.contractId || position.symbol);
-    if (vpin !== null && vpin > MOMENTUM.VPIN_DANGER) {
-      return { type: 'vpin', reason: `VPIN spike ${(vpin * 100).toFixed(0)}% - informed traders`, pnlTicks, vpin };
-    }
-    
-    // 6. TRAILING STOP
-    if (pnlTicks >= FAST_SCALPING.TRAILING_ACTIVATION_TICKS) {
-      const trailingPnl = this._calculateTrailingPnl(position, currentPrice);
-      if (trailingPnl !== null && trailingPnl <= -FAST_SCALPING.TRAILING_DISTANCE_TICKS) {
-        return { type: 'trailing', reason: 'Trailing stop triggered', pnlTicks, trailingPnl };
-      }
-    }
-    
-    // 7. MOMENTUM-BASED EXIT
-    const momentum = calculateMomentum({
-      strategy: this.strategy,
-      contractId: position.contractId || position.symbol,
-      side: position.side,
-      currentPrice: this.latestPrices.get(position.symbol),
-      tickSize: this._getTickSize(position),
-    });
-    
-    if (momentum !== null) {
-      if (momentum > MOMENTUM.STRONG_FAVORABLE && pnlTicks > 4) {
-        return null; // Don't exit - momentum is strong
-      }
-      
-      if (momentum < MOMENTUM.WEAK_THRESHOLD && pnlTicks > 0) {
-        return { type: 'momentum_weak', reason: 'Weak momentum - securing profit', pnlTicks, momentum };
-      }
-      
-      if (momentum < MOMENTUM.ADVERSE_THRESHOLD) {
-        return { type: 'momentum_adverse', reason: 'Adverse momentum detected', pnlTicks, momentum };
-      }
-    }
-    
-    return null;
-  }
-
-  _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) {
-    if (position.entryPrice === null || currentPrice === null) return null;
-    
-    const tickSize = this._getTickSize(position);
-    if (tickSize === null) {
-      log.error('Cannot calculate PnL - no tick size from API', { symbol: position.symbol });
-      return null;
-    }
-    
-    const priceDiff = currentPrice - position.entryPrice;
-    const signedDiff = position.side === 0 ? priceDiff : -priceDiff;
-    
-    return Math.round(signedDiff / tickSize);
-  }
-
-  _calculateTrailingPnl(position, currentPrice) {
-    const tickSize = this._getTickSize(position);
-    if (tickSize === null) return null;
-    
-    if (position.side === 0) {
-      if (position.highWaterMark === null) return null;
-      const dropFromHigh = position.highWaterMark - currentPrice;
-      return -Math.round(dropFromHigh / tickSize);
-    } else {
-      if (position.lowWaterMark === null) return null;
-      const riseFromLow = currentPrice - position.lowWaterMark;
-      return -Math.round(riseFromLow / tickSize);
-    }
-  }
-
-  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 };