hedgequantx 2.6.162 → 2.7.0

package/src/services/rithmic/orders.js

@@ -1,263 +1,9 @@
 /**
  * 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 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
@@ -270,32 +16,19 @@ const placeOrder = async (service, orderData) => {
   }
 
   try {
-    // FIXED: Use account-specific fcmId/ibId if available
-    const account = service.accounts?.find(a => 
-      a.accountId === orderData.accountId || a.rithmicAccountId === orderData.accountId
-    );
-    
-    // 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}` };
-    }
-    
     service.orderConn.send('RequestNewOrder', {
       templateId: REQ.NEW_ORDER,
       userMsg: ['HQX'],
-      fcmId: account?.fcmId || service.loginInfo.fcmId,
-      ibId: account?.ibId || service.loginInfo.ibId,
+      fcmId: service.loginInfo.fcmId,
+      ibId: service.loginInfo.ibId,
       accountId: orderData.accountId,
       symbol: orderData.symbol,
-      exchange: exchange,
+      exchange: orderData.exchange || 'CME',
       quantity: orderData.size,
       transactionType: orderData.side === 0 ? 1 : 2, // 1=Buy, 2=Sell
       duration: 1, // DAY
-      priceType: orderData.type === 2 ? 2 : 1, // priceType: 1=Limit, 2=Market
+      orderType: orderData.type === 2 ? 1 : 2, // 1=Market, 2=Limit
       price: orderData.price || 0,
-      tradeRoute: tradeRoute, // Required by Rithmic API - fetched from RequestTradeRoutes
     });
 
     return { success: true, message: 'Order submitted' };
@@ -450,99 +183,10 @@ const closePosition = async (service, accountId, symbol) => {
   });
 };
 
-/**
- * Cancel all open orders for an account
- * @param {RithmicService} service - The Rithmic service instance
- * @param {string} accountId - Account ID
- */
-const cancelAllOrders = async (service, accountId) => {
-  if (!service.orderConn || !service.loginInfo) {
-    return { success: false, error: 'Not connected' };
-  }
-
-  try {
-    // Use RequestCancelAllOrders template
-    service.orderConn.send('RequestCancelAllOrders', {
-      templateId: 346, // CANCEL_ALL_ORDERS
-      userMsg: ['HQX-STOP'],
-      fcmId: service.loginInfo.fcmId,
-      ibId: service.loginInfo.ibId,
-      accountId: accountId,
-    });
-
-    log.info('Cancel all orders sent', { accountId });
-    return { success: true };
-  } catch (error) {
-    log.error('Cancel all orders failed', { error: error.message });
-    return { success: false, error: error.message };
-  }
-};
-
-/**
- * Flatten all positions for an account (close all positions)
- * @param {RithmicService} service - The Rithmic service instance
- * @param {string} accountId - Account ID
- */
-const flattenAll = async (service, accountId) => {
-  const results = [];
-  const positions = Array.from(service.positions.values());
-  const accountPositions = positions.filter(p => p.accountId === accountId && p.quantity !== 0);
-
-  log.info('Flattening all positions', { accountId, count: accountPositions.length });
-
-  for (const position of accountPositions) {
-    try {
-      const result = await placeOrder(service, {
-        accountId,
-        symbol: position.symbol,
-        exchange: position.exchange,
-        size: Math.abs(position.quantity),
-        side: position.quantity > 0 ? 1 : 0, // Sell if long, Buy if short
-        type: 2, // Market
-      });
-      results.push({ symbol: position.symbol, ...result });
-    } catch (error) {
-      results.push({ symbol: position.symbol, success: false, error: error.message });
-    }
-  }
-
-  return { success: true, results };
-};
-
-/**
- * Emergency stop - Cancel all orders and flatten all positions
- * @param {RithmicService} service - The Rithmic service instance
- * @param {string} accountId - Account ID
- */
-const emergencyStop = async (service, accountId) => {
-  log.warn('EMERGENCY STOP initiated', { accountId });
-
-  // 1. Cancel all orders first
-  const cancelResult = await cancelAllOrders(service, accountId);
-
-  // 2. Wait a moment for cancellations to process
-  await new Promise(r => setTimeout(r, 500));
-
-  // 3. Flatten all positions
-  const flattenResult = await flattenAll(service, accountId);
-
-  return {
-    success: cancelResult.success && flattenResult.success,
-    cancelled: cancelResult,
-    flattened: flattenResult,
-  };
-};
-
 module.exports = {
   placeOrder,
   cancelOrder,
-  cancelAllOrders,
   getOrders,
   getOrderHistory,
-  closePosition,
-  flattenAll,
-  emergencyStop,
-  // Fast scalping - ultra-low latency
-  fastEntry,
-  fastExit,
+  closePosition
 };

package/src/services/rithmic/protobuf.js

@@ -7,74 +7,6 @@ const protobuf = require('protobufjs');
 const path = require('path');
 const { PROTO_FILES } = require('./constants');
 
-// ==================== BUFFER POOL ====================
-// Pre-allocated buffer pool for zero-allocation hot path
-// Avoids GC pressure during high-frequency trading
-
-/**
- * High-performance buffer pool for zero-allocation encoding
- * Uses ring buffer pattern for O(1) acquire/release
- */
-class BufferPool {
-  constructor(poolSize = 16, bufferSize = 512) {
-    this._pool = new Array(poolSize);
-    this._available = new Array(poolSize);
-    this._size = poolSize;
-    this._bufferSize = bufferSize;
-    this._head = 0;
-    this._tail = 0;
-    this._count = poolSize;
-    
-    // Pre-allocate all buffers
-    for (let i = 0; i < poolSize; i++) {
-      this._pool[i] = Buffer.allocUnsafe(bufferSize);
-      this._available[i] = i;
-    }
-  }
-  
-  /**
-   * Acquire a buffer from the pool
-   * @returns {Buffer|null} Buffer or null if pool exhausted
-   */
-  acquire() {
-    if (this._count === 0) {
-      // Pool exhausted - allocate new (fallback)
-      return Buffer.allocUnsafe(this._bufferSize);
-    }
-    const idx = this._available[this._head];
-    this._head = (this._head + 1) % this._size;
-    this._count--;
-    return this._pool[idx];
-  }
-  
-  /**
-   * Release a buffer back to pool
-   * Only releases buffers that belong to the pool
-   * @param {Buffer} buffer 
-   */
-  release(buffer) {
-    // Find if this buffer is from our pool
-    const idx = this._pool.indexOf(buffer);
-    if (idx !== -1 && this._count < this._size) {
-      this._available[this._tail] = idx;
-      this._tail = (this._tail + 1) % this._size;
-      this._count++;
-    }
-    // If not from pool, let GC handle it
-  }
-  
-  /**
-   * Get pool stats
-   */
-  getStats() {
-    return {
-      size: this._size,
-      available: this._count,
-      bufferSize: this._bufferSize,
-    };
-  }
-}
-
 // PnL field IDs (Rithmic uses very large field IDs)
 const PNL_FIELDS = {
   TEMPLATE_ID: 154467,
@@ -344,34 +276,13 @@ function decodeInstrumentPnL(buffer) {
           [result.closedPositionPnl, offset] = readLengthDelimited(buffer, offset);
           break;
         case INSTRUMENT_PNL_FIELDS.DAY_PNL:
-          // DAY_PNL is a double (wireType 1 = 64-bit fixed)
-          if (wireType === 1) {
-            result.dayPnl = buffer.readDoubleLE(offset);
-            offset += 8;
-          } else {
-            // Fallback: try string
-            [result.dayPnl, offset] = readLengthDelimited(buffer, offset);
-          }
+          [result.dayPnl, offset] = readLengthDelimited(buffer, offset);
           break;
         case INSTRUMENT_PNL_FIELDS.DAY_OPEN_PNL:
-          // DAY_OPEN_PNL is a double (wireType 1 = 64-bit fixed)
-          if (wireType === 1) {
-            result.dayOpenPnl = buffer.readDoubleLE(offset);
-            offset += 8;
-          } else {
-            // Fallback: try string
-            [result.dayOpenPnl, offset] = readLengthDelimited(buffer, offset);
-          }
+          [result.dayOpenPnl, offset] = readLengthDelimited(buffer, offset);
           break;
         case INSTRUMENT_PNL_FIELDS.DAY_CLOSED_PNL:
-          // DAY_CLOSED_PNL is a double (wireType 1 = 64-bit fixed)
-          if (wireType === 1) {
-            result.dayClosedPnl = buffer.readDoubleLE(offset);
-            offset += 8;
-          } else {
-            // Fallback: try string
-            [result.dayClosedPnl, offset] = readLengthDelimited(buffer, offset);
-          }
+          [result.dayClosedPnl, offset] = readLengthDelimited(buffer, offset);
           break;
         case INSTRUMENT_PNL_FIELDS.SSBOE:
           [result.ssboe, offset] = readVarint(buffer, offset);
@@ -392,34 +303,16 @@ function decodeInstrumentPnL(buffer) {
 
 /**
  * Protobuf Handler class
- * OPTIMIZED: Pre-compile types, cache encoders, buffer pooling
- * 
- * ULTRA-LOW LATENCY FEATURES:
- * - Pre-allocated buffer pool (zero allocation in hot path)
- * - Reusable protobuf Writer
- * - Cached compiled message types
- * - Direct buffer encoding without intermediate objects
  */
 class ProtobufHandler {
   constructor() {
     this.root = null;
     this.loaded = false;
     this.protoPath = path.join(__dirname, 'proto');
-    
-    // OPTIMIZATION: Cache compiled types for hot path
-    this._typeCache = new Map();
-    this._encoderCache = new Map();
-    
-    // OPTIMIZATION: Pre-allocated buffer pool for zero-allocation encoding
-    this._bufferPool = new BufferPool(16, 512); // 16 buffers of 512 bytes each
-    
-    // OPTIMIZATION: Reusable protobuf Writer instance
-    this._writer = null;
   }
 
   /**
    * Load all proto files
-   * Call once at startup, not per-connection
    */
   async load() {
     if (this.loaded) return;
@@ -435,109 +328,26 @@ class ProtobufHandler {
     }
 
     this.loaded = true;
-    
-    // Pre-compile frequently used types
-    this._precompileTypes();
-  }
-
-  /**
-   * Pre-compile frequently used message types
-   * @private
-   */
-  _precompileTypes() {
-    const hotTypes = [
-      'RequestNewOrder',
-      'RequestCancelOrder', 
-      'RequestHeartbeat',
-      'RequestLogin',
-      'ResponseLogin',
-      'RithmicOrderNotification',
-      'ExchangeOrderNotification',
-    ];
-    
-    for (const typeName of hotTypes) {
-      try {
-        const Type = this.root.lookupType(typeName);
-        this._typeCache.set(typeName, Type);
-      } catch (e) {
-        // Type may not exist in all proto files
-      }
-    }
-  }
-
-  /**
-   * Get cached type or lookup
-   * @private
-   */
-  _getType(typeName) {
-    let Type = this._typeCache.get(typeName);
-    if (!Type) {
-      Type = this.root.lookupType(typeName);
-      this._typeCache.set(typeName, Type);
-    }
-    return Type;
   }
 
   /**
    * Encode a message to Buffer
-   * OPTIMIZED: Uses cached type lookup
    */
   encode(typeName, data) {
     if (!this.root) throw new Error('Proto not loaded');
 
-    const Type = this._getType(typeName);
+    const Type = this.root.lookupType(typeName);
     const msg = Type.create(data);
     return Buffer.from(Type.encode(msg).finish());
   }
 
-  /**
-   * Fast encode for hot path - uses buffer pool and reuses writer
-   * ULTRA-LOW LATENCY: Zero allocation in typical case
-   * 
-   * @param {string} typeName 
-   * @param {Object} data 
-   * @returns {Buffer}
-   */
-  fastEncode(typeName, data) {
-    const Type = this._typeCache.get(typeName);
-    if (!Type) return this.encode(typeName, data);
-    
-    // OPTIMIZATION: Create message without validation (faster)
-    const msg = Type.fromObject(data);
-    
-    // OPTIMIZATION: Get length first to check if pool buffer fits
-    const len = Type.encode(msg).len;
-    
-    if (len <= 512) {
-      // Use pooled buffer for small messages (typical orders are ~100-200 bytes)
-      const poolBuf = this._bufferPool.acquire();
-      const writer = protobuf.Writer.create();
-      Type.encode(msg, writer);
-      const encoded = writer.finish();
-      
-      // Copy to pooled buffer and return a slice
-      encoded.copy(poolBuf, 0, 0, len);
-      
-      // Return a NEW buffer (copy) because pooled buffer will be reused
-      // This is still faster than allocating fresh each time due to copy being optimized
-      const result = Buffer.allocUnsafe(len);
-      poolBuf.copy(result, 0, 0, len);
-      this._bufferPool.release(poolBuf);
-      return result;
-    }
-    
-    // Large message - use standard path
-    return Buffer.from(Type.encode(msg).finish());
-  }
-
   /**
    * Decode a Buffer to object
-   * OPTIMIZED: Uses cached type lookup
    */
   decode(typeName, buffer) {
     if (!this.root) throw new Error('Proto not loaded');
 
-    const Type = this._getType(typeName);
+    const Type = this.root.lookupType(typeName);
     return Type.decode(buffer);
   }