hedgequantx 2.9.237 → 2.9.238

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.9.237",
+  "version": "2.9.238",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

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

package/src/services/rithmic/protobuf-decoders.js

@@ -1,6 +1,11 @@
 /**
  * Protobuf Decoders - Decode Rithmic protobuf messages
  * @module services/rithmic/protobuf-decoders
+ * 
+ * HFT-GRADE OPTIMIZATIONS:
+ * - Lookup tables for O(1) field dispatch (replaces O(n) switch)
+ * - Pre-built decoder maps at module load time
+ * - Zero branch misprediction in hot path
  */
 
 const { readVarint, readLengthDelimited, skipField } = require('./protobuf-utils');
@@ -70,241 +75,243 @@ const INSTRUMENT_PNL_FIELDS = {
   USECS: 150101,
 };
 
+// =============================================================================
+// HFT: PRE-BUILT LOOKUP TABLES FOR O(1) FIELD DISPATCH
+// =============================================================================
+
+// Decoder types: 0=skip, 1=varint, 2=string, 3=bool, 4=double
+const DECODE_SKIP = 0;
+const DECODE_VARINT = 1;
+const DECODE_STRING = 2;
+const DECODE_BOOL = 3;
+const DECODE_DOUBLE = 4;
+
 /**
- * Manually decode AccountPnL from raw bytes
- * Skips 4-byte length prefix if present
- * @param {Buffer} buffer - Raw protobuf buffer
- * @returns {Object} Decoded account PnL data
+ * Build lookup table from field definitions
+ * @param {Object} fields - Field ID mapping
+ * @param {Object} fieldTypes - Map of field name to [type, resultKey]
+ * @returns {Map} Lookup table: fieldNumber -> [type, resultKey]
  */
-function decodeAccountPnL(buffer) {
-  // Skip 4-byte length prefix
-  const data = buffer.length > 4 ? buffer.slice(4) : buffer;
-  
-  const result = {};
+function buildLookupTable(fields, fieldTypes) {
+  const table = new Map();
+  for (const [fieldName, fieldNumber] of Object.entries(fields)) {
+    if (fieldTypes[fieldName]) {
+      table.set(fieldNumber, fieldTypes[fieldName]);
+    }
+  }
+  return table;
+}
+
+// PnL field types: [decoderType, resultKey]
+const PNL_FIELD_TYPES = {
+  TEMPLATE_ID: [DECODE_VARINT, 'templateId'],
+  IS_SNAPSHOT: [DECODE_BOOL, 'isSnapshot'],
+  FCM_ID: [DECODE_STRING, 'fcmId'],
+  IB_ID: [DECODE_STRING, 'ibId'],
+  ACCOUNT_ID: [DECODE_STRING, 'accountId'],
+  ACCOUNT_BALANCE: [DECODE_STRING, 'accountBalance'],
+  CASH_ON_HAND: [DECODE_STRING, 'cashOnHand'],
+  MARGIN_BALANCE: [DECODE_STRING, 'marginBalance'],
+  MIN_ACCOUNT_BALANCE: [DECODE_STRING, 'minAccountBalance'],
+  OPEN_POSITION_PNL: [DECODE_STRING, 'openPositionPnl'],
+  CLOSED_POSITION_PNL: [DECODE_STRING, 'closedPositionPnl'],
+  DAY_PNL: [DECODE_STRING, 'dayPnl'],
+  DAY_OPEN_PNL: [DECODE_STRING, 'dayOpenPnl'],
+  DAY_CLOSED_PNL: [DECODE_STRING, 'dayClosedPnl'],
+  AVAILABLE_BUYING_POWER: [DECODE_STRING, 'availableBuyingPower'],
+  SSBOE: [DECODE_VARINT, 'ssboe'],
+  USECS: [DECODE_VARINT, 'usecs'],
+};
+
+// Instrument PnL field types
+const INSTRUMENT_PNL_FIELD_TYPES = {
+  TEMPLATE_ID: [DECODE_VARINT, 'templateId'],
+  IS_SNAPSHOT: [DECODE_BOOL, 'isSnapshot'],
+  FCM_ID: [DECODE_STRING, 'fcmId'],
+  IB_ID: [DECODE_STRING, 'ibId'],
+  ACCOUNT_ID: [DECODE_STRING, 'accountId'],
+  SYMBOL: [DECODE_STRING, 'symbol'],
+  EXCHANGE: [DECODE_STRING, 'exchange'],
+  PRODUCT_CODE: [DECODE_STRING, 'productCode'],
+  BUY_QTY: [DECODE_VARINT, 'buyQty'],
+  SELL_QTY: [DECODE_VARINT, 'sellQty'],
+  FILL_BUY_QTY: [DECODE_VARINT, 'fillBuyQty'],
+  FILL_SELL_QTY: [DECODE_VARINT, 'fillSellQty'],
+  NET_QUANTITY: [DECODE_VARINT, 'netQuantity'],
+  OPEN_POSITION_QUANTITY: [DECODE_VARINT, 'openPositionQuantity'],
+  AVG_OPEN_FILL_PRICE: [DECODE_DOUBLE, 'avgOpenFillPrice'],
+  OPEN_POSITION_PNL: [DECODE_STRING, 'openPositionPnl'],
+  CLOSED_POSITION_PNL: [DECODE_STRING, 'closedPositionPnl'],
+  DAY_PNL: [DECODE_STRING, 'dayPnl'],
+  DAY_OPEN_PNL: [DECODE_STRING, 'dayOpenPnl'],
+  DAY_CLOSED_PNL: [DECODE_STRING, 'dayClosedPnl'],
+  SSBOE: [DECODE_VARINT, 'ssboe'],
+  USECS: [DECODE_VARINT, 'usecs'],
+};
+
+// Symbol/Product codes field types
+const SYMBOL_FIELD_TYPES = {
+  TEMPLATE_ID: [DECODE_VARINT, 'templateId'],
+  RP_CODE: [DECODE_STRING, 'rpCode'],  // Array field - handled specially
+  EXCHANGE: [DECODE_STRING, 'exchange'],
+  PRODUCT_CODE: [DECODE_STRING, 'productCode'],
+  PRODUCT_NAME: [DECODE_STRING, 'productName'],
+  SYMBOL: [DECODE_STRING, 'symbol'],
+  TRADING_SYMBOL: [DECODE_STRING, 'tradingSymbol'],
+  DESCRIPTION: [DECODE_STRING, 'description'],
+  USER_MSG: [DECODE_STRING, 'userMsg'],
+};
+
+// Pre-build lookup tables at module load time (O(1) access in hot path)
+const PNL_LOOKUP = buildLookupTable(PNL_FIELDS, PNL_FIELD_TYPES);
+const INSTRUMENT_PNL_LOOKUP = buildLookupTable(INSTRUMENT_PNL_FIELDS, INSTRUMENT_PNL_FIELD_TYPES);
+const SYMBOL_LOOKUP = buildLookupTable(SYMBOL_FIELDS, SYMBOL_FIELD_TYPES);
+
+// =============================================================================
+// HFT: GENERIC DECODER WITH LOOKUP TABLE - O(1) FIELD DISPATCH
+// =============================================================================
+
+/**
+ * HFT-optimized generic decoder using lookup table
+ * Replaces O(n) switch statements with O(1) Map lookup
+ * @param {Buffer} data - Raw protobuf data (without length prefix)
+ * @param {Map} lookup - Pre-built field lookup table
+ * @param {Object} result - Pre-allocated result object (optional)
+ * @returns {Object} Decoded data
+ */
+function decodeWithLookup(data, lookup, result = {}) {
   let offset = 0;
+  const len = data.length;
 
-  while (offset < data.length) {
-    try {
-      const [tag, tagOffset] = readVarint(data, offset);
-      const wireType = tag & 0x7;
-      const fieldNumber = tag >>> 3;
-      offset = tagOffset;
+  while (offset < len) {
+    // Read tag (varint) - inlined for performance
+    let tag = 0;
+    let shift = 0;
+    let byte;
+    do {
+      byte = data[offset++];
+      tag |= (byte & 0x7f) << shift;
+      shift += 7;
+    } while (byte & 0x80);
 
-      switch (fieldNumber) {
-        case PNL_FIELDS.TEMPLATE_ID:
-          [result.templateId, offset] = readVarint(data, offset);
-          break;
-        case PNL_FIELDS.IS_SNAPSHOT:
-          const [isSnap, snapOffset] = readVarint(data, offset);
-          result.isSnapshot = isSnap !== 0;
-          offset = snapOffset;
-          break;
-        case PNL_FIELDS.FCM_ID:
-          [result.fcmId, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.IB_ID:
-          [result.ibId, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.ACCOUNT_ID:
-          [result.accountId, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.ACCOUNT_BALANCE:
-          [result.accountBalance, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.CASH_ON_HAND:
-          [result.cashOnHand, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.MARGIN_BALANCE:
-          [result.marginBalance, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.MIN_ACCOUNT_BALANCE:
-          [result.minAccountBalance, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.OPEN_POSITION_PNL:
-          [result.openPositionPnl, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.CLOSED_POSITION_PNL:
-          [result.closedPositionPnl, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.DAY_PNL:
-          [result.dayPnl, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.DAY_OPEN_PNL:
-          [result.dayOpenPnl, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.DAY_CLOSED_PNL:
-          [result.dayClosedPnl, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.AVAILABLE_BUYING_POWER:
-          [result.availableBuyingPower, offset] = readLengthDelimited(data, offset);
-          break;
-        case PNL_FIELDS.SSBOE:
-          [result.ssboe, offset] = readVarint(data, offset);
-          break;
-        case PNL_FIELDS.USECS:
-          [result.usecs, offset] = readVarint(data, offset);
-          break;
-        default:
+    const wireType = tag & 0x7;
+    const fieldNumber = tag >>> 3;
+
+    // O(1) lookup instead of O(n) switch
+    const fieldInfo = lookup.get(fieldNumber);
+    
+    if (fieldInfo) {
+      const [decodeType, key] = fieldInfo;
+      
+      // Decode based on type (minimal branching)
+      if (decodeType === DECODE_VARINT) {
+        let value = 0;
+        shift = 0;
+        do {
+          byte = data[offset++];
+          value |= (byte & 0x7f) << shift;
+          shift += 7;
+        } while (byte & 0x80);
+        result[key] = value;
+      } else if (decodeType === DECODE_STRING) {
+        // Read length
+        let strLen = 0;
+        shift = 0;
+        do {
+          byte = data[offset++];
+          strLen |= (byte & 0x7f) << shift;
+          shift += 7;
+        } while (byte & 0x80);
+        result[key] = data.toString('utf8', offset, offset + strLen);
+        offset += strLen;
+      } else if (decodeType === DECODE_BOOL) {
+        let value = 0;
+        shift = 0;
+        do {
+          byte = data[offset++];
+          value |= (byte & 0x7f) << shift;
+          shift += 7;
+        } while (byte & 0x80);
+        result[key] = value !== 0;
+      } else if (decodeType === DECODE_DOUBLE) {
+        if (wireType === 1) {
+          result[key] = data.readDoubleLE(offset);
+          offset += 8;
+        } else {
           offset = skipField(data, offset, wireType);
+        }
       }
-    } catch (error) {
-      break;
+    } else {
+      // Unknown field - skip efficiently
+      offset = skipField(data, offset, wireType);
     }
   }
 
   return result;
 }
 
+/**
+ * Manually decode AccountPnL from raw bytes
+ * HFT: Uses O(1) lookup table instead of O(n) switch
+ * @param {Buffer} buffer - Raw protobuf buffer
+ * @returns {Object} Decoded account PnL data
+ */
+function decodeAccountPnL(buffer) {
+  // Skip 4-byte length prefix
+  const data = buffer.length > 4 ? buffer.subarray(4) : buffer;
+  return decodeWithLookup(data, PNL_LOOKUP);
+}
+
 /**
  * Manually decode InstrumentPnLPositionUpdate from raw bytes
- * Skips 4-byte length prefix if present
+ * HFT: Uses O(1) lookup table instead of O(n) switch
  * @param {Buffer} buffer - Raw protobuf buffer
  * @returns {Object} Decoded instrument PnL data
  */
 function decodeInstrumentPnL(buffer) {
-  // Skip 4-byte length prefix
-  const data = buffer.length > 4 ? buffer.slice(4) : buffer;
-  
-  const result = {};
-  let offset = 0;
-
-  while (offset < data.length) {
-    try {
-      const [tag, tagOffset] = readVarint(data, offset);
-      const wireType = tag & 0x7;
-      const fieldNumber = tag >>> 3;
-      offset = tagOffset;
-
-      switch (fieldNumber) {
-        case INSTRUMENT_PNL_FIELDS.TEMPLATE_ID:
-          [result.templateId, offset] = readVarint(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.IS_SNAPSHOT:
-          const [isSnap, snapOffset] = readVarint(data, offset);
-          result.isSnapshot = isSnap !== 0;
-          offset = snapOffset;
-          break;
-        case INSTRUMENT_PNL_FIELDS.FCM_ID:
-          [result.fcmId, offset] = readLengthDelimited(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.IB_ID:
-          [result.ibId, offset] = readLengthDelimited(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.ACCOUNT_ID:
-          [result.accountId, offset] = readLengthDelimited(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.SYMBOL:
-          [result.symbol, offset] = readLengthDelimited(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.EXCHANGE:
-          [result.exchange, offset] = readLengthDelimited(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.PRODUCT_CODE:
-          [result.productCode, offset] = readLengthDelimited(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.BUY_QTY:
-          [result.buyQty, offset] = readVarint(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.SELL_QTY:
-          [result.sellQty, offset] = readVarint(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.FILL_BUY_QTY:
-          [result.fillBuyQty, offset] = readVarint(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.FILL_SELL_QTY:
-          [result.fillSellQty, offset] = readVarint(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.NET_QUANTITY:
-          [result.netQuantity, offset] = readVarint(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.OPEN_POSITION_QUANTITY:
-          [result.openPositionQuantity, offset] = readVarint(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.AVG_OPEN_FILL_PRICE:
-          // Double is 64-bit fixed
-          if (wireType === 1) {
-            result.avgOpenFillPrice = data.readDoubleLE(offset);
-            offset += 8;
-          } else {
-            offset = skipField(data, offset, wireType);
-          }
-          break;
-        case INSTRUMENT_PNL_FIELDS.OPEN_POSITION_PNL:
-          [result.openPositionPnl, offset] = readLengthDelimited(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.CLOSED_POSITION_PNL:
-          [result.closedPositionPnl, offset] = readLengthDelimited(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.DAY_PNL:
-          [result.dayPnl, offset] = readLengthDelimited(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.DAY_OPEN_PNL:
-          [result.dayOpenPnl, offset] = readLengthDelimited(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.DAY_CLOSED_PNL:
-          [result.dayClosedPnl, offset] = readLengthDelimited(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.SSBOE:
-          [result.ssboe, offset] = readVarint(data, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.USECS:
-          [result.usecs, offset] = readVarint(data, offset);
-          break;
-        default:
-          offset = skipField(data, offset, wireType);
-      }
-    } catch (error) {
-      break;
-    }
-  }
-
-  return result;
+  // Skip 4-byte length prefix - use subarray (no copy) instead of slice
+  const data = buffer.length > 4 ? buffer.subarray(4) : buffer;
+  return decodeWithLookup(data, INSTRUMENT_PNL_LOOKUP);
 }
 
 /**
  * Decode ResponseProductCodes (template 112) - list of available symbols
+ * Note: Not hot-path (initialization only), uses switch for rpCode array handling
  * @param {Buffer} buffer - Raw protobuf buffer (with 4-byte length prefix)
  * @returns {Object} Decoded product codes
  */
 function decodeProductCodes(buffer) {
-  // Skip 4-byte length prefix
-  const data = buffer.length > 4 ? buffer.slice(4) : buffer;
+  // HFT: Use subarray (zero-copy) instead of slice
+  const data = buffer.length > 4 ? buffer.subarray(4) : buffer;
   const result = { rpCode: [] };
   let offset = 0;
+  const len = data.length;
 
-  while (offset < data.length) {
-    try {
-      const [tag, tagOffset] = readVarint(data, offset);
-      const wireType = tag & 0x7;
-      const fieldNumber = tag >>> 3;
-      offset = tagOffset;
+  while (offset < len) {
+    const [tag, tagOffset] = readVarint(data, offset);
+    const wireType = tag & 0x7;
+    const fieldNumber = tag >>> 3;
+    offset = tagOffset;
 
-      switch (fieldNumber) {
-        case SYMBOL_FIELDS.TEMPLATE_ID:
-          [result.templateId, offset] = readVarint(data, offset);
-          break;
-        case SYMBOL_FIELDS.RP_CODE:
-          let rpCode;
-          [rpCode, offset] = readLengthDelimited(data, offset);
-          result.rpCode.push(rpCode);
-          break;
-        case SYMBOL_FIELDS.EXCHANGE:
-          [result.exchange, offset] = readLengthDelimited(data, offset);
-          break;
-        case SYMBOL_FIELDS.PRODUCT_CODE:
-          [result.productCode, offset] = readLengthDelimited(data, offset);
-          break;
-        case SYMBOL_FIELDS.PRODUCT_NAME:
-          [result.productName, offset] = readLengthDelimited(data, offset);
-          break;
-        case SYMBOL_FIELDS.USER_MSG:
-          [result.userMsg, offset] = readLengthDelimited(data, offset);
-          break;
-        default:
-          offset = skipField(data, offset, wireType);
+    // Use lookup for most fields, special case for rpCode array
+    const fieldInfo = SYMBOL_LOOKUP.get(fieldNumber);
+    if (fieldInfo) {
+      const [, key] = fieldInfo;
+      if (key === 'rpCode') {
+        // Array field - push to existing array
+        let rpCode;
+        [rpCode, offset] = readLengthDelimited(data, offset);
+        result.rpCode.push(rpCode);
+      } else {
+        // Regular field
+        let value;
+        [value, offset] = readLengthDelimited(data, offset);
+        result[key] = value;
       }
-    } catch (error) {
-      break;
+    } else if (fieldNumber === SYMBOL_FIELDS.TEMPLATE_ID) {
+      [result.templateId, offset] = readVarint(data, offset);
+    } else {
+      offset = skipField(data, offset, wireType);
     }
   }
 
@@ -313,53 +320,42 @@ function decodeProductCodes(buffer) {
 
 /**
  * Decode ResponseFrontMonthContract (template 114) - current tradeable contract
- * Skips 4-byte length prefix if present
+ * Note: Not hot-path (initialization only), uses switch for rpCode array handling
  * @param {Buffer} buffer - Raw protobuf buffer
  * @returns {Object} Decoded front month contract
  */
 function decodeFrontMonthContract(buffer) {
-  // Skip 4-byte length prefix
-  const data = buffer.length > 4 ? buffer.slice(4) : buffer;
-  
+  // HFT: Use subarray (zero-copy) instead of slice
+  const data = buffer.length > 4 ? buffer.subarray(4) : buffer;
   const result = { rpCode: [] };
   let offset = 0;
+  const len = data.length;
 
-  while (offset < data.length) {
-    try {
-      const [tag, tagOffset] = readVarint(data, offset);
-      const wireType = tag & 0x7;
-      const fieldNumber = tag >>> 3;
-      offset = tagOffset;
+  while (offset < len) {
+    const [tag, tagOffset] = readVarint(data, offset);
+    const wireType = tag & 0x7;
+    const fieldNumber = tag >>> 3;
+    offset = tagOffset;
 
-      switch (fieldNumber) {
-        case SYMBOL_FIELDS.TEMPLATE_ID:
-          [result.templateId, offset] = readVarint(data, offset);
-          break;
-        case SYMBOL_FIELDS.RP_CODE:
-          let rpCode;
-          [rpCode, offset] = readLengthDelimited(data, offset);
-          result.rpCode.push(rpCode);
-          break;
-        case SYMBOL_FIELDS.SYMBOL:
-          [result.symbol, offset] = readLengthDelimited(data, offset);
-          break;
-        case SYMBOL_FIELDS.EXCHANGE:
-          [result.exchange, offset] = readLengthDelimited(data, offset);
-          break;
-        case SYMBOL_FIELDS.TRADING_SYMBOL:
-          [result.tradingSymbol, offset] = readLengthDelimited(data, offset);
-          break;
-        case SYMBOL_FIELDS.DESCRIPTION:
-          [result.description, offset] = readLengthDelimited(data, offset);
-          break;
-        case SYMBOL_FIELDS.USER_MSG:
-          [result.userMsg, offset] = readLengthDelimited(data, offset);
-          break;
-        default:
-          offset = skipField(data, offset, wireType);
+    // Use lookup for most fields, special case for rpCode array
+    const fieldInfo = SYMBOL_LOOKUP.get(fieldNumber);
+    if (fieldInfo) {
+      const [, key] = fieldInfo;
+      if (key === 'rpCode') {
+        // Array field - push to existing array
+        let rpCode;
+        [rpCode, offset] = readLengthDelimited(data, offset);
+        result.rpCode.push(rpCode);
+      } else {
+        // Regular field
+        let value;
+        [value, offset] = readLengthDelimited(data, offset);
+        result[key] = value;
       }
-    } catch (error) {
-      break;
+    } else if (fieldNumber === SYMBOL_FIELDS.TEMPLATE_ID) {
+      [result.templateId, offset] = readVarint(data, offset);
+    } else {
+      offset = skipField(data, offset, wireType);
     }
   }