hedgequantx 2.6.37 → 2.6.39

package/package.json

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

package/src/services/rithmic/handlers.js

@@ -449,20 +449,21 @@ const FillInfoPool = {
    */
   fill(notif, receiveTime, latency) {
     const o = this._template;
-    o.orderTag = notif.userMsg?.[0] || null;
+    o.orderTag = notif.userTag || null; // userTag contains our order tag
     o.basketId = notif.basketId;
-    o.orderId = notif.orderId;
+    o.orderId = notif.exchangeOrderId || notif.orderId;
     o.status = notif.status;
     o.symbol = notif.symbol;
     o.exchange = notif.exchange;
     o.accountId = notif.accountId;
-    o.fillQuantity = notif.fillQuantity || 0;
-    o.totalFillQuantity = notif.totalFillQuantity || 0;
-    o.remainingQuantity = notif.remainingQuantity || 0;
+    // Proto uses totalFillSize, not fillQuantity
+    o.fillQuantity = notif.totalFillSize || notif.fillQuantity || 0;
+    o.totalFillQuantity = notif.totalFillSize || notif.totalFillQuantity || 0;
+    o.remainingQuantity = notif.totalUnfilledSize || notif.remainingQuantity || 0;
     o.avgFillPrice = parseFloat(notif.avgFillPrice || 0);
-    o.lastFillPrice = parseFloat(notif.fillPrice || 0);
+    o.lastFillPrice = parseFloat(notif.price || notif.fillPrice || 0);
     o.transactionType = notif.transactionType;
-    o.orderType = notif.orderType;
+    o.orderType = notif.priceType || notif.orderType;
     o.quantity = notif.quantity;
     o.ssboe = notif.ssboe;
     o.usecs = notif.usecs;
@@ -495,11 +496,13 @@ const handleOrderNotification = (service, data) => {
   
   try {
     const notif = proto.decode('RithmicOrderNotification', data);
-    const orderTag = notif.userMsg?.[0] || null;
+    // userTag contains our order tag (userMsg is not in this proto)
+    const orderTag = notif.userTag || null;
     
     // FAST PATH: Check for fill immediately
-    const fillQty = notif.fillQuantity || notif.totalFillQuantity || 0;
-    const isFill = fillQty > 0;
+    // Proto uses total_fill_size (camelCase: totalFillSize), not fillQuantity
+    const fillQty = notif.totalFillSize || notif.totalFillQuantity || notif.fillQuantity || 0;
+    const isFill = fillQty > 0 || notif.status === 'complete';
     
     // Calculate round-trip latency if this is a fill we're tracking
     let roundTripLatency = null;
@@ -521,15 +524,18 @@ const handleOrderNotification = (service, data) => {
     // Emit raw notification
     service.emit('orderNotification', fillInfo);
 
-    // Emit fill event if this is a fill
+    // Emit fill event if this is a fill (status=complete means order is fully filled)
     if (isFill) {
-      console.log(`[FILL] Received: ${orderTag} | ${fillInfo.transactionType === 1 ? 'BUY' : 'SELL'} ${fillQty}x @ ${fillInfo.avgFillPrice} | latency=${roundTripLatency}ms`);
+      const actualFillQty = fillInfo.totalFillQuantity || fillInfo.fillQuantity || notif.quantity || 0;
+      const fillPrice = fillInfo.avgFillPrice || fillInfo.lastFillPrice || 0;
+      
+      console.log(`[FILL] Received: ${orderTag} | ${fillInfo.transactionType === 1 ? 'BUY' : 'SELL'} ${actualFillQty}x @ ${fillPrice} | latency=${roundTripLatency}ms`);
       
       debug('ORDER FILLED:', {
         orderTag,
         side: fillInfo.transactionType === 1 ? 'BUY' : 'SELL',
-        qty: fillQty,
-        avgPrice: fillInfo.avgFillPrice,
+        qty: actualFillQty,
+        avgPrice: fillPrice,
         latencyMs: roundTripLatency,
       });
       

package/src/services/rithmic/index.js

@@ -7,7 +7,7 @@
 
 const EventEmitter = require('events');
 const { RithmicConnection } = require('./connection');
-const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS } = require('./constants');
+const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS, REQ } = require('./constants');
 const { createOrderHandler, createPnLHandler, LatencyTracker } = require('./handlers');
 const {
   fetchAccounts,
@@ -135,6 +135,7 @@ class RithmicService extends EventEmitter {
     this.completedTrades = []; // Store filled orders for trade history
     this.user = null;
     this.credentials = null;
+    this.tradeRoutes = new Map(); // exchange -> tradeRoute (from API)
     
     // Cache
     this._contractsCache = null;
@@ -175,6 +176,14 @@ class RithmicService extends EventEmitter {
           this.loginInfo = data;
           this.user = { userName: username, fcmId: data.fcmId, ibId: data.ibId };
           
+          // Fetch trade routes first (needed for orders)
+          try {
+            await this._fetchTradeRoutes();
+            log.debug('Fetched trade routes', { count: this.tradeRoutes.size });
+          } catch (err) {
+            log.warn('Failed to fetch trade routes', { error: err.message });
+          }
+          
           // Fetch accounts
           try {
             await fetchAccounts(this);
@@ -183,6 +192,22 @@ class RithmicService extends EventEmitter {
             log.warn('Failed to fetch accounts', { error: err.message });
           }
           
+          // Subscribe to order updates for each account (required to receive fill notifications)
+          try {
+            for (const acc of this.accounts) {
+              this.orderConn.send('RequestSubscribeForOrderUpdates', {
+                templateId: REQ.ORDER_UPDATES,
+                userMsg: ['HQX'],
+                fcmId: acc.fcmId || data.fcmId,
+                ibId: acc.ibId || data.ibId,
+                accountId: acc.accountId,
+              });
+              log.debug('Subscribed to order updates for account', { accountId: acc.accountId });
+            }
+          } catch (err) {
+            log.warn('Failed to subscribe to order updates', { error: err.message });
+          }
+          
           // Track open entries for P&L calculation
           this._openEntries = new Map(); // key: accountId:symbol, value: {side, qty, price}
           
@@ -381,6 +406,64 @@ class RithmicService extends EventEmitter {
     }
   }
 
+  // ==================== TRADE ROUTES ====================
+
+  /**
+   * Fetch trade routes from Rithmic API
+   * Trade routes are required for order submission
+   * @private
+   * @returns {Promise<void>}
+   */
+  async _fetchTradeRoutes() {
+    if (!this.orderConn || !this.loginInfo) {
+      return;
+    }
+
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        log.debug('Trade routes fetch timeout');
+        resolve();
+      }, 5000);
+
+      const onTradeRoute = (res) => {
+        if (res.tradeRoute && res.exchange) {
+          // Store trade route by exchange (from API)
+          this.tradeRoutes.set(res.exchange, res.tradeRoute);
+          log.debug('Trade route received', { exchange: res.exchange, route: res.tradeRoute });
+        }
+        if (res.rpCode?.[0] === '0' && !res.tradeRoute) {
+          // End of trade routes
+          clearTimeout(timeout);
+          this.removeListener('tradeRoutes', onTradeRoute);
+          resolve();
+        }
+      };
+
+      this.on('tradeRoutes', onTradeRoute);
+
+      try {
+        this.orderConn.send('RequestTradeRoutes', {
+          templateId: REQ.TRADE_ROUTES,
+          userMsg: ['HQX'],
+          subscribeForUpdates: true, // Required by Rithmic API
+        });
+      } catch (e) {
+        clearTimeout(timeout);
+        this.removeListener('tradeRoutes', onTradeRoute);
+        resolve();
+      }
+    });
+  }
+
+  /**
+   * Get trade route for an exchange
+   * @param {string} exchange - Exchange name (e.g., 'CME', 'NYMEX')
+   * @returns {string|null} Trade route from API, or null if not available
+   */
+  getTradeRoute(exchange) {
+    return this.tradeRoutes.get(exchange) || null;
+  }
+
   // ==================== DELEGATED METHODS ====================
 
   async getTradingAccounts() { return getTradingAccounts(this); }

package/src/services/rithmic/orders.js

@@ -40,6 +40,7 @@ const OrderPool = {
   _template: {
     templateId: REQ.NEW_ORDER,
     userMsg: [''],
+    userTag: '',        // Our order tag - returned in RithmicOrderNotification
     fcmId: '',
     ibId: '',
     accountId: '',
@@ -48,17 +49,22 @@ const OrderPool = {
     quantity: 0,
     transactionType: 1,
     duration: 1,
-    priceType: 2,       // FIXED: was 'orderType: 1' - priceType 2 = MARKET order
+    priceType: 2,       // priceType 2 = MARKET order
     manualOrAuto: 2,
+    tradeRoute: '',     // Required by Rithmic API - fetched from RequestTradeRoutes
   },
   
   /**
    * Get order object with values filled in
    * Reuses same object to avoid allocation
+   * @param {string} orderTag - Unique order tag
+   * @param {Object} loginInfo - { fcmId, ibId }
+   * @param {Object} orderData - { accountId, symbol, exchange, size, side, tradeRoute }
    */
   fill(orderTag, loginInfo, orderData) {
     const o = this._template;
     o.userMsg[0] = orderTag;
+    o.userTag = orderTag; // Set userTag for notification tracking
     o.fcmId = loginInfo.fcmId;
     o.ibId = loginInfo.ibId;
     o.accountId = orderData.accountId;
@@ -66,6 +72,7 @@ const OrderPool = {
     o.exchange = orderData.exchange || 'CME';
     o.quantity = orderData.size;
     o.transactionType = orderData.side === 0 ? 1 : 2;
+    o.tradeRoute = orderData.tradeRoute || ''; // From API via service.getTradeRoute()
     return o;
   }
 };
@@ -111,11 +118,25 @@ const fastEntry = (service, orderData) => {
       ibId: account?.ibId || service.loginInfo.ibId,
     };
     
+    // Get trade route from API (required by Rithmic)
+    const exchange = orderData.exchange || 'CME';
+    const tradeRoute = service.getTradeRoute?.(exchange);
+    if (!tradeRoute) {
+      return {
+        success: false,
+        error: `No trade route for exchange ${exchange}`,
+        orderTag,
+        entryTime,
+        latencyMs: performance.now() - startTime,
+      };
+    }
+    
     // OPTIMIZED: Use pre-allocated order object
-    const order = OrderPool.fill(orderTag, effectiveLoginInfo, orderData);
+    const orderWithRoute = { ...orderData, tradeRoute };
+    const order = OrderPool.fill(orderTag, effectiveLoginInfo, orderWithRoute);
     
     // DEBUG: Log order details
-    console.log(`[ORDER] Sending: ${orderTag} | ${orderData.side === 0 ? 'BUY' : 'SELL'} ${orderData.size}x ${orderData.symbol} | acct=${orderData.accountId} | fcm=${effectiveLoginInfo.fcmId} ib=${effectiveLoginInfo.ibId}`);
+    console.log(`[ORDER] Sending: ${orderTag} | ${orderData.side === 0 ? 'BUY' : 'SELL'} ${orderData.size}x ${orderData.symbol} | acct=${orderData.accountId} | route=${tradeRoute}`);
     
     // OPTIMIZED: Use fastEncode with cached type
     const buffer = proto.fastEncode('RequestNewOrder', order);
@@ -185,8 +206,22 @@ const fastExit = (service, orderData) => {
       ibId: account?.ibId || service.loginInfo.ibId,
     };
     
+    // Get trade route from API (required by Rithmic)
+    const exchange = orderData.exchange || 'CME';
+    const tradeRoute = service.getTradeRoute?.(exchange);
+    if (!tradeRoute) {
+      return {
+        success: false,
+        error: `No trade route for exchange ${exchange}`,
+        orderTag,
+        exitTime,
+        latencyMs: performance.now() - startTime,
+      };
+    }
+    
     // OPTIMIZED: Use pre-allocated order object
-    const order = OrderPool.fill(orderTag, effectiveLoginInfo, orderData);
+    const orderWithRoute = { ...orderData, tradeRoute };
+    const order = OrderPool.fill(orderTag, effectiveLoginInfo, orderWithRoute);
     
     // OPTIMIZED: Use fastEncode with cached type
     const buffer = proto.fastEncode('RequestNewOrder', order);
@@ -233,6 +268,13 @@ const placeOrder = async (service, orderData) => {
       a.accountId === orderData.accountId || a.rithmicAccountId === orderData.accountId
     );
     
+    // Get trade route from API (required by Rithmic)
+    const exchange = orderData.exchange || 'CME';
+    const tradeRoute = service.getTradeRoute?.(exchange);
+    if (!tradeRoute) {
+      return { success: false, error: `No trade route for exchange ${exchange}` };
+    }
+    
     service.orderConn.send('RequestNewOrder', {
       templateId: REQ.NEW_ORDER,
       userMsg: ['HQX'],
@@ -240,12 +282,13 @@ const placeOrder = async (service, orderData) => {
       ibId: account?.ibId || service.loginInfo.ibId,
       accountId: orderData.accountId,
       symbol: orderData.symbol,
-      exchange: orderData.exchange || 'CME',
+      exchange: exchange,
       quantity: orderData.size,
       transactionType: orderData.side === 0 ? 1 : 2, // 1=Buy, 2=Sell
       duration: 1, // DAY
-      priceType: orderData.type === 2 ? 2 : 1, // FIXED: was 'orderType' with inverted logic. priceType: 1=Limit, 2=Market
+      priceType: orderData.type === 2 ? 2 : 1, // priceType: 1=Limit, 2=Market
       price: orderData.price || 0,
+      tradeRoute: tradeRoute, // Required by Rithmic API - fetched from RequestTradeRoutes
     });
 
     return { success: true, message: 'Order submitted' };