hedgequantx 2.6.18 → 2.6.19

package/package.json

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

package/src/services/rithmic/handlers.js

@@ -196,10 +196,28 @@ const createOrderHandler = (service) => {
         debug('Handling ORDER_NOTIFICATION (351)');
         handleOrderNotification(service, data);
         break;
+      case RES.SHOW_ORDER_HISTORY:
+        debug('Handling SHOW_ORDER_HISTORY (325)');
+        handleOrderHistoryResponse(service, data);
+        break;
     }
   };
 };
 
+/**
+ * Handle order history response (325) - signals end of history snapshot
+ */
+const handleOrderHistoryResponse = (service, data) => {
+  try {
+    const res = proto.decode('ResponseShowOrderHistory', data);
+    debug('Order history complete:', { userMsg: res.userMsg, rpCode: res.rpCode });
+    service.emit('orderHistoryComplete', { userMsg: res.userMsg, rpCode: res.rpCode });
+  } catch (e) {
+    debug('Error decoding order history response:', e.message);
+    service.emit('orderHistoryComplete', {});
+  }
+};
+
 /**
  * Create PNL_PLANT message handler
  * @param {RithmicService} service - The Rithmic service instance

package/src/services/rithmic/index.js

@@ -409,24 +409,201 @@ class RithmicService extends EventEmitter {
   async getDailyStats() { return { success: true, stats: [] }; }
   
   /**
-   * Get trade history from completed fills
-   * Note: Rithmic doesn't provide historical P&L per trade via API
-   * We track fills in real-time during the session
+   * Get trade history from Rithmic API
+   * Uses RequestShowOrderHistory to fetch historical fills
    * @param {string} accountId - Optional account filter
-   * @param {number} days - Not used for Rithmic (session-only data)
+   * @param {number} days - Number of days to fetch (default: 30)
    * @returns {Promise<{success: boolean, trades: Array}>}
    */
-  async getTradeHistory(accountId, days) {
-    // Filter by account if specified
-    let trades = this.completedTrades;
-    if (accountId) {
-      trades = trades.filter(t => t.accountId === accountId);
+  async getTradeHistory(accountId, days = 30) {
+    if (!this.orderConn || !this.loginInfo) {
+      return { success: true, trades: this.completedTrades || [] };
     }
+
+    return new Promise((resolve) => {
+      const trades = [];
+      const historyOrders = [];
+      let resolved = false;
+      
+      // Timeout after 5 seconds
+      const timeout = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          cleanup();
+          // Combine API history with session trades
+          const allTrades = [...this._processHistoryToTrades(historyOrders), ...this.completedTrades];
+          resolve({ success: true, trades: allTrades });
+        }
+      }, 5000);
+      
+      // Listen for order history snapshots (RithmicOrderNotification with is_snapshot=true)
+      const onOrderNotification = (data) => {
+        try {
+          // Check if this is a historical order (snapshot)
+          if (data.isSnapshot || data.status === 'complete' || data.status === 'Complete') {
+            const order = {
+              orderId: data.orderId || data.orderTag,
+              accountId: data.accountId,
+              symbol: data.symbol,
+              exchange: data.exchange,
+              side: data.transactionType === 1 ? 0 : 1, // 1=BUY->0, 2=SELL->1
+              quantity: data.quantity || data.totalFillQuantity || 0,
+              fillPrice: data.avgFillPrice || data.lastFillPrice || 0,
+              timestamp: data.ssboe ? data.ssboe * 1000 : Date.now(),
+              status: data.status,
+            };
+            
+            if (order.quantity > 0 && order.fillPrice > 0) {
+              historyOrders.push(order);
+            }
+          }
+        } catch (e) {
+          // Ignore parse errors
+        }
+      };
+      
+      // Listen for history complete response
+      const onHistoryComplete = () => {
+        if (!resolved) {
+          resolved = true;
+          cleanup();
+          const allTrades = [...this._processHistoryToTrades(historyOrders), ...this.completedTrades];
+          resolve({ success: true, trades: allTrades });
+        }
+      };
+      
+      const cleanup = () => {
+        clearTimeout(timeout);
+        this.removeListener('orderNotification', onOrderNotification);
+        this.removeListener('orderHistoryComplete', onHistoryComplete);
+      };
+      
+      this.on('orderNotification', onOrderNotification);
+      this.on('orderHistoryComplete', onHistoryComplete);
+      
+      // Request order history for each account
+      try {
+        const accounts = accountId 
+          ? this.accounts.filter(a => a.accountId === accountId)
+          : this.accounts;
+        
+        for (const acc of accounts) {
+          this.orderConn.send('RequestShowOrderHistory', {
+            templateId: 324, // REQ.SHOW_ORDER_HISTORY
+            userMsg: ['HQX-HISTORY'],
+            fcmId: acc.fcmId || this.loginInfo.fcmId,
+            ibId: acc.ibId || this.loginInfo.ibId,
+            accountId: acc.accountId,
+          });
+        }
+      } catch (e) {
+        if (!resolved) {
+          resolved = true;
+          cleanup();
+          resolve({ success: false, error: e.message, trades: this.completedTrades || [] });
+        }
+      }
+    });
+  }
+  
+  /**
+   * Process historical orders into trades with P&L
+   * Matches entries and exits to calculate P&L
+   * @private
+   */
+  _processHistoryToTrades(orders) {
+    const trades = [];
+    const openPositions = new Map(); // key: accountId:symbol
+    
+    // Sort by timestamp (oldest first)
+    const sorted = [...orders].sort((a, b) => a.timestamp - b.timestamp);
     
-    // Sort by timestamp descending (newest first)
-    trades = [...trades].sort((a, b) => b.timestamp - a.timestamp);
+    for (const order of sorted) {
+      const key = `${order.accountId}:${order.symbol}`;
+      const open = openPositions.get(key);
+      
+      if (open && open.side !== order.side) {
+        // Closing trade - calculate P&L
+        const closeQty = Math.min(order.quantity, open.quantity);
+        let pnl;
+        
+        if (open.side === 0) {
+          // Was long (bought), now selling
+          pnl = (order.fillPrice - open.price) * closeQty;
+        } else {
+          // Was short (sold), now buying
+          pnl = (open.price - order.fillPrice) * closeQty;
+        }
+        
+        // Estimate tick value (futures typically $12.50-$50 per tick)
+        // For indices like ES/NQ, multiply by contract multiplier
+        const tickMultiplier = this._getTickMultiplier(order.symbol);
+        pnl = pnl * tickMultiplier;
+        
+        trades.push({
+          id: order.orderId,
+          accountId: order.accountId,
+          symbol: order.symbol,
+          exchange: order.exchange,
+          side: open.side,
+          size: closeQty,
+          entryPrice: open.price,
+          exitPrice: order.fillPrice,
+          price: order.fillPrice,
+          timestamp: order.timestamp,
+          creationTimestamp: new Date(order.timestamp).toISOString(),
+          status: 'CLOSED',
+          profitAndLoss: pnl,
+          pnl: pnl,
+          fees: 0,
+        });
+        
+        // Update or remove open position
+        const remaining = open.quantity - closeQty;
+        if (remaining <= 0) {
+          openPositions.delete(key);
+        } else {
+          open.quantity = remaining;
+        }
+      } else if (open && open.side === order.side) {
+        // Adding to position
+        const totalQty = open.quantity + order.quantity;
+        open.price = ((open.price * open.quantity) + (order.fillPrice * order.quantity)) / totalQty;
+        open.quantity = totalQty;
+      } else {
+        // Opening new position
+        openPositions.set(key, {
+          side: order.side,
+          quantity: order.quantity,
+          price: order.fillPrice,
+          timestamp: order.timestamp,
+        });
+      }
+    }
     
-    return { success: true, trades };
+    return trades;
+  }
+  
+  /**
+   * Get tick multiplier for P&L calculation
+   * @private
+   */
+  _getTickMultiplier(symbol) {
+    const sym = (symbol || '').toUpperCase();
+    if (sym.startsWith('ES')) return 50;      // E-mini S&P 500: $50 per point
+    if (sym.startsWith('NQ')) return 20;      // E-mini Nasdaq: $20 per point
+    if (sym.startsWith('YM')) return 5;       // E-mini Dow: $5 per point
+    if (sym.startsWith('RTY')) return 50;     // E-mini Russell: $50 per point
+    if (sym.startsWith('MES')) return 5;      // Micro E-mini S&P: $5 per point
+    if (sym.startsWith('MNQ')) return 2;      // Micro E-mini Nasdaq: $2 per point
+    if (sym.startsWith('GC')) return 100;     // Gold: $100 per point
+    if (sym.startsWith('SI')) return 5000;    // Silver: $5000 per point
+    if (sym.startsWith('CL')) return 1000;    // Crude Oil: $1000 per point
+    if (sym.startsWith('NG')) return 10000;   // Natural Gas: $10000 per point
+    if (sym.startsWith('ZB') || sym.startsWith('ZN')) return 1000; // Bonds
+    if (sym.startsWith('6E')) return 125000;  // Euro FX
+    if (sym.startsWith('6J')) return 12500000; // Japanese Yen
+    return 1; // Default
   }
 
   async getMarketStatus() {