hedgequantx 2.7.12 → 2.7.13

package/package.json

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

package/src/pages/accounts.js

@@ -116,14 +116,41 @@ const showAccounts = async (service) => {
       const pnlColor2 = pnl2 === null || pnl2 === undefined ? chalk.gray : (pnl2 >= 0 ? chalk.green : chalk.red);
       console.log(chalk.cyan('║') + fmtRow('P&L:', pnlColor1(pnlStr1), col1) + chalk.cyan('│') + (acc2 ? fmtRow('P&L:', pnlColor2(pnlStr2), col2) : ' '.repeat(col2)) + chalk.cyan('║'));
 
-      // Status
-      const status1 = ACCOUNT_STATUS[acc1.status] || { text: 'Unknown', color: 'gray' };
-      const status2 = acc2 ? (ACCOUNT_STATUS[acc2.status] || { text: 'Unknown', color: 'gray' }) : null;
+      // Status - handle both string from API and numeric lookup
+      const getStatusDisplay = (status) => {
+        if (!status && status !== 0) return { text: '--', color: 'gray' };
+        if (typeof status === 'string') {
+          // Direct string from Rithmic API (e.g., "Active", "Disabled")
+          const lowerStatus = status.toLowerCase();
+          if (lowerStatus.includes('active') || lowerStatus.includes('open')) return { text: status, color: 'green' };
+          if (lowerStatus.includes('disabled') || lowerStatus.includes('closed')) return { text: status, color: 'red' };
+          if (lowerStatus.includes('halt')) return { text: status, color: 'red' };
+          return { text: status, color: 'yellow' };
+        }
+        return ACCOUNT_STATUS[status] || { text: 'Unknown', color: 'gray' };
+      };
+      const status1 = getStatusDisplay(acc1.status);
+      const status2 = acc2 ? getStatusDisplay(acc2.status) : null;
       console.log(chalk.cyan('║') + fmtRow('Status:', chalk[status1.color](status1.text), col1) + chalk.cyan('│') + (acc2 ? fmtRow('Status:', chalk[status2.color](status2.text), col2) : ' '.repeat(col2)) + chalk.cyan('║'));
 
-      // Type
-      const type1 = ACCOUNT_TYPE[acc1.type] || { text: 'Unknown', color: 'white' };
-      const type2 = acc2 ? (ACCOUNT_TYPE[acc2.type] || { text: 'Unknown', color: 'white' }) : null;
+      // Type/Algorithm - handle both string from API and numeric lookup
+      const getTypeDisplay = (type, algorithm) => {
+        // Prefer algorithm from RMS info if available
+        const value = algorithm || type;
+        if (!value && value !== 0) return { text: '--', color: 'gray' };
+        if (typeof value === 'string') {
+          // Direct string from Rithmic API
+          const lowerValue = value.toLowerCase();
+          if (lowerValue.includes('eval')) return { text: value, color: 'yellow' };
+          if (lowerValue.includes('live') || lowerValue.includes('funded')) return { text: value, color: 'green' };
+          if (lowerValue.includes('sim') || lowerValue.includes('demo')) return { text: value, color: 'gray' };
+          if (lowerValue.includes('express')) return { text: value, color: 'magenta' };
+          return { text: value, color: 'cyan' };
+        }
+        return ACCOUNT_TYPE[value] || { text: 'Unknown', color: 'white' };
+      };
+      const type1 = getTypeDisplay(acc1.type, acc1.algorithm);
+      const type2 = acc2 ? getTypeDisplay(acc2.type, acc2.algorithm) : null;
       console.log(chalk.cyan('║') + fmtRow('Type:', chalk[type1.color](type1.text), col1) + chalk.cyan('│') + (acc2 ? fmtRow('Type:', chalk[type2.color](type2.text), col2) : ' '.repeat(col2)) + chalk.cyan('║'));
 
       if (i + 2 < allAccounts.length) {

package/src/services/rithmic/accounts.js

@@ -28,6 +28,108 @@ const hashAccountId = (str) => {
   return Math.abs(hash);
 };
 
+/**
+ * Fetch account RMS info (status, limits) from ORDER_PLANT
+ * @param {RithmicService} service - The Rithmic service instance
+ * @param {string} accountId - The account ID to fetch RMS info for
+ */
+const fetchAccountRmsInfo = async (service, accountId) => {
+  if (!service.orderConn || !service.loginInfo) {
+    debug('fetchAccountRmsInfo: no connection or loginInfo');
+    return null;
+  }
+
+  // Initialize map if needed
+  if (!service.accountRmsInfo) service.accountRmsInfo = new Map();
+
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      debug('fetchAccountRmsInfo: timeout for', accountId);
+      resolve(service.accountRmsInfo.get(accountId) || null);
+    }, 3000);
+
+    const onRmsInfo = (rmsInfo) => {
+      if (rmsInfo.accountId === accountId) {
+        debug('fetchAccountRmsInfo: received for', accountId);
+        clearTimeout(timeout);
+        service.removeListener('accountRmsInfoReceived', onRmsInfo);
+        resolve(rmsInfo);
+      }
+    };
+    service.on('accountRmsInfoReceived', onRmsInfo);
+
+    try {
+      debug('fetchAccountRmsInfo: sending RequestAccountRmsInfo for', accountId);
+      service.orderConn.send('RequestAccountRmsInfo', {
+        templateId: REQ.ACCOUNT_RMS,
+        userMsg: ['HQX'],
+        fcmId: service.loginInfo.fcmId,
+        ibId: service.loginInfo.ibId,
+        userType: 3, // USER_TYPE_TRADER
+      });
+    } catch (e) {
+      debug('fetchAccountRmsInfo: error', e.message);
+      clearTimeout(timeout);
+      service.removeListener('accountRmsInfoReceived', onRmsInfo);
+      resolve(null);
+    }
+  });
+};
+
+/**
+ * Fetch RMS info for all accounts
+ * @param {RithmicService} service - The Rithmic service instance
+ */
+const fetchAllAccountsRmsInfo = async (service) => {
+  if (!service.orderConn || !service.loginInfo || service.accounts.length === 0) {
+    return;
+  }
+
+  debug('fetchAllAccountsRmsInfo: fetching for', service.accounts.length, 'accounts');
+  
+  // Initialize map if needed
+  if (!service.accountRmsInfo) service.accountRmsInfo = new Map();
+
+  return new Promise((resolve) => {
+    let receivedCount = 0;
+    const expectedCount = service.accounts.length;
+    
+    const timeout = setTimeout(() => {
+      debug('fetchAllAccountsRmsInfo: timeout, received', receivedCount, 'of', expectedCount);
+      service.removeListener('accountRmsInfoReceived', onRmsInfo);
+      resolve();
+    }, 5000);
+
+    const onRmsInfo = (rmsInfo) => {
+      receivedCount++;
+      debug('fetchAllAccountsRmsInfo: received', receivedCount, 'of', expectedCount);
+      if (receivedCount >= expectedCount) {
+        clearTimeout(timeout);
+        service.removeListener('accountRmsInfoReceived', onRmsInfo);
+        resolve();
+      }
+    };
+    service.on('accountRmsInfoReceived', onRmsInfo);
+
+    try {
+      // Request RMS info - one request returns all accounts
+      debug('fetchAllAccountsRmsInfo: sending RequestAccountRmsInfo');
+      service.orderConn.send('RequestAccountRmsInfo', {
+        templateId: REQ.ACCOUNT_RMS,
+        userMsg: ['HQX'],
+        fcmId: service.loginInfo.fcmId,
+        ibId: service.loginInfo.ibId,
+        userType: 3, // USER_TYPE_TRADER
+      });
+    } catch (e) {
+      debug('fetchAllAccountsRmsInfo: error', e.message);
+      clearTimeout(timeout);
+      service.removeListener('accountRmsInfoReceived', onRmsInfo);
+      resolve();
+    }
+  });
+};
+
 /**
  * Fetch accounts from ORDER_PLANT
  * @param {RithmicService} service - The Rithmic service instance
@@ -103,12 +205,22 @@ const getTradingAccounts = async (service) => {
     await requestPnLSnapshot(service);
   }
 
+  // Fetch RMS info (status, limits) for all accounts
+  if (service.orderConn && service.accounts.length > 0) {
+    debug('Fetching account RMS info...');
+    await fetchAllAccountsRmsInfo(service);
+  }
+
   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);
     
+    // Get RMS info (status) from accountRmsInfo map
+    const rmsInfo = service.accountRmsInfo?.get(acc.accountId) || {};
+    debug(`Account ${acc.accountId} rmsInfo:`, JSON.stringify(rmsInfo));
+    
     // REAL DATA FROM RITHMIC ONLY - NO DEFAULTS
     const accountBalance = pnlData.accountBalance ? parseFloat(pnlData.accountBalance) : null;
     const openPnL = pnlData.openPositionPnl ? parseFloat(pnlData.openPositionPnl) : null;
@@ -124,7 +236,12 @@ const getTradingAccounts = async (service) => {
       profitAndLoss: dayPnL !== null ? dayPnL : (openPnL !== null || closedPnL !== null ? (openPnL || 0) + (closedPnL || 0) : null),
       openPnL: openPnL,
       todayPnL: closedPnL,
-      status: 0,
+      status: rmsInfo.status || null,  // Real status from API
+      algorithm: rmsInfo.algorithm || null,  // Trading algorithm/type
+      lossLimit: rmsInfo.lossLimit || null,
+      minAccountBalance: rmsInfo.minAccountBalance || null,
+      buyLimit: rmsInfo.buyLimit || null,
+      sellLimit: rmsInfo.sellLimit || null,
       platform: 'Rithmic',
       propfirm: service.propfirm.name,
     };
@@ -208,6 +325,8 @@ const getPositions = async (service) => {
 module.exports = {
   hashAccountId,
   fetchAccounts,
+  fetchAccountRmsInfo,
+  fetchAllAccountsRmsInfo,
   getTradingAccounts,
   requestPnLSnapshot,
   subscribePnLUpdates,

package/src/services/rithmic/constants.js

@@ -165,6 +165,8 @@ const PROTO_FILES = [
   'response_product_codes.proto',
   'request_front_month_contract.proto',
   'response_front_month_contract.proto',
+  'request_account_rms_info.proto',
+  'response_account_rms_info.proto',
 ];
 
 // NO STATIC DATA - All contract/symbol info comes from Rithmic API

package/src/services/rithmic/handlers.js

@@ -29,6 +29,10 @@ const createOrderHandler = (service) => {
         debug('Handling ACCOUNT_LIST (303)');
         handleAccountList(service, data);
         break;
+      case RES.ACCOUNT_RMS:
+        debug('Handling ACCOUNT_RMS (305)');
+        handleAccountRmsInfo(service, data);
+        break;
       case RES.TRADE_ROUTES:
         handleTradeRoutes(service, data);
         break;
@@ -211,6 +215,45 @@ const handleInstrumentPnLUpdate = (service, data) => {
   }
 };
 
+/**
+ * Handle account RMS info response (status, limits, etc.)
+ */
+const handleAccountRmsInfo = (service, data) => {
+  try {
+    const res = proto.decode('ResponseAccountRmsInfo', data);
+    debug('Decoded Account RMS Info:', JSON.stringify(res));
+    
+    if (res.accountId) {
+      const rmsInfo = {
+        accountId: res.accountId,
+        status: res.status || null,
+        currency: res.currency || null,
+        algorithm: res.algorithm || null,
+        lossLimit: res.lossLimit || null,
+        minAccountBalance: res.minAccountBalance || null,
+        minMarginBalance: res.minMarginBalance || null,
+        buyLimit: res.buyLimit || null,
+        sellLimit: res.sellLimit || null,
+        maxOrderQuantity: res.maxOrderQuantity || null,
+        autoLiquidate: res.autoLiquidate || null,
+        autoLiquidateThreshold: res.autoLiquidateThreshold || null,
+      };
+      debug('Account RMS Info for', res.accountId, ':', rmsInfo);
+      
+      // Store RMS info in service
+      if (!service.accountRmsInfo) service.accountRmsInfo = new Map();
+      service.accountRmsInfo.set(res.accountId, rmsInfo);
+      
+      service.emit('accountRmsInfoReceived', rmsInfo);
+    } else if (res.rpCode?.[0] === '0') {
+      debug('Account RMS Info complete signal');
+      service.emit('accountRmsInfoComplete');
+    }
+  } catch (e) {
+    debug('Error decoding Account RMS Info:', e.message);
+  }
+};
+
 /**
  * Handle exchange order notification (fills/trades)
  * NotifyType: 5 = FILL

package/src/services/rithmic/proto/request_account_rms_info.proto

@@ -0,0 +1,20 @@
+
+package rti;
+
+message RequestAccountRmsInfo
+	{                                
+	// PB_OFFSET = 100000, is the offset added for each MNM field id
+
+	enum UserType {
+	              USER_TYPE_FCM    = 1;
+		      USER_TYPE_IB     = 2;
+		      USER_TYPE_TRADER = 3;
+	              }
+
+	required int32    template_id     = 154467;    // PB_OFFSET + MNM_TEMPLATE_ID
+	repeated string   user_msg        = 132760;    // PB_OFFSET + MNM_USER_MSG	
+
+	optional string   fcm_id          = 154013;    // PB_OFFSET + MNM_FCM_ID
+	optional string   ib_id           = 154014;    // PB_OFFSET + MNM_IB_ID
+	optional UserType user_type       = 154036;    // PB_OFFSET + MNM_USER_TYPE
+	}

package/src/services/rithmic/proto/response_account_rms_info.proto

@@ -0,0 +1,61 @@
+
+package rti;
+
+message ResponseAccountRmsInfo
+	{       
+	// PB_OFFSET = 100000, is the offset added for each MNM field id
+
+	// below enum is just for reference only, not used in this message
+	enum PresenceBits {
+	                  BUY_LIMIT           =     1;
+			  SELL_LIMIT          =     2;
+			  LOSS_LIMIT          =     4;
+			  MAX_ORDER_QUANTITY  =     8;
+			  MIN_ACCOUNT_BALANCE =    16;
+			  MIN_MARGIN_BALANCE  =    32;
+			  ALGORITHM           =    64;
+			  STATUS              =   128;
+			  CURRENCY            =   256;
+			  DEFAULT_COMMISSION  =   512;
+	                  }
+
+	enum AutoLiquidateFlag {
+	                        ENABLED  =  1;
+				DISABLED =  2;
+	                       }
+
+
+	required int32    template_id                             = 154467;    // PB_OFFSET + MNM_TEMPLATE_ID
+	repeated string   user_msg                                = 132760;    // PB_OFFSET + MNM_USER_MSG	
+	repeated string   rq_handler_rp_code                      = 132764;    // PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
+	repeated string   rp_code                                 = 132766;    // PB_OFFSET + MNM_RESPONSE_CODE
+
+        optional uint32   presence_bits                           = 153622;    // PB_OFFSET + MNM_FIELD_PRESENCE_BITS
+
+	optional string   fcm_id                                  = 154013;    // PB_OFFSET + MNM_FCM_ID
+	optional string   ib_id                                   = 154014;    // PB_OFFSET + MNM_IB_ID
+	optional string   account_id                              = 154008;    // PB_OFFSET + MNM_ACCOUNT_ID
+
+	optional string   currency                                = 154383;    // PB_OFFSET + MNM_ACCOUNT_CURRENCY
+	optional string   status                                  = 154003;    // PB_OFFSET + MNM_ACCOUNT_STATUS
+	optional string   algorithm                               = 150142;    // PB_OFFSET + MNM_ALGORITHM
+
+	optional string   auto_liquidate_criteria                 = 131036;    // PB_OFFSET + MNM_ACCOUNT_AUTO_LIQUIDATE_CRITERIA
+
+	optional AutoLiquidateFlag auto_liquidate                 = 131035;    // PB_OFFSET + MNM_ACCOUNT_AUTO_LIQUIDATE
+	optional AutoLiquidateFlag disable_on_auto_liquidate      = 131038;    // PB_OFFSET + MNM_DISABLE_ON_AUTO_LIQUIDATE_FLAG
+
+	optional double   auto_liquidate_threshold                = 131037;    // PB_OFFSET + MNM_ACCOUNT_AUTO_LIQUIDATE_THRESHOLD
+	optional double   auto_liquidate_max_min_account_balance  = 131039;    // PB_OFFSET + MNM_AUTO_LIQ_MAX_MIN_ACCOUNT_BALANCE
+
+        optional double   loss_limit                              = 154019;    // PB_OFFSET + MNM_LOSS_LIMIT
+	optional double   min_account_balance                     = 156968;    // PB_OFFSET + MNM_MINIMUM_ACCOUNT_BALANCE
+	optional double   min_margin_balance                      = 156976;    // PB_OFFSET + MNM_MIN_MARGIN_BALANCE
+	optional double   default_commission                      = 153368;    // PB_OFFSET + MNM_DEFAULT_COMMISSION
+
+	optional int32    buy_limit                               = 154009;    // PB_OFFSET + MNM_BUY_LIMIT
+	optional int32    max_order_quantity                      = 110105;    // PB_OFFSET + MNM_MAX_LIMIT_QUAN
+	optional int32    sell_limit                              = 154035;    // PB_OFFSET + MNM_SELL_LIMIT
+
+	optional bool     check_min_account_balance               = 156972;    // PB_OFFSET + MNM_CHECK_MIN_ACCT_BALANCE
+	}