hedgequantx 2.5.43 → 2.6.0

package/src/services/rithmic/connection.js

@@ -1,6 +1,11 @@
 /**
  * Rithmic Connection Manager
  * Handles WebSocket connection and heartbeat
+ * 
+ * OPTIMIZED FOR ULTRA-LOW LATENCY:
+ * - TCP_NODELAY enabled (disable Nagle's algorithm)
+ * - Compression disabled
+ * - Skip UTF8 validation for binary
  */
 
 const WebSocket = require('ws');
@@ -15,6 +20,7 @@ class RithmicConnection extends EventEmitter {
     this.config = null;
     this.state = 'DISCONNECTED';
     this.heartbeatTimer = null;
+    this._socket = null; // Direct socket reference for fast access
   }
 
   get isConnected() {
@@ -27,6 +33,7 @@ class RithmicConnection extends EventEmitter {
 
   /**
    * Connect to Rithmic server
+   * OPTIMIZED: TCP_NODELAY, no compression, skip UTF8 validation
    */
   async connect(config) {
     this.config = config;
@@ -35,10 +42,24 @@ class RithmicConnection extends EventEmitter {
     await proto.load();
 
     return new Promise((resolve, reject) => {
-      this.ws = new WebSocket(config.uri, { rejectUnauthorized: false });
+      // OPTIMIZATION: Disable compression and UTF8 validation for speed
+      this.ws = new WebSocket(config.uri, { 
+        rejectUnauthorized: false,
+        perMessageDeflate: false,      // CRITICAL: Disable compression
+        skipUTF8Validation: true,      // Skip validation for binary protobuf
+        maxPayload: 64 * 1024,         // 64KB max (orders are small)
+      });
 
       this.ws.on('open', () => {
         this.state = 'CONNECTED';
+        
+        // CRITICAL: Disable Nagle's algorithm for low latency
+        // This sends packets immediately instead of buffering
+        if (this.ws._socket) {
+          this.ws._socket.setNoDelay(true);
+          this._socket = this.ws._socket; // Cache for fast access
+        }
+        
         this.emit('connected');
         resolve(true);
       });
@@ -92,6 +113,119 @@ class RithmicConnection extends EventEmitter {
     this.ws.send(buffer);
   }
 
+  /**
+   * Fast send - bypasses some ws overhead for hot path
+   * Use for time-critical order messages
+   * @param {Buffer} buffer - Pre-encoded protobuf buffer
+   */
+  fastSend(buffer) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(buffer);
+    }
+  }
+
+  /**
+   * Ultra-fast send - direct socket write with WebSocket framing
+   * MAXIMUM PERFORMANCE: Bypasses ws library overhead entirely
+   * Only use for pre-encoded binary protobuf messages
+   * 
+   * @param {Buffer} payload - Pre-encoded protobuf buffer
+   * @returns {boolean} true if sent successfully
+   */
+  ultraSend(payload) {
+    // Require cached socket reference
+    if (!this._socket || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+
+    try {
+      // Build WebSocket frame manually for binary message
+      // This avoids all ws library overhead (callbacks, validation, etc.)
+      const frame = this._buildBinaryFrame(payload);
+      
+      // Direct socket write - bypasses ws entirely
+      this._socket.write(frame);
+      return true;
+    } catch (e) {
+      // Fallback to standard send on error
+      this.ws.send(payload);
+      return true;
+    }
+  }
+
+  /**
+   * Build WebSocket binary frame manually
+   * Format: [opcode] [length] [payload]
+   * @private
+   * @param {Buffer} payload 
+   * @returns {Buffer}
+   */
+  _buildBinaryFrame(payload) {
+    const len = payload.length;
+    let frame;
+    
+    if (len < 126) {
+      // 2-byte header: FIN + opcode (0x82 = final binary), length
+      frame = Buffer.allocUnsafe(2 + len);
+      frame[0] = 0x82; // FIN=1, opcode=2 (binary)
+      frame[1] = len;  // No mask (server->client would need mask, but we're client)
+      payload.copy(frame, 2);
+    } else if (len < 65536) {
+      // 4-byte header for medium messages
+      frame = Buffer.allocUnsafe(4 + len);
+      frame[0] = 0x82;
+      frame[1] = 126;
+      frame.writeUInt16BE(len, 2);
+      payload.copy(frame, 4);
+    } else {
+      // 10-byte header for large messages (unlikely for orders)
+      frame = Buffer.allocUnsafe(10 + len);
+      frame[0] = 0x82;
+      frame[1] = 127;
+      frame.writeBigUInt64BE(BigInt(len), 2);
+      payload.copy(frame, 10);
+    }
+    
+    // Client frames MUST be masked per RFC 6455
+    // Apply masking key
+    return this._applyMask(frame, len < 126 ? 2 : (len < 65536 ? 4 : 10));
+  }
+
+  /**
+   * Apply WebSocket client masking
+   * @private
+   * @param {Buffer} frame - Frame with unmasked payload
+   * @param {number} headerLen - Length of header before payload
+   * @returns {Buffer} - New frame with mask applied
+   */
+  _applyMask(frame, headerLen) {
+    const payloadLen = frame.length - headerLen;
+    
+    // Generate 4-byte mask key
+    const mask = Buffer.allocUnsafe(4);
+    mask[0] = (Math.random() * 256) | 0;
+    mask[1] = (Math.random() * 256) | 0;
+    mask[2] = (Math.random() * 256) | 0;
+    mask[3] = (Math.random() * 256) | 0;
+    
+    // Create new frame with mask bit set and mask key inserted
+    const maskedFrame = Buffer.allocUnsafe(headerLen + 4 + payloadLen);
+    
+    // Copy header, set mask bit
+    frame.copy(maskedFrame, 0, 0, headerLen);
+    maskedFrame[1] |= 0x80; // Set MASK bit
+    
+    // Insert mask key after length
+    mask.copy(maskedFrame, headerLen);
+    
+    // Copy and mask payload
+    for (let i = 0; i < payloadLen; i++) {
+      maskedFrame[headerLen + 4 + i] = frame[headerLen + i] ^ mask[i & 3];
+    }
+    
+    return maskedFrame;
+  }
+
   /**
    * Login to system
    */
@@ -198,6 +332,72 @@ class RithmicConnection extends EventEmitter {
       this.heartbeatTimer = null;
     }
   }
+
+  /**
+   * Warmup connection for minimum latency on first order
+   * Call after login but before trading starts
+   * 
+   * OPTIMIZATIONS:
+   * - Pre-load protobuf types
+   * - Keep TCP connection "hot" with small pings
+   * - Configure socket for trading
+   */
+  async warmup() {
+    if (!this._socket) return false;
+    
+    try {
+      // Ensure TCP_NODELAY is set
+      this._socket.setNoDelay(true);
+      
+      // Set socket keep-alive to prevent idle disconnection
+      // Aggressive keep-alive: probe every 10 seconds
+      this._socket.setKeepAlive(true, 10000);
+      
+      // Pre-allocate socket buffer space
+      if (this._socket.setRecvBufferSize) {
+        this._socket.setRecvBufferSize(65536); // 64KB receive buffer
+      }
+      if (this._socket.setSendBufferSize) {
+        this._socket.setSendBufferSize(65536); // 64KB send buffer
+      }
+      
+      // Send a heartbeat to "warm up" the connection
+      this.send('RequestHeartbeat', { templateId: REQ.HEARTBEAT });
+      
+      this.emit('warmedUp');
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Get connection diagnostics
+   * @returns {Object}
+   */
+  getDiagnostics() {
+    const diag = {
+      state: this.state,
+      isConnected: this.isConnected,
+      hasSocket: !!this._socket,
+      socketState: null,
+    };
+    
+    if (this._socket) {
+      diag.socketState = {
+        readable: this._socket.readable,
+        writable: this._socket.writable,
+        bytesRead: this._socket.bytesRead,
+        bytesWritten: this._socket.bytesWritten,
+        localAddress: this._socket.localAddress,
+        localPort: this._socket.localPort,
+        remoteAddress: this._socket.remoteAddress,
+        remotePort: this._socket.remotePort,
+      };
+    }
+    
+    return diag;
+  }
 }
 
 module.exports = { RithmicConnection };

package/src/services/rithmic/handlers.js

@@ -1,14 +1,163 @@
 /**
  * Rithmic Message Handlers
  * Handles ORDER_PLANT and PNL_PLANT messages
+ * 
+ * FAST SCALPING: Handles order fill notifications (351) for position tracking
+ * 
+ * OPTIMIZED FOR LOW LATENCY:
+ * - Fast path for order notifications (351)
+ * - Minimal object creation in hot path
+ * - Template ID check before proto decode
+ * - Latency tracking for fills
  */
 
 const { proto, decodeAccountPnL, decodeInstrumentPnL } = require('./protobuf');
 const { RES, STREAM } = require('./constants');
+const { performance } = require('perf_hooks');
 
-// Debug mode
+// Debug mode - use no-op function when disabled for zero overhead
 const DEBUG = process.env.HQX_DEBUG === '1';
-const debug = (...args) => DEBUG && console.log('[Rithmic:Handler]', ...args);
+const debug = DEBUG ? (...args) => console.log('[Rithmic:Handler]', ...args) : () => {};
+
+// ==================== HIGH-RESOLUTION TIMING ====================
+// Use process.hrtime.bigint for sub-millisecond precision
+
+/**
+ * Get high-resolution timestamp in nanoseconds
+ * @returns {bigint}
+ */
+const hrNow = () => process.hrtime.bigint();
+
+/**
+ * Convert nanoseconds to milliseconds with precision
+ * @param {bigint} ns 
+ * @returns {number}
+ */
+const nsToMs = (ns) => Number(ns) / 1_000_000;
+
+// ==================== LATENCY TRACKING ====================
+// Track order-to-fill latency for performance monitoring
+// OPTIMIZED: Circular buffer (no array.shift), high-resolution timing
+
+const LatencyTracker = {
+  _pending: new Map(), // orderTag -> entryTime (bigint nanoseconds)
+  _samples: null,      // Pre-allocated Float64Array circular buffer
+  _maxSamples: 100,
+  _head: 0,            // Next write position
+  _count: 0,           // Number of valid samples
+  _initialized: false,
+  
+  /**
+   * Initialize circular buffer (lazy init)
+   * @private
+   */
+  _init() {
+    if (this._initialized) return;
+    this._samples = new Float64Array(this._maxSamples);
+    this._initialized = true;
+  },
+  
+  /**
+   * Record order sent time with high-resolution timestamp
+   * @param {string} orderTag 
+   * @param {number} entryTimeMs - Date.now() when order was sent (for compatibility)
+   */
+  recordEntry(orderTag, entryTimeMs) {
+    // Store high-resolution time for precise measurement
+    this._pending.set(orderTag, hrNow());
+  },
+  
+  /**
+   * Record fill received, calculate latency with sub-ms precision
+   * @param {string} orderTag 
+   * @returns {number|null} Round-trip latency in ms (with decimal precision), or null if not tracked
+   */
+  recordFill(orderTag) {
+    const entryTime = this._pending.get(orderTag);
+    if (!entryTime) return null;
+    
+    this._pending.delete(orderTag);
+    const latencyNs = hrNow() - entryTime;
+    const latencyMs = nsToMs(latencyNs);
+    
+    // Store in circular buffer (no shift, O(1))
+    this._init();
+    this._samples[this._head] = latencyMs;
+    this._head = (this._head + 1) % this._maxSamples;
+    if (this._count < this._maxSamples) this._count++;
+    
+    return latencyMs;
+  },
+  
+  /**
+   * Get average latency
+   * @returns {number|null}
+   */
+  getAverage() {
+    if (this._count === 0) return null;
+    let sum = 0;
+    for (let i = 0; i < this._count; i++) {
+      sum += this._samples[i];
+    }
+    return sum / this._count;
+  },
+  
+  /**
+   * Get min/max/avg stats with high precision
+   * @returns {Object}
+   */
+  getStats() {
+    if (this._count === 0) {
+      return { min: null, max: null, avg: null, p50: null, p99: null, samples: 0 };
+    }
+    
+    // Get valid samples
+    const valid = [];
+    for (let i = 0; i < this._count; i++) {
+      valid.push(this._samples[i]);
+    }
+    valid.sort((a, b) => a - b);
+    
+    const sum = valid.reduce((a, b) => a + b, 0);
+    
+    return {
+      min: valid[0],
+      max: valid[valid.length - 1],
+      avg: sum / valid.length,
+      p50: valid[Math.floor(valid.length * 0.5)],
+      p99: valid[Math.floor(valid.length * 0.99)] || valid[valid.length - 1],
+      samples: this._count,
+    };
+  },
+  
+  /**
+   * Get last N latency samples
+   * @param {number} n 
+   * @returns {number[]}
+   */
+  getRecent(n = 10) {
+    if (this._count === 0) return [];
+    const result = [];
+    const start = this._count < this._maxSamples ? 0 : this._head;
+    for (let i = 0; i < Math.min(n, this._count); i++) {
+      const idx = (start + this._count - 1 - i + this._maxSamples) % this._maxSamples;
+      result.push(this._samples[idx]);
+    }
+    return result;
+  },
+  
+  /**
+   * Clear all tracking data
+   */
+  clear() {
+    this._pending.clear();
+    this._head = 0;
+    this._count = 0;
+    if (this._samples) {
+      this._samples.fill(0);
+    }
+  }
+};
 
 /**
  * Create ORDER_PLANT message handler
@@ -35,11 +184,17 @@ const createOrderHandler = (service) => {
       case RES.SHOW_ORDERS:
         handleShowOrdersResponse(service, data);
         break;
+      case RES.NEW_ORDER:
+        debug('Handling NEW_ORDER response (313)');
+        handleNewOrderResponse(service, data);
+        break;
       case STREAM.EXCHANGE_NOTIFICATION:
-        service.emit('exchangeNotification', data);
+        debug('Handling EXCHANGE_NOTIFICATION (352)');
+        handleExchangeNotification(service, data);
         break;
       case STREAM.ORDER_NOTIFICATION:
-        service.emit('orderNotification', data);
+        debug('Handling ORDER_NOTIFICATION (351)');
+        handleOrderNotification(service, data);
         break;
     }
   };
@@ -211,7 +366,188 @@ const handleInstrumentPnLUpdate = (service, data) => {
   }
 };
 
+/**
+ * Handle new order response (313) - confirms order accepted
+ */
+const handleNewOrderResponse = (service, data) => {
+  try {
+    const res = proto.decode('ResponseNewOrder', data);
+    const orderTag = res.userMsg?.[0] || null;
+    const timestamp = performance.now();
+    
+    debug('New order response:', {
+      orderTag,
+      rpCode: res.rpCode,
+      basketId: res.basketId,
+      ssboe: res.ssboe,
+      usecs: res.usecs,
+    });
+
+    // Emit for position manager tracking
+    service.emit('orderAccepted', {
+      orderTag,
+      basketId: res.basketId,
+      rpCode: res.rpCode,
+      timestamp,
+    });
+  } catch (e) {
+    debug('Error decoding new order response:', e.message);
+  }
+};
+
+// ==================== PRE-ALLOCATED OBJECTS ====================
+// Reusable objects for hot path to avoid GC pressure
+
+const FillInfoPool = {
+  // Pre-allocated fill info template
+  _template: {
+    orderTag: null,
+    basketId: null,
+    orderId: null,
+    status: null,
+    symbol: null,
+    exchange: null,
+    accountId: null,
+    fillQuantity: 0,
+    totalFillQuantity: 0,
+    remainingQuantity: 0,
+    avgFillPrice: 0,
+    lastFillPrice: 0,
+    transactionType: 0,
+    orderType: 0,
+    quantity: 0,
+    ssboe: 0,
+    usecs: 0,
+    localTimestamp: 0,
+    roundTripLatencyMs: null,
+  },
+  
+  /**
+   * Fill template with notification data
+   * @param {Object} notif - Decoded notification
+   * @param {number} receiveTime - Local receive timestamp
+   * @param {number|null} latency - Round-trip latency
+   * @returns {Object}
+   */
+  fill(notif, receiveTime, latency) {
+    const o = this._template;
+    o.orderTag = notif.userMsg?.[0] || null;
+    o.basketId = notif.basketId;
+    o.orderId = notif.orderId;
+    o.status = notif.status;
+    o.symbol = notif.symbol;
+    o.exchange = notif.exchange;
+    o.accountId = notif.accountId;
+    o.fillQuantity = notif.fillQuantity || 0;
+    o.totalFillQuantity = notif.totalFillQuantity || 0;
+    o.remainingQuantity = notif.remainingQuantity || 0;
+    o.avgFillPrice = parseFloat(notif.avgFillPrice || 0);
+    o.lastFillPrice = parseFloat(notif.fillPrice || 0);
+    o.transactionType = notif.transactionType;
+    o.orderType = notif.orderType;
+    o.quantity = notif.quantity;
+    o.ssboe = notif.ssboe;
+    o.usecs = notif.usecs;
+    o.localTimestamp = receiveTime;
+    o.roundTripLatencyMs = latency;
+    return o;
+  },
+  
+  /**
+   * Create a copy for async operations that need to keep the data
+   * @param {Object} fillInfo 
+   * @returns {Object}
+   */
+  clone(fillInfo) {
+    return { ...fillInfo };
+  }
+};
+
+/**
+ * Handle order notification (351) - CRITICAL for fill tracking
+ * This is the primary notification for order status changes including FILLS
+ * 
+ * ULTRA-OPTIMIZED:
+ * - Pre-allocated fill info object (zero allocation in hot path)
+ * - Fast path for fill detection
+ * - High-resolution latency tracking
+ */
+const handleOrderNotification = (service, data) => {
+  const receiveTime = Date.now();
+  
+  try {
+    const notif = proto.decode('RithmicOrderNotification', data);
+    const orderTag = notif.userMsg?.[0] || null;
+    
+    // FAST PATH: Check for fill immediately
+    const fillQty = notif.fillQuantity || notif.totalFillQuantity || 0;
+    const isFill = fillQty > 0;
+    
+    // Calculate round-trip latency if this is a fill we're tracking
+    let roundTripLatency = null;
+    if (isFill && orderTag) {
+      roundTripLatency = LatencyTracker.recordFill(orderTag);
+    }
+    
+    debug('Order notification:', {
+      orderTag,
+      status: notif.status,
+      filledQty: fillQty,
+      avgFillPrice: notif.avgFillPrice,
+      roundTripLatency,
+    });
+
+    // OPTIMIZED: Use pre-allocated object
+    const fillInfo = FillInfoPool.fill(notif, receiveTime, roundTripLatency);
+
+    // Emit raw notification
+    service.emit('orderNotification', fillInfo);
+
+    // Emit fill event if this is a fill
+    if (isFill) {
+      debug('ORDER FILLED:', {
+        orderTag,
+        side: fillInfo.transactionType === 1 ? 'BUY' : 'SELL',
+        qty: fillQty,
+        avgPrice: fillInfo.avgFillPrice,
+        latencyMs: roundTripLatency,
+      });
+      
+      // Clone for fill event (async handlers may need to keep the data)
+      service.emit('orderFilled', FillInfoPool.clone(fillInfo));
+    }
+  } catch (e) {
+    debug('Error decoding order notification:', e.message);
+  }
+};
+
+/**
+ * Handle exchange notification (352) - exchange-level order updates
+ */
+const handleExchangeNotification = (service, data) => {
+  try {
+    const notif = proto.decode('ExchangeOrderNotification', data);
+    const timestamp = performance.now();
+    
+    debug('Exchange notification:', {
+      orderTag: notif.userMsg?.[0],
+      text: notif.text,
+      reportType: notif.reportType,
+    });
+
+    service.emit('exchangeNotification', {
+      orderTag: notif.userMsg?.[0] || null,
+      text: notif.text,
+      reportType: notif.reportType,
+      timestamp,
+    });
+  } catch (e) {
+    debug('Error decoding exchange notification:', e.message);
+  }
+};
+
 module.exports = {
   createOrderHandler,
-  createPnLHandler
+  createPnLHandler,
+  LatencyTracker,
 };