hedgequantx 2.6.163 → 2.7.0

package/src/services/rithmic/index.js

@@ -7,20 +7,42 @@
 
 const EventEmitter = require('events');
 const { RithmicConnection } = require('./connection');
-const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS, REQ } = require('./constants');
-const { createOrderHandler, createPnLHandler, LatencyTracker } = require('./handlers');
-const { fetchAccounts, getTradingAccounts, requestPnLSnapshot, subscribePnLUpdates, getPositions } = require('./accounts');
-const { placeOrder, cancelOrder, cancelAllOrders, getOrders, getOrderHistory, closePosition, flattenAll, emergencyStop, fastEntry, fastExit } = require('./orders');
+const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS } = require('./constants');
+const { createOrderHandler, createPnLHandler } = require('./handlers');
+const {
+  fetchAccounts,
+  getTradingAccounts,
+  requestPnLSnapshot,
+  subscribePnLUpdates,
+  getPositions,
+} = require('./accounts');
+const { placeOrder, cancelOrder, getOrders, getOrderHistory, closePosition } = require('./orders');
+const { getContracts, searchContracts } = require('./contracts');
 const { TIMEOUTS } = require('../../config/settings');
 const { logger } = require('../../utils/logger');
 
-// Extracted modules
-const { PROPFIRM_CONFIGS, checkMarketHours } = require('./specs');
-const { getTradeHistory, setupOrderFillListener } = require('./trade-history');
-const { getContracts, searchContracts } = require('./contracts');
-
 const log = logger.scope('Rithmic');
 
+/** PropFirm configurations */
+const PROPFIRM_CONFIGS = {
+  apex: { name: 'Apex Trader Funding', systemName: 'Apex', gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  apex_rithmic: { name: 'Apex Trader Funding', systemName: 'Apex', gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  topstep_r: { name: 'Topstep (Rithmic)', systemName: RITHMIC_SYSTEMS.TOPSTEP, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  bulenox_r: { name: 'Bulenox (Rithmic)', systemName: RITHMIC_SYSTEMS.BULENOX, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  earn2trade: { name: 'Earn2Trade', systemName: RITHMIC_SYSTEMS.EARN_2_TRADE, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  mescapital: { name: 'MES Capital', systemName: RITHMIC_SYSTEMS.MES_CAPITAL, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  tradefundrr: { name: 'TradeFundrr', systemName: RITHMIC_SYSTEMS.TRADEFUNDRR, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  thetradingpit: { name: 'The Trading Pit', systemName: RITHMIC_SYSTEMS.THE_TRADING_PIT, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  fundedfutures: { name: 'Funded Futures Network', systemName: RITHMIC_SYSTEMS.FUNDED_FUTURES_NETWORK, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  propshop: { name: 'PropShop Trader', systemName: RITHMIC_SYSTEMS.PROPSHOP_TRADER, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  '4proptrader': { name: '4PropTrader', systemName: RITHMIC_SYSTEMS.FOUR_PROP_TRADER, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  daytraders: { name: 'DayTraders.com', systemName: RITHMIC_SYSTEMS.DAY_TRADERS, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  '10xfutures': { name: '10X Futures', systemName: RITHMIC_SYSTEMS.TEN_X_FUTURES, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  lucidtrading: { name: 'Lucid Trading', systemName: RITHMIC_SYSTEMS.LUCID_TRADING, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  thrivetrading: { name: 'Thrive Trading', systemName: RITHMIC_SYSTEMS.THRIVE_TRADING, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  legendstrading: { name: 'Legends Trading', systemName: RITHMIC_SYSTEMS.LEGENDS_TRADING, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+};
+
 /**
  * Rithmic Service for prop firm trading
  */
@@ -45,10 +67,8 @@ class RithmicService extends EventEmitter {
     this.accountPnL = new Map();
     this.positions = new Map();
     this.orders = [];
-    this.completedTrades = [];
     this.user = null;
     this.credentials = null;
-    this.tradeRoutes = new Map();
     
     // Cache
     this._contractsCache = null;
@@ -83,15 +103,6 @@ class RithmicService extends EventEmitter {
           this.loginInfo = data;
           this.user = { userName: username, fcmId: data.fcmId, ibId: data.ibId };
           
-          // Fetch trade routes
-          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);
             log.debug('Fetched accounts', { count: this.accounts.length });
@@ -99,28 +110,8 @@ class RithmicService extends EventEmitter {
             log.warn('Failed to fetch accounts', { error: err.message });
           }
           
-          // Subscribe to order updates
-          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,
-              });
-            }
-          } catch (err) {
-            log.warn('Failed to subscribe to order updates', { error: err.message });
-          }
-          
-          // Setup order fill listener for P&L tracking
-          setupOrderFillListener(this);
-          
-          // Store credentials for reconnection
           this.credentials = { username, password };
           
-          // Connect to PNL_PLANT
           try {
             const pnlConnected = await this.connectPnL(username, password);
             if (pnlConnected && this.pnlConn) {
@@ -229,45 +220,6 @@ class RithmicService extends EventEmitter {
     }
   }
 
-  // ==================== TRADE ROUTES ====================
-
-  async _fetchTradeRoutes() {
-    if (!this.orderConn || !this.loginInfo) return;
-
-    return new Promise((resolve) => {
-      const timeout = setTimeout(() => resolve(), 5000);
-
-      const onTradeRoute = (res) => {
-        if (res.tradeRoute && res.exchange) {
-          this.tradeRoutes.set(res.exchange, res.tradeRoute);
-        }
-        if (res.rpCode?.[0] === '0' && !res.tradeRoute) {
-          clearTimeout(timeout);
-          this.removeListener('tradeRoutes', onTradeRoute);
-          resolve();
-        }
-      };
-
-      this.on('tradeRoutes', onTradeRoute);
-
-      try {
-        this.orderConn.send('RequestTradeRoutes', {
-          templateId: REQ.TRADE_ROUTES,
-          userMsg: ['HQX'],
-          subscribeForUpdates: true,
-        });
-      } catch (e) {
-        clearTimeout(timeout);
-        this.removeListener('tradeRoutes', onTradeRoute);
-        resolve();
-      }
-    });
-  }
-
-  getTradeRoute(exchange) {
-    return this.tradeRoutes.get(exchange) || null;
-  }
-
   // ==================== DELEGATED METHODS ====================
 
   async getTradingAccounts() { return getTradingAccounts(this); }
@@ -276,51 +228,22 @@ class RithmicService extends EventEmitter {
   async getOrderHistory(date) { return getOrderHistory(this, date); }
   async placeOrder(orderData) { return placeOrder(this, orderData); }
   async cancelOrder(orderId) { return cancelOrder(this, orderId); }
-  async cancelAllOrders(accountId) { return cancelAllOrders(this, accountId); }
   async closePosition(accountId, symbol) { return closePosition(this, accountId, symbol); }
-  async flattenAll(accountId) { return flattenAll(this, accountId); }
-  async emergencyStop(accountId) { return emergencyStop(this, accountId); }
-
-  // ==================== FAST SCALPING ====================
-
-  fastEntry(orderData) { return fastEntry(this, orderData); }
-  fastExit(orderData) { return fastExit(this, orderData); }
-
-  async warmup() {
-    const results = [];
-    if (this.orderConn) results.push(await this.orderConn.warmup());
-    if (this.pnlConn) results.push(await this.pnlConn.warmup());
-    log.debug('Connection warmup complete', { success: results.filter(Boolean).length, total: results.length });
-    return results.every(Boolean);
-  }
-
-  getLatencyStats() { return LatencyTracker.getStats(); }
-  getRecentLatencies(n = 10) { return LatencyTracker.getRecent(n); }
-
-  getDiagnostics() {
-    return {
-      orderConn: this.orderConn?.getDiagnostics() || null,
-      pnlConn: this.pnlConn?.getDiagnostics() || null,
-      tickerConn: this.tickerConn?.getDiagnostics() || null,
-      latency: this.getLatencyStats(),
-      accounts: this.accounts.length,
-      positions: this.positions.size,
-    };
-  }
+  async getContracts() { return getContracts(this); }
+  async searchContracts(searchText) { return searchContracts(this, searchText); }
 
   // ==================== STUBS ====================
 
   async getUser() { return this.user; }
   async getLifetimeStats() { return { success: true, stats: null }; }
   async getDailyStats() { return { success: true, stats: [] }; }
-  async getTradeHistory(accountId, days = 30) { return getTradeHistory(this, accountId, days); }
+  async getTradeHistory() { return { success: true, trades: [] }; }
 
   async getMarketStatus() {
-    const status = checkMarketHours();
+    const status = this.checkMarketHours();
     return { success: true, isOpen: status.isOpen, message: status.message };
   }
 
-  checkMarketHours() { return checkMarketHours(); }
   getToken() { return this.loginInfo ? 'connected' : null; }
   getPropfirm() { return this.propfirmKey || 'apex'; }
 
@@ -334,10 +257,28 @@ class RithmicService extends EventEmitter {
     };
   }
 
-  // ==================== CONTRACTS ====================
-
-  async getContracts() { return getContracts(this); }
-  async searchContracts(searchText) { return searchContracts(this, searchText); }
+  // ==================== MARKET HOURS ====================
+
+  checkMarketHours() {
+    const now = new Date();
+    const utcDay = now.getUTCDay();
+    const utcHour = now.getUTCHours();
+
+    const isDST = now.getTimezoneOffset() < Math.max(
+      new Date(now.getFullYear(), 0, 1).getTimezoneOffset(),
+      new Date(now.getFullYear(), 6, 1).getTimezoneOffset()
+    );
+    const ctOffset = isDST ? 5 : 6;
+    const ctHour = (utcHour - ctOffset + 24) % 24;
+    const ctDay = utcHour < ctOffset ? (utcDay + 6) % 7 : utcDay;
+
+    if (ctDay === 6) return { isOpen: false, message: 'Market closed (Saturday)' };
+    if (ctDay === 0 && ctHour < 17) return { isOpen: false, message: 'Market opens Sunday 5:00 PM CT' };
+    if (ctDay === 5 && ctHour >= 16) return { isOpen: false, message: 'Market closed (Friday after 4PM CT)' };
+    if (ctHour === 16 && ctDay >= 1 && ctDay <= 4) return { isOpen: false, message: 'Daily maintenance (4:00-5:00 PM CT)' };
+    
+    return { isOpen: true, message: 'Market is open' };
+  }
 
   // ==================== CLEANUP ====================
 
@@ -346,7 +287,11 @@ class RithmicService extends EventEmitter {
     
     for (const conn of connections) {
       if (conn) {
-        try { await conn.disconnect(); } catch (err) { log.warn('Disconnect error', { error: err.message }); }
+        try {
+          await conn.disconnect();
+        } catch (err) {
+          log.warn('Disconnect error', { error: err.message });
+        }
       }
     }
 
@@ -357,8 +302,6 @@ 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;
@@ -368,4 +311,4 @@ class RithmicService extends EventEmitter {
   }
 }
 
-module.exports = { RithmicService, RITHMIC_SYSTEMS, RITHMIC_ENDPOINTS, LatencyTracker };
+module.exports = { RithmicService, RITHMIC_SYSTEMS, RITHMIC_ENDPOINTS };

package/src/services/rithmic/market.js

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Market hours utilities for Rithmic
+ * @module services/rithmic/market
+ */
+
+/**
+ * Check if market is currently open
+ * @returns {{isOpen: boolean, message: string}}
+ */
+const checkMarketHours = () => {
+  const now = new Date();
+  const utcDay = now.getUTCDay();
+  const utcHour = now.getUTCHours();
+
+  const isDST = now.getTimezoneOffset() < Math.max(
+    new Date(now.getFullYear(), 0, 1).getTimezoneOffset(),
+    new Date(now.getFullYear(), 6, 1).getTimezoneOffset()
+  );
+  const ctOffset = isDST ? 5 : 6;
+  const ctHour = (utcHour - ctOffset + 24) % 24;
+  const ctDay = utcHour < ctOffset ? (utcDay + 6) % 7 : utcDay;
+
+  if (ctDay === 6) return { isOpen: false, message: 'Market closed (Saturday)' };
+  if (ctDay === 0 && ctHour < 17) return { isOpen: false, message: 'Market opens Sunday 5:00 PM CT' };
+  if (ctDay === 5 && ctHour >= 16) return { isOpen: false, message: 'Market closed (Friday after 4PM CT)' };
+  if (ctHour === 16 && ctDay >= 1 && ctDay <= 4) return { isOpen: false, message: 'Daily maintenance (4:00-5:00 PM CT)' };
+  
+  return { isOpen: true, message: 'Market is open' };
+};
+
+module.exports = { checkMarketHours };

package/src/services/rithmic/orders.js

@@ -4,10 +4,6 @@
  */
 
 const { REQ } = require('./constants');
-const { logger } = require('../../utils/logger');
-const { fastEntry, fastExit, getEffectiveLoginInfo } = require('./orders-fast');
-
-const log = logger.scope('RithmicOrders');
 
 /**
  * Place order via ORDER_PLANT
@@ -20,32 +16,19 @@ const placeOrder = async (service, orderData) => {
   }
 
   try {
-    // FIXED: Use account-specific fcmId/ibId if available
-    const account = service.accounts?.find(a => 
-      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'],
-      fcmId: account?.fcmId || service.loginInfo.fcmId,
-      ibId: account?.ibId || service.loginInfo.ibId,
+      fcmId: service.loginInfo.fcmId,
+      ibId: service.loginInfo.ibId,
       accountId: orderData.accountId,
       symbol: orderData.symbol,
-      exchange: exchange,
+      exchange: orderData.exchange || 'CME',
       quantity: orderData.size,
       transactionType: orderData.side === 0 ? 1 : 2, // 1=Buy, 2=Sell
       duration: 1, // DAY
-      priceType: orderData.type === 2 ? 2 : 1, // priceType: 1=Limit, 2=Market
+      orderType: orderData.type === 2 ? 1 : 2, // 1=Market, 2=Limit
       price: orderData.price || 0,
-      tradeRoute: tradeRoute, // Required by Rithmic API - fetched from RequestTradeRoutes
     });
 
     return { success: true, message: 'Order submitted' };
@@ -200,99 +183,10 @@ const closePosition = async (service, accountId, symbol) => {
   });
 };
 
-/**
- * Cancel all open orders for an account
- * @param {RithmicService} service - The Rithmic service instance
- * @param {string} accountId - Account ID
- */
-const cancelAllOrders = async (service, accountId) => {
-  if (!service.orderConn || !service.loginInfo) {
-    return { success: false, error: 'Not connected' };
-  }
-
-  try {
-    // Use RequestCancelAllOrders template
-    service.orderConn.send('RequestCancelAllOrders', {
-      templateId: 346, // CANCEL_ALL_ORDERS
-      userMsg: ['HQX-STOP'],
-      fcmId: service.loginInfo.fcmId,
-      ibId: service.loginInfo.ibId,
-      accountId: accountId,
-    });
-
-    log.info('Cancel all orders sent', { accountId });
-    return { success: true };
-  } catch (error) {
-    log.error('Cancel all orders failed', { error: error.message });
-    return { success: false, error: error.message };
-  }
-};
-
-/**
- * Flatten all positions for an account (close all positions)
- * @param {RithmicService} service - The Rithmic service instance
- * @param {string} accountId - Account ID
- */
-const flattenAll = async (service, accountId) => {
-  const results = [];
-  const positions = Array.from(service.positions.values());
-  const accountPositions = positions.filter(p => p.accountId === accountId && p.quantity !== 0);
-
-  log.info('Flattening all positions', { accountId, count: accountPositions.length });
-
-  for (const position of accountPositions) {
-    try {
-      const result = await placeOrder(service, {
-        accountId,
-        symbol: position.symbol,
-        exchange: position.exchange,
-        size: Math.abs(position.quantity),
-        side: position.quantity > 0 ? 1 : 0, // Sell if long, Buy if short
-        type: 2, // Market
-      });
-      results.push({ symbol: position.symbol, ...result });
-    } catch (error) {
-      results.push({ symbol: position.symbol, success: false, error: error.message });
-    }
-  }
-
-  return { success: true, results };
-};
-
-/**
- * Emergency stop - Cancel all orders and flatten all positions
- * @param {RithmicService} service - The Rithmic service instance
- * @param {string} accountId - Account ID
- */
-const emergencyStop = async (service, accountId) => {
-  log.warn('EMERGENCY STOP initiated', { accountId });
-
-  // 1. Cancel all orders first
-  const cancelResult = await cancelAllOrders(service, accountId);
-
-  // 2. Wait a moment for cancellations to process
-  await new Promise(r => setTimeout(r, 500));
-
-  // 3. Flatten all positions
-  const flattenResult = await flattenAll(service, accountId);
-
-  return {
-    success: cancelResult.success && flattenResult.success,
-    cancelled: cancelResult,
-    flattened: flattenResult,
-  };
-};
-
 module.exports = {
   placeOrder,
   cancelOrder,
-  cancelAllOrders,
   getOrders,
   getOrderHistory,
-  closePosition,
-  flattenAll,
-  emergencyStop,
-  // Fast scalping - ultra-low latency
-  fastEntry,
-  fastExit,
+  closePosition
 };