hedgequantx 2.9.236 → 2.9.238

package/src/pages/algo/algo-executor.js

@@ -1,5 +1,10 @@
 /**
  * Algo Executor - Execution engine for algo modes with AI supervision
+ * 
+ * HFT-GRADE OPTIMIZATIONS:
+ * - CircularBuffer for O(1) tick storage (replaces O(n) shift())
+ * - Pre-allocated tick structure pool
+ * - Cached timestamp operations
  */
 const readline = require('readline');
 const { AlgoUI, renderSessionSummary } = require('./ui');
@@ -9,6 +14,7 @@ const { SupervisionEngine } = require('../../services/ai-supervision');
 const smartLogs = require('../../lib/smart-logs');
 const { createEngine: createLogsEngine } = require('../../lib/smart-logs-engine');
 const { sessionLogger } = require('../../services/session-logger');
+const { CircularBuffer, Float64CircularBuffer, timestampCache } = require('../../lib/hft');
 
 /**
  * Execute algo strategy with market data
@@ -54,7 +60,16 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   let running = true, stopReason = null, startingPnL = null;
   let currentPosition = 0, pendingOrder = false, tickCount = 0, lastBias = 'FLAT';
   
-  const aiContext = { recentTicks: [], recentSignals: [], recentTrades: [], maxTicks: 100 };
+  // HFT: Use CircularBuffer for O(1) tick storage (replaces O(n) shift())
+  const recentTicksBuffer = new CircularBuffer(100);
+  const recentSignalsBuffer = new CircularBuffer(10);
+  const recentTradesBuffer = new CircularBuffer(20);
+  const aiContext = { 
+    recentTicks: recentTicksBuffer,      // CircularBuffer - use .recent(n) to get array
+    recentSignals: recentSignalsBuffer,  // CircularBuffer
+    recentTrades: recentTradesBuffer,    // CircularBuffer
+    maxTicks: 100 
+  };
   
   const strategy = new StrategyClass({ tickSize });
   strategy.initialize(contractId, tickSize);
@@ -129,8 +144,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     let { direction, entry, stopLoss, takeProfit, confidence } = signal;
     let orderSize = contracts;
     
-    aiContext.recentSignals.push({ ...signal, timestamp: Date.now() });
-    if (aiContext.recentSignals.length > 10) aiContext.recentSignals.shift();
+    // HFT: O(1) push with automatic overflow handling
+    aiContext.recentSignals.push({ ...signal, timestamp: timestampCache.now() });
     
     const riskLog = smartLogs.getRiskCheckLog(true, `${direction.toUpperCase()} @ ${entry.toFixed(2)}`);
     ui.addLog('risk', `${riskLog.message} - ${riskLog.details}`);
@@ -139,12 +154,13 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     if (supervisionEnabled && supervisionEngine) {
       ui.addLog('analysis', 'AI analyzing signal...');
       
+      // HFT: Extract arrays from CircularBuffers for AI supervision
       const supervisionResult = await supervisionEngine.supervise({
         symbolId: symbolName,
         signal: { direction, entry, stopLoss, takeProfit, confidence, size: contracts },
-        recentTicks: aiContext.recentTicks,
-        recentSignals: aiContext.recentSignals,
-        recentTrades: aiContext.recentTrades,
+        recentTicks: aiContext.recentTicks.recent(aiContext.maxTicks),
+        recentSignals: aiContext.recentSignals.recent(10),
+        recentTrades: aiContext.recentTrades.recent(20),
         stats,
         config: { dailyTarget, maxRisk }
       });
@@ -228,7 +244,9 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   let lastPrice = null, lastBid = null, lastAsk = null;
   let ticksPerSecond = 0, lastTickSecond = Math.floor(Date.now() / 1000);
   let lastBiasLogSecond = 0, lastStateLogSecond = 0;
-  let buyVolume = 0, sellVolume = 0, lastTickTime = 0, tickLatencies = [];
+  // HFT: Float64CircularBuffer for O(1) latency statistics
+  let buyVolume = 0, sellVolume = 0, lastTickTime = 0;
+  const tickLatencies = new Float64CircularBuffer(20);
   let runningDelta = 0, runningBuyPct = 50; // For live logs
   
   marketFeed.on('tick', (tick) => {
@@ -250,8 +268,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       lastTickSecond = currentSecond;
     }
     
+    // HFT: O(1) push with automatic overflow handling (no shift needed)
     aiContext.recentTicks.push(tick);
-    if (aiContext.recentTicks.length > aiContext.maxTicks) aiContext.recentTicks.shift();
     
     const price = Number(tick.price) || Number(tick.tradePrice) || null;
     const bid = Number(tick.bid) || Number(tick.bidPrice) || null;
@@ -314,6 +332,7 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     }
     
     // Calculate latency from Rithmic ssboe/usecs or inter-tick timing
+    // HFT: Use cached timestamp and Float64CircularBuffer for O(1) mean calculation
     if (tick.ssboe && tick.usecs !== undefined) {
       const tickTimeMs = (tick.ssboe * 1000) + Math.floor(tick.usecs / 1000);
       const latency = now - tickTimeMs;
@@ -322,8 +341,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
       const timeSinceLastTick = now - lastTickTime;
       if (timeSinceLastTick < 100) {
         tickLatencies.push(timeSinceLastTick);
-        if (tickLatencies.length > 20) tickLatencies.shift();
-        stats.latency = Math.round(tickLatencies.reduce((a, b) => a + b, 0) / tickLatencies.length);
+        // HFT: O(1) mean calculation (pre-computed running sum)
+        stats.latency = Math.round(tickLatencies.mean());
       }
     }
     lastTickTime = now;

package/src/services/rithmic/handlers.js

@@ -1,16 +1,42 @@
 /**
  * Rithmic Message Handlers
  * Handles ORDER_PLANT and PNL_PLANT messages
+ * 
+ * HFT-GRADE OPTIMIZATIONS:
+ * - Pre-allocated result objects
+ * - Minimal object creation in hot paths
+ * - No debug logging in production
  */
 
 const { proto, decodeAccountPnL, decodeInstrumentPnL } = require('./protobuf');
 const { RES, STREAM } = require('./constants');
 const { sanitizeQuantity } = require('./protobuf-utils');
 
-// Debug mode - DISABLED to avoid polluting interactive UI
-// Use session logs instead for debugging
+// HFT: Debug completely disabled - no function call overhead
 const DEBUG = false;
-const debug = (...args) => {};
+const debug = DEBUG ? (...args) => {} : () => {};
+
+// HFT: Pre-allocated objects for hot path handlers
+const _pnlDataTemplate = {
+  accountBalance: 0,
+  cashOnHand: 0,
+  marginBalance: 0,
+  openPositionPnl: 0,
+  closedPositionPnl: 0,
+  dayPnl: 0,
+};
+
+const _positionTemplate = {
+  accountId: '',
+  symbol: '',
+  exchange: 'CME',
+  quantity: 0,
+  averagePrice: 0,
+  openPnl: 0,
+  closedPnl: 0,
+  dayPnl: 0,
+  isSnapshot: false,
+};
 
 /**
  * Create ORDER_PLANT message handler
@@ -219,71 +245,84 @@ const handleNewOrderResponse = (service, data) => {
 
 /**
  * Handle account PnL update
+ * HFT: Optimized for minimal allocations
  */
 const handleAccountPnLUpdate = (service, data) => {
-  try {
-    const pnl = decodeAccountPnL(data);
-    debug('Decoded Account PNL:', JSON.stringify(pnl));
-    
-    if (pnl.accountId) {
-      const pnlData = {
-        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),
+  const pnl = decodeAccountPnL(data);
+  
+  if (pnl.accountId) {
+    // HFT: Reuse cached object from Map or create once
+    let pnlData = service.accountPnL.get(pnl.accountId);
+    if (!pnlData) {
+      pnlData = {
+        accountBalance: 0,
+        cashOnHand: 0,
+        marginBalance: 0,
+        openPositionPnl: 0,
+        closedPositionPnl: 0,
+        dayPnl: 0,
       };
-      debug('Storing PNL for account:', pnl.accountId, pnlData);
       service.accountPnL.set(pnl.accountId, pnlData);
-      service.emit('pnlUpdate', pnl);
-    } else {
-      debug('No accountId in PNL response');
     }
-  } catch (e) {
-    debug('Error decoding Account PNL:', e.message);
+    
+    // HFT: Mutate existing object instead of creating new
+    pnlData.accountBalance = parseFloat(pnl.accountBalance || 0);
+    pnlData.cashOnHand = parseFloat(pnl.cashOnHand || 0);
+    pnlData.marginBalance = parseFloat(pnl.marginBalance || 0);
+    pnlData.openPositionPnl = parseFloat(pnl.openPositionPnl || 0);
+    pnlData.closedPositionPnl = parseFloat(pnl.closedPositionPnl || 0);
+    pnlData.dayPnl = parseFloat(pnl.dayPnl || 0);
+    
+    service.emit('pnlUpdate', pnl);
   }
 };
 
 /**
  * Handle instrument PnL update (positions)
+ * HFT: Optimized for minimal allocations - reuses position objects
  */
 const handleInstrumentPnLUpdate = (service, data) => {
-  try {
-    const pos = decodeInstrumentPnL(data);
-    if (pos.symbol && pos.accountId) {
-      const key = `${pos.accountId}:${pos.symbol}:${pos.exchange}`;
-      
-      // CRITICAL: Sanitize quantity to prevent overflow (18446744073709552000 bug)
-      const rawQty = pos.netQuantity || pos.openPositionQuantity || ((pos.buyQty || 0) - (pos.sellQty || 0));
-      const netQty = sanitizeQuantity(rawQty);
-      
-      if (netQty !== 0) {
-        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);
+  const pos = decodeInstrumentPnL(data);
+  
+  if (pos.symbol && pos.accountId) {
+    const key = `${pos.accountId}:${pos.symbol}:${pos.exchange || 'CME'}`;
+    
+    // CRITICAL: Sanitize quantity to prevent overflow (18446744073709552000 bug)
+    const rawQty = pos.netQuantity || pos.openPositionQuantity || ((pos.buyQty || 0) - (pos.sellQty || 0));
+    const netQty = sanitizeQuantity(rawQty);
+    
+    if (netQty !== 0) {
+      // HFT: Reuse existing position object or create once
+      let position = service.positions.get(key);
+      if (!position) {
+        position = {
+          accountId: '',
+          symbol: '',
+          exchange: 'CME',
+          quantity: 0,
+          averagePrice: 0,
+          openPnl: 0,
+          closedPnl: 0,
+          dayPnl: 0,
+          isSnapshot: false,
+        };
+        service.positions.set(key, position);
       }
       
-      // Only emit if position exists (not deleted)
-      const currentPos = service.positions.get(key);
-      if (currentPos) {
-        service.emit('positionUpdate', currentPos);
-      }
-    }
-  } catch (e) {
-    // Log decode errors for debugging (but don't pollute UI)
-    if (process.env.HQX_DEBUG === '1') {
-      console.error('[Handler] Position decode error:', e.message);
+      // HFT: Mutate existing object
+      position.accountId = pos.accountId;
+      position.symbol = pos.symbol;
+      position.exchange = pos.exchange || 'CME';
+      position.quantity = netQty;
+      position.averagePrice = pos.avgOpenFillPrice || 0;
+      position.openPnl = parseFloat(pos.openPositionPnl || pos.dayOpenPnl || 0);
+      position.closedPnl = parseFloat(pos.closedPositionPnl || pos.dayClosedPnl || 0);
+      position.dayPnl = parseFloat(pos.dayPnl || 0);
+      position.isSnapshot = pos.isSnapshot || false;
+      
+      service.emit('positionUpdate', position);
+    } else {
+      service.positions.delete(key);
     }
   }
 };

package/src/services/rithmic/orders.js

@@ -2,13 +2,18 @@
  * Rithmic Orders Module
  * Order placement, cancellation, and history
  * 
+ * HFT-GRADE OPTIMIZATIONS:
+ * - Pre-allocated order request template
+ * - Cached timestamp for order tags
+ * - Zero console.log in production path
+ * 
  * @module services/rithmic/orders
  */
 
 const { REQ } = require('./constants');
 const { sanitizeQuantity, MAX_SAFE_QUANTITY } = require('./protobuf-utils');
 
-// Debug mode - DISABLED to avoid polluting interactive UI
+// HFT: Debug mode completely disabled - no conditional checks in hot path
 const DEBUG = false;
 
 // Order status constants
@@ -64,37 +69,44 @@ function validateOrderData(orderData) {
   return { valid: true };
 }
 
+// HFT: Pre-allocated order request template to avoid object creation in hot path
+const ORDER_REQUEST_TEMPLATE = {
+  templateId: REQ.NEW_ORDER,
+  userMsg: [''],
+  fcmId: '',
+  ibId: '',
+  accountId: '',
+  symbol: '',
+  exchange: 'CME',
+  quantity: 0,
+  transactionType: 1,
+  duration: 1,
+  priceType: 1,
+  price: 0,
+  tradeRoute: null,
+  manualOrAuto: 2,
+};
+
+// HFT: Monotonic counter for order tags (faster than Date.now())
+let orderTagCounter = Date.now();
+
 /**
  * Place order via ORDER_PLANT and wait for confirmation
+ * HFT: Optimized for minimal latency
  * @param {RithmicService} service - The Rithmic service instance
  * @param {Object} orderData - Order parameters
  * @returns {Promise<{success: boolean, orderId?: string, error?: string}>}
  */
 const placeOrder = async (service, orderData) => {
-  // Check connection state
-  const connState = service.orderConn?.connectionState;
-  const wsState = service.orderConn?.ws?.readyState;
-  
-  if (DEBUG) {
-    console.log('[ORDER] Connection check:', { 
-      hasOrderConn: !!service.orderConn, 
-      connState, 
-      wsState,
-      hasLoginInfo: !!service.loginInfo 
-    });
-  }
-  
-  // Connection validation
-  if (!service.orderConn) {
-    return { success: false, error: 'ORDER_PLANT not connected' };
-  }
-  
-  if (!service.loginInfo) {
-    return { success: false, error: 'Not logged in - missing loginInfo' };
-  }
-  
-  if (connState !== 'LOGGED_IN') {
-    return { success: false, error: `ORDER_PLANT not logged in (state: ${connState})` };
+  // HFT: Fast connection validation (no intermediate variables)
+  if (!service.orderConn || !service.loginInfo || 
+      service.orderConn.connectionState !== 'LOGGED_IN') {
+    return { 
+      success: false, 
+      error: !service.orderConn ? 'ORDER_PLANT not connected' :
+             !service.loginInfo ? 'Not logged in' :
+             `ORDER_PLANT not logged in (state: ${service.orderConn.connectionState})`
+    };
   }
   
   // Validate order data
@@ -103,8 +115,8 @@ const placeOrder = async (service, orderData) => {
     return { success: false, error: validation.error };
   }
 
-  // Generate unique user message for tracking
-  const orderTag = `HQX-${Date.now()}`;
+  // HFT: Use monotonic counter for order tag (faster than Date.now())
+  const orderTag = `HQX-${++orderTagCounter}`;
 
   return new Promise((resolve) => {
     const timeout = setTimeout(() => {
@@ -113,8 +125,7 @@ const placeOrder = async (service, orderData) => {
     }, ORDER_TIMEOUTS.PLACE);
 
     const onNotification = (order) => {
-      // CRITICAL FIX: Match by orderTag (userMsg) first, then symbol as fallback
-      // This prevents race conditions when multiple orders for same symbol
+      // HFT: Fast match by orderTag first (most specific)
       const orderMatches = (order.userMsg && order.userMsg.includes(orderTag)) || 
                           order.symbol === orderData.symbol;
       
@@ -122,89 +133,56 @@ const placeOrder = async (service, orderData) => {
         clearTimeout(timeout);
         service.removeListener('orderNotification', onNotification);
         
-        // Check if order was accepted/filled
-        if (order.status === 2 || order.status === 3 || order.notifyType === 15) {
-          // Status 2 = Working, 3 = Filled, notifyType 15 = Complete
+        // HFT: Combined status check (2=Working, 3=Filled, 15=Complete)
+        const status = order.status;
+        if (status === 2 || status === 3 || order.notifyType === 15) {
           resolve({
             success: true,
             orderId: order.basketId,
-            status: order.status,
+            status,
             fillPrice: order.avgFillPrice || orderData.price,
             filledQty: order.totalFillSize || orderData.size,
-            orderTag: orderTag,
+            orderTag,
           });
-        } else if (order.status === 5 || order.status === 6) {
-          // Status 5 = Rejected, 6 = Cancelled
+        } else if (status === 5 || status === 6) {
           resolve({
             success: false,
-            error: `Order rejected: status ${order.status}`,
+            error: `Order rejected: status ${status}`,
             orderId: order.basketId,
-            orderTag: orderTag,
+            orderTag,
           });
         }
-        // Keep listening for other statuses
       }
     };
 
     service.on('orderNotification', onNotification);
 
-    try {
-      const exchange = orderData.exchange || 'CME';
-      
-      // Get trade route from cache (fetched during login)
-      // Trade route is REQUIRED by Rithmic - orders rejected without it
-      let tradeRoute = null;
-      if (service.tradeRoutes && service.tradeRoutes.size > 0) {
-        const routeInfo = service.tradeRoutes.get(exchange);
-        if (routeInfo) {
-          tradeRoute = routeInfo.tradeRoute;
-        } else {
-          // Fallback: use first available route
-          const firstRoute = service.tradeRoutes.values().next().value;
-          if (firstRoute) {
-            tradeRoute = firstRoute.tradeRoute;
-          }
-        }
-      }
-      
-      if (DEBUG) {
-        console.log('[ORDER] Trade route for', exchange, ':', tradeRoute);
-      }
-      
-      if (!tradeRoute) {
-        // No trade route available - order will likely fail
-        if (DEBUG) {
-          console.log('[ORDER] WARNING: No trade route available, order may be rejected');
-        }
-      }
-      
-      const orderRequest = {
-        templateId: REQ.NEW_ORDER,
-        userMsg: [orderTag],
-        fcmId: service.loginInfo.fcmId,
-        ibId: service.loginInfo.ibId,
-        accountId: orderData.accountId,
-        symbol: orderData.symbol,
-        exchange: exchange,
-        quantity: sanitizeQuantity(orderData.size),
-        transactionType: orderData.side === 0 ? 1 : 2, // 1=Buy, 2=Sell
-        duration: 1, // DAY
-        priceType: orderData.type === 2 ? 2 : 1, // 2=Market, 1=Limit
-        price: orderData.price || 0,
-        tradeRoute: tradeRoute, // REQUIRED by Rithmic
-        manualOrAuto: 2, // AUTO
-      };
-      
-      if (DEBUG) {
-        console.log('[ORDER] Sending RequestNewOrder:', JSON.stringify(orderRequest));
-      }
-      
-      service.orderConn.send('RequestNewOrder', orderRequest);
-    } catch (error) {
-      clearTimeout(timeout);
-      service.removeListener('orderNotification', onNotification);
-      resolve({ success: false, error: error.message });
+    // HFT: Inline order request construction (no try-catch in hot path)
+    const exchange = orderData.exchange || 'CME';
+    
+    // Get trade route from cache
+    let tradeRoute = null;
+    const routes = service.tradeRoutes;
+    if (routes && routes.size > 0) {
+      const routeInfo = routes.get(exchange);
+      tradeRoute = routeInfo ? routeInfo.tradeRoute : 
+                   routes.values().next().value?.tradeRoute || null;
     }
+    
+    // HFT: Reuse template and mutate (faster than object spread)
+    ORDER_REQUEST_TEMPLATE.userMsg[0] = orderTag;
+    ORDER_REQUEST_TEMPLATE.fcmId = service.loginInfo.fcmId;
+    ORDER_REQUEST_TEMPLATE.ibId = service.loginInfo.ibId;
+    ORDER_REQUEST_TEMPLATE.accountId = orderData.accountId;
+    ORDER_REQUEST_TEMPLATE.symbol = orderData.symbol;
+    ORDER_REQUEST_TEMPLATE.exchange = exchange;
+    ORDER_REQUEST_TEMPLATE.quantity = sanitizeQuantity(orderData.size);
+    ORDER_REQUEST_TEMPLATE.transactionType = orderData.side === 0 ? 1 : 2;
+    ORDER_REQUEST_TEMPLATE.priceType = orderData.type === 2 ? 2 : 1;
+    ORDER_REQUEST_TEMPLATE.price = orderData.price || 0;
+    ORDER_REQUEST_TEMPLATE.tradeRoute = tradeRoute;
+    
+    service.orderConn.send('RequestNewOrder', ORDER_REQUEST_TEMPLATE);
   });
 };