hedgequantx 2.7.10 → 2.7.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.7.10",
+  "version": "2.7.12",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/app.js

@@ -20,6 +20,7 @@ const { algoTradingMenu } = require('./pages/algo');
 
 // Menus
 const { rithmicMenu, dashboardMenu, handleUpdate } = require('./menus');
+const { PROPFIRM_CHOICES } = require('./config');
 
 /** @type {Object|null} */
 let currentService = null;
@@ -177,29 +178,94 @@ const run = async () => {
         await banner();
 
         if (!connections.isConnected()) {
-          // Not connected - show Rithmic menu directly
+          // Not connected - show propfirm selection directly
           const boxWidth = getLogoWidth();
           const innerWidth = boxWidth - 2;
+          const numCols = 3;
+          
+          const propfirms = PROPFIRM_CHOICES;
+          const numbered = propfirms.map((pf, i) => ({ num: i + 1, key: pf.value, name: pf.name }));
+          
+          // Find max name length for alignment
+          const maxNameLen = Math.max(...numbered.map(n => n.name.length));
+          const colWidth = 4 + 1 + maxNameLen + 2; // [##] + space + name + gap
+          const totalContentWidth = numCols * colWidth;
+          const leftMargin = Math.max(2, Math.floor((innerWidth - totalContentWidth) / 2));
           
           console.log(chalk.cyan('╠' + '═'.repeat(innerWidth) + '╣'));
-          console.log(chalk.cyan('║') + chalk.white.bold(centerText('CONNECT TO PROPFIRM', innerWidth)) + chalk.cyan('║'));
-          console.log(chalk.cyan('╠' + '═'.repeat(innerWidth) + '╣'));
-          console.log(chalk.cyan('║') + '  ' + chalk.cyan('[1] Connect') + ' '.repeat(innerWidth - 14) + chalk.cyan('║'));
-          console.log(chalk.cyan('║') + '  ' + chalk.red('[X] Exit') + ' '.repeat(innerWidth - 11) + chalk.cyan('║'));
+          console.log(chalk.cyan('║') + chalk.white.bold(centerText('SELECT PROPFIRM', innerWidth)) + chalk.cyan('║'));
+          console.log(chalk.cyan('║') + ' '.repeat(innerWidth) + chalk.cyan('║'));
+          
+          const rows = Math.ceil(numbered.length / numCols);
+          for (let row = 0; row < rows; row++) {
+            let lineParts = [];
+            for (let col = 0; col < numCols; col++) {
+              const idx = row + col * rows;
+              if (idx < numbered.length) {
+                const item = numbered[idx];
+                const numStr = item.num.toString().padStart(2, ' ');
+                const namePadded = item.name.padEnd(maxNameLen);
+                lineParts.push({ num: `[${numStr}]`, name: namePadded });
+              } else {
+                lineParts.push(null);
+              }
+            }
+            
+            let line = ' '.repeat(leftMargin);
+            for (let i = 0; i < lineParts.length; i++) {
+              if (lineParts[i]) {
+                line += chalk.cyan(lineParts[i].num) + ' ' + chalk.white(lineParts[i].name);
+              } else {
+                line += ' '.repeat(4 + 1 + maxNameLen);
+              }
+              if (i < lineParts.length - 1) line += '  ';
+            }
+            
+            const lineLen = line.replace(/\x1b\[[0-9;]*m/g, '').length;
+            const rightPad = Math.max(0, innerWidth - lineLen);
+            console.log(chalk.cyan('║') + line + ' '.repeat(rightPad) + chalk.cyan('║'));
+          }
+          
+          console.log(chalk.cyan('╠' + '─'.repeat(innerWidth) + '╣'));
+          console.log(chalk.cyan('║') + chalk.red(centerText('[X] Exit', innerWidth)) + chalk.cyan('║'));
           console.log(chalk.cyan('╚' + '═'.repeat(innerWidth) + '╝'));
           
-          const input = await prompts.textInput(chalk.cyan('Select (1/X):'));
+          const input = await prompts.textInput(chalk.cyan('Select number (or X):'));
           
           if (!input || input.toLowerCase() === 'x') {
             console.log(chalk.gray('Goodbye!'));
             process.exit(0);
           }
           
-          if (input === '1') {
-            const service = await rithmicMenu();
-            if (service) {
-              currentService = service;
-              await refreshStats();
+          const action = parseInt(input);
+          if (!isNaN(action) && action >= 1 && action <= numbered.length) {
+            const selectedPropfirm = numbered[action - 1];
+            const { loginPrompt } = require('./menus/connect');
+            const credentials = await loginPrompt(selectedPropfirm.name);
+            
+            if (credentials) {
+              const spinner = ora({ text: 'Connecting to Rithmic...', color: 'yellow' }).start();
+              try {
+                const { RithmicService } = require('./services/rithmic');
+                const service = new RithmicService(selectedPropfirm.key);
+                const result = await service.login(credentials.username, credentials.password);
+                
+                if (result.success) {
+                  spinner.text = 'Fetching accounts...';
+                  const accResult = await service.getTradingAccounts();
+                  connections.add('rithmic', service, service.propfirm.name);
+                  spinner.succeed(`Connected to ${service.propfirm.name} (${accResult.accounts?.length || 0} accounts)`);
+                  currentService = service;
+                  await refreshStats();
+                  await new Promise(r => setTimeout(r, 1500));
+                } else {
+                  spinner.fail(result.error || 'Authentication failed');
+                  await new Promise(r => setTimeout(r, 2000));
+                }
+              } catch (error) {
+                spinner.fail(`Connection error: ${error.message}`);
+                await new Promise(r => setTimeout(r, 2000));
+              }
             }
           }
         } else {

package/src/config/propfirms.js

@@ -10,7 +10,7 @@ const PROPFIRMS = {
   apex_rithmic: {
     id: 'rithmic-apex',
     name: 'Apex',
-    displayName: 'Apex (Rithmic)',
+    displayName: 'Apex',
     platform: 'Rithmic',
     rithmicSystem: 'Apex',
     wsEndpoint: 'wss://ritpa11120.11.rithmic.com:443',
@@ -34,7 +34,7 @@ const PROPFIRMS = {
   bulenox_rithmic: {
     id: 'rithmic-bulenox',
     name: 'Bulenox',
-    displayName: 'Bulenox (Rithmic)',
+    displayName: 'Bulenox',
     platform: 'Rithmic',
     rithmicSystem: 'Bulenox',
     wsEndpoint: 'wss://ritpa11120.11.rithmic.com:443'
@@ -138,11 +138,23 @@ const PROPFIRMS = {
 };
 
 /**
- * PropFirm choices for menus
+ * PropFirm choices for menus (Apex first, 4PropTrader/10XFutures last, then alphabetical)
  */
 const PROPFIRM_CHOICES = Object.entries(PROPFIRMS)
   .map(([key, val]) => ({ name: val.displayName, value: key }))
-  .sort((a, b) => a.name.localeCompare(b.name));
+  .sort((a, b) => {
+    // Apex always first
+    if (a.name === 'Apex') return -1;
+    if (b.name === 'Apex') return 1;
+    // 4PropTrader and 10XFutures always last
+    const lastItems = ['4PropTrader', '10XFutures'];
+    const aIsLast = lastItems.includes(a.name);
+    const bIsLast = lastItems.includes(b.name);
+    if (aIsLast && !bIsLast) return 1;
+    if (!aIsLast && bIsLast) return -1;
+    // Then alphabetical
+    return a.name.localeCompare(b.name);
+  });
 
 /**
  * Gets a PropFirm by key

package/src/menus/connect.js

@@ -70,8 +70,8 @@ const rithmicMenu = async () => {
     console.log(chalk.cyan('║') + line + ' '.repeat(Math.max(0, innerWidth - lineLen)) + chalk.cyan('║'));
   }
   
-  console.log(chalk.cyan('║') + ' '.repeat(innerWidth) + chalk.cyan('║'));
-  console.log(chalk.cyan('║') + '  ' + chalk.red('[X] Back') + ' '.repeat(innerWidth - 10) + chalk.cyan('║'));
+  console.log(chalk.cyan('╠' + '─'.repeat(innerWidth) + '╣'));
+  console.log(chalk.cyan('║') + chalk.red(centerText('[X] Exit', innerWidth)) + chalk.cyan('║'));
   console.log(chalk.cyan('╚' + '═'.repeat(innerWidth) + '╝'));
 
   const input = await prompts.textInput(chalk.cyan('Select number (or X):'));

package/src/pages/stats/display.js

@@ -100,7 +100,7 @@ const renderQuantMetrics = (data) => {
 };
 
 /**
- * Render trades history section
+ * Render trades history section (round-trips)
  */
 const renderTradesHistory = (data) => {
   const { allTrades } = data;
@@ -108,60 +108,73 @@ const renderTradesHistory = (data) => {
   const innerWidth = boxWidth - 2;
   
   console.log();
-  drawBoxHeader('TRADES HISTORY', boxWidth);
+  drawBoxHeader('TRADES HISTORY (Round-Trips)', boxWidth);
   
   const extractSymbol = (contractId) => {
     if (!contractId) return 'N/A';
-    if (contractId.length <= 10) return contractId;
-    return contractId.substring(0, 10);
+    if (contractId.length <= 8) return contractId;
+    return contractId.substring(0, 8);
   };
   
   if (allTrades.length > 0) {
-    const colTime = 10;
-    const colSymbol = 12;
-    const colPrice = 12;
-    const colPnl = 12;
+    const colSymbol = 9;
     const colSide = 6;
-    const separators = 15;
-    const fixedWidth = colTime + colSymbol + colPrice + colPnl + colSide + separators;
-    const colAccount = Math.max(10, innerWidth - fixedWidth);
+    const colQty = 4;
+    const colEntry = 11;
+    const colExit = 11;
+    const colPnl = 10;
+    const separators = 18;
+    const fixedWidth = colSymbol + colSide + colQty + colEntry + colExit + colPnl + separators;
+    const colDate = Math.max(10, innerWidth - fixedWidth);
     
-    const header = ` ${'Time'.padEnd(colTime)}| ${'Symbol'.padEnd(colSymbol)}| ${'Price'.padEnd(colPrice)}| ${'P&L'.padEnd(colPnl)}| ${'Side'.padEnd(colSide)}| ${'Account'.padEnd(colAccount - 2)}`;
+    const header = ` ${'Symbol'.padEnd(colSymbol)}| ${'Side'.padEnd(colSide)}| ${'Qty'.padEnd(colQty)}| ${'Entry'.padEnd(colEntry)}| ${'Exit'.padEnd(colExit)}| ${'P&L'.padEnd(colPnl)}| ${'Date'.padEnd(colDate - 2)}`;
     console.log(chalk.cyan('\u2551') + chalk.white(header) + chalk.cyan('\u2551'));
     console.log(chalk.cyan('\u2551') + chalk.gray('\u2500'.repeat(innerWidth)) + chalk.cyan('\u2551'));
     
-    const recentTrades = allTrades.slice(-10).reverse();
+    // Show most recent trades first (already sorted by exitTime desc)
+    const recentTrades = allTrades.slice(0, 10);
     
     for (const trade of recentTrades) {
-      const timestamp = trade.creationTimestamp || trade.timestamp;
-      const time = timestamp ? new Date(timestamp).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: true }) : '--:--';
-      const symbol = extractSymbol(trade.contractId || trade.symbol);
-      const price = (trade.price || 0).toFixed(2);
-      const pnl = trade.profitAndLoss || trade.pnl || 0;
+      const symbol = extractSymbol(trade.symbol);
+      // Round-trip: side=1 means Long (BUY then SELL), side=2 means Short (SELL then BUY)
+      const side = trade.side === 1 ? 'LONG' : trade.side === 2 ? 'SHORT' : 'N/A';
+      const qty = String(trade.quantity || 1);
+      const entry = (trade.entryPrice || 0).toFixed(2);
+      const exit = (trade.exitPrice || 0).toFixed(2);
+      const pnl = trade.pnl || trade.profitAndLoss || 0;
       const pnlText = pnl >= 0 ? `+$${pnl.toFixed(0)}` : `-$${Math.abs(pnl).toFixed(0)}`;
-      const side = trade.side === 0 ? 'BUY' : trade.side === 1 ? 'SELL' : 'N/A';
-      const accountName = (trade.accountName || 'N/A').substring(0, colAccount - 3);
       
-      const timeStr = time.padEnd(colTime);
+      // Format date from exitDate (YYYYMMDD) or exitTime
+      let dateStr = '--/--';
+      if (trade.exitDate) {
+        const d = trade.exitDate;
+        dateStr = `${d.slice(4,6)}/${d.slice(6,8)}`;
+      } else if (trade.exitTime) {
+        const dt = new Date(trade.exitTime);
+        dateStr = `${(dt.getMonth()+1).toString().padStart(2,'0')}/${dt.getDate().toString().padStart(2,'0')}`;
+      }
+      
       const symbolStr = symbol.padEnd(colSymbol);
-      const priceStr = price.padEnd(colPrice);
-      const pnlStr = pnlText.padEnd(colPnl);
       const sideStr = side.padEnd(colSide);
-      const accountStr = accountName.padEnd(colAccount - 2);
+      const qtyStr = qty.padEnd(colQty);
+      const entryStr = entry.padEnd(colEntry);
+      const exitStr = exit.padEnd(colExit);
+      const pnlStr = pnlText.padEnd(colPnl);
+      const dateStrPad = dateStr.padEnd(colDate - 2);
       
       const pnlColored = pnl >= 0 ? chalk.green(pnlStr) : chalk.red(pnlStr);
-      const sideColored = trade.side === 0 ? chalk.green(sideStr) : chalk.red(sideStr);
+      const sideColored = trade.side === 1 ? chalk.green(sideStr) : chalk.red(sideStr);
       
-      const row = ` ${timeStr}| ${symbolStr}| ${priceStr}| ${pnlColored}| ${sideColored}| ${accountStr}`;
+      const row = ` ${symbolStr}| ${sideColored}| ${qtyStr}| ${entryStr}| ${exitStr}| ${pnlColored}| ${dateStrPad}`;
       console.log(chalk.cyan('\u2551') + row + chalk.cyan('\u2551'));
     }
     
     if (allTrades.length > 10) {
-      const moreMsg = `  ... and ${allTrades.length - 10} more trades`;
+      const moreMsg = `  ... and ${allTrades.length - 10} more round-trips`;
       console.log(chalk.cyan('\u2551') + moreMsg.padEnd(innerWidth) + chalk.cyan('\u2551'));
     }
   } else {
-    const msg = '  No trades found';
+    const msg = '  No round-trip trades found';
     console.log(chalk.cyan('\u2551') + chalk.gray(msg.padEnd(innerWidth)) + chalk.cyan('\u2551'));
   }
   

package/src/pages/stats/metrics.js

@@ -100,17 +100,25 @@ const aggregateStats = (activeAccounts, allTrades) => {
     
     for (const trade of allTrades) {
       const pnl = trade.profitAndLoss || trade.pnl || 0;
-      const size = trade.size || trade.quantity || 1;
+      const size = trade.size || trade.fillSize || trade.quantity || 1;
+      // Rithmic: 1=BUY, 2=SELL. Other APIs: 0=BUY, 1=SELL
       const side = trade.side;
+      const isBuy = side === 0 || side === 1; // 0 or 1 = BUY depending on API
+      const isSell = side === 2 || (side === 1 && trade.connectionType !== 'rithmic'); // 2 = SELL for Rithmic
       
       stats.totalVolume += Math.abs(size);
       
-      if (side === 0) {
+      // For Rithmic: 1=BUY (long), 2=SELL (short)
+      if (side === 1) {
         stats.longTrades++;
         if (pnl > 0) stats.longWins++;
-      } else if (side === 1) {
+      } else if (side === 2) {
         stats.shortTrades++;
         if (pnl > 0) stats.shortWins++;
+      } else if (side === 0) {
+        // Other APIs: 0=BUY
+        stats.longTrades++;
+        if (pnl > 0) stats.longWins++;
       }
       
       if (pnl > 0) {

package/src/services/rithmic/constants.js

@@ -149,6 +149,8 @@ const PROTO_FILES = [
   'response_show_order_history.proto',
   'request_show_order_history_dates.proto',
   'response_show_order_history_dates.proto',
+  'request_show_order_history_summary.proto',
+  'response_show_order_history_summary.proto',
   'request_market_data_update.proto',
   'response_market_data_update.proto',
   'last_trade.proto',

package/src/services/rithmic/index.js

@@ -17,6 +17,7 @@ const {
   getPositions,
 } = require('./accounts');
 const { placeOrder, cancelOrder, getOrders, getOrderHistory, getOrderHistoryDates, getTradeHistoryFull, closePosition } = require('./orders');
+const { fillsToRoundTrips, calculateTradeStats } = require('./trades');
 const { getContracts, searchContracts } = require('./contracts');
 const { TIMEOUTS } = require('../../config/settings');
 const { logger } = require('../../utils/logger');
@@ -242,53 +243,50 @@ class RithmicService extends EventEmitter {
   async getUser() { return this.user; }
   
   /**
-   * Get trade history from Rithmic API
+   * Get trade history from Rithmic API as round-trips
    * @param {string} accountId - Optional account filter
    * @param {number} days - Number of days to look back (default 30)
    */
   async getTradeHistory(accountId, days = 30) {
-    // Fetch from API
+    // Fetch fills from API
     const result = await getTradeHistoryFull(this, days);
     
     if (!result.success) {
       return { success: false, trades: [] };
     }
     
-    let trades = result.trades || [];
+    let fills = result.trades || [];
     
     // Filter by account if specified
     if (accountId) {
-      trades = trades.filter(t => t.accountId === accountId);
+      fills = fills.filter(t => t.accountId === accountId);
     }
     
-    // Add timestamp from fillDate/fillTime if not present
-    trades = trades.map(t => ({
-      ...t,
-      timestamp: t.timestamp || this._parseDateTime(t.fillDate, t.fillTime),
-    }));
+    // Convert fills to round-trips with P&L
+    const roundTrips = fillsToRoundTrips(fills);
     
-    // Sort by timestamp descending (newest first)
-    trades.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
-    
-    return { success: true, trades };
+    return { success: true, trades: roundTrips };
   }
   
   /**
-   * Parse Rithmic date/time to timestamp
-   * @private
+   * Get raw fills (not matched to round-trips)
+   * @param {string} accountId - Optional account filter
+   * @param {number} days - Number of days to look back (default 30)
    */
-  _parseDateTime(dateStr, timeStr) {
-    if (!dateStr) return Date.now();
-    try {
-      // dateStr format: YYYYMMDD, timeStr format: HH:MM:SS
-      const year = dateStr.slice(0, 4);
-      const month = dateStr.slice(4, 6);
-      const day = dateStr.slice(6, 8);
-      const time = timeStr || '00:00:00';
-      return new Date(`${year}-${month}-${day}T${time}Z`).getTime();
-    } catch (e) {
-      return Date.now();
+  async getRawFills(accountId, days = 30) {
+    const result = await getTradeHistoryFull(this, days);
+    
+    if (!result.success) {
+      return { success: false, fills: [] };
+    }
+    
+    let fills = result.trades || [];
+    
+    if (accountId) {
+      fills = fills.filter(t => t.accountId === accountId);
     }
+    
+    return { success: true, fills };
   }
   
   /**
@@ -297,54 +295,12 @@ class RithmicService extends EventEmitter {
   async getLifetimeStats(accountId) {
     const { trades } = await this.getTradeHistory(accountId, 365);
     
-    if (trades.length === 0) {
+    if (!trades || trades.length === 0) {
       return { success: true, stats: null };
     }
     
-    // Calculate stats from trades
-    let totalTrades = trades.length;
-    let winningTrades = 0;
-    let losingTrades = 0;
-    let totalProfit = 0;
-    let totalLoss = 0;
-    let longTrades = 0;
-    let shortTrades = 0;
-    let totalVolume = 0;
-    
-    // Group fills by basketId to calculate P&L per trade
-    const tradeGroups = new Map();
-    for (const trade of trades) {
-      const key = trade.basketId || trade.id;
-      if (!tradeGroups.has(key)) {
-        tradeGroups.set(key, []);
-      }
-      tradeGroups.get(key).push(trade);
-    }
-    
-    for (const [, fills] of tradeGroups) {
-      const firstFill = fills[0];
-      totalVolume += fills.reduce((sum, f) => sum + f.size, 0);
-      
-      if (firstFill.side === 1) longTrades++;
-      else if (firstFill.side === 2) shortTrades++;
-      
-      // P&L calculation requires entry/exit matching which needs position tracking
-      // For now, count trades
-      totalTrades = tradeGroups.size;
-    }
-    
-    const stats = {
-      totalTrades,
-      winningTrades,
-      losingTrades,
-      winRate: totalTrades > 0 ? ((winningTrades / totalTrades) * 100).toFixed(2) : 0,
-      totalProfit,
-      totalLoss,
-      netPnL: totalProfit - totalLoss,
-      longTrades,
-      shortTrades,
-      totalVolume,
-    };
+    // Calculate stats from round-trips
+    const stats = calculateTradeStats(trades);
     
     return { success: true, stats };
   }

package/src/services/rithmic/orders.js

@@ -5,6 +5,9 @@
 
 const { REQ } = require('./constants');
 
+// Debug mode
+const DEBUG = process.env.HQX_DEBUG === '1';
+
 /**
  * Place order via ORDER_PLANT
  * @param {RithmicService} service - The Rithmic service instance
@@ -120,6 +123,7 @@ const getOrders = async (service) => {
 
 /**
  * Get available order history dates
+ * RequestShowOrderHistoryDates (318) does NOT require account_id
  * @param {RithmicService} service - The Rithmic service instance
  * @returns {Promise<{success: boolean, dates: string[]}>}
  */
@@ -128,35 +132,53 @@ const getOrderHistoryDates = async (service) => {
     return { success: false, dates: [] };
   }
 
+  const { proto } = require('./protobuf');
+
   return new Promise((resolve) => {
     const dates = [];
     const timeout = setTimeout(() => {
+      service.orderConn.removeListener('message', handler);
       resolve({ success: true, dates });
     }, 5000);
 
     const handler = (msg) => {
-      if (msg.templateId === 319 && msg.date) {
-        // ResponseShowOrderHistoryDates returns dates array
-        if (Array.isArray(msg.date)) {
-          dates.push(...msg.date);
-        } else {
-          dates.push(msg.date);
+      // msg contains { templateId, data }
+      if (msg.templateId === 319) {
+        try {
+          const res = proto.decode('ResponseShowOrderHistoryDates', msg.data);
+          DEBUG && console.log('[OrderHistory] 319 response:', JSON.stringify(res));
+          
+          // Dates come as repeated string field
+          if (res.date) {
+            const dateList = Array.isArray(res.date) ? res.date : [res.date];
+            for (const d of dateList) {
+              if (d && !dates.includes(d)) {
+                dates.push(d);
+              }
+            }
+          }
+          
+          // Check for completion (rpCode = '0')
+          if (res.rpCode && res.rpCode.length > 0 && res.rpCode[0] === '0') {
+            clearTimeout(timeout);
+            service.orderConn.removeListener('message', handler);
+            resolve({ success: true, dates });
+          }
+        } catch (e) {
+          DEBUG && console.log('[OrderHistory] Error decoding 319:', e.message);
         }
       }
-      if (msg.templateId === 319 && msg.rpCode && msg.rpCode[0] === '0') {
-        clearTimeout(timeout);
-        service.orderConn.removeListener('message', handler);
-        resolve({ success: true, dates });
-      }
     };
 
     service.orderConn.on('message', handler);
 
     try {
+      // Request 318 does NOT need account_id - just template_id and user_msg
       service.orderConn.send('RequestShowOrderHistoryDates', {
         templateId: REQ.SHOW_ORDER_HISTORY_DATES,
         userMsg: ['HQX'],
       });
+      DEBUG && console.log('[OrderHistory] Sent request 318 (ShowOrderHistoryDates)');
     } catch (e) {
       clearTimeout(timeout);
       service.orderConn.removeListener('message', handler);
@@ -166,52 +188,82 @@ const getOrderHistoryDates = async (service) => {
 };
 
 /**
- * Get order history for a specific date
+ * Get order history for a specific date using show_order_history_summary
+ * RequestShowOrderHistorySummary (324) returns ExchangeOrderNotification (352) with is_snapshot=true
  * @param {RithmicService} service - The Rithmic service instance
  * @param {string} date - Date in YYYYMMDD format
  * @returns {Promise<{success: boolean, orders: Array}>}
  */
 const getOrderHistory = async (service, date) => {
-  if (!service.orderConn || !service.loginInfo) {
+  if (!service.orderConn || !service.loginInfo || service.accounts.length === 0) {
     return { success: true, orders: [] };
   }
 
+  const { proto } = require('./protobuf');
   const dateStr = date || new Date().toISOString().slice(0, 10).replace(/-/g, '');
   
   return new Promise((resolve) => {
     const orders = [];
+    let receivedCount = 0;
+    const expectedAccounts = service.accounts.length;
+    const requestId = `HQX-${Date.now()}`;
+    
     const timeout = setTimeout(() => {
       service.orderConn.removeListener('message', handler);
+      DEBUG && console.log(`[OrderHistory] Timeout. Got ${orders.length} orders`);
       resolve({ success: true, orders });
     }, 10000);
 
     const handler = (msg) => {
-      // ExchangeOrderNotification (352) contains order/fill details
-      if (msg.templateId === 352 && msg.data) {
+      // Response comes as template 352 (ExchangeOrderNotification) with is_snapshot=true
+      if (msg.templateId === 352) {
         try {
-          const notification = service.orderConn.proto.decode('ExchangeOrderNotification', msg.data);
-          if (notification && notification.symbol) {
-            orders.push({
-              id: notification.fillId || notification.basketId || `${Date.now()}`,
-              accountId: notification.accountId,
-              symbol: notification.symbol,
-              exchange: notification.exchange || 'CME',
-              side: notification.transactionType, // 1=BUY, 2=SELL
-              quantity: notification.quantity,
-              price: notification.price,
-              fillPrice: notification.fillPrice,
-              fillSize: notification.fillSize,
-              fillTime: notification.fillTime,
-              fillDate: notification.fillDate,
-              avgFillPrice: notification.avgFillPrice,
-              totalFillSize: notification.totalFillSize,
-              status: notification.status,
-              notifyType: notification.notifyType,
-              isSnapshot: notification.isSnapshot,
-            });
+          const notification = proto.decode('ExchangeOrderNotification', msg.data);
+          
+          // Only process snapshot data (historical orders)
+          if (notification.isSnapshot) {
+            DEBUG && console.log('[OrderHistory] 352 snapshot:', notification.symbol, notification.notifyType);
+            
+            if (notification.symbol) {
+              orders.push({
+                id: notification.fillId || notification.basketId || `${Date.now()}-${orders.length}`,
+                accountId: notification.accountId,
+                symbol: notification.symbol,
+                exchange: notification.exchange || 'CME',
+                side: notification.transactionType, // 1=BUY, 2=SELL
+                quantity: parseInt(notification.quantity) || 0,
+                price: parseFloat(notification.price) || 0,
+                fillPrice: parseFloat(notification.fillPrice) || 0,
+                fillSize: parseInt(notification.fillSize) || 0,
+                fillTime: notification.fillTime,
+                fillDate: notification.fillDate,
+                avgFillPrice: parseFloat(notification.avgFillPrice) || 0,
+                totalFillSize: parseInt(notification.totalFillSize) || 0,
+                status: notification.status,
+                notifyType: notification.notifyType,
+                isSnapshot: true,
+              });
+            }
           }
         } catch (e) {
-          // Ignore decode errors
+          DEBUG && console.log('[OrderHistory] Error decoding 352:', e.message);
+        }
+      }
+      
+      // Template 325 signals completion of order history summary
+      if (msg.templateId === 325) {
+        try {
+          const res = proto.decode('ResponseShowOrderHistorySummary', msg.data);
+          DEBUG && console.log('[OrderHistory] 325 response:', JSON.stringify(res));
+          receivedCount++;
+          
+          if (receivedCount >= expectedAccounts) {
+            clearTimeout(timeout);
+            service.orderConn.removeListener('message', handler);
+            resolve({ success: true, orders });
+          }
+        } catch (e) {
+          DEBUG && console.log('[OrderHistory] Error decoding 325:', e.message);
         }
       }
     };
@@ -219,23 +271,18 @@ const getOrderHistory = async (service, date) => {
     service.orderConn.on('message', handler);
 
     try {
+      // Send request 324 for each account
       for (const acc of service.accounts) {
-        service.orderConn.send('RequestShowOrderHistory', {
+        DEBUG && console.log(`[OrderHistory] Sending 324 for account ${acc.accountId}, date ${dateStr}`);
+        service.orderConn.send('RequestShowOrderHistorySummary', {
           templateId: REQ.SHOW_ORDER_HISTORY,
-          userMsg: ['HQX'],
+          userMsg: [requestId],
           fcmId: acc.fcmId || service.loginInfo.fcmId,
           ibId: acc.ibId || service.loginInfo.ibId,
           accountId: acc.accountId,
           date: dateStr,
         });
       }
-      
-      // Wait for responses
-      setTimeout(() => {
-        clearTimeout(timeout);
-        service.orderConn.removeListener('message', handler);
-        resolve({ success: true, orders });
-      }, 5000);
     } catch (e) {
       clearTimeout(timeout);
       service.orderConn.removeListener('message', handler);

package/src/services/rithmic/proto/response_show_order_history_summary.proto

@@ -3,9 +3,9 @@ package rti;
 
 message ResponseShowOrderHistorySummary
 {
-	// Based on async_rithmic proto definitions
-	optional int32        template_id  = 156580;
-	repeated string       user_msg     = 142744;
-	repeated string       rp_code      = 142750;
-	optional int32        fills_collected = 156569;
+	// Field IDs from rundef/async_rithmic (verified Jan 2026)
+	// Same field IDs as other messages (PB_OFFSET = 100000)
+	optional int32        template_id  = 154467;
+	repeated string       user_msg     = 132760;
+	repeated string       rp_code      = 132766;
 }

package/src/services/rithmic/trades.js

@@ -0,0 +1,334 @@
+/**
+ * Rithmic Trades Module
+ * Convert individual fills to round-trip trades with P&L
+ * 
+ * NO MOCK DATA - Only real fills from Rithmic API
+ */
+
+// Tick values for common futures contracts
+const TICK_VALUES = {
+  // E-mini contracts
+  'ES': { tickSize: 0.25, tickValue: 12.50 },
+  'NQ': { tickSize: 0.25, tickValue: 5.00 },
+  'YM': { tickSize: 1.00, tickValue: 5.00 },
+  'RTY': { tickSize: 0.10, tickValue: 5.00 },
+  // Micro contracts
+  'MES': { tickSize: 0.25, tickValue: 1.25 },
+  'MNQ': { tickSize: 0.25, tickValue: 0.50 },
+  'MYM': { tickSize: 1.00, tickValue: 0.50 },
+  'M2K': { tickSize: 0.10, tickValue: 0.50 },
+  // Commodities
+  'CL': { tickSize: 0.01, tickValue: 10.00 },
+  'GC': { tickSize: 0.10, tickValue: 10.00 },
+  'SI': { tickSize: 0.005, tickValue: 25.00 },
+  'NG': { tickSize: 0.001, tickValue: 10.00 },
+  // Bonds
+  'ZB': { tickSize: 0.03125, tickValue: 31.25 },
+  'ZN': { tickSize: 0.015625, tickValue: 15.625 },
+  'ZF': { tickSize: 0.0078125, tickValue: 7.8125 },
+  // Default
+  'DEFAULT': { tickSize: 0.25, tickValue: 1.25 },
+};
+
+/**
+ * Get base symbol from contract (e.g., "MNQH6" -> "MNQ")
+ * @param {string} symbol - Full contract symbol
+ * @returns {string} Base symbol
+ */
+const getBaseSymbol = (symbol) => {
+  if (!symbol) return 'DEFAULT';
+  // Remove month/year suffix (e.g., H6, M5, Z4)
+  const match = symbol.match(/^([A-Z0-9]+?)([FGHJKMNQUVXZ]\d{1,2})?$/i);
+  return match ? match[1].toUpperCase() : symbol.toUpperCase();
+};
+
+/**
+ * Get tick value for a symbol
+ * @param {string} symbol - Contract symbol
+ * @returns {Object} { tickSize, tickValue }
+ */
+const getTickInfo = (symbol) => {
+  const base = getBaseSymbol(symbol);
+  return TICK_VALUES[base] || TICK_VALUES['DEFAULT'];
+};
+
+/**
+ * Calculate P&L for a round-trip trade
+ * @param {number} entryPrice - Entry price
+ * @param {number} exitPrice - Exit price
+ * @param {number} quantity - Number of contracts
+ * @param {number} side - 1=Long (BUY first), 2=Short (SELL first)
+ * @param {string} symbol - Contract symbol
+ * @returns {number} P&L in dollars
+ */
+const calculatePnL = (entryPrice, exitPrice, quantity, side, symbol) => {
+  const { tickSize, tickValue } = getTickInfo(symbol);
+  const priceDiff = side === 1 ? (exitPrice - entryPrice) : (entryPrice - exitPrice);
+  const ticks = priceDiff / tickSize;
+  return ticks * tickValue * quantity;
+};
+
+/**
+ * Convert fills to round-trip trades using FIFO matching
+ * @param {Array} fills - Array of fill objects from Rithmic API
+ * @returns {Array} Array of round-trip trade objects
+ */
+const fillsToRoundTrips = (fills) => {
+  if (!fills || fills.length === 0) return [];
+
+  // Group fills by account and symbol
+  const groups = new Map();
+  
+  for (const fill of fills) {
+    const key = `${fill.accountId}:${fill.symbol}`;
+    if (!groups.has(key)) {
+      groups.set(key, []);
+    }
+    groups.get(key).push({
+      ...fill,
+      size: fill.fillSize || fill.quantity || 1,
+      price: fill.fillPrice || fill.price || 0,
+      side: fill.side || fill.transactionType, // 1=BUY, 2=SELL
+      timestamp: fill.timestamp || parseDateTime(fill.fillDate, fill.fillTime),
+    });
+  }
+
+  const roundTrips = [];
+
+  // Process each symbol group
+  for (const [key, symbolFills] of groups) {
+    // Sort by timestamp ascending (oldest first for FIFO)
+    symbolFills.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+
+    // Position tracking: positive = long, negative = short
+    let position = 0;
+    let openTrades = []; // Stack of open fills for matching
+
+    for (const fill of symbolFills) {
+      const fillSide = fill.side; // 1=BUY, 2=SELL
+      const fillQty = fill.size;
+      const fillPrice = fill.price;
+
+      if (fillSide === 1) {
+        // BUY
+        if (position >= 0) {
+          // Opening or adding to long position
+          openTrades.push({ ...fill, remainingQty: fillQty });
+          position += fillQty;
+        } else {
+          // Closing short position (BUY to cover)
+          let qtyToClose = fillQty;
+          
+          while (qtyToClose > 0 && openTrades.length > 0) {
+            const openTrade = openTrades[0];
+            const closeQty = Math.min(qtyToClose, openTrade.remainingQty);
+            
+            // Create round-trip (short trade)
+            const pnl = calculatePnL(openTrade.price, fillPrice, closeQty, 2, fill.symbol);
+            roundTrips.push({
+              id: `${openTrade.id || openTrade.fillId}-${fill.id || fill.fillId}`,
+              accountId: fill.accountId,
+              symbol: fill.symbol,
+              exchange: fill.exchange,
+              side: 2, // Short
+              quantity: closeQty,
+              entryPrice: openTrade.price,
+              exitPrice: fillPrice,
+              entryTime: openTrade.timestamp,
+              exitTime: fill.timestamp,
+              entryDate: openTrade.fillDate,
+              exitDate: fill.fillDate,
+              pnl: pnl,
+              profitAndLoss: pnl,
+            });
+
+            openTrade.remainingQty -= closeQty;
+            qtyToClose -= closeQty;
+            position += closeQty;
+
+            if (openTrade.remainingQty === 0) {
+              openTrades.shift();
+            }
+          }
+
+          // If still have qty, it's opening a new long
+          if (qtyToClose > 0) {
+            openTrades.push({ ...fill, remainingQty: qtyToClose });
+            position += qtyToClose;
+          }
+        }
+      } else if (fillSide === 2) {
+        // SELL
+        if (position <= 0) {
+          // Opening or adding to short position
+          openTrades.push({ ...fill, remainingQty: fillQty });
+          position -= fillQty;
+        } else {
+          // Closing long position (SELL to close)
+          let qtyToClose = fillQty;
+          
+          while (qtyToClose > 0 && openTrades.length > 0) {
+            const openTrade = openTrades[0];
+            const closeQty = Math.min(qtyToClose, openTrade.remainingQty);
+            
+            // Create round-trip (long trade)
+            const pnl = calculatePnL(openTrade.price, fillPrice, closeQty, 1, fill.symbol);
+            roundTrips.push({
+              id: `${openTrade.id || openTrade.fillId}-${fill.id || fill.fillId}`,
+              accountId: fill.accountId,
+              symbol: fill.symbol,
+              exchange: fill.exchange,
+              side: 1, // Long
+              quantity: closeQty,
+              entryPrice: openTrade.price,
+              exitPrice: fillPrice,
+              entryTime: openTrade.timestamp,
+              exitTime: fill.timestamp,
+              entryDate: openTrade.fillDate,
+              exitDate: fill.fillDate,
+              pnl: pnl,
+              profitAndLoss: pnl,
+            });
+
+            openTrade.remainingQty -= closeQty;
+            qtyToClose -= closeQty;
+            position -= closeQty;
+
+            if (openTrade.remainingQty === 0) {
+              openTrades.shift();
+            }
+          }
+
+          // If still have qty, it's opening a new short
+          if (qtyToClose > 0) {
+            openTrades.push({ ...fill, remainingQty: qtyToClose });
+            position -= qtyToClose;
+          }
+        }
+      }
+    }
+  }
+
+  // Sort round-trips by exit time descending (newest first)
+  roundTrips.sort((a, b) => (b.exitTime || 0) - (a.exitTime || 0));
+
+  return roundTrips;
+};
+
+/**
+ * Parse Rithmic date/time to timestamp
+ * @param {string} dateStr - Date in YYYYMMDD format
+ * @param {string} timeStr - Time in HH:MM:SS format
+ * @returns {number} Unix timestamp in milliseconds
+ */
+const parseDateTime = (dateStr, timeStr) => {
+  if (!dateStr) return Date.now();
+  try {
+    const year = dateStr.slice(0, 4);
+    const month = dateStr.slice(4, 6);
+    const day = dateStr.slice(6, 8);
+    const time = timeStr || '00:00:00';
+    return new Date(`${year}-${month}-${day}T${time}Z`).getTime();
+  } catch (e) {
+    return Date.now();
+  }
+};
+
+/**
+ * Calculate summary statistics from round-trips
+ * @param {Array} roundTrips - Array of round-trip trades
+ * @returns {Object} Summary statistics
+ */
+const calculateTradeStats = (roundTrips) => {
+  if (!roundTrips || roundTrips.length === 0) {
+    return {
+      totalTrades: 0,
+      winningTrades: 0,
+      losingTrades: 0,
+      breakEvenTrades: 0,
+      totalPnL: 0,
+      totalProfit: 0,
+      totalLoss: 0,
+      winRate: 0,
+      avgWin: 0,
+      avgLoss: 0,
+      largestWin: 0,
+      largestLoss: 0,
+      profitFactor: 0,
+      longTrades: 0,
+      shortTrades: 0,
+      longWins: 0,
+      shortWins: 0,
+      totalVolume: 0,
+    };
+  }
+
+  let stats = {
+    totalTrades: roundTrips.length,
+    winningTrades: 0,
+    losingTrades: 0,
+    breakEvenTrades: 0,
+    totalPnL: 0,
+    totalProfit: 0,
+    totalLoss: 0,
+    largestWin: 0,
+    largestLoss: 0,
+    longTrades: 0,
+    shortTrades: 0,
+    longWins: 0,
+    shortWins: 0,
+    totalVolume: 0,
+  };
+
+  for (const trade of roundTrips) {
+    const pnl = trade.pnl || 0;
+    stats.totalPnL += pnl;
+    stats.totalVolume += trade.quantity || 1;
+
+    if (trade.side === 1) {
+      stats.longTrades++;
+      if (pnl > 0) stats.longWins++;
+    } else {
+      stats.shortTrades++;
+      if (pnl > 0) stats.shortWins++;
+    }
+
+    if (pnl > 0) {
+      stats.winningTrades++;
+      stats.totalProfit += pnl;
+      if (pnl > stats.largestWin) stats.largestWin = pnl;
+    } else if (pnl < 0) {
+      stats.losingTrades++;
+      stats.totalLoss += Math.abs(pnl);
+      if (pnl < stats.largestLoss) stats.largestLoss = pnl;
+    } else {
+      stats.breakEvenTrades++;
+    }
+  }
+
+  // Calculate derived metrics
+  stats.winRate = stats.totalTrades > 0 
+    ? (stats.winningTrades / stats.totalTrades) * 100 
+    : 0;
+  stats.avgWin = stats.winningTrades > 0 
+    ? stats.totalProfit / stats.winningTrades 
+    : 0;
+  stats.avgLoss = stats.losingTrades > 0 
+    ? stats.totalLoss / stats.losingTrades 
+    : 0;
+  stats.profitFactor = stats.totalLoss > 0 
+    ? stats.totalProfit / stats.totalLoss 
+    : (stats.totalProfit > 0 ? Infinity : 0);
+
+  return stats;
+};
+
+module.exports = {
+  fillsToRoundTrips,
+  calculateTradeStats,
+  calculatePnL,
+  getTickInfo,
+  getBaseSymbol,
+  parseDateTime,
+  TICK_VALUES,
+};