hedgequantx 1.8.33 → 1.8.35

package/package.json

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

package/src/pages/algo/copy-trading.js

@@ -180,7 +180,7 @@ const getContractsFromAPI = async () => {
 };
 
 /**
- * Symbol selection helper - uses API contracts for all services
+ * Symbol selection helper - grouped by category with indices first
  */
 const selectSymbol = async (service, label) => {
   const spinner = ora({ text: 'Loading symbols...', color: 'yellow' }).start();
@@ -193,6 +193,7 @@ const selectSymbol = async (service, label) => {
     if (!contracts && typeof service.getContracts === 'function') {
       const result = await service.getContracts();
       if (result.success && result.contracts?.length > 0) {
+        // Contracts from Rithmic are already categorized and sorted
         contracts = result.contracts;
       }
     }
@@ -203,23 +204,36 @@ const selectSymbol = async (service, label) => {
       return null;
     }
     
-    // Sort: Popular indices first (ES, NQ, YM, RTY, MES, MNQ)
-    const prioritySymbols = ['ES', 'NQ', 'YM', 'RTY', 'MES', 'MNQ', 'MYM', 'M2K', 'NKD', 'CL', 'GC'];
-    contracts.sort((a, b) => {
-      const aSymbol = (a.symbol || a.name || '').toUpperCase();
-      const bSymbol = (b.symbol || b.name || '').toUpperCase();
-      const aIdx = prioritySymbols.findIndex(p => aSymbol.startsWith(p));
-      const bIdx = prioritySymbols.findIndex(p => bSymbol.startsWith(p));
-      if (aIdx !== -1 && bIdx !== -1) return aIdx - bIdx;
-      if (aIdx !== -1) return -1;
-      if (bIdx !== -1) return 1;
-      return (a.name || '').localeCompare(b.name || '');
-    });
-    
     spinner.succeed(`Found ${contracts.length} contracts`);
     
-    const options = contracts.map(c => ({ label: c.name || c.symbol, value: c }));
-    options.push({ label: '< Cancel', value: null });
+    // Build options with category headers (if contracts have category info)
+    const options = [];
+    let currentCategory = null;
+    
+    for (const c of contracts) {
+      // Add category header when category changes (if available)
+      if (c.categoryName && c.categoryName !== currentCategory) {
+        currentCategory = c.categoryName;
+        options.push({ 
+          label: chalk.cyan.bold(`── ${currentCategory} ──`), 
+          value: null, 
+          disabled: true 
+        });
+      }
+      
+      // Format label based on available data
+      const symbolDisplay = c.symbol || c.name;
+      const nameDisplay = c.name || c.symbol;
+      const exchangeDisplay = c.exchange ? ` (${c.exchange})` : '';
+      const label = c.categoryName 
+        ? `  ${symbolDisplay} - ${nameDisplay}${exchangeDisplay}`
+        : `${nameDisplay}${exchangeDisplay}`;
+      
+      options.push({ label, value: c });
+    }
+    
+    options.push({ label: '', value: null, disabled: true }); // Spacer
+    options.push({ label: chalk.gray('< Cancel'), value: null });
     
     return await prompts.selectOption(`${label} Symbol:`, options);
   } catch (e) {

package/src/pages/algo/one-account.js

@@ -72,7 +72,7 @@ const oneAccountMenu = async (service) => {
 };
 
 /**
- * Symbol selection - same as copy-trading
+ * Symbol selection - grouped by category with indices first
  */
 const selectSymbol = async (service, account) => {
   const spinner = ora({ text: 'Loading symbols...', color: 'yellow' }).start();
@@ -83,33 +83,36 @@ const selectSymbol = async (service, account) => {
     return null;
   }
   
-  // Normalize contract structure - API returns { name: "ESH6", description: "E-mini S&P 500..." }
-  const contracts = contractsResult.contracts.map(c => ({
-    ...c,
-    symbol: c.name || c.symbol,
-    name: c.description || c.name || c.symbol
-  }));
-  
-  // Sort: Popular indices first (ES, NQ, YM, RTY, MES, MNQ)
-  const prioritySymbols = ['ES', 'NQ', 'YM', 'RTY', 'MES', 'MNQ', 'MYM', 'M2K', 'NKD', 'CL', 'GC'];
-  contracts.sort((a, b) => {
-    const aSymbol = (a.symbol || '').toUpperCase();
-    const bSymbol = (b.symbol || '').toUpperCase();
-    const aIdx = prioritySymbols.findIndex(p => aSymbol.startsWith(p));
-    const bIdx = prioritySymbols.findIndex(p => bSymbol.startsWith(p));
-    if (aIdx !== -1 && bIdx !== -1) return aIdx - bIdx;
-    if (aIdx !== -1) return -1;
-    if (bIdx !== -1) return 1;
-    return (a.name || '').localeCompare(b.name || '');
-  });
+  // Contracts are already sorted by category from getContracts()
+  const contracts = contractsResult.contracts;
   
   spinner.succeed(`Found ${contracts.length} contracts`);
   
-  const options = contracts.map(c => ({ label: c.name, value: c }));
-  options.push({ label: '< Back', value: 'back' });
+  // Build options with category headers
+  const options = [];
+  let currentCategory = null;
+  
+  for (const c of contracts) {
+    // Add category header when category changes
+    if (c.categoryName !== currentCategory) {
+      currentCategory = c.categoryName;
+      options.push({ 
+        label: chalk.cyan.bold(`── ${currentCategory} ──`), 
+        value: null, 
+        disabled: true 
+      });
+    }
+    
+    // Format: "ESH6 - E-mini S&P 500 (CME)"
+    const label = `  ${c.symbol} - ${c.name} (${c.exchange})`;
+    options.push({ label, value: c });
+  }
+  
+  options.push({ label: '', value: null, disabled: true }); // Spacer
+  options.push({ label: chalk.gray('< Back'), value: 'back' });
   
   const contract = await prompts.selectOption(chalk.yellow('Select Symbol:'), options);
-  return contract === 'back' ? null : contract;
+  return contract === 'back' || contract === null ? null : contract;
 };
 
 /**

package/src/services/rithmic/constants.js

@@ -165,6 +165,155 @@ const PROTO_FILES = [
   'response_front_month_contract.proto',
 ];
 
+// Symbol Categories - Order matters for display (indices first)
+const SYMBOL_CATEGORIES = {
+  INDICES: {
+    name: 'Indices',
+    order: 1,
+    symbols: {
+      // E-mini Indices
+      'ES': { name: 'E-mini S&P 500', tickSize: 0.25, tickValue: 12.50 },
+      'NQ': { name: 'E-mini Nasdaq-100', tickSize: 0.25, tickValue: 5.00 },
+      'YM': { name: 'E-mini Dow Jones', tickSize: 1.00, tickValue: 5.00 },
+      'RTY': { name: 'E-mini Russell 2000', tickSize: 0.10, tickValue: 5.00 },
+      'EMD': { name: 'E-mini S&P MidCap 400', tickSize: 0.10, tickValue: 10.00 },
+      // Micro Indices
+      'MES': { name: 'Micro E-mini S&P 500', tickSize: 0.25, tickValue: 1.25 },
+      'MNQ': { name: 'Micro E-mini Nasdaq-100', tickSize: 0.25, tickValue: 0.50 },
+      'MYM': { name: 'Micro E-mini Dow Jones', tickSize: 1.00, tickValue: 0.50 },
+      'M2K': { name: 'Micro E-mini Russell 2000', tickSize: 0.10, tickValue: 0.50 },
+      // International Indices
+      'NKD': { name: 'Nikkei 225 (USD)', tickSize: 5.00, tickValue: 25.00 },
+    }
+  },
+  ENERGY: {
+    name: 'Energy',
+    order: 2,
+    symbols: {
+      'CL': { name: 'Crude Oil WTI', tickSize: 0.01, tickValue: 10.00 },
+      'MCL': { name: 'Micro Crude Oil WTI', tickSize: 0.01, tickValue: 1.00 },
+      'BZ': { name: 'Brent Crude Oil', tickSize: 0.01, tickValue: 10.00 },
+      'NG': { name: 'Natural Gas', tickSize: 0.001, tickValue: 10.00 },
+      'HO': { name: 'Heating Oil', tickSize: 0.0001, tickValue: 4.20 },
+      'RB': { name: 'RBOB Gasoline', tickSize: 0.0001, tickValue: 4.20 },
+    }
+  },
+  METALS: {
+    name: 'Metals',
+    order: 3,
+    symbols: {
+      'GC': { name: 'Gold', tickSize: 0.10, tickValue: 10.00 },
+      'MGC': { name: 'Micro Gold', tickSize: 0.10, tickValue: 1.00 },
+      '1OZ': { name: '1 Ounce Gold', tickSize: 0.25, tickValue: 0.25 },
+      'SI': { name: 'Silver', tickSize: 0.005, tickValue: 25.00 },
+      'SIL': { name: 'Silver 1000oz', tickSize: 0.005, tickValue: 5.00 },
+      'HG': { name: 'Copper', tickSize: 0.0005, tickValue: 12.50 },
+      'MHG': { name: 'Micro Copper', tickSize: 0.0005, tickValue: 1.25 },
+      'PL': { name: 'Platinum', tickSize: 0.10, tickValue: 5.00 },
+      'PA': { name: 'Palladium', tickSize: 0.10, tickValue: 10.00 },
+    }
+  },
+  CURRENCIES: {
+    name: 'Currencies (FX)',
+    order: 4,
+    symbols: {
+      '6E': { name: 'Euro FX', tickSize: 0.00005, tickValue: 6.25 },
+      'M6E': { name: 'Micro Euro FX', tickSize: 0.0001, tickValue: 1.25 },
+      '6B': { name: 'British Pound', tickSize: 0.0001, tickValue: 6.25 },
+      'M6B': { name: 'Micro British Pound', tickSize: 0.0001, tickValue: 0.625 },
+      '6J': { name: 'Japanese Yen', tickSize: 0.0000005, tickValue: 6.25 },
+      '6A': { name: 'Australian Dollar', tickSize: 0.0001, tickValue: 10.00 },
+      'M6A': { name: 'Micro Australian Dollar', tickSize: 0.0001, tickValue: 1.00 },
+      '6C': { name: 'Canadian Dollar', tickSize: 0.00005, tickValue: 5.00 },
+      '6S': { name: 'Swiss Franc', tickSize: 0.0001, tickValue: 12.50 },
+      '6N': { name: 'New Zealand Dollar', tickSize: 0.0001, tickValue: 10.00 },
+      '6M': { name: 'Mexican Peso', tickSize: 0.00001, tickValue: 5.00 },
+      'E7': { name: 'E-mini Euro FX', tickSize: 0.0001, tickValue: 6.25 },
+      'RF': { name: 'Euro FX/Swiss Franc', tickSize: 0.0001, tickValue: 12.50 },
+      'RP': { name: 'Euro FX/British Pound', tickSize: 0.00005, tickValue: 6.25 },
+      'RY': { name: 'Euro FX/Japanese Yen', tickSize: 0.01, tickValue: 6.25 },
+      'SEK': { name: 'Swedish Krona', tickSize: 0.00001, tickValue: 12.50 },
+    }
+  },
+  CRYPTO: {
+    name: 'Crypto',
+    order: 5,
+    symbols: {
+      'BTC': { name: 'Bitcoin', tickSize: 5.00, tickValue: 25.00 },
+      'MBT': { name: 'Micro Bitcoin', tickSize: 5.00, tickValue: 0.50 },
+      'ETH': { name: 'Ether', tickSize: 0.25, tickValue: 12.50 },
+      'MET': { name: 'Micro Ether', tickSize: 0.05, tickValue: 0.25 },
+    }
+  },
+  RATES: {
+    name: 'Interest Rates',
+    order: 6,
+    symbols: {
+      'ZB': { name: '30-Year T-Bond', tickSize: 0.03125, tickValue: 31.25 },
+      'ZN': { name: '10-Year T-Note', tickSize: 0.015625, tickValue: 15.625 },
+      'ZF': { name: '5-Year T-Note', tickSize: 0.0078125, tickValue: 7.8125 },
+      'ZT': { name: '2-Year T-Note', tickSize: 0.0078125, tickValue: 15.625 },
+      'TN': { name: 'Ultra 10-Year T-Note', tickSize: 0.015625, tickValue: 15.625 },
+      'ZQ': { name: '30-Day Fed Funds', tickSize: 0.0025, tickValue: 10.4167 },
+    }
+  },
+  AGRICULTURE: {
+    name: 'Agriculture',
+    order: 7,
+    symbols: {
+      'ZC': { name: 'Corn', tickSize: 0.25, tickValue: 12.50 },
+      'ZS': { name: 'Soybeans', tickSize: 0.25, tickValue: 12.50 },
+      'ZW': { name: 'Wheat', tickSize: 0.25, tickValue: 12.50 },
+      'ZL': { name: 'Soybean Oil', tickSize: 0.01, tickValue: 6.00 },
+      'ZM': { name: 'Soybean Meal', tickSize: 0.10, tickValue: 10.00 },
+      'ZO': { name: 'Oats', tickSize: 0.25, tickValue: 12.50 },
+    }
+  },
+  MEATS: {
+    name: 'Meats',
+    order: 8,
+    symbols: {
+      'LE': { name: 'Live Cattle', tickSize: 0.025, tickValue: 10.00 },
+      'HE': { name: 'Lean Hogs', tickSize: 0.025, tickValue: 10.00 },
+      'GF': { name: 'Feeder Cattle', tickSize: 0.025, tickValue: 12.50 },
+    }
+  },
+};
+
+/**
+ * Get symbol info (category, name, tick info)
+ */
+function getSymbolInfo(baseSymbol) {
+  for (const [catKey, category] of Object.entries(SYMBOL_CATEGORIES)) {
+    if (category.symbols[baseSymbol]) {
+      return {
+        category: catKey,
+        categoryName: category.name,
+        categoryOrder: category.order,
+        ...category.symbols[baseSymbol]
+      };
+    }
+  }
+  // Unknown symbol
+  return {
+    category: 'OTHER',
+    categoryName: 'Other',
+    categoryOrder: 99,
+    name: baseSymbol,
+    tickSize: null,
+    tickValue: null
+  };
+}
+
+/**
+ * Get all categories in display order
+ */
+function getCategoryOrder() {
+  return Object.entries(SYMBOL_CATEGORIES)
+    .sort((a, b) => a[1].order - b[1].order)
+    .map(([key, val]) => ({ key, name: val.name, order: val.order }));
+}
+
 module.exports = {
   RITHMIC_ENDPOINTS,
   RITHMIC_SYSTEMS,
@@ -173,4 +322,7 @@ module.exports = {
   RES,
   STREAM,
   PROTO_FILES,
+  SYMBOL_CATEGORIES,
+  getSymbolInfo,
+  getCategoryOrder,
 };

package/src/services/rithmic/index.js

@@ -5,53 +5,16 @@
 
 const EventEmitter = require('events');
 const { RithmicConnection } = require('./connection');
-const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS } = require('./constants');
+const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS, getSymbolInfo, getCategoryOrder } = 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,181 @@ 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 and add category info
+          const results = [];
+          for (const [baseSymbol, contract] of contracts) {
+            const productKey = `${baseSymbol}:${contract.exchange}`;
+            const product = productsToCheck.get(productKey);
+            const symbolInfo = getSymbolInfo(baseSymbol);
+            
+            results.push({
+              symbol: contract.symbol,
+              baseSymbol: baseSymbol,
+              name: symbolInfo.name || product?.productName || baseSymbol,
+              exchange: contract.exchange,
+              category: symbolInfo.category,
+              categoryName: symbolInfo.categoryName,
+              categoryOrder: symbolInfo.categoryOrder,
+              tickSize: symbolInfo.tickSize,
+              tickValue: symbolInfo.tickValue,
+            });
+          }
+
+          // Sort by category order, then by symbol name within category
+          results.sort((a, b) => {
+            if (a.categoryOrder !== b.categoryOrder) {
+              return a.categoryOrder - b.categoryOrder;
+            }
+            return a.baseSymbol.localeCompare(b.baseSymbol);
+          });
+
+          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 +484,14 @@ class RithmicService extends EventEmitter {
         }
       }
 
-      const contracts = [];
-      const allSymbols = [...BASE_SYMBOLS.quarterly, ...BASE_SYMBOLS.monthly];
-      
-      debug(`Fetching front months for ${allSymbols.length} symbols...`);
+      // Increase max listeners to avoid warnings
+      this.tickerConn.setMaxListeners(5000);
 
-      // 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));
-      }
+      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

package/src/utils/prompts.js

@@ -126,6 +126,7 @@ const numberInput = async (message, defaultVal = 1, min = 1, max = 1000) => {
 
 /**
  * Select - arrow keys navigation
+ * Supports disabled options (separators) via opt.disabled
  */
 const selectOption = async (message, options) => {
   // Close shared readline before inquirer to avoid conflicts
@@ -135,10 +136,16 @@ const selectOption = async (message, options) => {
   }
   prepareStdin();
   
-  const choices = options.map(opt => ({
-    name: opt.label,
-    value: opt.value
-  }));
+  const choices = options.map(opt => {
+    if (opt.disabled) {
+      // Use inquirer Separator for disabled items (category headers)
+      return new inquirer.Separator(opt.label);
+    }
+    return {
+      name: opt.label,
+      value: opt.value
+    };
+  });
   
   const { value } = await inquirer.prompt([{
     type: 'list',
@@ -147,7 +154,7 @@ const selectOption = async (message, options) => {
     choices,
     prefix: '',
     loop: false,
-    pageSize: 15
+    pageSize: 20  // Increased to show more symbols
   }]);
   
   return value;