hedgequantx 1.8.33 → 1.8.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "1.8.33",
+  "version": "1.8.34",
   "description": "Prop Futures Algo Trading CLI - Connect to Topstep, Alpha Futures, and other prop firms",
   "main": "src/app.js",
   "bin": {

package/src/services/rithmic/index.js

@@ -9,49 +9,12 @@ const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS } = require('./constants');
 const { createOrderHandler, createPnLHandler } = require('./handlers');
 const { fetchAccounts, getTradingAccounts, requestPnLSnapshot, subscribePnLUpdates, getPositions, hashAccountId } = require('./accounts');
 const { placeOrder, cancelOrder, getOrders, getOrderHistory, closePosition } = require('./orders');
-const { decodeFrontMonthContract } = require('./protobuf');
+const { decodeFrontMonthContract, readVarint, readLengthDelimited, skipField } = require('./protobuf');
 
 // Debug mode
 const DEBUG = process.env.HQX_DEBUG === '1';
 const debug = (...args) => DEBUG && console.log('[Rithmic:Service]', ...args);
 
-// Base symbols for futures contracts
-const BASE_SYMBOLS = {
-  // Equity Index (Quarterly: H, M, U, Z)
-  quarterly: [
-    { base: 'ES', name: 'E-mini S&P 500', exchange: 'CME', category: 'Index' },
-    { base: 'NQ', name: 'E-mini NASDAQ-100', exchange: 'CME', category: 'Index' },
-    { base: 'YM', name: 'E-mini Dow Jones', exchange: 'CBOT', category: 'Index' },
-    { base: 'RTY', name: 'E-mini Russell 2000', exchange: 'CME', category: 'Index' },
-    { base: 'MES', name: 'Micro E-mini S&P 500', exchange: 'CME', category: 'Micro Index' },
-    { base: 'MNQ', name: 'Micro E-mini NASDAQ-100', exchange: 'CME', category: 'Micro Index' },
-    { base: 'MYM', name: 'Micro E-mini Dow Jones', exchange: 'CBOT', category: 'Micro Index' },
-    { base: 'M2K', name: 'Micro E-mini Russell 2000', exchange: 'CME', category: 'Micro Index' },
-    // Currencies (Quarterly)
-    { base: '6E', name: 'Euro FX', exchange: 'CME', category: 'Currency' },
-    { base: 'M6E', name: 'Micro Euro FX', exchange: 'CME', category: 'Currency' },
-    { base: '6B', name: 'British Pound', exchange: 'CME', category: 'Currency' },
-    { base: '6J', name: 'Japanese Yen', exchange: 'CME', category: 'Currency' },
-    { base: '6A', name: 'Australian Dollar', exchange: 'CME', category: 'Currency' },
-    { base: '6C', name: 'Canadian Dollar', exchange: 'CME', category: 'Currency' },
-    // Bonds (Quarterly)
-    { base: 'ZB', name: '30-Year T-Bond', exchange: 'CBOT', category: 'Bonds' },
-    { base: 'ZN', name: '10-Year T-Note', exchange: 'CBOT', category: 'Bonds' },
-    { base: 'ZF', name: '5-Year T-Note', exchange: 'CBOT', category: 'Bonds' },
-    { base: 'ZT', name: '2-Year T-Note', exchange: 'CBOT', category: 'Bonds' },
-  ],
-  // Energy & Metals (Monthly)
-  monthly: [
-    { base: 'CL', name: 'Crude Oil WTI', exchange: 'NYMEX', category: 'Energy' },
-    { base: 'MCL', name: 'Micro Crude Oil', exchange: 'NYMEX', category: 'Energy' },
-    { base: 'NG', name: 'Natural Gas', exchange: 'NYMEX', category: 'Energy' },
-    { base: 'GC', name: 'Gold', exchange: 'COMEX', category: 'Metals' },
-    { base: 'MGC', name: 'Micro Gold', exchange: 'COMEX', category: 'Metals' },
-    { base: 'SI', name: 'Silver', exchange: 'COMEX', category: 'Metals' },
-    { base: 'HG', name: 'Copper', exchange: 'COMEX', category: 'Metals' },
-  ],
-};
-
 // PropFirm configurations - NO FAKE DATA
 const PROPFIRM_CONFIGS = {
   'apex': { name: 'Apex Trader Funding', systemName: 'Apex', gateway: RITHMIC_ENDPOINTS.CHICAGO },
@@ -293,39 +256,31 @@ class RithmicService extends EventEmitter {
   }
 
   /**
-   * Get front month contract from Rithmic API
+   * Get front month contracts for multiple symbols at once - batch request
    */
-  async getFrontMonth(baseSymbol, exchange) {
+  async getFrontMonthsBatch(products) {
     if (!this.tickerConn) {
-      if (!this.credentials) {
-        throw new Error('Not logged in - cannot fetch front month');
-      }
-      const connected = await this.connectTicker(this.credentials.username, this.credentials.password);
-      if (!connected) {
-        throw new Error('Failed to connect to TICKER_PLANT');
-      }
+      throw new Error('TICKER_PLANT not connected');
     }
 
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error(`Timeout getting front month for ${baseSymbol}`));
-      }, 10000);
+    return new Promise((resolve) => {
+      const results = new Map();
+      const pending = new Set(products.map(p => p.productCode));
 
       const handler = (msg) => {
         if (msg.templateId === 114) {  // ResponseFrontMonthContract
           const decoded = decodeFrontMonthContract(msg.data);
-          if (decoded.userMsg === baseSymbol) {
-            clearTimeout(timeout);
-            this.tickerConn.removeListener('message', handler);
+          const baseSymbol = decoded.userMsg;
+          
+          if (pending.has(baseSymbol)) {
+            pending.delete(baseSymbol);
             
-            if (decoded.rpCode[0] === '0') {
-              resolve({
+            if (decoded.rpCode[0] === '0' && decoded.tradingSymbol) {
+              results.set(baseSymbol, {
+                symbol: decoded.tradingSymbol,
                 baseSymbol: baseSymbol,
-                symbol: decoded.tradingSymbol || decoded.symbol,
-                exchange: decoded.exchange || exchange,
+                exchange: decoded.exchange,
               });
-            } else {
-              reject(new Error(`API error for ${baseSymbol}: ${decoded.rpCode.join(' ')}`));
             }
           }
         }
@@ -333,18 +288,166 @@ class RithmicService extends EventEmitter {
 
       this.tickerConn.on('message', handler);
 
-      // Send RequestFrontMonthContract (template 113)
-      this.tickerConn.send('RequestFrontMonthContract', {
-        templateId: 113,
-        userMsg: [baseSymbol],
-        symbol: baseSymbol,
-        exchange: exchange,
+      // Send all requests
+      for (const product of products) {
+        this.tickerConn.send('RequestFrontMonthContract', {
+          templateId: 113,
+          userMsg: [product.productCode],
+          symbol: product.productCode,
+          exchange: product.exchange,
+        });
+      }
+
+      // Wait for responses (with timeout)
+      setTimeout(() => {
+        this.tickerConn.removeListener('message', handler);
+        resolve(Array.from(results.values()));
+      }, 5000);
+    });
+  }
+
+  /**
+   * Decode ProductCodes response (template 112) - field IDs from Rithmic API
+   */
+  decodeProductCodesResponse(buffer) {
+    const result = {};
+    let offset = 0;
+
+    while (offset < buffer.length) {
+      try {
+        const [tag, tagOffset] = readVarint(buffer, offset);
+        const wireType = tag & 0x7;
+        const fieldNumber = tag >>> 3;
+        offset = tagOffset;
+
+        if (wireType === 0) {
+          const [val, newOff] = readVarint(buffer, offset);
+          offset = newOff;
+          if (fieldNumber === 154467) result.templateId = val;
+        } else if (wireType === 2) {
+          const [val, newOff] = readLengthDelimited(buffer, offset);
+          offset = newOff;
+          if (fieldNumber === 110101) result.exchange = val;        // exchange
+          if (fieldNumber === 100749) result.productCode = val;     // product_code (base symbol)
+          if (fieldNumber === 100003) result.productName = val;     // symbol_name
+          if (fieldNumber === 132760) result.userMsg = val;         // user_msg
+          if (fieldNumber === 132764) result.rpCode = val;          // rp_code
+        } else {
+          offset = skipField(buffer, offset, wireType);
+        }
+      } catch (e) { break; }
+    }
+
+    return result;
+  }
+
+  /**
+   * Get all tradeable futures from Rithmic API - 100% REAL DATA
+   * Sends RequestFrontMonthContract for known futures and gets real trading symbols
+   */
+  async fetchAllFrontMonths() {
+    if (!this.tickerConn) {
+      throw new Error('TICKER_PLANT not connected');
+    }
+
+    // Request front months for ALL products that might be futures
+    // The API will return the current trading symbol for each
+    return new Promise((resolve) => {
+      const contracts = new Map();
+      const productsToCheck = new Map(); // Will collect from ProductCodes
+
+      // Handler for ProductCodes responses
+      const productHandler = (msg) => {
+        if (msg.templateId === 112) {
+          const decoded = this.decodeProductCodesResponse(msg.data);
+          if (!decoded.productCode || !decoded.exchange) return;
+          
+          // Only main futures exchanges
+          const validExchanges = ['CME', 'CBOT', 'NYMEX', 'COMEX', 'NYBOT', 'CFE'];
+          if (!validExchanges.includes(decoded.exchange)) return;
+          
+          // Skip obvious non-futures
+          const name = (decoded.productName || '').toLowerCase();
+          if (name.includes('option')) return;
+          if (name.includes('swap')) return;
+          if (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) {
+          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,
+            });
+          }
+        }
+      };
+
+      this.tickerConn.on('message', productHandler);
+      this.tickerConn.on('message', frontMonthHandler);
+
+      // Step 1: Get all product codes
+      this.tickerConn.send('RequestProductCodes', {
+        templateId: 111,
+        userMsg: ['get-products'],
       });
+
+      // After 5 seconds, request front months for all collected products
+      setTimeout(() => {
+        this.tickerConn.removeListener('message', productHandler);
+        debug(`Collected ${productsToCheck.size} products, requesting front months...`);
+
+        // Send front month requests for all products
+        for (const [key, product] of productsToCheck) {
+          this.tickerConn.send('RequestFrontMonthContract', {
+            templateId: 113,
+            userMsg: [product.productCode],
+            symbol: product.productCode,
+            exchange: product.exchange,
+          });
+        }
+
+        // After another 5 seconds, collect results
+        setTimeout(() => {
+          this.tickerConn.removeListener('message', frontMonthHandler);
+          
+          // Merge with product names
+          const results = [];
+          for (const [baseSymbol, contract] of contracts) {
+            const productKey = `${baseSymbol}:${contract.exchange}`;
+            const product = productsToCheck.get(productKey);
+            results.push({
+              symbol: contract.symbol,
+              baseSymbol: baseSymbol,
+              name: product ? product.productName : baseSymbol,
+              exchange: contract.exchange,
+            });
+          }
+
+          debug(`Got ${results.length} tradeable contracts from API`);
+          resolve(results);
+        }, 8000);
+      }, 5000);
     });
   }
 
   /**
-   * Get all available contracts - REAL DATA from Rithmic API
+   * Get all available contracts - 100% REAL DATA from Rithmic API
+   * Fetches product codes and front months directly from the API
    */
   async getContracts() {
     // Return cached if available and fresh (5 min cache)
@@ -366,37 +469,14 @@ class RithmicService extends EventEmitter {
         }
       }
 
-      const contracts = [];
-      const allSymbols = [...BASE_SYMBOLS.quarterly, ...BASE_SYMBOLS.monthly];
-      
-      debug(`Fetching front months for ${allSymbols.length} symbols...`);
-
-      // Fetch front months in parallel batches
-      const batchSize = 10;
-      for (let i = 0; i < allSymbols.length; i += batchSize) {
-        const batch = allSymbols.slice(i, i + batchSize);
-        const promises = batch.map(async (sym) => {
-          try {
-            const result = await this.getFrontMonth(sym.base, sym.exchange);
-            return {
-              symbol: result.symbol,
-              name: `${sym.name} (${result.symbol})`,
-              exchange: result.exchange,
-              category: sym.category,
-              baseSymbol: sym.base,
-            };
-          } catch (e) {
-            debug(`Failed to get front month for ${sym.base}: ${e.message}`);
-            return null;
-          }
-        });
+      // Increase max listeners to avoid warnings
+      this.tickerConn.setMaxListeners(5000);
 
-        const results = await Promise.all(promises);
-        contracts.push(...results.filter(r => r !== null));
-      }
+      debug('Fetching all tradeable contracts from Rithmic API...');
+      const contracts = await this.fetchAllFrontMonths();
 
       if (contracts.length === 0) {
-        return { success: false, error: 'No contracts returned from API' };
+        return { success: false, error: 'No tradeable contracts found' };
       }
 
       // Cache the results