hedgequantx 2.7.3 → 2.7.4

package/package.json

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

package/src/services/rithmic/index.js

@@ -16,7 +16,7 @@ const {
   subscribePnLUpdates,
   getPositions,
 } = require('./accounts');
-const { placeOrder, cancelOrder, getOrders, getOrderHistory, closePosition } = require('./orders');
+const { placeOrder, cancelOrder, getOrders, getOrderHistory, getOrderHistoryDates, getTradeHistoryFull, closePosition } = require('./orders');
 const { getContracts, searchContracts } = require('./contracts');
 const { TIMEOUTS } = require('../../config/settings');
 const { logger } = require('../../utils/logger');
@@ -229,6 +229,8 @@ class RithmicService extends EventEmitter {
   async getPositions() { return getPositions(this); }
   async getOrders() { return getOrders(this); }
   async getOrderHistory(date) { return getOrderHistory(this, date); }
+  async getOrderHistoryDates() { return getOrderHistoryDates(this); }
+  async getTradeHistoryFull(days) { return getTradeHistoryFull(this, days); }
   async placeOrder(orderData) { return placeOrder(this, orderData); }
   async cancelOrder(orderId) { return cancelOrder(this, orderId); }
   async closePosition(accountId, symbol) { return closePosition(this, accountId, symbol); }
@@ -240,24 +242,55 @@ class RithmicService extends EventEmitter {
   async getUser() { return this.user; }
   
   /**
-   * Get trade history from captured fills
+   * Get trade history from Rithmic API
    * @param {string} accountId - Optional account filter
    * @param {number} days - Number of days to look back (default 30)
    */
   async getTradeHistory(accountId, days = 30) {
-    const cutoff = Date.now() - (days * 24 * 60 * 60 * 1000);
-    let trades = this.trades.filter(t => t.timestamp >= cutoff);
+    // Fetch from API
+    const result = await getTradeHistoryFull(this, days);
     
+    if (!result.success) {
+      return { success: false, trades: [] };
+    }
+    
+    let trades = result.trades || [];
+    
+    // Filter by account if specified
     if (accountId) {
       trades = trades.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),
+    }));
+    
     // Sort by timestamp descending (newest first)
-    trades.sort((a, b) => b.timestamp - a.timestamp);
+    trades.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
     
     return { success: true, trades };
   }
   
+  /**
+   * Parse Rithmic date/time to timestamp
+   * @private
+   */
+  _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();
+    }
+  }
+  
   /**
    * Get lifetime stats calculated from trade history
    */

package/src/services/rithmic/orders.js

@@ -119,9 +119,57 @@ const getOrders = async (service) => {
 };
 
 /**
- * Get order history
+ * Get available order history dates
+ * @param {RithmicService} service - The Rithmic service instance
+ * @returns {Promise<{success: boolean, dates: string[]}>}
+ */
+const getOrderHistoryDates = async (service) => {
+  if (!service.orderConn || !service.loginInfo) {
+    return { success: false, dates: [] };
+  }
+
+  return new Promise((resolve) => {
+    const dates = [];
+    const timeout = setTimeout(() => {
+      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);
+        }
+      }
+      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 {
+      service.orderConn.send('RequestShowOrderHistoryDates', {
+        templateId: REQ.SHOW_ORDER_HISTORY_DATES,
+        userMsg: ['HQX'],
+      });
+    } catch (e) {
+      clearTimeout(timeout);
+      service.orderConn.removeListener('message', handler);
+      resolve({ success: false, error: e.message, dates: [] });
+    }
+  });
+};
+
+/**
+ * Get order history for a specific date
  * @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) {
@@ -133,12 +181,46 @@ const getOrderHistory = async (service, date) => {
   return new Promise((resolve) => {
     const orders = [];
     const timeout = setTimeout(() => {
+      service.orderConn.removeListener('message', handler);
       resolve({ success: true, orders });
-    }, 3000);
+    }, 10000);
+
+    const handler = (msg) => {
+      // ExchangeOrderNotification (352) contains order/fill details
+      if (msg.templateId === 352 && msg.data) {
+        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,
+            });
+          }
+        } catch (e) {
+          // Ignore decode errors
+        }
+      }
+    };
+
+    service.orderConn.on('message', handler);
 
     try {
       for (const acc of service.accounts) {
-        service.orderConn.send('RequestShowOrderHistorySummary', {
+        service.orderConn.send('RequestShowOrderHistory', {
           templateId: REQ.SHOW_ORDER_HISTORY,
           userMsg: ['HQX'],
           fcmId: acc.fcmId || service.loginInfo.fcmId,
@@ -148,17 +230,53 @@ const getOrderHistory = async (service, date) => {
         });
       }
       
+      // Wait for responses
       setTimeout(() => {
         clearTimeout(timeout);
+        service.orderConn.removeListener('message', handler);
         resolve({ success: true, orders });
-      }, 2000);
+      }, 5000);
     } catch (e) {
       clearTimeout(timeout);
+      service.orderConn.removeListener('message', handler);
       resolve({ success: false, error: e.message, orders: [] });
     }
   });
 };
 
+/**
+ * Get full trade history for multiple dates
+ * @param {RithmicService} service - The Rithmic service instance
+ * @param {number} days - Number of days to fetch (default 30)
+ * @returns {Promise<{success: boolean, trades: Array}>}
+ */
+const getTradeHistoryFull = async (service, days = 30) => {
+  if (!service.orderConn || !service.loginInfo) {
+    return { success: false, trades: [] };
+  }
+
+  // Get available dates
+  const { dates } = await getOrderHistoryDates(service);
+  if (!dates || dates.length === 0) {
+    return { success: true, trades: [] };
+  }
+
+  // Sort dates descending and limit to requested days
+  const sortedDates = dates.sort((a, b) => b.localeCompare(a)).slice(0, days);
+  
+  const allTrades = [];
+  
+  // Fetch history for each date
+  for (const date of sortedDates) {
+    const { orders } = await getOrderHistory(service, date);
+    // Filter only fills (notifyType 5)
+    const fills = orders.filter(o => o.notifyType === 5 || o.fillPrice);
+    allTrades.push(...fills);
+  }
+
+  return { success: true, trades: allTrades };
+};
+
 /**
  * Close position (market order to flatten)
  * @param {RithmicService} service - The Rithmic service instance
@@ -188,5 +306,7 @@ module.exports = {
   cancelOrder,
   getOrders,
   getOrderHistory,
+  getOrderHistoryDates,
+  getTradeHistoryFull,
   closePosition
 };