hedgequantx 2.7.11 → 2.7.13

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,14 +123,17 @@ 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[]}>}
  */
 const getOrderHistoryDates = async (service) => {
-  if (!service.orderConn || !service.loginInfo || service.accounts.length === 0) {
+  if (!service.orderConn || !service.loginInfo) {
     return { success: false, dates: [] };
   }
 
+  const { proto } = require('./protobuf');
+
   return new Promise((resolve) => {
     const dates = [];
     const timeout = setTimeout(() => {
@@ -136,19 +142,30 @@ const getOrderHistoryDates = async (service) => {
     }, 5000);
 
     const handler = (msg) => {
+      // msg contains { templateId, data }
       if (msg.templateId === 319) {
-        // ResponseShowOrderHistoryDates returns dates
-        if (msg.date) {
-          if (Array.isArray(msg.date)) {
-            dates.push(...msg.date);
-          } else {
-            dates.push(msg.date);
+        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);
+              }
+            }
           }
-        }
-        if (msg.rpCode && msg.rpCode[0] === '0') {
-          clearTimeout(timeout);
-          service.orderConn.removeListener('message', handler);
-          resolve({ success: true, dates });
+          
+          // 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);
         }
       }
     };
@@ -156,16 +173,12 @@ const getOrderHistoryDates = async (service) => {
     service.orderConn.on('message', handler);
 
     try {
-      // Send for each account
-      for (const acc of service.accounts) {
-        service.orderConn.send('RequestShowOrderHistoryDates', {
-          templateId: REQ.SHOW_ORDER_HISTORY_DATES,
-          userMsg: ['HQX'],
-          fcmId: acc.fcmId || service.loginInfo.fcmId,
-          ibId: acc.ibId || service.loginInfo.ibId,
-          accountId: acc.accountId,
-        });
-      }
+      // 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);
@@ -176,86 +189,103 @@ const getOrderHistoryDates = async (service) => {
 
 /**
  * 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 receivedEnd = false;
+    let receivedCount = 0;
+    const expectedAccounts = service.accounts.length;
+    const requestId = `HQX-${Date.now()}`;
     
     const timeout = setTimeout(() => {
-      service.removeListener('exchangeNotification', handler);
+      service.orderConn.removeListener('message', handler);
+      DEBUG && console.log(`[OrderHistory] Timeout. Got ${orders.length} orders`);
       resolve({ success: true, orders });
     }, 10000);
 
-    const handler = (notification) => {
-      // ExchangeOrderNotification with isSnapshot=true contains history
-      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: 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: notification.isSnapshot,
-          profitAndLoss: 0, // Will be calculated from fills
-          pnl: 0,
-        });
+    const handler = (msg) => {
+      // Response comes as template 352 (ExchangeOrderNotification) with is_snapshot=true
+      if (msg.templateId === 352) {
+        try {
+          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) {
+          DEBUG && console.log('[OrderHistory] Error decoding 352:', e.message);
+        }
       }
       
-      // Check for end of snapshot (rpCode = '0')
-      if (notification && notification.rpCode && notification.rpCode[0] === '0') {
-        receivedEnd = true;
-        clearTimeout(timeout);
-        service.removeListener('exchangeNotification', handler);
-        resolve({ success: true, orders });
+      // 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);
+        }
       }
     };
 
-    service.on('exchangeNotification', handler);
+    service.orderConn.on('message', handler);
 
     try {
-      // Use template 324 (RequestShowOrderHistorySummary) 
+      // Send request 324 for each account
       for (const acc of service.accounts) {
+        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(() => {
-        if (!receivedEnd) {
-          clearTimeout(timeout);
-          service.removeListener('exchangeNotification', handler);
-          resolve({ success: true, orders });
-        }
-      }, 5000);
     } catch (e) {
       clearTimeout(timeout);
-      service.removeListener('exchangeNotification', handler);
+      service.orderConn.removeListener('message', handler);
       resolve({ success: false, error: e.message, orders: [] });
     }
   });

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
+	}

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;
 }