hedgequantx 2.6.162 → 2.6.163

package/src/services/rithmic/market-data.js

@@ -13,6 +13,7 @@
 
 const EventEmitter = require('events');
 const { logger } = require('../../utils/logger');
+const { decodeLastTrade, decodeBestBidOffer } = require('./market-data-decoders');
 
 const log = logger.scope('RithmicMD');
 
@@ -25,284 +26,6 @@ const TEMPLATE_IDS = {
   BEST_BID_OFFER: 151,
 };
 
-// Rithmic field IDs for LastTrade (from protobuf)
-const LAST_TRADE_FIELDS = {
-  TEMPLATE_ID: 154467,
-  SYMBOL: 110100,
-  EXCHANGE: 110101,
-  TRADE_PRICE: 100006,
-  TRADE_SIZE: 100178,
-  AGGRESSOR: 112003,  // 1=BUY, 2=SELL
-  SSBOE: 150100,
-  USECS: 150101,
-};
-
-// Rithmic field IDs for BestBidOffer (from protobuf)
-const BBO_FIELDS = {
-  TEMPLATE_ID: 154467,
-  SYMBOL: 110100,
-  EXCHANGE: 110101,
-  BID_PRICE: 100022,
-  BID_SIZE: 100030,
-  ASK_PRICE: 100025,
-  ASK_SIZE: 100031,
-  SSBOE: 150100,
-  USECS: 150101,
-};
-
-/**
- * Read a varint from buffer starting at offset
- * Uses BigInt internally to handle large field IDs correctly
- * @param {Buffer} buffer 
- * @param {number} offset 
- * @returns {[number, number]} [value, newOffset]
- */
-function readVarint(buffer, offset) {
-  let result = BigInt(0);
-  let shift = BigInt(0);
-  let pos = offset;
-
-  while (pos < buffer.length) {
-    const byte = buffer[pos++];
-    result |= BigInt(byte & 0x7f) << shift;
-    if ((byte & 0x80) === 0) {
-      return [Number(result), pos];
-    }
-    shift += BigInt(7);
-    if (shift > BigInt(63)) {
-      throw new Error('Varint too large');
-    }
-  }
-
-  throw new Error('Incomplete varint');
-}
-
-/**
- * Read a length-delimited field (string/bytes)
- * @param {Buffer} buffer 
- * @param {number} offset 
- * @returns {[string, number]} [value, newOffset]
- */
-function readLengthDelimited(buffer, offset) {
-  const [length, newOffset] = readVarint(buffer, offset);
-  const value = buffer.slice(newOffset, newOffset + length).toString('utf8');
-  return [value, newOffset + length];
-}
-
-/**
- * Skip a field based on wire type
- * @param {Buffer} buffer 
- * @param {number} offset 
- * @param {number} wireType 
- * @returns {number} newOffset
- */
-function skipField(buffer, offset, wireType) {
-  switch (wireType) {
-    case 0: // Varint
-      const [, newOffset] = readVarint(buffer, offset);
-      return newOffset;
-    case 1: // 64-bit
-      return offset + 8;
-    case 2: // Length-delimited
-      const [length, lenOffset] = readVarint(buffer, offset);
-      return lenOffset + length;
-    case 5: // 32-bit
-      return offset + 4;
-    default:
-      throw new Error(`Unknown wire type: ${wireType}`);
-  }
-}
-
-/**
- * Manually decode LastTrade message from Rithmic
- * Required because protobufjs can't handle field IDs > 100000
- * @param {Buffer} buffer 
- * @returns {Object}
- */
-function decodeLastTrade(buffer) {
-  const result = {};
-  let offset = 0;
-
-  while (offset < buffer.length) {
-    try {
-      const [tag, newOffset] = readVarint(buffer, offset);
-      const fieldNumber = tag >>> 3;
-      const wireType = tag & 0x7;
-      offset = newOffset;
-
-      switch (fieldNumber) {
-        case LAST_TRADE_FIELDS.SYMBOL:
-          if (wireType === 2) {
-            const [val, next] = readLengthDelimited(buffer, offset);
-            result.symbol = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case LAST_TRADE_FIELDS.EXCHANGE:
-          if (wireType === 2) {
-            const [val, next] = readLengthDelimited(buffer, offset);
-            result.exchange = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case LAST_TRADE_FIELDS.TRADE_PRICE:
-          if (wireType === 1) {
-            result.tradePrice = buffer.readDoubleLE(offset);
-            offset += 8;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case LAST_TRADE_FIELDS.TRADE_SIZE:
-          if (wireType === 0) {
-            const [val, next] = readVarint(buffer, offset);
-            result.tradeSize = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case LAST_TRADE_FIELDS.AGGRESSOR:
-          if (wireType === 0) {
-            const [val, next] = readVarint(buffer, offset);
-            result.aggressor = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case LAST_TRADE_FIELDS.SSBOE:
-          if (wireType === 0) {
-            const [val, next] = readVarint(buffer, offset);
-            result.ssboe = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case LAST_TRADE_FIELDS.USECS:
-          if (wireType === 0) {
-            const [val, next] = readVarint(buffer, offset);
-            result.usecs = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        default:
-          offset = skipField(buffer, offset, wireType);
-      }
-    } catch {
-      break;
-    }
-  }
-
-  return result;
-}
-
-/**
- * Manually decode BestBidOffer message from Rithmic
- * Required because protobufjs can't handle field IDs > 100000
- * @param {Buffer} buffer 
- * @returns {Object}
- */
-function decodeBestBidOffer(buffer) {
-  const result = {};
-  let offset = 0;
-
-  while (offset < buffer.length) {
-    try {
-      const [tag, newOffset] = readVarint(buffer, offset);
-      const fieldNumber = tag >>> 3;
-      const wireType = tag & 0x7;
-      offset = newOffset;
-
-      switch (fieldNumber) {
-        case BBO_FIELDS.SYMBOL:
-          if (wireType === 2) {
-            const [val, next] = readLengthDelimited(buffer, offset);
-            result.symbol = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case BBO_FIELDS.EXCHANGE:
-          if (wireType === 2) {
-            const [val, next] = readLengthDelimited(buffer, offset);
-            result.exchange = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case BBO_FIELDS.BID_PRICE:
-          if (wireType === 1) {
-            result.bidPrice = buffer.readDoubleLE(offset);
-            offset += 8;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case BBO_FIELDS.BID_SIZE:
-          if (wireType === 0) {
-            const [val, next] = readVarint(buffer, offset);
-            result.bidSize = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case BBO_FIELDS.ASK_PRICE:
-          if (wireType === 1) {
-            result.askPrice = buffer.readDoubleLE(offset);
-            offset += 8;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case BBO_FIELDS.ASK_SIZE:
-          if (wireType === 0) {
-            const [val, next] = readVarint(buffer, offset);
-            result.askSize = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case BBO_FIELDS.SSBOE:
-          if (wireType === 0) {
-            const [val, next] = readVarint(buffer, offset);
-            result.ssboe = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case BBO_FIELDS.USECS:
-          if (wireType === 0) {
-            const [val, next] = readVarint(buffer, offset);
-            result.usecs = val;
-            offset = next;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        default:
-          offset = skipField(buffer, offset, wireType);
-      }
-    } catch {
-      break;
-    }
-  }
-
-  return result;
-}
-
 /**
  * Rithmic Market Data Feed
  * Provides real-time market data via Rithmic WebSocket connection

package/src/services/rithmic/orders-fast.js

@@ -0,0 +1,246 @@
+/**
+ * Rithmic Fast Orders Module
+ * @module services/rithmic/orders-fast
+ * 
+ * Ultra-low latency order entry/exit for scalping
+ * Target: < 5ms local processing (network latency separate)
+ * 
+ * OPTIMIZATIONS:
+ * - Pre-allocated order template objects
+ * - Fast orderTag generation (no Date.now in hot path)
+ * - Direct proto encoding with cached types
+ * - Minimal object creation
+ */
+
+const { REQ } = require('./constants');
+const { proto } = require('./protobuf');
+const { LatencyTracker } = require('./latency-tracker');
+const { performance } = require('perf_hooks');
+
+// Debug mode - use no-op function when disabled for zero overhead
+const DEBUG = process.env.HQX_DEBUG === '1';
+const debug = DEBUG ? (...args) => console.log('[Rithmic:Orders]', ...args) : () => {};
+
+// ==================== FAST ORDER TAG ====================
+// Pre-generate prefix once at module load (not per-order)
+const ORDER_TAG_PREFIX = `HQX${process.pid}-`;
+let orderIdCounter = 0;
+
+/**
+ * Ultra-fast order tag generation
+ * Avoids Date.now() and string interpolation in hot path
+ * @returns {string}
+ */
+const generateOrderTag = () => ORDER_TAG_PREFIX + (++orderIdCounter);
+
+// ==================== PRE-ALLOCATED ORDER TEMPLATES ====================
+
+/**
+ * Order object pool for zero-allocation hot path
+ */
+const OrderPool = {
+  // Pre-allocated order template
+  _template: {
+    templateId: REQ.NEW_ORDER,
+    userMsg: [''],
+    userTag: '',
+    fcmId: '',
+    ibId: '',
+    accountId: '',
+    symbol: '',
+    exchange: 'CME',
+    quantity: 0,
+    transactionType: 1,
+    duration: 1,
+    priceType: 2,       // priceType 2 = MARKET order
+    manualOrAuto: 2,
+    tradeRoute: '',
+  },
+  
+  /**
+   * Get order object with values filled in
+   * @param {string} orderTag
+   * @param {Object} loginInfo - { fcmId, ibId }
+   * @param {Object} orderData - { accountId, symbol, exchange, size, side, tradeRoute }
+   */
+  fill(orderTag, loginInfo, orderData) {
+    const o = this._template;
+    o.userMsg[0] = orderTag;
+    o.userTag = orderTag;
+    o.fcmId = loginInfo.fcmId;
+    o.ibId = loginInfo.ibId;
+    o.accountId = orderData.accountId;
+    o.symbol = orderData.symbol;
+    o.exchange = orderData.exchange || 'CME';
+    o.quantity = orderData.size;
+    o.transactionType = orderData.side === 0 ? 1 : 2;
+    o.tradeRoute = orderData.tradeRoute || '';
+    return o;
+  }
+};
+
+/**
+ * Get effective login info for account
+ * @param {RithmicService} service
+ * @param {string} accountId
+ * @returns {{ fcmId: string, ibId: string }}
+ */
+function getEffectiveLoginInfo(service, accountId) {
+  const account = service.accounts?.find(a => 
+    a.accountId === accountId || a.rithmicAccountId === accountId
+  );
+  return {
+    fcmId: account?.fcmId || service.loginInfo.fcmId,
+    ibId: account?.ibId || service.loginInfo.ibId,
+  };
+}
+
+/**
+ * Send order buffer via optimized path
+ * @param {Object} conn - Order connection
+ * @param {Buffer} buffer
+ */
+function sendOrderBuffer(conn, buffer) {
+  const sent = conn.ultraSend 
+    ? conn.ultraSend(buffer)
+    : (conn.fastSend(buffer), true);
+  
+  if (!sent) {
+    conn.fastSend(buffer);
+  }
+}
+
+/**
+ * Ultra-fast market order entry - HOT PATH
+ * NO SL/TP, NO await confirmation, fire-and-forget
+ * 
+ * @param {RithmicService} service
+ * @param {Object} orderData - { accountId, symbol, exchange, size, side }
+ * @returns {{ success: boolean, orderTag: string, entryTime: number, latencyMs: number }}
+ */
+const fastEntry = (service, orderData) => {
+  const startTime = performance.now();
+  const orderTag = generateOrderTag();
+  const entryTime = Date.now();
+  
+  if (!service.orderConn?.isConnected || !service.loginInfo) {
+    return { 
+      success: false, 
+      error: 'Not connected',
+      orderTag,
+      entryTime,
+      latencyMs: performance.now() - startTime,
+    };
+  }
+
+  try {
+    const effectiveLoginInfo = getEffectiveLoginInfo(service, orderData.accountId);
+    
+    const exchange = orderData.exchange || 'CME';
+    const tradeRoute = service.getTradeRoute?.(exchange);
+    if (!tradeRoute) {
+      return {
+        success: false,
+        error: `No trade route for exchange ${exchange}`,
+        orderTag,
+        entryTime,
+        latencyMs: performance.now() - startTime,
+      };
+    }
+    
+    const orderWithRoute = { ...orderData, tradeRoute };
+    const order = OrderPool.fill(orderTag, effectiveLoginInfo, orderWithRoute);
+    
+    debug('ORDER Sending:', orderTag, orderData.side === 0 ? 'BUY' : 'SELL', orderData.size, 'x', orderData.symbol);
+    
+    const buffer = proto.fastEncode('RequestNewOrder', order);
+    sendOrderBuffer(service.orderConn, buffer);
+    
+    debug('ORDER Sent to Rithmic:', orderTag, 'buffer:', buffer.length, 'bytes');
+    
+    LatencyTracker.recordEntry(orderTag, entryTime);
+
+    return { 
+      success: true, 
+      orderTag,
+      entryTime,
+      latencyMs: performance.now() - startTime,
+    };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error.message,
+      orderTag,
+      entryTime,
+      latencyMs: performance.now() - startTime,
+    };
+  }
+};
+
+/**
+ * Ultra-fast market exit - for position closing
+ * 
+ * @param {RithmicService} service
+ * @param {Object} orderData - { accountId, symbol, exchange, size, side }
+ * @returns {{ success: boolean, orderTag: string, exitTime: number, latencyMs: number }}
+ */
+const fastExit = (service, orderData) => {
+  const startTime = performance.now();
+  const orderTag = generateOrderTag();
+  const exitTime = Date.now();
+  
+  if (!service.orderConn?.isConnected || !service.loginInfo) {
+    return { 
+      success: false, 
+      error: 'Not connected',
+      orderTag,
+      exitTime,
+      latencyMs: performance.now() - startTime,
+    };
+  }
+
+  try {
+    const effectiveLoginInfo = getEffectiveLoginInfo(service, orderData.accountId);
+    
+    const exchange = orderData.exchange || 'CME';
+    const tradeRoute = service.getTradeRoute?.(exchange);
+    if (!tradeRoute) {
+      return {
+        success: false,
+        error: `No trade route for exchange ${exchange}`,
+        orderTag,
+        exitTime,
+        latencyMs: performance.now() - startTime,
+      };
+    }
+    
+    const orderWithRoute = { ...orderData, tradeRoute };
+    const order = OrderPool.fill(orderTag, effectiveLoginInfo, orderWithRoute);
+    
+    const buffer = proto.fastEncode('RequestNewOrder', order);
+    sendOrderBuffer(service.orderConn, buffer);
+    
+    return { 
+      success: true, 
+      orderTag,
+      exitTime,
+      latencyMs: performance.now() - startTime,
+    };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error.message,
+      orderTag,
+      exitTime,
+      latencyMs: performance.now() - startTime,
+    };
+  }
+};
+
+module.exports = {
+  generateOrderTag,
+  OrderPool,
+  getEffectiveLoginInfo,
+  fastEntry,
+  fastExit,
+};