hedgequantx 2.6.162 → 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,
+};

package/src/services/position-manager.js

@@ -16,7 +16,7 @@ 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 { checkExitConditions, checkBreakevenActivation, calculatePnlTicks } = require('./position-exit-logic');
 
 const log = logger.scope('PositionMgr');
 
@@ -292,50 +292,10 @@ class PositionManager extends EventEmitter {
       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;
+      // 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', {
@@ -352,46 +312,22 @@ class PositionManager extends EventEmitter {
           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 };
-      }
+      // Check exit conditions
+      const exitReason = checkExitConditions({
+        position,
+        currentPrice,
+        pnlTicks,
+        holdDuration,
+        strategy: this.strategy,
+        getTickSize: (p) => this._getTickSize(p),
+        latestPrices: this.latestPrices,
+      });
       
-      if (momentum < MOMENTUM.ADVERSE_THRESHOLD) {
-        return { type: 'momentum_adverse', reason: 'Adverse momentum detected', pnlTicks, momentum };
+      if (exitReason) {
+        this._executeExit(orderTag, exitReason);
       }
     }
-    
-    return null;
   }
 
   _executeExit(orderTag, exitReason) {
@@ -468,33 +404,7 @@ class PositionManager extends EventEmitter {
   }
 
   _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);
-    }
+    return calculatePnlTicks(position, currentPrice, (p) => this._getTickSize(p));
   }
 
   getActivePositions() {

package/src/services/rithmic/contracts.js

@@ -0,0 +1,218 @@
+/**
+ * Rithmic Contracts Module
+ * @module services/rithmic/contracts
+ * 
+ * Contract lookup and front month discovery
+ */
+
+const { decodeFrontMonthContract } = require('./protobuf');
+const { CME_CONTRACT_SPECS } = require('./specs');
+const { TIMEOUTS, CACHE } = require('../../config/settings');
+const { logger } = require('../../utils/logger');
+
+const log = logger.scope('RithmicContracts');
+
+/**
+ * Decode product codes from raw protobuf buffer
+ * @param {Buffer} buffer
+ * @returns {Object}
+ */
+function decodeProductCodes(buffer) {
+  const result = {};
+  let offset = 0;
+
+  const readVarint = (buf, off) => {
+    let value = 0, shift = 0;
+    while (off < buf.length) {
+      const byte = buf[off++];
+      value |= (byte & 0x7F) << shift;
+      if (!(byte & 0x80)) break;
+      shift += 7;
+    }
+    return [value, off];
+  };
+
+  const readString = (buf, off) => {
+    const [len, newOff] = readVarint(buf, off);
+    return [buf.slice(newOff, newOff + len).toString('utf8'), newOff + len];
+  };
+
+  while (offset < buffer.length) {
+    try {
+      const [tag, tagOff] = readVarint(buffer, offset);
+      const wireType = tag & 0x7;
+      const fieldNumber = tag >>> 3;
+      offset = tagOff;
+
+      if (wireType === 0) {
+        const [, newOff] = readVarint(buffer, offset);
+        offset = newOff;
+      } else if (wireType === 2) {
+        const [val, newOff] = readString(buffer, offset);
+        offset = newOff;
+        if (fieldNumber === 110101) result.exchange = val;
+        if (fieldNumber === 100749) result.productCode = val;
+        if (fieldNumber === 100003) result.productName = val;
+      } else {
+        break;
+      }
+    } catch { break; }
+  }
+
+  return result;
+}
+
+/**
+ * Fetch all front month contracts from TICKER_PLANT
+ * @param {RithmicService} service
+ * @returns {Promise<Array>}
+ */
+async function fetchAllFrontMonths(service) {
+  if (!service.tickerConn) throw new Error('TICKER_PLANT not connected');
+
+  return new Promise((resolve) => {
+    const contracts = new Map();
+    const productsToCheck = new Map();
+
+    const productHandler = (msg) => {
+      if (msg.templateId !== 112) return;
+      
+      const decoded = decodeProductCodes(msg.data);
+      if (!decoded.productCode || !decoded.exchange) return;
+      
+      const validExchanges = ['CME', 'CBOT', 'NYMEX', 'COMEX', 'NYBOT', 'CFE'];
+      if (!validExchanges.includes(decoded.exchange)) return;
+      
+      const name = (decoded.productName || '').toLowerCase();
+      if (name.includes('option') || name.includes('swap') || name.includes('spread')) return;
+      
+      const key = `${decoded.productCode}:${decoded.exchange}`;
+      if (!productsToCheck.has(key)) {
+        productsToCheck.set(key, {
+          productCode: decoded.productCode,
+          productName: decoded.productName || decoded.productCode,
+          exchange: decoded.exchange,
+        });
+      }
+    };
+
+    const frontMonthHandler = (msg) => {
+      if (msg.templateId !== 114) return;
+      
+      const decoded = decodeFrontMonthContract(msg.data);
+      if (decoded.rpCode[0] === '0' && decoded.tradingSymbol) {
+        contracts.set(decoded.userMsg, {
+          symbol: decoded.tradingSymbol,
+          baseSymbol: decoded.userMsg,
+          exchange: decoded.exchange,
+        });
+      }
+    };
+
+    service.tickerConn.on('message', productHandler);
+    service.tickerConn.on('message', frontMonthHandler);
+
+    service.tickerConn.send('RequestProductCodes', {
+      templateId: 111,
+      userMsg: ['get-products'],
+    });
+
+    setTimeout(() => {
+      service.tickerConn.removeListener('message', productHandler);
+      log.debug('Collected products', { count: productsToCheck.size });
+
+      for (const product of productsToCheck.values()) {
+        service.tickerConn.send('RequestFrontMonthContract', {
+          templateId: 113,
+          userMsg: [product.productCode],
+          symbol: product.productCode,
+          exchange: product.exchange,
+        });
+      }
+
+      setTimeout(() => {
+        service.tickerConn.removeListener('message', frontMonthHandler);
+
+        const results = [];
+        for (const [baseSymbol, contract] of contracts) {
+          const productKey = `${baseSymbol}:${contract.exchange}`;
+          const product = productsToCheck.get(productKey);
+          const specs = CME_CONTRACT_SPECS[baseSymbol] || null;
+          const productName = specs?.name || product?.productName || baseSymbol;
+          
+          results.push({
+            symbol: contract.symbol,
+            baseSymbol,
+            name: contract.symbol,
+            description: productName,
+            exchange: contract.exchange,
+            tickSize: specs?.tickSize ?? null,
+            tickValue: specs?.tickValue ?? null,
+          });
+        }
+
+        results.sort((a, b) => a.baseSymbol.localeCompare(b.baseSymbol));
+        log.debug('Got contracts from API', { count: results.length });
+        resolve(results);
+      }, TIMEOUTS.RITHMIC_PRODUCTS);
+    }, TIMEOUTS.RITHMIC_CONTRACTS);
+  });
+}
+
+/**
+ * Get contracts with caching
+ * @param {RithmicService} service
+ * @returns {Promise<Object>}
+ */
+async function getContracts(service) {
+  if (service._contractsCache && Date.now() - service._contractsCacheTime < CACHE.CONTRACTS_TTL) {
+    return { success: true, contracts: service._contractsCache, source: 'cache' };
+  }
+
+  if (!service.credentials) return { success: false, error: 'Not logged in' };
+
+  try {
+    if (!service.tickerConn) {
+      const connected = await service.connectTicker(service.credentials.username, service.credentials.password);
+      if (!connected) return { success: false, error: 'Failed to connect to TICKER_PLANT' };
+    }
+
+    service.tickerConn.setMaxListeners(5000);
+    log.debug('Fetching contracts from Rithmic API');
+    const contracts = await fetchAllFrontMonths(service);
+
+    if (!contracts.length) return { success: false, error: 'No tradeable contracts found' };
+
+    service._contractsCache = contracts;
+    service._contractsCacheTime = Date.now();
+
+    return { success: true, contracts, source: 'api' };
+  } catch (err) {
+    log.error('getContracts error', { error: err.message });
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Search contracts by text
+ * @param {RithmicService} service
+ * @param {string} searchText
+ * @returns {Promise<Array>}
+ */
+async function searchContracts(service, searchText) {
+  const result = await getContracts(service);
+  if (!searchText || !result.success) return result.contracts || [];
+  
+  const search = searchText.toUpperCase();
+  return result.contracts.filter(c =>
+    c.symbol.toUpperCase().includes(search) ||
+    c.name.toUpperCase().includes(search)
+  );
+}
+
+module.exports = {
+  decodeProductCodes,
+  fetchAllFrontMonths,
+  getContracts,
+  searchContracts,
+};