hedgequantx 2.6.163 → 2.7.0

package/src/services/rithmic/contracts.js

@@ -1,79 +1,92 @@
 /**
- * Rithmic Contracts Module
+ * @fileoverview Rithmic contract methods
  * @module services/rithmic/contracts
  * 
- * Contract lookup and front month discovery
+ * NO FAKE DATA - Only real values from Rithmic API
  */
 
 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');
+const log = logger.scope('Rithmic:Contracts');
 
 /**
- * Decode product codes from raw protobuf buffer
- * @param {Buffer} buffer
- * @returns {Object}
+ * Get all available contracts from Rithmic API
+ * @param {RithmicService} service - Service instance
+ * @returns {Promise<{success: boolean, contracts: Array, source?: string, error?: string}>}
  */
-function decodeProductCodes(buffer) {
-  const result = {};
-  let offset = 0;
+const getContracts = async (service) => {
+  // Check cache
+  if (service._contractsCache && Date.now() - service._contractsCacheTime < CACHE.CONTRACTS_TTL) {
+    return { success: true, contracts: service._contractsCache, source: 'cache' };
+  }
 
-  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;
+  if (!service.credentials) {
+    return { success: false, error: 'Not logged in' };
+  }
+
+  try {
+    // Connect to TICKER_PLANT if needed
+    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' };
+      }
     }
-    return [value, off];
-  };
 
-  const readString = (buf, off) => {
-    const [len, newOff] = readVarint(buf, off);
-    return [buf.slice(newOff, newOff + len).toString('utf8'), newOff + len];
-  };
+    service.tickerConn.setMaxListeners(5000);
 
-  while (offset < buffer.length) {
-    try {
-      const [tag, tagOff] = readVarint(buffer, offset);
-      const wireType = tag & 0x7;
-      const fieldNumber = tag >>> 3;
-      offset = tagOff;
+    log.debug('Fetching contracts from Rithmic API');
+    const contracts = await fetchAllFrontMonths(service);
 
-      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; }
+    if (!contracts.length) {
+      return { success: false, error: 'No tradeable contracts found' };
+    }
+
+    // Cache results
+    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 };
   }
+};
 
-  return result;
-}
+/**
+ * Search contracts
+ * @param {RithmicService} service - Service instance
+ * @param {string} searchText - Search text
+ * @returns {Promise<Array>}
+ */
+const searchContracts = async (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)
+  );
+};
 
 /**
- * Fetch all front month contracts from TICKER_PLANT
- * @param {RithmicService} service
+ * Fetch all front month contracts from API
+ * @param {RithmicService} service - Service instance
  * @returns {Promise<Array>}
  */
-async function fetchAllFrontMonths(service) {
-  if (!service.tickerConn) throw new Error('TICKER_PLANT not connected');
+const fetchAllFrontMonths = (service) => {
+  if (!service.tickerConn) {
+    throw new Error('TICKER_PLANT not connected');
+  }
 
   return new Promise((resolve) => {
     const contracts = new Map();
     const productsToCheck = new Map();
 
+    // Handler for ProductCodes responses
     const productHandler = (msg) => {
       if (msg.templateId !== 112) return;
       
@@ -96,6 +109,7 @@ async function fetchAllFrontMonths(service) {
       }
     };
 
+    // Handler for FrontMonth responses
     const frontMonthHandler = (msg) => {
       if (msg.templateId !== 114) return;
       
@@ -112,11 +126,13 @@ async function fetchAllFrontMonths(service) {
     service.tickerConn.on('message', productHandler);
     service.tickerConn.on('message', frontMonthHandler);
 
+    // Request all product codes
     service.tickerConn.send('RequestProductCodes', {
       templateId: 111,
       userMsg: ['get-products'],
     });
 
+    // After timeout, request front months
     setTimeout(() => {
       service.tickerConn.removeListener('message', productHandler);
       log.debug('Collected products', { count: productsToCheck.size });
@@ -130,6 +146,7 @@ async function fetchAllFrontMonths(service) {
         });
       }
 
+      // Collect results after timeout
       setTimeout(() => {
         service.tickerConn.removeListener('message', frontMonthHandler);
 
@@ -137,82 +154,82 @@ async function fetchAllFrontMonths(service) {
         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;
-          
+
+          // 100% API data - no static symbol info
           results.push({
             symbol: contract.symbol,
             baseSymbol,
-            name: contract.symbol,
-            description: productName,
+            name: product?.productName || baseSymbol,
             exchange: contract.exchange,
-            tickSize: specs?.tickSize ?? null,
-            tickValue: specs?.tickValue ?? null,
           });
         }
 
+        // Sort alphabetically by base symbol
         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>}
+ * Decode ProductCodes response
+ * @param {Buffer} buffer - Protobuf buffer
+ * @returns {Object} Decoded product data
  */
-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' };
+const decodeProductCodes = (buffer) => {
+  const result = {};
+  let offset = 0;
 
-  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' };
+  const readVarint = (buf, off) => {
+    let value = 0;
+    let shift = 0;
+    while (off < buf.length) {
+      const byte = buf[off++];
+      value |= (byte & 0x7F) << shift;
+      if (!(byte & 0x80)) break;
+      shift += 7;
     }
+    return [value, off];
+  };
 
-    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' };
+  const readString = (buf, off) => {
+    const [len, newOff] = readVarint(buf, off);
+    return [buf.slice(newOff, newOff + len).toString('utf8'), newOff + len];
+  };
 
-    service._contractsCache = contracts;
-    service._contractsCacheTime = Date.now();
+  while (offset < buffer.length) {
+    try {
+      const [tag, tagOff] = readVarint(buffer, offset);
+      const wireType = tag & 0x7;
+      const fieldNumber = tag >>> 3;
+      offset = tagOff;
 
-    return { success: true, contracts, source: 'api' };
-  } catch (err) {
-    log.error('getContracts error', { error: err.message });
-    return { success: false, error: err.message };
+      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;
+    }
   }
-}
 
-/**
- * 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)
-  );
-}
+  return result;
+};
 
 module.exports = {
-  decodeProductCodes,
-  fetchAllFrontMonths,
   getContracts,
   searchContracts,
+  fetchAllFrontMonths,
+  decodeProductCodes,
 };

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
 };