hedgequantx 2.6.161 → 2.6.163

package/src/services/rithmic/contracts.js

@@ -0,0 +1,218 @@
+/**
+ * Rithmic Contracts Module
+ * @module services/rithmic/contracts
+ * 
+ * Contract lookup and front month discovery
+ */
+
+const { decodeFrontMonthContract } = require('./protobuf');
+const { CME_CONTRACT_SPECS } = require('./specs');
+const { TIMEOUTS, CACHE } = require('../../config/settings');
+const { logger } = require('../../utils/logger');
+
+const log = logger.scope('RithmicContracts');
+
+/**
+ * Decode product codes from raw protobuf buffer
+ * @param {Buffer} buffer
+ * @returns {Object}
+ */
+function decodeProductCodes(buffer) {
+  const result = {};
+  let offset = 0;
+
+  const readVarint = (buf, off) => {
+    let value = 0, 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;
+}
+
+/**
+ * Fetch all front month contracts from TICKER_PLANT
+ * @param {RithmicService} service
+ * @returns {Promise<Array>}
+ */
+async function fetchAllFrontMonths(service) {
+  if (!service.tickerConn) throw new Error('TICKER_PLANT not connected');
+
+  return new Promise((resolve) => {
+    const contracts = new Map();
+    const productsToCheck = new Map();
+
+    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,
+        });
+      }
+    };
+
+    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);
+
+    service.tickerConn.send('RequestProductCodes', {
+      templateId: 111,
+      userMsg: ['get-products'],
+    });
+
+    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,
+        });
+      }
+
+      setTimeout(() => {
+        service.tickerConn.removeListener('message', frontMonthHandler);
+
+        const results = [];
+        for (const [baseSymbol, contract] of contracts) {
+          const productKey = `${baseSymbol}:${contract.exchange}`;
+          const product = productsToCheck.get(productKey);
+          const specs = CME_CONTRACT_SPECS[baseSymbol] || null;
+          const productName = specs?.name || product?.productName || baseSymbol;
+          
+          results.push({
+            symbol: contract.symbol,
+            baseSymbol,
+            name: contract.symbol,
+            description: productName,
+            exchange: contract.exchange,
+            tickSize: specs?.tickSize ?? null,
+            tickValue: specs?.tickValue ?? null,
+          });
+        }
+
+        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);
+  });
+}
+
+/**
+ * Get contracts with caching
+ * @param {RithmicService} service
+ * @returns {Promise<Object>}
+ */
+async function getContracts(service) {
+  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 {
+    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' };
+
+    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 by text
+ * @param {RithmicService} service
+ * @param {string} searchText
+ * @returns {Promise<Array>}
+ */
+async function searchContracts(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)
+  );
+}
+
+module.exports = {
+  decodeProductCodes,
+  fetchAllFrontMonths,
+  getContracts,
+  searchContracts,
+};

package/src/services/rithmic/handlers.js

@@ -14,151 +14,12 @@
 const { proto, decodeAccountPnL, decodeInstrumentPnL } = require('./protobuf');
 const { RES, STREAM } = require('./constants');
 const { performance } = require('perf_hooks');
+const { LatencyTracker, FillInfoPool } = require('./latency-tracker');
 
 // 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: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
  * @param {RithmicService} service - The Rithmic service instance
@@ -436,74 +297,7 @@ const handleNewOrderResponse = (service, data) => {
   }
 };
 
-// ==================== 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.userTag || null; // userTag contains our order tag
-    o.basketId = notif.basketId;
-    o.orderId = notif.exchangeOrderId || notif.orderId;
-    o.status = notif.status;
-    o.symbol = notif.symbol;
-    o.exchange = notif.exchange;
-    o.accountId = notif.accountId;
-    // Proto uses totalFillSize, not fillQuantity
-    o.fillQuantity = notif.totalFillSize || notif.fillQuantity || 0;
-    o.totalFillQuantity = notif.totalFillSize || notif.totalFillQuantity || 0;
-    o.remainingQuantity = notif.totalUnfilledSize || notif.remainingQuantity || 0;
-    o.avgFillPrice = parseFloat(notif.avgFillPrice || 0);
-    o.lastFillPrice = parseFloat(notif.price || notif.fillPrice || 0);
-    o.transactionType = notif.transactionType;
-    o.orderType = notif.priceType || 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 };
-  }
-};
+// FillInfoPool imported from ./latency-tracker
 
 /**
  * Handle order notification (351) - CRITICAL for fill tracking