hedgequantx 2.6.162 → 2.7.0

package/src/services/rithmic/handlers.js

@@ -1,24 +1,14 @@
 /**
  * Rithmic Message Handlers
  * Handles ORDER_PLANT and PNL_PLANT messages
- * 
- * FAST SCALPING: Handles order fill notifications (351) for position tracking
- * 
- * OPTIMIZED FOR LOW LATENCY:
- * - Fast path for order notifications (351)
- * - Minimal object creation in hot path
- * - Template ID check before proto decode
- * - Latency tracking for fills
  */
 
 const { proto, decodeAccountPnL, decodeInstrumentPnL } = require('./protobuf');
 const { RES, STREAM } = require('./constants');
-const { performance } = require('perf_hooks');
-const { LatencyTracker, FillInfoPool } = require('./latency-tracker');
 
-// Debug mode - use no-op function when disabled for zero overhead
+// Debug mode
 const DEBUG = process.env.HQX_DEBUG === '1';
-const debug = DEBUG ? (...args) => console.log('[Rithmic:Handler]', ...args) : () => {};
+const debug = (...args) => DEBUG && console.log('[Rithmic:Handler]', ...args);
 
 /**
  * Create ORDER_PLANT message handler
@@ -45,40 +35,16 @@ const createOrderHandler = (service) => {
       case RES.SHOW_ORDERS:
         handleShowOrdersResponse(service, data);
         break;
-      case RES.NEW_ORDER:
-        debug('Handling NEW_ORDER response (313)');
-        handleNewOrderResponse(service, data);
-        break;
       case STREAM.EXCHANGE_NOTIFICATION:
-        debug('Handling EXCHANGE_NOTIFICATION (352)');
-        handleExchangeNotification(service, data);
+        service.emit('exchangeNotification', data);
         break;
       case STREAM.ORDER_NOTIFICATION:
-        debug('Handling ORDER_NOTIFICATION (351)');
-        handleOrderNotification(service, data);
-        break;
-      case RES.SHOW_ORDER_HISTORY:
-        debug('Handling SHOW_ORDER_HISTORY (325)');
-        handleOrderHistoryResponse(service, data);
+        service.emit('orderNotification', data);
         break;
     }
   };
 };
 
-/**
- * Handle order history response (325) - signals end of history snapshot
- */
-const handleOrderHistoryResponse = (service, data) => {
-  try {
-    const res = proto.decode('ResponseShowOrderHistory', data);
-    debug('Order history complete:', { userMsg: res.userMsg, rpCode: res.rpCode });
-    service.emit('orderHistoryComplete', { userMsg: res.userMsg, rpCode: res.rpCode });
-  } catch (e) {
-    debug('Error decoding order history response:', e.message);
-    service.emit('orderHistoryComplete', {});
-  }
-};
-
 /**
  * Create PNL_PLANT message handler
  * @param {RithmicService} service - The Rithmic service instance
@@ -193,23 +159,17 @@ const handleAccountPnLUpdate = (service, data) => {
     debug('Decoded Account PNL:', JSON.stringify(pnl));
     
     if (pnl.accountId) {
-      // Store ALL R Trader metrics from ACCOUNT_PNL_UPDATE (451)
       const pnlData = {
-        // Core P&L
         accountBalance: parseFloat(pnl.accountBalance || 0),
+        cashOnHand: parseFloat(pnl.cashOnHand || 0),
+        marginBalance: parseFloat(pnl.marginBalance || 0),
         openPositionPnl: parseFloat(pnl.openPositionPnl || 0),
         closedPositionPnl: parseFloat(pnl.closedPositionPnl || 0),
         dayPnl: parseFloat(pnl.dayPnl || 0),
-        // R Trader additional metrics
-        availableBuyingPower: parseFloat(pnl.availableBuyingPower || 0),
-        marginBalance: parseFloat(pnl.marginBalance || 0),
-        cashOnHand: parseFloat(pnl.cashOnHand || 0),
-        // Net Liquidation = Account Balance + Open P&L (same as R Trader)
-        netLiquidation: parseFloat(pnl.accountBalance || 0) + parseFloat(pnl.openPositionPnl || 0),
       };
       debug('Storing PNL for account:', pnl.accountId, pnlData);
       service.accountPnL.set(pnl.accountId, pnlData);
-      service.emit('pnlUpdate', { accountId: pnl.accountId, ...pnlData });
+      service.emit('pnlUpdate', pnl);
     } else {
       debug('No accountId in PNL response');
     }
@@ -220,8 +180,6 @@ const handleAccountPnLUpdate = (service, data) => {
 
 /**
  * Handle instrument PnL update (positions)
- * INSTRUMENT_PNL_UPDATE (450) - Real-time position and P&L per instrument
- * This is the PRIMARY source for unrealized P&L (same as R Trader Positions panel)
  */
 const handleInstrumentPnLUpdate = (service, data) => {
   try {
@@ -230,163 +188,30 @@ const handleInstrumentPnLUpdate = (service, data) => {
       const key = `${pos.accountId}:${pos.symbol}:${pos.exchange}`;
       const netQty = pos.netQuantity || pos.openPositionQuantity || ((pos.buyQty || 0) - (pos.sellQty || 0));
       
-      // Build position data - ALWAYS emit, even when FLAT (netQty === 0)
-      // This ensures Open P&L resets to 0 when position closes (like R Trader)
-      // 
-      // OPEN PNL PRIORITY (real-time unrealized P&L):
-      // 1. dayOpenPnl (double) - most reliable from INSTRUMENT_PNL_UPDATE
-      // 2. openPositionPnl (string) - fallback
-      // 3. Calculate from price if available
-      const rawOpenPnl = pos.dayOpenPnl ?? pos.openPositionPnl;
-      const rawClosedPnl = pos.dayClosedPnl ?? pos.closedPositionPnl;
-      
-      const positionData = {
-        accountId: pos.accountId,
-        symbol: pos.symbol,
-        exchange: pos.exchange || 'CME',
-        quantity: netQty,
-        averagePrice: netQty !== 0 ? (pos.avgOpenFillPrice || 0) : 0,
-        // Open P&L - parse as float, handle both double and string formats
-        openPnl: typeof rawOpenPnl === 'number' ? rawOpenPnl : parseFloat(rawOpenPnl || 0),
-        closedPnl: typeof rawClosedPnl === 'number' ? rawClosedPnl : parseFloat(rawClosedPnl || 0),
-        dayPnl: typeof pos.dayPnl === 'number' ? pos.dayPnl : parseFloat(pos.dayPnl || 0),
-        isSnapshot: pos.isSnapshot || false,
-      };
-      
       if (netQty !== 0) {
-        service.positions.set(key, positionData);
+        service.positions.set(key, {
+          accountId: pos.accountId,
+          symbol: pos.symbol,
+          exchange: pos.exchange || 'CME',
+          quantity: netQty,
+          averagePrice: pos.avgOpenFillPrice || 0,
+          openPnl: parseFloat(pos.openPositionPnl || pos.dayOpenPnl || 0),
+          closedPnl: parseFloat(pos.closedPositionPnl || pos.dayClosedPnl || 0),
+          dayPnl: parseFloat(pos.dayPnl || 0),
+          isSnapshot: pos.isSnapshot || false,
+        });
       } else {
         service.positions.delete(key);
       }
       
-      // ALWAYS emit positionUpdate - even when FLAT
-      // This ensures UI updates Open P&L to 0 when position closes
-      service.emit('positionUpdate', positionData);
+      service.emit('positionUpdate', service.positions.get(key));
     }
   } catch (e) {
-    debug('Error decoding Instrument PNL:', e.message);
-  }
-};
-
-/**
- * Handle new order response (313) - confirms order accepted
- */
-const handleNewOrderResponse = (service, data) => {
-  try {
-    const res = proto.decode('ResponseNewOrder', data);
-    const orderTag = res.userMsg?.[0] || null;
-    const timestamp = performance.now();
-    
-    debug('New order response:', {
-      orderTag,
-      rpCode: res.rpCode,
-      basketId: res.basketId,
-      ssboe: res.ssboe,
-      usecs: res.usecs,
-    });
-
-    // Emit for position manager tracking
-    service.emit('orderAccepted', {
-      orderTag,
-      basketId: res.basketId,
-      rpCode: res.rpCode,
-      timestamp,
-    });
-  } catch (e) {
-    debug('Error decoding new order response:', e.message);
-  }
-};
-
-// FillInfoPool imported from ./latency-tracker
-
-/**
- * Handle order notification (351) - CRITICAL for fill tracking
- * This is the primary notification for order status changes including FILLS
- * 
- * ULTRA-OPTIMIZED:
- * - Pre-allocated fill info object (zero allocation in hot path)
- * - Fast path for fill detection
- * - High-resolution latency tracking
- */
-const handleOrderNotification = (service, data) => {
-  const receiveTime = Date.now();
-  
-  try {
-    const notif = proto.decode('RithmicOrderNotification', data);
-    // userTag contains our order tag (userMsg is not in this proto)
-    const orderTag = notif.userTag || null;
-    
-    // FAST PATH: Check for fill immediately
-    // Proto uses total_fill_size (camelCase: totalFillSize), not fillQuantity
-    const fillQty = notif.totalFillSize || notif.totalFillQuantity || notif.fillQuantity || 0;
-    const isFill = fillQty > 0 || notif.status === 'complete';
-    
-    // Calculate round-trip latency if this is a fill we're tracking
-    let roundTripLatency = null;
-    if (isFill && orderTag) {
-      roundTripLatency = LatencyTracker.recordFill(orderTag);
-    }
-    
-    debug('Order notification:', {
-      orderTag,
-      status: notif.status,
-      filledQty: fillQty,
-      avgFillPrice: notif.avgFillPrice,
-      roundTripLatency,
-    });
-
-    // OPTIMIZED: Use pre-allocated object
-    const fillInfo = FillInfoPool.fill(notif, receiveTime, roundTripLatency);
-
-    // Emit raw notification
-    service.emit('orderNotification', fillInfo);
-
-    // Emit fill event if this is a fill (status=complete means order is fully filled)
-    if (isFill) {
-      const actualFillQty = fillInfo.totalFillQuantity || fillInfo.fillQuantity || notif.quantity || 0;
-      const fillPrice = fillInfo.avgFillPrice || fillInfo.lastFillPrice || 0;
-      
-      // Debug only - UI handles display via orderFilled event
-      debug('FILL Received:', orderTag, fillInfo.transactionType === 1 ? 'BUY' : 'SELL', actualFillQty, '@', fillPrice, 'latency:', roundTripLatency, 'ms');
-      
-      // Clone for fill event (async handlers may need to keep the data)
-      service.emit('orderFilled', FillInfoPool.clone(fillInfo));
-    } else {
-      // Debug only - UI handles display via orderNotification event
-      debug('ORDER STATUS:', orderTag, 'status:', fillInfo.status, 'text:', fillInfo.text || 'N/A');
-    }
-  } catch (e) {
-    debug('Error decoding order notification:', e.message);
-  }
-};
-
-/**
- * Handle exchange notification (352) - exchange-level order updates
- */
-const handleExchangeNotification = (service, data) => {
-  try {
-    const notif = proto.decode('ExchangeOrderNotification', data);
-    const timestamp = performance.now();
-    
-    debug('Exchange notification:', {
-      orderTag: notif.userMsg?.[0],
-      text: notif.text,
-      reportType: notif.reportType,
-    });
-
-    service.emit('exchangeNotification', {
-      orderTag: notif.userMsg?.[0] || null,
-      text: notif.text,
-      reportType: notif.reportType,
-      timestamp,
-    });
-  } catch (e) {
-    debug('Error decoding exchange notification:', e.message);
+    // Ignore decode errors
   }
 };
 
 module.exports = {
   createOrderHandler,
-  createPnLHandler,
-  LatencyTracker,
+  createPnLHandler
 };