hedgequantx 2.6.37 → 2.6.38

package/package.json

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

package/src/services/rithmic/index.js

@@ -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,19 @@ class RithmicService extends EventEmitter {
             log.warn('Failed to fetch accounts', { error: err.message });
           }
           
+          // Subscribe to order updates (required to receive fill notifications)
+          try {
+            this.orderConn.send('RequestSubscribeForOrderUpdates', {
+              templateId: REQ.ORDER_UPDATES,
+              userMsg: ['HQX'],
+              fcmId: data.fcmId,
+              ibId: data.ibId,
+            });
+            log.debug('Subscribed to order updates');
+          } 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 +403,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

@@ -48,13 +48,17 @@ 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;
@@ -66,6 +70,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 +116,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 +204,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 +266,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 +280,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' };