hedgequantx 2.6.162 → 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 { decodeFrontMonthContract } = require('./protobuf');
-const { TIMEOUTS, CACHE } = require('../../config/settings');
+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 { CME_CONTRACT_SPECS, PROPFIRM_CONFIGS, checkMarketHours } = require('./specs');
-const { getTradeHistory, setupOrderFillListener } = require('./trade-history');
-
 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,183 +257,27 @@ class RithmicService extends EventEmitter {
     };
   }
 
-  // ==================== CONTRACTS ====================
-
-  async getContracts() {
-    if (this._contractsCache && Date.now() - this._contractsCacheTime < CACHE.CONTRACTS_TTL) {
-      return { success: true, contracts: this._contractsCache, source: 'cache' };
-    }
+  // ==================== MARKET HOURS ====================
 
-    if (!this.credentials) return { success: false, error: 'Not logged in' };
+  checkMarketHours() {
+    const now = new Date();
+    const utcDay = now.getUTCDay();
+    const utcHour = now.getUTCHours();
 
-    try {
-      if (!this.tickerConn) {
-        const connected = await this.connectTicker(this.credentials.username, this.credentials.password);
-        if (!connected) return { success: false, error: 'Failed to connect to TICKER_PLANT' };
-      }
-
-      this.tickerConn.setMaxListeners(5000);
-      log.debug('Fetching contracts from Rithmic API');
-      const contracts = await this._fetchAllFrontMonths();
-
-      if (!contracts.length) return { success: false, error: 'No tradeable contracts found' };
-
-      this._contractsCache = contracts;
-      this._contractsCacheTime = Date.now();
-
-      return { success: true, contracts, source: 'api' };
-    } catch (err) {
-      log.error('getContracts error', { error: err.message });
-      return { success: false, error: err.message };
-    }
-  }
-
-  async searchContracts(searchText) {
-    const result = await this.getContracts();
-    if (!searchText || !result.success) return result.contracts || [];
-    
-    const search = searchText.toUpperCase();
-    return result.contracts.filter(c =>
-      c.symbol.toUpperCase().includes(search) ||
-      c.name.toUpperCase().includes(search)
+    const isDST = now.getTimezoneOffset() < Math.max(
+      new Date(now.getFullYear(), 0, 1).getTimezoneOffset(),
+      new Date(now.getFullYear(), 6, 1).getTimezoneOffset()
     );
-  }
-
-  async _fetchAllFrontMonths() {
-    if (!this.tickerConn) throw new Error('TICKER_PLANT not connected');
-
-    return new Promise((resolve) => {
-      const contracts = new Map();
-      const productsToCheck = new Map();
-
-      const productHandler = (msg) => {
-        if (msg.templateId !== 112) return;
-        
-        const decoded = this._decodeProductCodes(msg.data);
-        if (!decoded.productCode || !decoded.exchange) return;
-        
-        const validExchanges = ['CME', 'CBOT', 'NYMEX', 'COMEX', 'NYBOT', 'CFE'];
-        if (!validExchanges.includes(decoded.exchange)) return;
-        
-        const name = (decoded.productName || '').toLowerCase();
-        if (name.includes('option') || name.includes('swap') || name.includes('spread')) return;
-        
-        const key = `${decoded.productCode}:${decoded.exchange}`;
-        if (!productsToCheck.has(key)) {
-          productsToCheck.set(key, {
-            productCode: decoded.productCode,
-            productName: decoded.productName || decoded.productCode,
-            exchange: decoded.exchange,
-          });
-        }
-      };
-
-      const frontMonthHandler = (msg) => {
-        if (msg.templateId !== 114) return;
-        
-        const decoded = decodeFrontMonthContract(msg.data);
-        if (decoded.rpCode[0] === '0' && decoded.tradingSymbol) {
-          contracts.set(decoded.userMsg, {
-            symbol: decoded.tradingSymbol,
-            baseSymbol: decoded.userMsg,
-            exchange: decoded.exchange,
-          });
-        }
-      };
-
-      this.tickerConn.on('message', productHandler);
-      this.tickerConn.on('message', frontMonthHandler);
-
-      this.tickerConn.send('RequestProductCodes', {
-        templateId: 111,
-        userMsg: ['get-products'],
-      });
-
-      setTimeout(() => {
-        this.tickerConn.removeListener('message', productHandler);
-        log.debug('Collected products', { count: productsToCheck.size });
-
-        for (const product of productsToCheck.values()) {
-          this.tickerConn.send('RequestFrontMonthContract', {
-            templateId: 113,
-            userMsg: [product.productCode],
-            symbol: product.productCode,
-            exchange: product.exchange,
-          });
-        }
-
-        setTimeout(() => {
-          this.tickerConn.removeListener('message', frontMonthHandler);
-
-          const results = [];
-          for (const [baseSymbol, contract] of contracts) {
-            const productKey = `${baseSymbol}:${contract.exchange}`;
-            const product = productsToCheck.get(productKey);
-            const specs = CME_CONTRACT_SPECS[baseSymbol] || null;
-            const productName = specs?.name || product?.productName || baseSymbol;
-            
-            results.push({
-              symbol: contract.symbol,
-              baseSymbol,
-              name: contract.symbol,
-              description: productName,
-              exchange: contract.exchange,
-              tickSize: specs?.tickSize ?? null,
-              tickValue: specs?.tickValue ?? null,
-            });
-          }
-
-          results.sort((a, b) => a.baseSymbol.localeCompare(b.baseSymbol));
-          log.debug('Got contracts from API', { count: results.length });
-          resolve(results);
-        }, TIMEOUTS.RITHMIC_PRODUCTS);
-      }, TIMEOUTS.RITHMIC_CONTRACTS);
-    });
-  }
-
-  _decodeProductCodes(buffer) {
-    const result = {};
-    let offset = 0;
-
-    const readVarint = (buf, off) => {
-      let value = 0, shift = 0;
-      while (off < buf.length) {
-        const byte = buf[off++];
-        value |= (byte & 0x7F) << shift;
-        if (!(byte & 0x80)) break;
-        shift += 7;
-      }
-      return [value, off];
-    };
-
-    const readString = (buf, off) => {
-      const [len, newOff] = readVarint(buf, off);
-      return [buf.slice(newOff, newOff + len).toString('utf8'), newOff + len];
-    };
-
-    while (offset < buffer.length) {
-      try {
-        const [tag, tagOff] = readVarint(buffer, offset);
-        const wireType = tag & 0x7;
-        const fieldNumber = tag >>> 3;
-        offset = tagOff;
-
-        if (wireType === 0) {
-          const [, newOff] = readVarint(buffer, offset);
-          offset = newOff;
-        } else if (wireType === 2) {
-          const [val, newOff] = readString(buffer, offset);
-          offset = newOff;
-          if (fieldNumber === 110101) result.exchange = val;
-          if (fieldNumber === 100749) result.productCode = val;
-          if (fieldNumber === 100003) result.productName = val;
-        } else {
-          break;
-        }
-      } catch { break; }
-    }
-
-    return result;
+    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 ====================
@@ -520,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 });
+        }
       }
     }
 
@@ -531,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;
@@ -542,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 };