hedgequantx 1.8.32 → 1.8.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "1.8.32",
+  "version": "1.8.33",
   "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,11 +9,49 @@ 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');
 
 // 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 },
@@ -45,6 +83,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 +91,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 +248,165 @@ 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 contract from Rithmic API
+   */
+  async getFrontMonth(baseSymbol, exchange) {
+    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');
+      }
+    }
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Timeout getting front month for ${baseSymbol}`));
+      }, 10000);
+
+      const handler = (msg) => {
+        if (msg.templateId === 114) {  // ResponseFrontMonthContract
+          const decoded = decodeFrontMonthContract(msg.data);
+          if (decoded.userMsg === baseSymbol) {
+            clearTimeout(timeout);
+            this.tickerConn.removeListener('message', handler);
+            
+            if (decoded.rpCode[0] === '0') {
+              resolve({
+                baseSymbol: baseSymbol,
+                symbol: decoded.tradingSymbol || decoded.symbol,
+                exchange: decoded.exchange || exchange,
+              });
+            } else {
+              reject(new Error(`API error for ${baseSymbol}: ${decoded.rpCode.join(' ')}`));
+            }
+          }
+        }
+      };
+
+      this.tickerConn.on('message', handler);
+
+      // Send RequestFrontMonthContract (template 113)
+      this.tickerConn.send('RequestFrontMonthContract', {
+        templateId: 113,
+        userMsg: [baseSymbol],
+        symbol: baseSymbol,
+        exchange: exchange,
+      });
+    });
+  }
+
+  /**
+   * Get all available contracts - REAL DATA from Rithmic 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' };
+        }
+      }
+
+      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;
+          }
+        });
+
+        const results = await Promise.all(promises);
+        contracts.push(...results.filter(r => r !== null));
+      }
+
+      if (contracts.length === 0) {
+        return { success: false, error: 'No contracts returned from API' };
+      }
+
+      // 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 +448,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 +459,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,