hedgequantx 2.9.190 → 2.9.192

package/package.json

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

package/src/pages/algo/algo-executor.js

@@ -486,6 +486,35 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   clearInterval(refreshInterval);
   clearInterval(pnlInterval);
   clearInterval(liveLogInterval);
+  
+  // Flatten any open position before stopping
+  if (currentPosition !== 0) {
+    ui.addLog('system', `Flattening position: ${currentPosition > 0 ? 'LONG' : 'SHORT'} ${Math.abs(currentPosition)}`);
+    sessionLogger.log('EXIT', `Flattening position: ${currentPosition}`);
+    try {
+      const flattenResult = await service.placeOrder({
+        accountId: account.rithmicAccountId || account.accountId,
+        symbol: symbolCode,
+        exchange: contract.exchange || 'CME',
+        type: 2, // Market
+        side: currentPosition > 0 ? 1 : 0, // Sell if long, Buy if short
+        size: Math.abs(currentPosition)
+      });
+      if (flattenResult.success) {
+        ui.addLog('fill_' + (currentPosition > 0 ? 'sell' : 'buy'), `Position flattened @ market`);
+        sessionLogger.log('EXIT', `Position flattened successfully`);
+      } else {
+        ui.addLog('error', `Flatten failed: ${flattenResult.error}`);
+        sessionLogger.log('EXIT', `Flatten failed: ${flattenResult.error}`);
+      }
+    } catch (e) {
+      ui.addLog('error', `Flatten error: ${e.message}`);
+      sessionLogger.log('EXIT', `Flatten error: ${e.message}`);
+    }
+    // Wait for fill
+    await new Promise(r => setTimeout(r, 2000));
+  }
+  
   await marketFeed.disconnect();
   if (cleanupKeys) cleanupKeys();
   ui.cleanup();

package/src/services/rithmic/accounts.js

@@ -335,6 +335,47 @@ const getPositions = async (service) => {
   return { success: true, positions };
 };
 
+/**
+ * Fetch trade routes from ORDER_PLANT
+ * Routes are needed to place orders - Rithmic rejects orders without trade_route
+ * @param {RithmicService} service - The Rithmic service instance
+ */
+const fetchTradeRoutes = async (service) => {
+  if (!service.orderConn || !service.loginInfo) {
+    debug('fetchTradeRoutes: no connection or loginInfo');
+    return;
+  }
+
+  // Initialize map if needed
+  if (!service.tradeRoutes) service.tradeRoutes = new Map();
+
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      debug('fetchTradeRoutes: timeout, found', service.tradeRoutes.size, 'routes');
+      resolve();
+    }, 5000);
+
+    service.once('tradeRoutesComplete', () => {
+      debug('fetchTradeRoutes: complete, found', service.tradeRoutes.size, 'routes');
+      clearTimeout(timeout);
+      resolve();
+    });
+
+    try {
+      debug('fetchTradeRoutes: sending RequestTradeRoutes');
+      service.orderConn.send('RequestTradeRoutes', {
+        templateId: REQ.TRADE_ROUTES,
+        userMsg: ['HQX'],
+        subscribeForUpdates: false,
+      });
+    } catch (e) {
+      debug('fetchTradeRoutes: error', e.message);
+      clearTimeout(timeout);
+      resolve();
+    }
+  });
+};
+
 module.exports = {
   hashAccountId,
   fetchAccounts,
@@ -343,5 +384,6 @@ module.exports = {
   getTradingAccounts,
   requestPnLSnapshot,
   subscribePnLUpdates,
-  getPositions
+  getPositions,
+  fetchTradeRoutes
 };

package/src/services/rithmic/handlers.js

@@ -133,13 +133,41 @@ const handleAccountList = (service, data) => {
 
 /**
  * Handle trade routes response
+ * Stores trade routes in service.tradeRoutes Map keyed by exchange
  */
 const handleTradeRoutes = (service, data) => {
   try {
     const res = proto.decode('ResponseTradeRoutes', data);
+    debug('Trade routes response:', JSON.stringify(res));
+    
+    // Store trade route if we have exchange and trade_route
+    if (res.exchange && res.tradeRoute) {
+      const routeInfo = {
+        fcmId: res.fcmId,
+        ibId: res.ibId,
+        exchange: res.exchange,
+        tradeRoute: res.tradeRoute,
+        status: res.status,
+        isDefault: res.isDefault || false,
+      };
+      
+      // Use exchange as key, prefer default route
+      const existing = service.tradeRoutes.get(res.exchange);
+      if (!existing || res.isDefault) {
+        service.tradeRoutes.set(res.exchange, routeInfo);
+        debug('Stored trade route for', res.exchange, ':', res.tradeRoute, res.isDefault ? '(default)' : '');
+      }
+    }
+    
+    // Signal completion when rpCode is '0'
+    if (res.rpCode?.[0] === '0') {
+      debug('Trade routes complete, total:', service.tradeRoutes.size);
+      service.emit('tradeRoutesComplete');
+    }
+    
     service.emit('tradeRoutes', res);
   } catch (e) {
-    // Ignore decode errors
+    debug('Error decoding trade routes:', e.message);
   }
 };
 

package/src/services/rithmic/index.js

@@ -15,6 +15,7 @@ const {
   requestPnLSnapshot,
   subscribePnLUpdates,
   getPositions,
+  fetchTradeRoutes,
 } = require('./accounts');
 const { placeOrder, cancelOrder, getOrders, getOrderHistory, getOrderHistoryDates, getTradeHistoryFull, closePosition } = require('./orders');
 const { fillsToRoundTrips, calculateTradeStats } = require('./trades');
@@ -78,6 +79,9 @@ class RithmicService extends EventEmitter {
     this._contractsCache = null;
     this._contractsCacheTime = 0;
     
+    // Trade routes cache (keyed by exchange)
+    this.tradeRoutes = new Map();
+    
     // Trades history (captured from ExchangeOrderNotification fills)
     this.trades = [];
   }
@@ -155,6 +159,14 @@ class RithmicService extends EventEmitter {
             log.warn('PnL connection failed', { error: err.message });
           }
           
+          // Fetch trade routes (required for order placement)
+          try {
+            await fetchTradeRoutes(this);
+            log.debug('Trade routes fetched', { count: this.tradeRoutes.size });
+          } catch (err) {
+            log.warn('Trade routes fetch failed', { error: err.message });
+          }
+          
           // Get trading accounts (uses existing this.accounts, no new API call)
           const result = await getTradingAccounts(this);
           log.info('Login successful', { accounts: result.accounts.length });
@@ -472,6 +484,7 @@ class RithmicService extends EventEmitter {
     this.accounts = [];
     this.accountPnL.clear();
     this.positions.clear();
+    this.tradeRoutes.clear();
     this.orders = [];
     this.loginInfo = null;
     this.user = null;

package/src/services/rithmic/orders.js

@@ -75,6 +75,35 @@ const placeOrder = async (service, orderData) => {
     service.on('orderNotification', onNotification);
 
     try {
+      const exchange = orderData.exchange || 'CME';
+      
+      // Get trade route from cache (fetched during login)
+      // Trade route is REQUIRED by Rithmic - orders rejected without it
+      let tradeRoute = null;
+      if (service.tradeRoutes && service.tradeRoutes.size > 0) {
+        const routeInfo = service.tradeRoutes.get(exchange);
+        if (routeInfo) {
+          tradeRoute = routeInfo.tradeRoute;
+        } else {
+          // Fallback: use first available route
+          const firstRoute = service.tradeRoutes.values().next().value;
+          if (firstRoute) {
+            tradeRoute = firstRoute.tradeRoute;
+          }
+        }
+      }
+      
+      if (DEBUG) {
+        console.log('[ORDER] Trade route for', exchange, ':', tradeRoute);
+      }
+      
+      if (!tradeRoute) {
+        // No trade route available - order will likely fail
+        if (DEBUG) {
+          console.log('[ORDER] WARNING: No trade route available, order may be rejected');
+        }
+      }
+      
       const orderRequest = {
         templateId: REQ.NEW_ORDER,
         userMsg: [orderTag],
@@ -82,12 +111,13 @@ const placeOrder = async (service, orderData) => {
         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, // 2=Market, 1=Limit
         price: orderData.price || 0,
+        tradeRoute: tradeRoute, // REQUIRED by Rithmic
         manualOrAuto: 2, // AUTO
       };