hedgequantx 1.8.31 → 1.8.33

package/package.json

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

@@ -196,7 +196,7 @@ const PROPFIRMS = {
     platform: 'Rithmic',
     rithmicSystem: 'Apex',
     wsEndpoint: 'wss://ritpa11120.11.rithmic.com:443',
-    defaultStartingBalance: 300000
+
   },
   topsteptrader: {
     id: 'topsteptrader',

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

@@ -72,7 +72,7 @@ const copyTradingMenu = async () => {
   // Step 1: Select Lead Account
   console.log(chalk.cyan('  Step 1: Select LEAD Account'));
   const leadOptions = allAccounts.map((a, i) => ({
-    label: `${a.propfirm} - ${a.account.accountName || a.account.accountId} ($${a.account.balance.toLocaleString()})`,
+    label: `${a.propfirm} - ${a.account.accountName || a.account.accountId}${a.account.balance !== null ? ` ($${a.account.balance.toLocaleString()})` : ''}`,
     value: i
   }));
   leadOptions.push({ label: '< Cancel', value: -1 });
@@ -88,7 +88,7 @@ const copyTradingMenu = async () => {
     .map((a, i) => ({ a, i }))
     .filter(x => x.i !== leadIdx)
     .map(x => ({
-      label: `${x.a.propfirm} - ${x.a.account.accountName || x.a.account.accountId} ($${x.a.account.balance.toLocaleString()})`,
+      label: `${x.a.propfirm} - ${x.a.account.accountName || x.a.account.accountId}${x.a.account.balance !== null ? ` ($${x.a.account.balance.toLocaleString()})` : ''}`,
       value: x.i
     }));
   followerOptions.push({ label: '< Cancel', value: -1 });

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

@@ -49,7 +49,7 @@ const oneAccountMenu = async (service) => {
   
   // Select account
   const options = activeAccounts.map(acc => ({
-    label: `${acc.accountName || acc.accountId} (${acc.propfirm || 'Unknown'}) - $${(acc.balance || 0).toLocaleString()}`,
+    label: `${acc.accountName || acc.accountId} (${acc.propfirm || 'Unknown'})${acc.balance !== null ? ` - $${acc.balance.toLocaleString()}` : ''}`,
     value: acc
   }));
   options.push({ label: '< Back', value: 'back' });
@@ -183,26 +183,17 @@ const launchAlgo = async (service, account, contract, config) => {
     if (!showName && account.accountName) msg = msg.replace(new RegExp(account.accountName, 'gi'), 'HQX *****');
     ui.addLog(d.type || 'info', msg);
   });
-  hqx.on('signal', (d) => {
-    stats.signals = (stats.signals || 0) + 1;
-    ui.addLog('signal', `${d.side === 'long' ? 'BUY' : 'SELL'} @ ${d.entry?.toFixed(2) || 'MKT'}`);
-  });
-  hqx.on('trade', (d) => {
-    stats.trades++;
-    stats.pnl += d.pnl || 0;
-    if (d.pnl >= 0) { stats.wins++; ui.addLog('trade', `+$${d.pnl.toFixed(2)}`); }
-    else { stats.losses++; ui.addLog('loss', `-$${Math.abs(d.pnl).toFixed(2)}`); }
-    
-    if (stats.pnl >= dailyTarget) {
-      stopReason = 'target'; running = false;
-      ui.addLog('success', `TARGET! +$${stats.pnl.toFixed(2)}`);
-      hqx.stopAlgo();
-    } else if (stats.pnl <= -maxRisk) {
-      stopReason = 'risk'; running = false;
-      ui.addLog('error', `MAX RISK! -$${Math.abs(stats.pnl).toFixed(2)}`);
-      hqx.stopAlgo();
+  
+  // REAL P&L direct from Rithmic - no calculation
+  hqx.on('stats', (d) => {
+    if (d.realTimePnL) {
+      stats.pnl = d.realTimePnL.totalPnL;
     }
+    stats.trades = d.trades;
+    stats.wins = d.wins;
+    stats.losses = d.losses;
   });
+  
   hqx.on('error', (d) => { ui.addLog('error', d.message || 'Error'); });
   hqx.on('disconnected', () => { stats.connected = false; ui.addLog('warning', 'Disconnected'); });
   

package/src/pages/algo/ui.js

@@ -128,8 +128,9 @@ class AlgoUI {
     const { W } = this;
     const isCopyTrading = this.config.mode === 'copy-trading';
     
-    const pnlColor = stats.pnl >= 0 ? chalk.green : chalk.red;
-    const pnlStr = (stats.pnl >= 0 ? '+$' : '-$') + Math.abs(stats.pnl).toFixed(2);
+    const pnl = stats.pnl !== null && stats.pnl !== undefined ? stats.pnl : null;
+    const pnlColor = pnl === null ? chalk.gray : (pnl >= 0 ? chalk.green : chalk.red);
+    const pnlStr = pnl === null ? '--' : ((pnl >= 0 ? '+$' : '-$') + Math.abs(pnl).toFixed(2));
     const latencyColor = stats.latency < 100 ? chalk.green : (stats.latency < 300 ? chalk.yellow : chalk.red);
     const serverColor = stats.connected ? chalk.green : chalk.red;
     
@@ -172,8 +173,10 @@ class AlgoUI {
     this._line(chalk.cyan(GM));
     
     // Row 3: Target | Risk
-    const r3c1 = buildCell('Target', '$' + (stats.target || 0).toFixed(2), chalk.green, colL);
-    const r3c2 = buildCell('Risk', '$' + (stats.risk || 0).toFixed(2), chalk.red, colR);
+    const targetStr = stats.target !== null && stats.target !== undefined ? '$' + stats.target.toFixed(2) : '--';
+    const riskStr = stats.risk !== null && stats.risk !== undefined ? '$' + stats.risk.toFixed(2) : '--';
+    const r3c1 = buildCell('Target', targetStr, chalk.green, colL);
+    const r3c2 = buildCell('Risk', riskStr, chalk.red, colR);
     row(r3c1.padded, r3c2.padded);
     
     this._line(chalk.cyan(GM));

package/src/pages/stats.js

@@ -65,10 +65,9 @@ const showStats = async (service) => {
     return;
   }
 
-  // Collect stats
-  let totalBalance = 0;
-  let totalStartingBalance = 0;
-  let totalPnL = 0;
+  // Collect REAL stats only - no estimation
+  let totalBalance = null;
+  let totalPnL = null;
   let allTrades = [];
   let totalOpenPositions = 0;
   let totalOpenOrders = 0;
@@ -78,27 +77,15 @@ const showStats = async (service) => {
 
   for (const account of activeAccounts) {
     const svc = account.service;
-    const currentBalance = account.balance || 0;
-    totalBalance += currentBalance;
     
-    // Estimate starting balance
-    let startingBalance = account.startingBalance || account.initialBalance || 0;
-    if (!startingBalance) {
-      const name = (account.accountName || '').toUpperCase();
-      if (name.includes('150K') || name.includes('150')) startingBalance = 150000;
-      else if (name.includes('100K') || name.includes('100')) startingBalance = 100000;
-      else if (name.includes('50K') || name.includes('50')) startingBalance = 50000;
-      else if (currentBalance >= 140000) startingBalance = 150000;
-      else if (currentBalance >= 90000) startingBalance = 100000;
-      else if (currentBalance >= 45000) startingBalance = 50000;
-      else startingBalance = currentBalance;
+    // Only add REAL balance from API
+    if (account.balance !== null && account.balance !== undefined) {
+      totalBalance = (totalBalance || 0) + account.balance;
     }
     
-    totalStartingBalance += startingBalance;
-    account.startingBalance = startingBalance;
-    
-    if (account.profitAndLoss !== undefined) {
-      totalPnL += account.profitAndLoss;
+    // Only add REAL P&L from API
+    if (account.profitAndLoss !== null && account.profitAndLoss !== undefined) {
+      totalPnL = (totalPnL || 0) + account.profitAndLoss;
     }
     
     // Positions & Orders
@@ -138,9 +125,7 @@ const showStats = async (service) => {
     }
   }
 
-  if (totalPnL === 0 && totalStartingBalance > 0) {
-    totalPnL = totalBalance - totalStartingBalance;
-  }
+  // NO estimation - only real data from API
 
   // Aggregate stats
   let stats = {

package/src/services/rithmic/accounts.js

@@ -34,6 +34,7 @@ const hashAccountId = (str) => {
  */
 const fetchAccounts = async (service) => {
   if (!service.orderConn || !service.loginInfo) {
+    debug('fetchAccounts: no connection or loginInfo');
     return [];
   }
 
@@ -41,29 +42,39 @@ const fetchAccounts = async (service) => {
     const accounts = [];
     
     const timeout = setTimeout(() => {
+      debug('fetchAccounts: timeout, found', accounts.length, 'accounts');
       service.accounts = accounts;
       resolve(accounts);
-    }, 2000);
+    }, 5000);
 
-    service.once('accountReceived', (account) => {
+    // Listen for ALL accounts (not just once)
+    const onAccount = (account) => {
+      debug('fetchAccounts: received account', account.accountId);
       accounts.push(account);
-    });
+    };
+    service.on('accountReceived', onAccount);
 
     service.once('accountListComplete', () => {
+      debug('fetchAccounts: complete, found', accounts.length, 'accounts');
       clearTimeout(timeout);
+      service.removeListener('accountReceived', onAccount);
       service.accounts = accounts;
       resolve(accounts);
     });
 
     try {
+      debug('fetchAccounts: sending RequestAccountList');
       service.orderConn.send('RequestAccountList', {
         templateId: REQ.ACCOUNT_LIST,
         userMsg: ['HQX'],
         fcmId: service.loginInfo.fcmId,
         ibId: service.loginInfo.ibId,
+        userType: 3, // USER_TYPE_TRADER - required by Rithmic API
       });
     } catch (e) {
+      debug('fetchAccounts: error', e.message);
       clearTimeout(timeout);
+      service.removeListener('accountReceived', onAccount);
       resolve([]);
     }
   });
@@ -98,36 +109,19 @@ const getTradingAccounts = async (service) => {
     debug(`Account ${acc.accountId} pnlData:`, JSON.stringify(pnlData));
     debug(`  accountPnL map size:`, service.accountPnL.size);
     
-    // Use API values if available
-    const accountBalance = parseFloat(pnlData.accountBalance || 0);
-    const openPnL = parseFloat(pnlData.openPositionPnl || 0);
-    const closedPnL = parseFloat(pnlData.closedPositionPnl || 0);
-    const dayPnL = parseFloat(pnlData.dayPnl || 0);
-    
-    // Balance: use API value if > 0, otherwise default
-    // Most prop firms don't report balance via PnL stream, so we use default
-    const startingBalance = service.propfirm.defaultBalance;
-    const balance = accountBalance > 0 ? accountBalance : startingBalance;
-    
-    // P&L: prefer dayPnl from API, otherwise calculate from open+closed
-    let profitAndLoss = 0;
-    if (dayPnL !== 0) {
-      profitAndLoss = dayPnL;
-    } else if (openPnL !== 0 || closedPnL !== 0) {
-      profitAndLoss = openPnL + closedPnL;
-    }
-    // Don't calculate P&L from balance difference - that's estimation
-
-    debug(`  balance: ${balance}, startingBalance: ${startingBalance}, P&L: ${profitAndLoss}`);
+    // REAL DATA FROM RITHMIC ONLY - NO DEFAULTS
+    const accountBalance = pnlData.accountBalance ? parseFloat(pnlData.accountBalance) : null;
+    const openPnL = pnlData.openPositionPnl ? parseFloat(pnlData.openPositionPnl) : null;
+    const closedPnL = pnlData.closedPositionPnl ? parseFloat(pnlData.closedPositionPnl) : null;
+    const dayPnL = pnlData.dayPnl ? parseFloat(pnlData.dayPnl) : null;
 
     return {
       accountId: hashAccountId(acc.accountId),
       rithmicAccountId: acc.accountId,
       accountName: acc.accountName || acc.accountId,
       name: acc.accountName || acc.accountId,
-      balance: balance,
-      startingBalance: startingBalance,
-      profitAndLoss: profitAndLoss,
+      balance: accountBalance,
+      profitAndLoss: dayPnL !== null ? dayPnL : (openPnL !== null || closedPnL !== null ? (openPnL || 0) + (closedPnL || 0) : null),
       openPnL: openPnL,
       todayPnL: closedPnL,
       status: 0,
@@ -136,24 +130,7 @@ const getTradingAccounts = async (service) => {
     };
   });
 
-  // Fallback if no accounts
-  if (tradingAccounts.length === 0 && service.user) {
-    const userName = service.user.userName || 'Unknown';
-    tradingAccounts = [{
-      accountId: hashAccountId(userName),
-      rithmicAccountId: userName,
-      accountName: userName,
-      name: userName,
-      balance: service.propfirm.defaultBalance,
-      startingBalance: service.propfirm.defaultBalance,
-      profitAndLoss: 0,
-      openPnL: 0,
-      todayPnL: 0,
-      status: 0,
-      platform: 'Rithmic',
-      propfirm: service.propfirm.name,
-    }];
-  }
+  // No fallback - only real accounts from Rithmic
 
   return { success: true, accounts: tradingAccounts };
 };

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/handlers.js

@@ -17,12 +17,16 @@ const debug = (...args) => DEBUG && console.log('[Rithmic:Handler]', ...args);
 const createOrderHandler = (service) => {
   return (msg) => {
     const { templateId, data } = msg;
+    
+    debug('ORDER_PLANT message received, templateId:', templateId);
 
     switch (templateId) {
       case RES.LOGIN_INFO:
+        debug('Handling LOGIN_INFO');
         handleLoginInfo(service, data);
         break;
       case RES.ACCOUNT_LIST:
+        debug('Handling ACCOUNT_LIST (303)');
         handleAccountList(service, data);
         break;
       case RES.TRADE_ROUTES:
@@ -93,10 +97,13 @@ const handleLoginInfo = (service, data) => {
  */
 const handleAccountList = (service, data) => {
   try {
+    debug('Decoding ResponseAccountList...');
     const res = proto.decode('ResponseAccountList', data);
+    debug('Decoded account list response:', JSON.stringify(res));
     
     if (res.rpCode?.[0] === '0') {
       // End of list
+      debug('Account list complete signal received');
       service.emit('accountListComplete');
     } else if (res.accountId) {
       const account = {
@@ -106,11 +113,14 @@ const handleAccountList = (service, data) => {
         accountName: res.accountName,
         accountCurrency: res.accountCurrency,
       };
+      debug('Account received:', account.accountId);
       service.accounts.push(account);
       service.emit('accountReceived', account);
+    } else {
+      debug('No accountId and no rpCode[0]=0, raw response:', res);
     }
   } catch (e) {
-    // Ignore decode errors
+    debug('Error decoding account list:', e.message);
   }
 };
 

package/src/services/rithmic/index.js

@@ -9,29 +9,67 @@ 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);
 
-// PropFirm configurations
+// 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', defaultBalance: 300000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'apex_rithmic': { name: 'Apex Trader Funding', systemName: 'Apex', defaultBalance: 300000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'topstep_r': { name: 'Topstep (Rithmic)', systemName: RITHMIC_SYSTEMS.TOPSTEP, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'bulenox_r': { name: 'Bulenox (Rithmic)', systemName: RITHMIC_SYSTEMS.BULENOX, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'earn2trade': { name: 'Earn2Trade', systemName: RITHMIC_SYSTEMS.EARN_2_TRADE, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'mescapital': { name: 'MES Capital', systemName: RITHMIC_SYSTEMS.MES_CAPITAL, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'tradefundrr': { name: 'TradeFundrr', systemName: RITHMIC_SYSTEMS.TRADEFUNDRR, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'thetradingpit': { name: 'The Trading Pit', systemName: RITHMIC_SYSTEMS.THE_TRADING_PIT, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'fundedfutures': { name: 'Funded Futures Network', systemName: RITHMIC_SYSTEMS.FUNDED_FUTURES_NETWORK, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'propshop': { name: 'PropShop Trader', systemName: RITHMIC_SYSTEMS.PROPSHOP_TRADER, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  '4proptrader': { name: '4PropTrader', systemName: RITHMIC_SYSTEMS.FOUR_PROP_TRADER, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'daytraders': { name: 'DayTraders.com', systemName: RITHMIC_SYSTEMS.DAY_TRADERS, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  '10xfutures': { name: '10X Futures', systemName: RITHMIC_SYSTEMS.TEN_X_FUTURES, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'lucidtrading': { name: 'Lucid Trading', systemName: RITHMIC_SYSTEMS.LUCID_TRADING, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'thrivetrading': { name: 'Thrive Trading', systemName: RITHMIC_SYSTEMS.THRIVE_TRADING, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
-  'legendstrading': { name: 'Legends Trading', systemName: RITHMIC_SYSTEMS.LEGENDS_TRADING, defaultBalance: 150000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'apex': { name: 'Apex Trader Funding', systemName: 'Apex', gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'apex_rithmic': { name: 'Apex Trader Funding', systemName: 'Apex', gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'topstep_r': { name: 'Topstep (Rithmic)', systemName: RITHMIC_SYSTEMS.TOPSTEP, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'bulenox_r': { name: 'Bulenox (Rithmic)', systemName: RITHMIC_SYSTEMS.BULENOX, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'earn2trade': { name: 'Earn2Trade', systemName: RITHMIC_SYSTEMS.EARN_2_TRADE, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'mescapital': { name: 'MES Capital', systemName: RITHMIC_SYSTEMS.MES_CAPITAL, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'tradefundrr': { name: 'TradeFundrr', systemName: RITHMIC_SYSTEMS.TRADEFUNDRR, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'thetradingpit': { name: 'The Trading Pit', systemName: RITHMIC_SYSTEMS.THE_TRADING_PIT, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'fundedfutures': { name: 'Funded Futures Network', systemName: RITHMIC_SYSTEMS.FUNDED_FUTURES_NETWORK, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'propshop': { name: 'PropShop Trader', systemName: RITHMIC_SYSTEMS.PROPSHOP_TRADER, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  '4proptrader': { name: '4PropTrader', systemName: RITHMIC_SYSTEMS.FOUR_PROP_TRADER, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'daytraders': { name: 'DayTraders.com', systemName: RITHMIC_SYSTEMS.DAY_TRADERS, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  '10xfutures': { name: '10X Futures', systemName: RITHMIC_SYSTEMS.TEN_X_FUTURES, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'lucidtrading': { name: 'Lucid Trading', systemName: RITHMIC_SYSTEMS.LUCID_TRADING, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'thrivetrading': { name: 'Thrive Trading', systemName: RITHMIC_SYSTEMS.THRIVE_TRADING, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  'legendstrading': { name: 'Legends Trading', systemName: RITHMIC_SYSTEMS.LEGENDS_TRADING, gateway: RITHMIC_ENDPOINTS.CHICAGO },
 };
 
 class RithmicService extends EventEmitter {
@@ -41,11 +79,11 @@ class RithmicService extends EventEmitter {
     this.propfirm = PROPFIRM_CONFIGS[propfirmKey] || { 
       name: propfirmKey, 
       systemName: 'Rithmic Paper Trading', 
-      defaultBalance: 150000, 
       gateway: RITHMIC_ENDPOINTS.PAPER 
     };
     this.orderConn = null;
     this.pnlConn = null;
+    this.tickerConn = null; // TICKER_PLANT for symbol lookup
     this.loginInfo = null;
     this.accounts = [];
     this.accountPnL = new Map();
@@ -53,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
   }
 
   /**
@@ -85,17 +124,15 @@ class RithmicService extends EventEmitter {
           this.loginInfo = data;
           this.user = { userName: username, fcmId: data.fcmId, ibId: data.ibId };
           
-          try { await fetchAccounts(this); } catch (e) {}
-          
-          if (this.accounts.length === 0) {
-            this.accounts = [{
-              accountId: username,
-              accountName: username,
-              fcmId: data.fcmId,
-              ibId: data.ibId,
-            }];
+          try { 
+            await fetchAccounts(this); 
+            debug('Fetched accounts:', this.accounts.map(a => a.accountId));
+          } catch (e) {
+            debug('fetchAccounts error:', e.message);
           }
           
+          // NO FAKE ACCOUNTS - only real from Rithmic API
+          
           this.credentials = { username, password };
           
           debug('Accounts found:', this.accounts.length);
@@ -211,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) {
@@ -299,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();
@@ -306,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,

package/src/services/tradovate/index.js

@@ -34,11 +34,11 @@ class TradovateService extends EventEmitter {
    */
   getPropFirmConfig(key) {
     const propfirms = {
-      'apex_tradovate': { name: 'Apex (Tradovate)', isDemo: false, defaultBalance: 300000 },
-      'takeprofittrader': { name: 'TakeProfitTrader', isDemo: false, defaultBalance: 150000 },
-      'myfundedfutures': { name: 'MyFundedFutures', isDemo: false, defaultBalance: 150000 },
+      'apex_tradovate': { name: 'Apex (Tradovate)', isDemo: false },
+      'takeprofittrader': { name: 'TakeProfitTrader', isDemo: false },
+      'myfundedfutures': { name: 'MyFundedFutures', isDemo: false },
     };
-    return propfirms[key] || { name: key, isDemo: false, defaultBalance: 150000 };
+    return propfirms[key] || { name: key, isDemo: false };
   }
 
   /**