hedgequantx 2.6.17 → 2.6.19

package/package.json

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

package/src/pages/stats.js

@@ -170,8 +170,9 @@ const showStats = async (service) => {
           } catch (e) {}
         }
         
-        // ===== TRADE HISTORY (from API - ProjectX only) =====
-        // Rithmic doesn't have getTradeHistory - returns empty array
+        // ===== TRADE HISTORY (from API) =====
+        // ProjectX: Historical trades from API
+        // Rithmic: Session trades tracked locally (entry/exit matching)
         if (typeof svc.getTradeHistory === 'function') {
           try {
             const tradesResult = await svc.getTradeHistory(account.accountId, 30);

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

@@ -71,6 +71,7 @@ class RithmicService extends EventEmitter {
     this.accountPnL = new Map();
     this.positions = new Map();
     this.orders = [];
+    this.completedTrades = []; // Store filled orders for trade history
     this.user = null;
     this.credentials = null;
     
@@ -121,6 +122,80 @@ class RithmicService extends EventEmitter {
             log.warn('Failed to fetch accounts', { error: err.message });
           }
           
+          // Track open entries for P&L calculation
+          this._openEntries = new Map(); // key: accountId:symbol, value: {side, qty, price}
+          
+          // Listen for filled orders to build trade history
+          this.on('orderFilled', (fillInfo) => {
+            const key = `${fillInfo.accountId}:${fillInfo.symbol}`;
+            const side = fillInfo.transactionType === 1 ? 0 : 1; // 0=BUY, 1=SELL (entry side)
+            const qty = fillInfo.fillQuantity || fillInfo.totalFillQuantity || 0;
+            const price = fillInfo.avgFillPrice || fillInfo.lastFillPrice || 0;
+            
+            // Check if this is closing an existing position
+            const openEntry = this._openEntries.get(key);
+            let pnl = null;
+            let isClosingTrade = false;
+            
+            if (openEntry && openEntry.side !== side) {
+              // This is a closing trade (opposite side of open position)
+              isClosingTrade = true;
+              const closeQty = Math.min(qty, openEntry.qty);
+              
+              // Calculate P&L based on direction
+              // If we bought (side=0), we sell to close - profit if close price > entry price
+              // If we sold (side=1), we buy to close - profit if entry price > close price
+              if (openEntry.side === 0) {
+                // Was long, selling to close
+                pnl = (price - openEntry.price) * closeQty;
+              } else {
+                // Was short, buying to close
+                pnl = (openEntry.price - price) * closeQty;
+              }
+              
+              // Update or remove open entry
+              const remainingQty = openEntry.qty - closeQty;
+              if (remainingQty <= 0) {
+                this._openEntries.delete(key);
+              } else {
+                openEntry.qty = remainingQty;
+              }
+              
+              // Store the closing trade with P&L
+              this.completedTrades.push({
+                id: fillInfo.orderId || fillInfo.orderTag,
+                orderTag: fillInfo.orderTag,
+                accountId: fillInfo.accountId,
+                symbol: fillInfo.symbol,
+                exchange: fillInfo.exchange,
+                side: openEntry.side, // Original entry side (for stats: LONG or SHORT)
+                size: closeQty,
+                entryPrice: openEntry.price,
+                exitPrice: price,
+                price: price,
+                timestamp: fillInfo.localTimestamp || Date.now(),
+                creationTimestamp: new Date().toISOString(),
+                status: 'CLOSED',
+                profitAndLoss: pnl,
+                pnl: pnl,
+                fees: 0,
+              });
+              log.debug('Trade closed', { symbol: fillInfo.symbol, pnl, trades: this.completedTrades.length });
+            } else {
+              // This is opening a new position or adding to existing
+              if (openEntry && openEntry.side === side) {
+                // Adding to position - update average price
+                const totalQty = openEntry.qty + qty;
+                openEntry.price = ((openEntry.price * openEntry.qty) + (price * qty)) / totalQty;
+                openEntry.qty = totalQty;
+              } else {
+                // New position
+                this._openEntries.set(key, { side, qty, price, timestamp: Date.now() });
+              }
+              log.debug('Position opened/added', { symbol: fillInfo.symbol, side, qty, price });
+            }
+          });
+          
           // Store credentials for reconnection
           this.credentials = { username, password };
           
@@ -332,7 +407,204 @@ class RithmicService extends EventEmitter {
   async getUser() { return this.user; }
   async getLifetimeStats() { return { success: true, stats: null }; }
   async getDailyStats() { return { success: true, stats: [] }; }
-  async getTradeHistory() { return { success: true, trades: [] }; }
+  
+  /**
+   * Get trade history from Rithmic API
+   * Uses RequestShowOrderHistory to fetch historical fills
+   * @param {string} accountId - Optional account filter
+   * @param {number} days - Number of days to fetch (default: 30)
+   * @returns {Promise<{success: boolean, trades: Array}>}
+   */
+  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);
+    
+    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 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() {
     const status = this.checkMarketHours();
@@ -615,6 +887,8 @@ class RithmicService extends EventEmitter {
     this.accountPnL.clear();
     this.positions.clear();
     this.orders = [];
+    this.completedTrades = [];
+    this._openEntries = null;
     this.loginInfo = null;
     this.user = null;
     this.credentials = null;