hedgequantx 1.8.32 → 1.8.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "1.8.32",
+  "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/constants.js

@@ -58,6 +58,8 @@ const REQ = {
   SYSTEM_INFO: 16,
   HEARTBEAT: 18,
   MARKET_DATA: 100,
+  PRODUCT_CODES: 111,
+  FRONT_MONTH_CONTRACT: 113,
   LOGIN_INFO: 300,
   ACCOUNT_LIST: 302,
   ACCOUNT_RMS: 304,
@@ -84,6 +86,8 @@ const RES = {
   SYSTEM_INFO: 17,
   HEARTBEAT: 19,
   MARKET_DATA: 101,
+  PRODUCT_CODES: 112,
+  FRONT_MONTH_CONTRACT: 114,
   LOGIN_INFO: 301,
   ACCOUNT_LIST: 303,
   ACCOUNT_RMS: 305,
@@ -155,6 +159,10 @@ const PROTO_FILES = [
   'response_pnl_position_updates.proto',
   'account_pnl_position_update.proto',
   'instrument_pnl_position_update.proto',
+  'request_product_codes.proto',
+  'response_product_codes.proto',
+  'request_front_month_contract.proto',
+  'response_front_month_contract.proto',
 ];
 
 module.exports = {

package/src/services/rithmic/index.js

@@ -9,6 +9,7 @@ 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, readVarint, readLengthDelimited, skipField } = require('./protobuf');
 
 // Debug mode
 const DEBUG = process.env.HQX_DEBUG === '1';
@@ -45,6 +46,7 @@ class RithmicService extends EventEmitter {
     };
     this.orderConn = null;
     this.pnlConn = null;
+    this.tickerConn = null; // TICKER_PLANT for symbol lookup
     this.loginInfo = null;
     this.accounts = [];
     this.accountPnL = new Map();
@@ -52,6 +54,7 @@ class RithmicService extends EventEmitter {
     this.orders = [];
     this.user = null;
     this.credentials = null;
+    this.cachedContracts = null; // Cache contracts to avoid repeated API calls
   }
 
   /**
@@ -208,53 +211,282 @@ class RithmicService extends EventEmitter {
   }
 
   /**
-   * Get contracts from Rithmic
-   * TODO: Implement TICKER_PLANT connection to fetch real contracts
-   * For now, returns common futures contracts that are available on Rithmic
+   * Connect to TICKER_PLANT for symbol lookup
+   */
+  async connectTicker(username, password) {
+    try {
+      this.tickerConn = new RithmicConnection();
+      const gateway = this.propfirm.gateway || RITHMIC_ENDPOINTS.CHICAGO;
+
+      const config = {
+        uri: gateway,
+        systemName: this.propfirm.systemName,
+        userId: username,
+        password: password,
+        appName: 'HQX-CLI',
+        appVersion: '1.0.0',
+      };
+
+      await this.tickerConn.connect(config);
+
+      return new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          debug('TICKER_PLANT login timeout');
+          resolve(false);
+        }, 10000);
+
+        this.tickerConn.once('loggedIn', () => {
+          clearTimeout(timeout);
+          debug('TICKER_PLANT connected');
+          resolve(true);
+        });
+
+        this.tickerConn.once('loginFailed', () => {
+          clearTimeout(timeout);
+          debug('TICKER_PLANT login failed');
+          resolve(false);
+        });
+
+        this.tickerConn.login('TICKER_PLANT');
+      });
+    } catch (e) {
+      debug('TICKER_PLANT connection error:', e.message);
+      return false;
+    }
+  }
+
+  /**
+   * Get front month contracts for multiple symbols at once - batch request
+   */
+  async getFrontMonthsBatch(products) {
+    if (!this.tickerConn) {
+      throw new Error('TICKER_PLANT not connected');
+    }
+
+    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);
+          const baseSymbol = decoded.userMsg;
+          
+          if (pending.has(baseSymbol)) {
+            pending.delete(baseSymbol);
+            
+            if (decoded.rpCode[0] === '0' && decoded.tradingSymbol) {
+              results.set(baseSymbol, {
+                symbol: decoded.tradingSymbol,
+                baseSymbol: baseSymbol,
+                exchange: decoded.exchange,
+              });
+            }
+          }
+        }
+      };
+
+      this.tickerConn.on('message', handler);
+
+      // 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 - 100% REAL DATA from Rithmic API
+   * Fetches product codes and front months directly from the API
    */
   async getContracts() {
-    // Calculate current front month dynamically
-    const now = new Date();
-    const month = now.getMonth();
-    const year = now.getFullYear() % 100;
-    
-    // Quarterly months for index futures: H=Mar, M=Jun, U=Sep, Z=Dec
-    const quarterlyMonths = ['H', 'M', 'U', 'Z'];
-    const monthNames = ['Mar', 'Jun', 'Sep', 'Dec'];
-    const quarterIndex = Math.floor(month / 3);
-    
-    // If past 15th of expiry month, use next quarter
-    let frontMonth = quarterlyMonths[quarterIndex];
-    let frontMonthName = monthNames[quarterIndex];
-    let frontYear = year;
-    
-    if (now.getDate() > 15 && [2, 5, 8, 11].includes(month)) {
-      const nextIdx = (quarterIndex + 1) % 4;
-      frontMonth = quarterlyMonths[nextIdx];
-      frontMonthName = monthNames[nextIdx];
-      if (nextIdx === 0) frontYear++;
+    // Return cached if available and fresh (5 min cache)
+    if (this.cachedContracts && this.cachedContracts.timestamp > Date.now() - 300000) {
+      return { success: true, contracts: this.cachedContracts.data, source: 'cache' };
+    }
+
+    // Need credentials to fetch real data
+    if (!this.credentials) {
+      return { success: false, error: 'Not logged in - cannot fetch contracts from API' };
+    }
+
+    try {
+      // Connect to TICKER_PLANT if not connected
+      if (!this.tickerConn) {
+        const connected = await this.connectTicker(this.credentials.username, this.credentials.password);
+        if (!connected) {
+          return { success: false, error: 'Failed to connect to TICKER_PLANT' };
+        }
+      }
+
+      // Increase max listeners to avoid warnings
+      this.tickerConn.setMaxListeners(5000);
+
+      debug('Fetching all tradeable contracts from Rithmic API...');
+      const contracts = await this.fetchAllFrontMonths();
+
+      if (contracts.length === 0) {
+        return { success: false, error: 'No tradeable contracts found' };
+      }
+
+      // Cache the results
+      this.cachedContracts = { data: contracts, timestamp: Date.now() };
+      return { success: true, contracts, source: 'api' };
+
+    } catch (e) {
+      debug('getContracts error:', e.message);
+      return { success: false, error: e.message };
     }
-    
-    const y = frontYear; // e.g., 26 for 2026
-    const fy = `${frontYear}`; // full year string
-    
-    const contracts = [
-      { symbol: `ES${frontMonth}${y}`, name: `E-mini S&P 500 (${frontMonthName} ${fy})`, exchange: 'CME' },
-      { symbol: `NQ${frontMonth}${y}`, name: `E-mini NASDAQ-100 (${frontMonthName} ${fy})`, exchange: 'CME' },
-      { symbol: `MES${frontMonth}${y}`, name: `Micro E-mini S&P 500 (${frontMonthName} ${fy})`, exchange: 'CME' },
-      { symbol: `MNQ${frontMonth}${y}`, name: `Micro E-mini NASDAQ-100 (${frontMonthName} ${fy})`, exchange: 'CME' },
-      { symbol: `RTY${frontMonth}${y}`, name: `E-mini Russell 2000 (${frontMonthName} ${fy})`, exchange: 'CME' },
-      { symbol: `M2K${frontMonth}${y}`, name: `Micro E-mini Russell 2000 (${frontMonthName} ${fy})`, exchange: 'CME' },
-      { symbol: `YM${frontMonth}${y}`, name: `E-mini Dow Jones (${frontMonthName} ${fy})`, exchange: 'CBOT' },
-      { symbol: `MYM${frontMonth}${y}`, name: `Micro E-mini Dow Jones (${frontMonthName} ${fy})`, exchange: 'CBOT' },
-      { symbol: `CL${frontMonth}${y}`, name: `Crude Oil (${frontMonthName} ${fy})`, exchange: 'NYMEX' },
-      { symbol: `MCL${frontMonth}${y}`, name: `Micro Crude Oil (${frontMonthName} ${fy})`, exchange: 'NYMEX' },
-      { symbol: `GC${frontMonth}${y}`, name: `Gold (${frontMonthName} ${fy})`, exchange: 'COMEX' },
-      { symbol: `MGC${frontMonth}${y}`, name: `Micro Gold (${frontMonthName} ${fy})`, exchange: 'COMEX' },
-      { symbol: `SI${frontMonth}${y}`, name: `Silver (${frontMonthName} ${fy})`, exchange: 'COMEX' },
-      { symbol: `NG${frontMonth}${y}`, name: `Natural Gas (${frontMonthName} ${fy})`, exchange: 'NYMEX' },
-    ];
-    return { success: true, contracts };
   }
 
   async searchContracts(searchText) {
@@ -296,6 +528,10 @@ class RithmicService extends EventEmitter {
       await this.pnlConn.disconnect();
       this.pnlConn = null;
     }
+    if (this.tickerConn) {
+      await this.tickerConn.disconnect();
+      this.tickerConn = null;
+    }
     this.accounts = [];
     this.accountPnL.clear();
     this.positions.clear();
@@ -303,6 +539,7 @@ class RithmicService extends EventEmitter {
     this.loginInfo = null;
     this.user = null;
     this.credentials = null;
+    this.cachedContracts = null;
   }
 }
 

package/src/services/rithmic/proto/request_front_month_contract.proto

@@ -0,0 +1,11 @@
+
+package rti;
+
+message RequestFrontMonthContract
+	{
+	required int32  template_id     = 154467;  // Template ID = 113
+	repeated string user_msg        = 132760;  // User message for tracking
+	optional string symbol          = 110100;  // Base symbol (e.g., "MNQ", "ES")
+	optional string exchange        = 110101;  // Exchange (e.g., "CME")
+	optional bool   need_updates    = 154352;  // Request updates
+	}

package/src/services/rithmic/proto/request_product_codes.proto

@@ -0,0 +1,9 @@
+
+package rti;
+
+message RequestProductCodes
+	{
+	required int32  template_id     = 154467;  // Template ID = 111
+	repeated string user_msg        = 132760;  // User message for tracking
+	optional string exchange        = 110101;  // Exchange filter (optional)
+	}

package/src/services/rithmic/proto/response_front_month_contract.proto

@@ -0,0 +1,13 @@
+
+package rti;
+
+message ResponseFrontMonthContract
+	{
+	required int32  template_id     = 154467;  // Template ID = 114
+	repeated string rp_code         = 132766;  // Response code
+	repeated string user_msg        = 132760;  // Echo of user message
+	optional string symbol          = 110100;  // Full contract symbol (e.g., "MNQH5")
+	optional string exchange        = 110101;  // Exchange
+	optional string trading_symbol  = 157095;  // Trading symbol
+	optional string description     = 110114;  // Contract description
+	}

package/src/services/rithmic/proto/response_product_codes.proto

@@ -0,0 +1,12 @@
+
+package rti;
+
+message ResponseProductCodes
+	{
+	required int32  template_id     = 154467;  // Template ID = 112
+	repeated string rp_code         = 132766;  // Response code
+	repeated string user_msg        = 132760;  // Echo of user message
+	optional string exchange        = 110101;  // Exchange
+	optional string product_code    = 110102;  // Product code (e.g., "MNQ", "ES")
+	optional string product_name    = 110103;  // Product name
+	}

package/src/services/rithmic/protobuf.js

@@ -28,6 +28,19 @@ const PNL_FIELDS = {
   USECS: 150101,
 };
 
+// Symbol/Contract field IDs (ResponseProductCodes, ResponseFrontMonthContract)
+const SYMBOL_FIELDS = {
+  TEMPLATE_ID: 154467,
+  RP_CODE: 132766,
+  EXCHANGE: 110101,
+  PRODUCT_CODE: 110102,   // Base symbol (ES, NQ, MNQ)
+  PRODUCT_NAME: 110103,   // Product name
+  SYMBOL: 110100,         // Full contract symbol (ESH26)
+  TRADING_SYMBOL: 157095, // Trading symbol
+  DESCRIPTION: 110114,    // Contract description
+  USER_MSG: 132760,
+};
+
 // Instrument PnL Position Update field IDs
 const INSTRUMENT_PNL_FIELDS = {
   TEMPLATE_ID: 154467,
@@ -377,6 +390,101 @@ class ProtobufHandler {
   }
 }
 
+/**
+ * Decode ResponseProductCodes (template 112) - list of available symbols
+ */
+function decodeProductCodes(buffer) {
+  const result = { rpCode: [] };
+  let offset = 0;
+
+  while (offset < buffer.length) {
+    try {
+      const [tag, tagOffset] = readVarint(buffer, offset);
+      const wireType = tag & 0x7;
+      const fieldNumber = tag >>> 3;
+      offset = tagOffset;
+
+      switch (fieldNumber) {
+        case SYMBOL_FIELDS.TEMPLATE_ID:
+          [result.templateId, offset] = readVarint(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.RP_CODE:
+          let rpCode;
+          [rpCode, offset] = readLengthDelimited(buffer, offset);
+          result.rpCode.push(rpCode);
+          break;
+        case SYMBOL_FIELDS.EXCHANGE:
+          [result.exchange, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.PRODUCT_CODE:
+          [result.productCode, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.PRODUCT_NAME:
+          [result.productName, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.USER_MSG:
+          [result.userMsg, offset] = readLengthDelimited(buffer, offset);
+          break;
+        default:
+          offset = skipField(buffer, offset, wireType);
+      }
+    } catch (error) {
+      break;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Decode ResponseFrontMonthContract (template 114) - current tradeable contract
+ */
+function decodeFrontMonthContract(buffer) {
+  const result = { rpCode: [] };
+  let offset = 0;
+
+  while (offset < buffer.length) {
+    try {
+      const [tag, tagOffset] = readVarint(buffer, offset);
+      const wireType = tag & 0x7;
+      const fieldNumber = tag >>> 3;
+      offset = tagOffset;
+
+      switch (fieldNumber) {
+        case SYMBOL_FIELDS.TEMPLATE_ID:
+          [result.templateId, offset] = readVarint(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.RP_CODE:
+          let rpCode;
+          [rpCode, offset] = readLengthDelimited(buffer, offset);
+          result.rpCode.push(rpCode);
+          break;
+        case SYMBOL_FIELDS.SYMBOL:
+          [result.symbol, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.EXCHANGE:
+          [result.exchange, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.TRADING_SYMBOL:
+          [result.tradingSymbol, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.DESCRIPTION:
+          [result.description, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.USER_MSG:
+          [result.userMsg, offset] = readLengthDelimited(buffer, offset);
+          break;
+        default:
+          offset = skipField(buffer, offset, wireType);
+      }
+    } catch (error) {
+      break;
+    }
+  }
+
+  return result;
+}
+
 // Singleton
 const proto = new ProtobufHandler();
 
@@ -384,6 +492,8 @@ module.exports = {
   proto,
   decodeAccountPnL,
   decodeInstrumentPnL,
+  decodeProductCodes,
+  decodeFrontMonthContract,
   readVarint,
   readLengthDelimited,
   skipField,