hedgequantx 1.3.5 → 1.3.7

package/package.json

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

package/src/pages/accounts.js

@@ -80,12 +80,14 @@ const showAccounts = async (service) => {
     const pf2 = acc2 ? chalk.magenta(acc2.propfirm || 'Unknown') : '';
     console.log(chalk.cyan('║') + fmtRow('PropFirm:', pf1, col1) + chalk.cyan('│') + (acc2 ? fmtRow('PropFirm:', pf2, col2) : ' '.repeat(col2)) + chalk.cyan('║'));
 
-    // Balance
-    const bal1 = acc1.balance || 0;
-    const bal2 = acc2 ? (acc2.balance || 0) : 0;
-    const balColor1 = bal1 >= 0 ? chalk.green : chalk.red;
-    const balColor2 = bal2 >= 0 ? chalk.green : chalk.red;
-    console.log(chalk.cyan('║') + fmtRow('Balance:', balColor1('$' + bal1.toLocaleString()), col1) + chalk.cyan('│') + (acc2 ? fmtRow('Balance:', balColor2('$' + bal2.toLocaleString()), col2) : ' '.repeat(col2)) + chalk.cyan('║'));
+    // Balance - show '--' if null (not available from API)
+    const bal1 = acc1.balance;
+    const bal2 = acc2 ? acc2.balance : null;
+    const balStr1 = bal1 !== null && bal1 !== undefined ? '$' + bal1.toLocaleString() : '--';
+    const balStr2 = bal2 !== null && bal2 !== undefined ? '$' + bal2.toLocaleString() : '--';
+    const balColor1 = bal1 === null ? chalk.gray : (bal1 >= 0 ? chalk.green : chalk.red);
+    const balColor2 = bal2 === null ? chalk.gray : (bal2 >= 0 ? chalk.green : chalk.red);
+    console.log(chalk.cyan('║') + fmtRow('Balance:', balColor1(balStr1), col1) + chalk.cyan('│') + (acc2 ? fmtRow('Balance:', balColor2(balStr2), col2) : ' '.repeat(col2)) + chalk.cyan('║'));
 
     // Status
     const status1 = ACCOUNT_STATUS[acc1.status] || { text: 'Unknown', color: 'gray' };

package/src/services/rithmic/accounts.js

@@ -2,12 +2,16 @@
  * Rithmic Accounts Module
  * Account fetching, PnL, and positions
  * 
- * STRICT RULE: Display ONLY values returned by API. No estimation, no simulation.
+ * P&L Data Sources:
+ * - accountBalance: from PNL_PLANT API
+ * - openPositionPnl: unrealized P&L from API
+ * - closedPositionPnl: realized P&L from API
+ * - dayPnl: total day P&L from API
  */
 
 const { REQ } = require('./constants');
 
-// Debug mode - set HQX_DEBUG=1 to enable
+// Debug mode
 const DEBUG = process.env.HQX_DEBUG === '1';
 const debug = (...args) => DEBUG && console.log('[Rithmic]', ...args);
 
@@ -66,87 +70,89 @@ const fetchAccounts = async (service) => {
 };
 
 /**
- * Get trading accounts - ONLY returns values from API
- * No estimation, no simulation
- * 
+ * Get trading accounts with P&L data from API
  * @param {RithmicService} service - The Rithmic service instance
  */
 const getTradingAccounts = async (service) => {
+  debug('getTradingAccounts called');
+  
   // Fetch accounts if not already loaded
   if (service.accounts.length === 0 && service.orderConn && service.loginInfo) {
     try {
       await fetchAccounts(service);
+      debug('Accounts fetched:', service.accounts.length);
     } catch (e) {
-      // Ignore fetch errors
+      debug('Failed to fetch accounts:', e.message);
     }
   }
 
-  // Request fresh P&L data from API
+  // Request fresh P&L data if PnL connection exists
   if (service.pnlConn && service.accounts.length > 0) {
+    debug('Requesting P&L snapshot...');
     await requestPnLSnapshot(service);
   }
 
-  const tradingAccounts = service.accounts.map((acc) => {
-    // Get P&L data from API (stored in accountPnL map from handlers.js)
-    const pnlData = service.accountPnL.get(acc.accountId);
+  let tradingAccounts = service.accounts.map((acc) => {
+    // Get P&L data from accountPnL map (populated by PNL_PLANT messages)
+    const pnlData = service.accountPnL.get(acc.accountId) || {};
+    debug(`Account ${acc.accountId} pnlData:`, JSON.stringify(pnlData));
+    debug(`  accountPnL map size:`, service.accountPnL.size);
     
-    // ONLY use values that came from API - null if not available
-    let balance = null;
-    let todayPnL = null;
-    let openPnL = null;
-    let closedPnL = null;
+    // 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);
     
-    if (pnlData) {
-      // These values come directly from Rithmic API via handleAccountPnLUpdate
-      balance = pnlData.accountBalance !== undefined ? pnlData.accountBalance : null;
-      openPnL = pnlData.openPositionPnl !== undefined ? pnlData.openPositionPnl : null;
-      closedPnL = pnlData.closedPositionPnl !== undefined ? pnlData.closedPositionPnl : null;
-      todayPnL = pnlData.dayPnl !== undefined ? pnlData.dayPnl : null;
+    // 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
 
-    // Total P&L from API only
-    let profitAndLoss = null;
-    if (todayPnL !== null) {
-      profitAndLoss = todayPnL;
-    } else if (openPnL !== null || closedPnL !== null) {
-      profitAndLoss = (openPnL || 0) + (closedPnL || 0);
-    }
+    debug(`  balance: ${balance}, startingBalance: ${startingBalance}, P&L: ${profitAndLoss}`);
 
     return {
       accountId: hashAccountId(acc.accountId),
       rithmicAccountId: acc.accountId,
       accountName: acc.accountName || acc.accountId,
       name: acc.accountName || acc.accountId,
-      // From API only - null if not available
       balance: balance,
-      todayPnL: closedPnL,      // Realized P&L from API
-      openPnL: openPnL,         // Unrealized P&L from API  
+      startingBalance: startingBalance,
       profitAndLoss: profitAndLoss,
-      // No estimation - these are null
-      startingBalance: null,
+      openPnL: openPnL,
+      todayPnL: closedPnL,
       status: 0,
       platform: 'Rithmic',
       propfirm: service.propfirm.name,
     };
   });
 
-  // Fallback if no accounts found
+  // Fallback if no accounts
   if (tradingAccounts.length === 0 && service.user) {
     const userName = service.user.userName || 'Unknown';
-    tradingAccounts.push({
+    tradingAccounts = [{
       accountId: hashAccountId(userName),
       rithmicAccountId: userName,
       accountName: userName,
       name: userName,
-      balance: null,
-      startingBalance: null,
-      todayPnL: null,
-      openPnL: null,
-      profitAndLoss: null,
+      balance: service.propfirm.defaultBalance,
+      startingBalance: service.propfirm.defaultBalance,
+      profitAndLoss: 0,
+      openPnL: 0,
+      todayPnL: 0,
       status: 0,
       platform: 'Rithmic',
       propfirm: service.propfirm.name,
-    });
+    }];
   }
 
   return { success: true, accounts: tradingAccounts };
@@ -157,8 +163,13 @@ const getTradingAccounts = async (service) => {
  * @param {RithmicService} service - The Rithmic service instance
  */
 const requestPnLSnapshot = async (service) => {
-  if (!service.pnlConn || !service.loginInfo) return;
+  if (!service.pnlConn || !service.loginInfo) {
+    debug('Cannot request P&L - no pnlConn or loginInfo');
+    return;
+  }
 
+  debug('Requesting P&L for', service.accounts.length, 'accounts');
+  
   for (const acc of service.accounts) {
     service.pnlConn.send('RequestPnLPositionSnapshot', {
       templateId: REQ.PNL_POSITION_SNAPSHOT,
@@ -169,8 +180,9 @@ const requestPnLSnapshot = async (service) => {
     });
   }
 
-  // Wait for P&L data to arrive
-  await new Promise(resolve => setTimeout(resolve, 1500));
+  // Wait for responses
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  debug('P&L snapshot complete, accountPnL size:', service.accountPnL.size);
 };
 
 /**
@@ -193,11 +205,11 @@ const subscribePnLUpdates = (service) => {
 };
 
 /**
- * Get positions - ONLY returns values from API
+ * Get positions
  * @param {RithmicService} service - The Rithmic service instance
  */
 const getPositions = async (service) => {
-  // Ensure PnL connection is active
+  // Connect to PnL if needed
   if (!service.pnlConn && service.credentials) {
     await service.connectPnL(service.credentials.username, service.credentials.password);
     await requestPnLSnapshot(service);
@@ -208,10 +220,8 @@ const getPositions = async (service) => {
     exchange: pos.exchange,
     quantity: pos.quantity,
     averagePrice: pos.averagePrice,
-    // From API only
-    unrealizedPnl: pos.openPnl !== undefined ? pos.openPnl : null,
-    realizedPnl: pos.closedPnl !== undefined ? pos.closedPnl : null,
-    dayPnl: pos.dayPnl !== undefined ? pos.dayPnl : null,
+    unrealizedPnl: pos.openPnl,
+    realizedPnl: pos.closedPnl,
     side: pos.quantity > 0 ? 'LONG' : 'SHORT',
   }));
   

package/src/services/rithmic/handlers.js

@@ -6,6 +6,10 @@
 const { proto, decodeAccountPnL, decodeInstrumentPnL } = require('./protobuf');
 const { RES, STREAM } = require('./constants');
 
+// Debug mode
+const DEBUG = process.env.HQX_DEBUG === '1';
+const debug = (...args) => DEBUG && console.log('[Rithmic:Handler]', ...args);
+
 /**
  * Create ORDER_PLANT message handler
  * @param {RithmicService} service - The Rithmic service instance
@@ -44,18 +48,24 @@ const createOrderHandler = (service) => {
 const createPnLHandler = (service) => {
   return (msg) => {
     const { templateId, data } = msg;
+    
+    debug('PNL message received, templateId:', templateId);
 
     switch (templateId) {
       case RES.PNL_POSITION_SNAPSHOT:
       case RES.PNL_POSITION_UPDATES:
-        // OK response, nothing to do
+        debug('PNL snapshot/updates response OK');
         break;
       case STREAM.ACCOUNT_PNL_UPDATE:
+        debug('Account PNL update received');
         handleAccountPnLUpdate(service, data);
         break;
       case STREAM.INSTRUMENT_PNL_UPDATE:
+        debug('Instrument PNL update received');
         handleInstrumentPnLUpdate(service, data);
         break;
+      default:
+        debug('Unknown PNL templateId:', templateId);
     }
   };
 };
@@ -136,19 +146,25 @@ const handleShowOrdersResponse = (service, data) => {
 const handleAccountPnLUpdate = (service, data) => {
   try {
     const pnl = decodeAccountPnL(data);
+    debug('Decoded Account PNL:', JSON.stringify(pnl));
+    
     if (pnl.accountId) {
-      service.accountPnL.set(pnl.accountId, {
+      const pnlData = {
         accountBalance: parseFloat(pnl.accountBalance || 0),
         cashOnHand: parseFloat(pnl.cashOnHand || 0),
         marginBalance: parseFloat(pnl.marginBalance || 0),
         openPositionPnl: parseFloat(pnl.openPositionPnl || 0),
         closedPositionPnl: parseFloat(pnl.closedPositionPnl || 0),
         dayPnl: parseFloat(pnl.dayPnl || 0),
-      });
+      };
+      debug('Storing PNL for account:', pnl.accountId, pnlData);
+      service.accountPnL.set(pnl.accountId, pnlData);
       service.emit('pnlUpdate', pnl);
+    } else {
+      debug('No accountId in PNL response');
     }
   } catch (e) {
-    // Ignore decode errors
+    debug('Error decoding Account PNL:', e.message);
   }
 };
 

package/src/services/rithmic/index.js

@@ -10,6 +10,10 @@ const { createOrderHandler, createPnLHandler } = require('./handlers');
 const { fetchAccounts, getTradingAccounts, requestPnLSnapshot, subscribePnLUpdates, getPositions, hashAccountId } = require('./accounts');
 const { placeOrder, cancelOrder, getOrders, getOrderHistory, closePosition } = require('./orders');
 
+// Debug mode
+const DEBUG = process.env.HQX_DEBUG === '1';
+const debug = (...args) => DEBUG && console.log('[Rithmic:Service]', ...args);
+
 // PropFirm configurations
 const PROPFIRM_CONFIGS = {
   'apex': { name: 'Apex Trader Funding', systemName: 'Apex', defaultBalance: 300000, gateway: RITHMIC_ENDPOINTS.CHICAGO },
@@ -94,16 +98,30 @@ class RithmicService extends EventEmitter {
           
           this.credentials = { username, password };
           
-          const formattedAccounts = this.accounts.map(acc => ({
-            accountId: acc.accountId,
-            accountName: acc.accountName || acc.accountId,
-            balance: this.propfirm.defaultBalance,
-            startingBalance: this.propfirm.defaultBalance,
-            profitAndLoss: 0,
-            status: 0
-          }));
+          debug('Accounts found:', this.accounts.length);
+          debug('Account IDs:', this.accounts.map(a => a.accountId));
+          
+          // Connect to PNL_PLANT for balance/P&L data
+          try {
+            debug('Connecting to PNL_PLANT...');
+            const pnlConnected = await this.connectPnL(username, password);
+            debug('PNL_PLANT connected:', pnlConnected, 'pnlConn:', !!this.pnlConn);
+            
+            if (this.pnlConn) {
+              debug('Requesting P&L snapshot...');
+              await requestPnLSnapshot(this);
+              debug('accountPnL map size after snapshot:', this.accountPnL.size);
+              subscribePnLUpdates(this);
+            }
+          } catch (e) {
+            debug('PnL connection failed:', e.message);
+          }
+          
+          // Get accounts with P&L data (if available)
+          const result = await getTradingAccounts(this);
+          debug('Final accounts:', result.accounts.length);
           
-          resolve({ success: true, user: this.user, accounts: formattedAccounts });
+          resolve({ success: true, user: this.user, accounts: result.accounts });
         });
 
         this.orderConn.once('loginFailed', (data) => {