hedgequantx 2.6.162 → 2.7.0

package/src/services/hqx-server/latency.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Latency tracking and adaptive heartbeat
+ * @module services/hqx-server/latency
+ */
+
+/**
+ * Latency tracker with adaptive heartbeat
+ */
+class LatencyTracker {
+  constructor() {
+    this.latency = 0;
+    this.minLatency = Infinity;
+    this.maxLatency = 0;
+    this.avgLatency = 0;
+    this.latencySamples = [];
+    this.adaptiveHeartbeat = 1000;
+  }
+
+  /**
+   * Update latency with new sample
+   * @param {number} latency - Latency in ms
+   */
+  update(latency) {
+    this.latency = latency;
+    this.minLatency = Math.min(this.minLatency, latency);
+    this.maxLatency = Math.max(this.maxLatency, latency);
+    
+    // Rolling average (last 100 samples)
+    this.latencySamples.push(latency);
+    if (this.latencySamples.length > 100) {
+      this.latencySamples.shift();
+    }
+    this.avgLatency = this.latencySamples.reduce((a, b) => a + b, 0) / this.latencySamples.length;
+    
+    this._adaptHeartbeat();
+  }
+
+  /**
+   * Adapt heartbeat interval based on connection quality
+   * @private
+   */
+  _adaptHeartbeat() {
+    if (this.avgLatency < 10) {
+      this.adaptiveHeartbeat = 2000;  // <10ms: 2s heartbeat
+    } else if (this.avgLatency < 50) {
+      this.adaptiveHeartbeat = 1000;  // <50ms: 1s heartbeat
+    } else if (this.avgLatency < 100) {
+      this.adaptiveHeartbeat = 500;   // <100ms: 500ms heartbeat
+    } else {
+      this.adaptiveHeartbeat = 250;   // High latency: 250ms heartbeat
+    }
+  }
+
+  /**
+   * Get latency statistics
+   * @returns {Object}
+   */
+  getStats() {
+    return {
+      current: this.latency,
+      min: this.minLatency === Infinity ? 0 : this.minLatency,
+      max: this.maxLatency,
+      avg: this.avgLatency,
+      samples: this.latencySamples.length,
+    };
+  }
+
+  /**
+   * Reset all statistics
+   */
+  reset() {
+    this.latency = 0;
+    this.minLatency = Infinity;
+    this.maxLatency = 0;
+    this.avgLatency = 0;
+    this.latencySamples = [];
+    this.adaptiveHeartbeat = 1000;
+  }
+}
+
+module.exports = { LatencyTracker };

package/src/services/index.js

@@ -1,13 +1,22 @@
 /**
  * @fileoverview Services module exports
  * @module services
+ * 
+ * Rithmic-only service hub
  */
 
-const { ProjectXService } = require('./projectx/index');
+const { RithmicService } = require('./rithmic/index');
+const { HQXServerService } = require('./hqx-server/index');
 const { storage, connections } = require('./session');
 
 module.exports = {
-  ProjectXService,
+  // Platform Service (Rithmic only)
+  RithmicService,
+  
+  // HQX Algo Server
+  HQXServerService,
+  
+  // Session Management
   storage,
-  connections
+  connections,
 };

package/src/services/rithmic/accounts.js

@@ -109,46 +109,21 @@ const getTradingAccounts = async (service) => {
     debug(`Account ${acc.accountId} pnlData:`, JSON.stringify(pnlData));
     debug(`  accountPnL map size:`, service.accountPnL.size);
     
-    // REAL DATA FROM RITHMIC ONLY - NO DEFAULTS (RULES.md compliant)
-    // All values are null if not available from API
-    const accountBalance = pnlData.accountBalance !== undefined ? parseFloat(pnlData.accountBalance) : null;
-    const openPnL = pnlData.openPositionPnl !== undefined ? parseFloat(pnlData.openPositionPnl) : null;
-    const closedPnL = pnlData.closedPositionPnl !== undefined ? parseFloat(pnlData.closedPositionPnl) : null;
-    const dayPnL = pnlData.dayPnl !== undefined ? parseFloat(pnlData.dayPnl) : null;
-    
-    // R Trader additional metrics (from ACCOUNT_PNL_UPDATE 451)
-    const buyingPower = pnlData.availableBuyingPower !== undefined ? parseFloat(pnlData.availableBuyingPower) : null;
-    const margin = pnlData.marginBalance !== undefined ? parseFloat(pnlData.marginBalance) : null;
-    const cashOnHand = pnlData.cashOnHand !== undefined ? parseFloat(pnlData.cashOnHand) : null;
-
-    // Calculate P&L like R Trader: openPositionPnl + closedPositionPnl
-    // This matches what R Trader shows as "Today's P&L"
-    const totalPnL = (openPnL !== null || closedPnL !== null) 
-      ? (openPnL || 0) + (closedPnL || 0) 
-      : null;
-    
-    // Net Liquidation Value = Account Balance + Open P&L (same as R Trader)
-    const netLiquidation = (accountBalance !== null || openPnL !== null)
-      ? (accountBalance || 0) + (openPnL || 0)
-      : null;
+    // REAL DATA FROM RITHMIC ONLY - NO DEFAULTS
+    const accountBalance = pnlData.accountBalance ? parseFloat(pnlData.accountBalance) : null;
+    const openPnL = pnlData.openPositionPnl ? parseFloat(pnlData.openPositionPnl) : null;
+    const closedPnL = pnlData.closedPositionPnl ? parseFloat(pnlData.closedPositionPnl) : null;
+    const dayPnL = pnlData.dayPnl ? parseFloat(pnlData.dayPnl) : null;
 
     return {
       accountId: hashAccountId(acc.accountId),
       rithmicAccountId: acc.accountId,
       accountName: acc.accountId,  // Never expose real name - only account ID
       name: acc.accountId,         // Never expose real name - only account ID
-      // Core metrics (same as R Trader)
       balance: accountBalance,
-      profitAndLoss: totalPnL,  // Same as R Trader: open + closed
+      profitAndLoss: dayPnL !== null ? dayPnL : (openPnL !== null || closedPnL !== null ? (openPnL || 0) + (closedPnL || 0) : null),
       openPnL: openPnL,
-      closedPnL: closedPnL,
-      dayPnL: dayPnL,
-      // R Trader additional metrics
-      buyingPower: buyingPower,
-      margin: margin,
-      cashOnHand: cashOnHand,
-      netLiquidation: netLiquidation,
-      // Meta
+      todayPnL: closedPnL,
       status: 0,
       platform: 'Rithmic',
       propfirm: service.propfirm.name,

package/src/services/rithmic/connection.js

@@ -1,11 +1,6 @@
 /**
  * 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');
@@ -20,7 +15,6 @@ class RithmicConnection extends EventEmitter {
     this.config = null;
     this.state = 'DISCONNECTED';
     this.heartbeatTimer = null;
-    this._socket = null; // Direct socket reference for fast access
   }
 
   get isConnected() {
@@ -33,7 +27,6 @@ class RithmicConnection extends EventEmitter {
 
   /**
    * Connect to Rithmic server
-   * OPTIMIZED: TCP_NODELAY, no compression, skip UTF8 validation
    */
   async connect(config) {
     this.config = config;
@@ -42,24 +35,10 @@ class RithmicConnection extends EventEmitter {
     await proto.load();
 
     return new Promise((resolve, reject) => {
-      // 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 = new WebSocket(config.uri, { rejectUnauthorized: false });
 
       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);
       });
@@ -113,122 +92,6 @@ 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
-   * @returns {boolean} true if sent, false if connection not open
-   */
-  fastSend(buffer) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(buffer);
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * 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
    */
@@ -335,72 +198,6 @@ 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/contracts.js

@@ -0,0 +1,235 @@
+/**
+ * @fileoverview Rithmic contract methods
+ * @module services/rithmic/contracts
+ * 
+ * NO FAKE DATA - Only real values from Rithmic API
+ */
+
+const { decodeFrontMonthContract } = require('./protobuf');
+const { TIMEOUTS, CACHE } = require('../../config/settings');
+const { logger } = require('../../utils/logger');
+
+const log = logger.scope('Rithmic:Contracts');
+
+/**
+ * Get all available contracts from Rithmic API
+ * @param {RithmicService} service - Service instance
+ * @returns {Promise<{success: boolean, contracts: Array, source?: string, error?: string}>}
+ */
+const getContracts = async (service) => {
+  // Check cache
+  if (service._contractsCache && Date.now() - service._contractsCacheTime < CACHE.CONTRACTS_TTL) {
+    return { success: true, contracts: service._contractsCache, source: 'cache' };
+  }
+
+  if (!service.credentials) {
+    return { success: false, error: 'Not logged in' };
+  }
+
+  try {
+    // Connect to TICKER_PLANT if needed
+    if (!service.tickerConn) {
+      const connected = await service.connectTicker(service.credentials.username, service.credentials.password);
+      if (!connected) {
+        return { success: false, error: 'Failed to connect to TICKER_PLANT' };
+      }
+    }
+
+    service.tickerConn.setMaxListeners(5000);
+
+    log.debug('Fetching contracts from Rithmic API');
+    const contracts = await fetchAllFrontMonths(service);
+
+    if (!contracts.length) {
+      return { success: false, error: 'No tradeable contracts found' };
+    }
+
+    // Cache results
+    service._contractsCache = contracts;
+    service._contractsCacheTime = Date.now();
+
+    return { success: true, contracts, source: 'api' };
+  } catch (err) {
+    log.error('getContracts error', { error: err.message });
+    return { success: false, error: err.message };
+  }
+};
+
+/**
+ * Search contracts
+ * @param {RithmicService} service - Service instance
+ * @param {string} searchText - Search text
+ * @returns {Promise<Array>}
+ */
+const searchContracts = async (service, searchText) => {
+  const result = await getContracts(service);
+  if (!searchText || !result.success) return result.contracts || [];
+  
+  const search = searchText.toUpperCase();
+  return result.contracts.filter(c =>
+    c.symbol.toUpperCase().includes(search) ||
+    c.name.toUpperCase().includes(search)
+  );
+};
+
+/**
+ * Fetch all front month contracts from API
+ * @param {RithmicService} service - Service instance
+ * @returns {Promise<Array>}
+ */
+const fetchAllFrontMonths = (service) => {
+  if (!service.tickerConn) {
+    throw new Error('TICKER_PLANT not connected');
+  }
+
+  return new Promise((resolve) => {
+    const contracts = new Map();
+    const productsToCheck = new Map();
+
+    // Handler for ProductCodes responses
+    const productHandler = (msg) => {
+      if (msg.templateId !== 112) return;
+      
+      const decoded = decodeProductCodes(msg.data);
+      if (!decoded.productCode || !decoded.exchange) return;
+      
+      const validExchanges = ['CME', 'CBOT', 'NYMEX', 'COMEX', 'NYBOT', 'CFE'];
+      if (!validExchanges.includes(decoded.exchange)) return;
+      
+      const name = (decoded.productName || '').toLowerCase();
+      if (name.includes('option') || name.includes('swap') || name.includes('spread')) return;
+      
+      const key = `${decoded.productCode}:${decoded.exchange}`;
+      if (!productsToCheck.has(key)) {
+        productsToCheck.set(key, {
+          productCode: decoded.productCode,
+          productName: decoded.productName || decoded.productCode,
+          exchange: decoded.exchange,
+        });
+      }
+    };
+
+    // Handler for FrontMonth responses
+    const frontMonthHandler = (msg) => {
+      if (msg.templateId !== 114) return;
+      
+      const decoded = decodeFrontMonthContract(msg.data);
+      if (decoded.rpCode[0] === '0' && decoded.tradingSymbol) {
+        contracts.set(decoded.userMsg, {
+          symbol: decoded.tradingSymbol,
+          baseSymbol: decoded.userMsg,
+          exchange: decoded.exchange,
+        });
+      }
+    };
+
+    service.tickerConn.on('message', productHandler);
+    service.tickerConn.on('message', frontMonthHandler);
+
+    // Request all product codes
+    service.tickerConn.send('RequestProductCodes', {
+      templateId: 111,
+      userMsg: ['get-products'],
+    });
+
+    // After timeout, request front months
+    setTimeout(() => {
+      service.tickerConn.removeListener('message', productHandler);
+      log.debug('Collected products', { count: productsToCheck.size });
+
+      for (const product of productsToCheck.values()) {
+        service.tickerConn.send('RequestFrontMonthContract', {
+          templateId: 113,
+          userMsg: [product.productCode],
+          symbol: product.productCode,
+          exchange: product.exchange,
+        });
+      }
+
+      // Collect results after timeout
+      setTimeout(() => {
+        service.tickerConn.removeListener('message', frontMonthHandler);
+
+        const results = [];
+        for (const [baseSymbol, contract] of contracts) {
+          const productKey = `${baseSymbol}:${contract.exchange}`;
+          const product = productsToCheck.get(productKey);
+
+          // 100% API data - no static symbol info
+          results.push({
+            symbol: contract.symbol,
+            baseSymbol,
+            name: product?.productName || baseSymbol,
+            exchange: contract.exchange,
+          });
+        }
+
+        // Sort alphabetically by base symbol
+        results.sort((a, b) => a.baseSymbol.localeCompare(b.baseSymbol));
+
+        log.debug('Got contracts from API', { count: results.length });
+        resolve(results);
+      }, TIMEOUTS.RITHMIC_PRODUCTS);
+    }, TIMEOUTS.RITHMIC_CONTRACTS);
+  });
+};
+
+/**
+ * Decode ProductCodes response
+ * @param {Buffer} buffer - Protobuf buffer
+ * @returns {Object} Decoded product data
+ */
+const decodeProductCodes = (buffer) => {
+  const result = {};
+  let offset = 0;
+
+  const readVarint = (buf, off) => {
+    let value = 0;
+    let shift = 0;
+    while (off < buf.length) {
+      const byte = buf[off++];
+      value |= (byte & 0x7F) << shift;
+      if (!(byte & 0x80)) break;
+      shift += 7;
+    }
+    return [value, off];
+  };
+
+  const readString = (buf, off) => {
+    const [len, newOff] = readVarint(buf, off);
+    return [buf.slice(newOff, newOff + len).toString('utf8'), newOff + len];
+  };
+
+  while (offset < buffer.length) {
+    try {
+      const [tag, tagOff] = readVarint(buffer, offset);
+      const wireType = tag & 0x7;
+      const fieldNumber = tag >>> 3;
+      offset = tagOff;
+
+      if (wireType === 0) {
+        const [, newOff] = readVarint(buffer, offset);
+        offset = newOff;
+      } else if (wireType === 2) {
+        const [val, newOff] = readString(buffer, offset);
+        offset = newOff;
+        if (fieldNumber === 110101) result.exchange = val;
+        if (fieldNumber === 100749) result.productCode = val;
+        if (fieldNumber === 100003) result.productName = val;
+      } else {
+        break;
+      }
+    } catch {
+      break;
+    }
+  }
+
+  return result;
+};
+
+module.exports = {
+  getContracts,
+  searchContracts,
+  fetchAllFrontMonths,
+  decodeProductCodes,
+};