hedgequantx 2.6.161 → 2.6.163

package/src/services/position-exit-logic.js

@@ -0,0 +1,174 @@
+/**
+ * Position Exit Logic
+ * @module services/position-exit-logic
+ * 
+ * Exit condition evaluation for fast scalping positions
+ */
+
+const { FAST_SCALPING } = require('../config/settings');
+const { MOMENTUM, WEIGHTS } = require('./position-constants');
+const { calculateMomentum, getVPIN } = require('./position-momentum');
+const { logger } = require('../utils/logger');
+
+const log = logger.scope('PositionExit');
+
+/**
+ * Check all exit conditions for a position
+ * @param {Object} params
+ * @param {Object} params.position - Position data
+ * @param {number} params.currentPrice - Current market price
+ * @param {number} params.pnlTicks - Current P&L in ticks
+ * @param {number} params.holdDuration - Time held in ms
+ * @param {Object} params.strategy - Strategy instance
+ * @param {Function} params.getTickSize - Function to get tick size
+ * @param {Map} params.latestPrices - Latest prices map
+ * @returns {Object|null} - Exit reason or null
+ */
+function checkExitConditions({
+  position,
+  currentPrice,
+  pnlTicks,
+  holdDuration,
+  strategy,
+  getTickSize,
+  latestPrices,
+}) {
+  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 = 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. VPIN DANGER
+  const vpin = getVPIN(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 };
+  }
+  
+  // 5. TRAILING STOP
+  if (pnlTicks >= FAST_SCALPING.TRAILING_ACTIVATION_TICKS) {
+    const trailingPnl = calculateTrailingPnl(position, currentPrice, getTickSize);
+    if (trailingPnl !== null && trailingPnl <= -FAST_SCALPING.TRAILING_DISTANCE_TICKS) {
+      return { type: 'trailing', reason: 'Trailing stop triggered', pnlTicks, trailingPnl };
+    }
+  }
+  
+  // 6. MOMENTUM-BASED EXIT
+  const momentum = calculateMomentum({
+    strategy: strategy,
+    contractId: position.contractId || position.symbol,
+    side: position.side,
+    currentPrice: latestPrices.get(position.symbol),
+    tickSize: 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;
+}
+
+/**
+ * Check and activate breakeven if conditions met
+ * @param {Object} position
+ * @param {number} pnlTicks
+ * @param {Function} getTickSize
+ * @returns {Object|null} - Breakeven activation info or null
+ */
+function checkBreakevenActivation(position, pnlTicks, getTickSize) {
+  if (position.breakevenActive) return null;
+  if (pnlTicks < FAST_SCALPING.BREAKEVEN_ACTIVATION_TICKS) return null;
+  
+  const tickSize = getTickSize(position);
+  if (!tickSize || !position.entryPrice) return null;
+  
+  const offset = FAST_SCALPING.BREAKEVEN_OFFSET_TICKS * tickSize;
+  const breakevenPrice = position.side === 0 
+    ? position.entryPrice + offset 
+    : position.entryPrice - offset;
+  
+  return {
+    breakevenPrice,
+    pnlTicks,
+  };
+}
+
+/**
+ * Calculate trailing P&L from high/low water mark
+ * @param {Object} position
+ * @param {number} currentPrice
+ * @param {Function} getTickSize
+ * @returns {number|null}
+ */
+function calculateTrailingPnl(position, currentPrice, getTickSize) {
+  const tickSize = 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);
+  }
+}
+
+/**
+ * Calculate P&L in ticks
+ * @param {Object} position
+ * @param {number} currentPrice
+ * @param {Function} getTickSize
+ * @returns {number|null}
+ */
+function calculatePnlTicks(position, currentPrice, getTickSize) {
+  if (position.entryPrice === null || currentPrice === null) return null;
+  
+  const tickSize = getTickSize(position);
+  if (tickSize === null) return null;
+  
+  const priceDiff = currentPrice - position.entryPrice;
+  const signedDiff = position.side === 0 ? priceDiff : -priceDiff;
+  
+  return Math.round(signedDiff / tickSize);
+}
+
+module.exports = {
+  checkExitConditions,
+  checkBreakevenActivation,
+  calculateTrailingPnl,
+  calculatePnlTicks,
+};