hedgequantx 2.6.161 → 2.6.163

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

package/src/services/rithmic/orders.js

@@ -1,264 +1,14 @@
 /**
  * Rithmic Orders Module
  * Order placement, cancellation, and history
- * 
- * FAST SCALPING: fastEntry() and fastExit() for ultra-low latency execution
- * 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('./handlers');
-const { performance } = require('perf_hooks');
 const { logger } = require('../../utils/logger');
+const { fastEntry, fastExit, getEffectiveLoginInfo } = require('./orders-fast');
 
 const log = logger.scope('RithmicOrders');
 
-// 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 ====================
-// Reusable order object to minimize GC pressure
-
-/**
- * Order object pool for zero-allocation hot path
- */
-const OrderPool = {
-  // Pre-allocated order template
-  _template: {
-    templateId: REQ.NEW_ORDER,
-    userMsg: [''],
-    userTag: '',        // Our order tag - returned in RithmicOrderNotification
-    fcmId: '',
-    ibId: '',
-    accountId: '',
-    symbol: '',
-    exchange: 'CME',
-    quantity: 0,
-    transactionType: 1,
-    duration: 1,
-    priceType: 2,       // priceType 2 = MARKET order
-    manualOrAuto: 2,
-    tradeRoute: '',     // Required by Rithmic API - fetched from RequestTradeRoutes
-  },
-  
-  /**
-   * Get order object with values filled in
-   * Reuses same object to avoid allocation
-   * @param {string} orderTag - Unique order tag
-   * @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; // Set userTag for notification tracking
-    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 || ''; // From API via service.getTradeRoute()
-    return o;
-  }
-};
-
-/**
- * Ultra-fast market order entry - HOT PATH
- * NO SL/TP, NO await confirmation, fire-and-forget
- * Target latency: < 5ms local processing
- * 
- * OPTIMIZATIONS:
- * - Reuses pre-allocated order object
- * - Fast orderTag (no Date.now)
- * - Uses fastEncode for cached protobuf type
- * - Minimal branching
- * 
- * @param {RithmicService} service - The Rithmic service instance
- * @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();
-  
-  // Fast connection check
-  if (!service.orderConn?.isConnected || !service.loginInfo) {
-    return { 
-      success: false, 
-      error: 'Not connected',
-      orderTag,
-      entryTime,
-      latencyMs: performance.now() - startTime,
-    };
-  }
-
-  try {
-    // FIXED: Use account-specific fcmId/ibId if available (some prop firms have different IDs per account)
-    const account = service.accounts?.find(a => 
-      a.accountId === orderData.accountId || a.rithmicAccountId === orderData.accountId
-    );
-    const effectiveLoginInfo = {
-      fcmId: account?.fcmId || service.loginInfo.fcmId,
-      ibId: account?.ibId || service.loginInfo.ibId,
-    };
-    
-    // Get trade route from API (required by Rithmic)
-    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,
-      };
-    }
-    
-    // OPTIMIZED: Use pre-allocated order object
-    const orderWithRoute = { ...orderData, tradeRoute };
-    const order = OrderPool.fill(orderTag, effectiveLoginInfo, orderWithRoute);
-    
-    // Debug only - UI handles display via events
-    debug('ORDER Sending:', orderTag, orderData.side === 0 ? 'BUY' : 'SELL', orderData.size, 'x', orderData.symbol, 'acct:', orderData.accountId, 'route:', tradeRoute);
-    
-    // OPTIMIZED: Use fastEncode with cached type
-    const buffer = proto.fastEncode('RequestNewOrder', order);
-    
-    // ULTRA-OPTIMIZED: Try direct socket write first, fallback to fastSend
-    const sent = service.orderConn.ultraSend 
-      ? service.orderConn.ultraSend(buffer)
-      : (service.orderConn.fastSend(buffer), true);
-    
-    if (!sent) {
-      service.orderConn.fastSend(buffer);
-    }
-    
-    debug('ORDER Sent to Rithmic:', orderTag, 'buffer:', buffer.length, 'bytes');
-    
-    // Track for round-trip latency measurement
-    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
- * Fire-and-forget like fastEntry
- * Same optimizations as fastEntry
- * 
- * @param {RithmicService} service - The Rithmic service instance
- * @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 {
-    // FIXED: Use account-specific fcmId/ibId if available
-    const account = service.accounts?.find(a => 
-      a.accountId === orderData.accountId || a.rithmicAccountId === orderData.accountId
-    );
-    const effectiveLoginInfo = {
-      fcmId: account?.fcmId || service.loginInfo.fcmId,
-      ibId: account?.ibId || service.loginInfo.ibId,
-    };
-    
-    // Get trade route from API (required by Rithmic)
-    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,
-      };
-    }
-    
-    // OPTIMIZED: Use pre-allocated order object
-    const orderWithRoute = { ...orderData, tradeRoute };
-    const order = OrderPool.fill(orderTag, effectiveLoginInfo, orderWithRoute);
-    
-    // OPTIMIZED: Use fastEncode with cached type
-    const buffer = proto.fastEncode('RequestNewOrder', order);
-    
-    // ULTRA-OPTIMIZED: Try direct socket write first, fallback to fastSend
-    const sent = service.orderConn.ultraSend 
-      ? service.orderConn.ultraSend(buffer)
-      : (service.orderConn.fastSend(buffer), true);
-    
-    if (!sent) {
-      service.orderConn.fastSend(buffer);
-    }
-    
-    return { 
-      success: true, 
-      orderTag,
-      exitTime,
-      latencyMs: performance.now() - startTime,
-    };
-  } catch (error) {
-    return { 
-      success: false, 
-      error: error.message,
-      orderTag,
-      exitTime,
-      latencyMs: performance.now() - startTime,
-    };
-  }
-};
-
 /**
  * Place order via ORDER_PLANT
  * @param {RithmicService} service - The Rithmic service instance