hedgequantx 2.6.161 → 2.6.163

package/src/services/rithmic/index.js

@@ -9,109 +9,22 @@ 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,
-  hashAccountId,
-} = require('./accounts');
+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 { TIMEOUTS } = require('../../config/settings');
 const { logger } = require('../../utils/logger');
 
-const log = logger.scope('Rithmic');
-
-/**
- * CME Contract Specifications - Official exchange tick sizes, values, and names
- * These are technical constants defined by the exchange, not market data.
- * Source: CME Group contract specifications
- */
-const CME_CONTRACT_SPECS = {
-  // E-mini Index Futures (CME)
-  ES: { tickSize: 0.25, tickValue: 12.50, name: 'E-mini S&P 500' },
-  NQ: { tickSize: 0.25, tickValue: 5.00, name: 'E-mini NASDAQ-100' },
-  RTY: { tickSize: 0.10, tickValue: 5.00, name: 'E-mini Russell 2000' },
-  YM: { tickSize: 1.00, tickValue: 5.00, name: 'E-mini Dow' },
-  
-  // Micro Index Futures (CME)
-  MES: { tickSize: 0.25, tickValue: 1.25, name: 'Micro E-mini S&P 500' },
-  MNQ: { tickSize: 0.25, tickValue: 0.50, name: 'Micro E-mini NASDAQ-100' },
-  M2K: { tickSize: 0.10, tickValue: 0.50, name: 'Micro E-mini Russell 2000' },
-  MYM: { tickSize: 1.00, tickValue: 0.50, name: 'Micro E-mini Dow' },
-  
-  // Energy Futures (NYMEX)
-  CL: { tickSize: 0.01, tickValue: 10.00, name: 'Crude Oil' },
-  QM: { tickSize: 0.025, tickValue: 12.50, name: 'E-mini Crude Oil' },
-  MCL: { tickSize: 0.01, tickValue: 1.00, name: 'Micro Crude Oil' },
-  NG: { tickSize: 0.001, tickValue: 10.00, name: 'Natural Gas' },
-  QG: { tickSize: 0.005, tickValue: 12.50, name: 'E-mini Natural Gas' },
-  
-  // Metal Futures (COMEX)
-  GC: { tickSize: 0.10, tickValue: 10.00, name: 'Gold' },
-  MGC: { tickSize: 0.10, tickValue: 1.00, name: 'Micro Gold' },
-  SI: { tickSize: 0.005, tickValue: 25.00, name: 'Silver' },
-  SIL: { tickSize: 0.005, tickValue: 2.50, name: '1000oz Silver' },
-  HG: { tickSize: 0.0005, tickValue: 12.50, name: 'Copper' },
-  MHG: { tickSize: 0.0005, tickValue: 1.25, name: 'Micro Copper' },
-  
-  // Treasury Futures (CBOT)
-  ZB: { tickSize: 0.03125, tickValue: 31.25, name: '30-Year T-Bond' },
-  ZN: { tickSize: 0.015625, tickValue: 15.625, name: '10-Year T-Note' },
-  ZF: { tickSize: 0.0078125, tickValue: 7.8125, name: '5-Year T-Note' },
-  ZT: { tickSize: 0.0078125, tickValue: 15.625, name: '2-Year T-Note' },
-  
-  // Agricultural Futures (CBOT)
-  ZC: { tickSize: 0.25, tickValue: 12.50, name: 'Corn' },
-  ZS: { tickSize: 0.25, tickValue: 12.50, name: 'Soybeans' },
-  ZW: { tickSize: 0.25, tickValue: 12.50, name: 'Wheat' },
-  ZL: { tickSize: 0.01, tickValue: 6.00, name: 'Soybean Oil' },
-  ZM: { tickSize: 0.10, tickValue: 10.00, name: 'Soybean Meal' },
-  
-  // Currency Futures (CME)
-  '6E': { tickSize: 0.00005, tickValue: 6.25, name: 'Euro FX' },
-  '6J': { tickSize: 0.0000005, tickValue: 6.25, name: 'Japanese Yen' },
-  '6B': { tickSize: 0.0001, tickValue: 6.25, name: 'British Pound' },
-  '6A': { tickSize: 0.0001, tickValue: 10.00, name: 'Australian Dollar' },
-  '6C': { tickSize: 0.00005, tickValue: 5.00, name: 'Canadian Dollar' },
-  '6M': { tickSize: 0.0001, tickValue: 5.00, name: 'Mexican Peso' },
-  
-  // Nikkei (CME)
-  NKD: { tickSize: 5.0, tickValue: 25.00, name: 'Nikkei 225' },
-  
-  // VIX Futures (CFE)
-  VX: { tickSize: 0.05, tickValue: 50.00, name: 'VIX Futures' },
-};
+// Extracted modules
+const { PROPFIRM_CONFIGS, checkMarketHours } = require('./specs');
+const { getTradeHistory, setupOrderFillListener } = require('./trade-history');
+const { getContracts, searchContracts } = require('./contracts');
 
-/** 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 },
-};
+const log = logger.scope('Rithmic');
 
 /**
  * Rithmic Service for prop firm trading
  */
 class RithmicService extends EventEmitter {
-  /**
-   * @param {string} propfirmKey - PropFirm identifier
-   */
   constructor(propfirmKey) {
     super();
     this.propfirmKey = propfirmKey;
@@ -132,10 +45,10 @@ class RithmicService extends EventEmitter {
     this.accountPnL = new Map();
     this.positions = new Map();
     this.orders = [];
-    this.completedTrades = []; // Store filled orders for trade history
+    this.completedTrades = [];
     this.user = null;
     this.credentials = null;
-    this.tradeRoutes = new Map(); // exchange -> tradeRoute (from API)
+    this.tradeRoutes = new Map();
     
     // Cache
     this._contractsCache = null;
@@ -144,12 +57,6 @@ class RithmicService extends EventEmitter {
 
   // ==================== AUTH ====================
 
-  /**
-   * Login to Rithmic
-   * @param {string} username - Username
-   * @param {string} password - Password
-   * @returns {Promise<{success: boolean, user?: Object, accounts?: Array, error?: string}>}
-   */
   async login(username, password) {
     try {
       this.orderConn = new RithmicConnection();
@@ -176,7 +83,7 @@ class RithmicService extends EventEmitter {
           this.loginInfo = data;
           this.user = { userName: username, fcmId: data.fcmId, ibId: data.ibId };
           
-          // Fetch trade routes first (needed for orders)
+          // Fetch trade routes
           try {
             await this._fetchTradeRoutes();
             log.debug('Fetched trade routes', { count: this.tradeRoutes.size });
@@ -192,7 +99,7 @@ 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)
+          // Subscribe to order updates
           try {
             for (const acc of this.accounts) {
               this.orderConn.send('RequestSubscribeForOrderUpdates', {
@@ -202,85 +109,13 @@ class RithmicService extends EventEmitter {
                 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}
-          
-          // Listen for filled orders to build trade history
-          this.on('orderFilled', (fillInfo) => {
-            const key = `${fillInfo.accountId}:${fillInfo.symbol}`;
-            const side = fillInfo.transactionType === 1 ? 0 : 1; // 0=BUY, 1=SELL (entry side)
-            const qty = fillInfo.fillQuantity || fillInfo.totalFillQuantity || 0;
-            const price = fillInfo.avgFillPrice || fillInfo.lastFillPrice || 0;
-            
-            // Check if this is closing an existing position
-            const openEntry = this._openEntries.get(key);
-            let pnl = null;
-            let isClosingTrade = false;
-            
-            if (openEntry && openEntry.side !== side) {
-              // This is a closing trade (opposite side of open position)
-              isClosingTrade = true;
-              const closeQty = Math.min(qty, openEntry.qty);
-              
-              // Calculate P&L based on direction
-              // If we bought (side=0), we sell to close - profit if close price > entry price
-              // If we sold (side=1), we buy to close - profit if entry price > close price
-              if (openEntry.side === 0) {
-                // Was long, selling to close
-                pnl = (price - openEntry.price) * closeQty;
-              } else {
-                // Was short, buying to close
-                pnl = (openEntry.price - price) * closeQty;
-              }
-              
-              // Update or remove open entry
-              const remainingQty = openEntry.qty - closeQty;
-              if (remainingQty <= 0) {
-                this._openEntries.delete(key);
-              } else {
-                openEntry.qty = remainingQty;
-              }
-              
-              // Store the closing trade with P&L
-              this.completedTrades.push({
-                id: fillInfo.orderId || fillInfo.orderTag,
-                orderTag: fillInfo.orderTag,
-                accountId: fillInfo.accountId,
-                symbol: fillInfo.symbol,
-                exchange: fillInfo.exchange,
-                side: openEntry.side, // Original entry side (for stats: LONG or SHORT)
-                size: closeQty,
-                entryPrice: openEntry.price,
-                exitPrice: price,
-                price: price,
-                timestamp: fillInfo.localTimestamp || Date.now(),
-                creationTimestamp: new Date().toISOString(),
-                status: 'CLOSED',
-                profitAndLoss: pnl,
-                pnl: pnl,
-                fees: 0,
-              });
-              log.debug('Trade closed', { symbol: fillInfo.symbol, pnl, trades: this.completedTrades.length });
-            } else {
-              // This is opening a new position or adding to existing
-              if (openEntry && openEntry.side === side) {
-                // Adding to position - update average price
-                const totalQty = openEntry.qty + qty;
-                openEntry.price = ((openEntry.price * openEntry.qty) + (price * qty)) / totalQty;
-                openEntry.qty = totalQty;
-              } else {
-                // New position
-                this._openEntries.set(key, { side, qty, price, timestamp: Date.now() });
-              }
-              log.debug('Position opened/added', { symbol: fillInfo.symbol, side, qty, price });
-            }
-          });
+          // Setup order fill listener for P&L tracking
+          setupOrderFillListener(this);
           
           // Store credentials for reconnection
           this.credentials = { username, password };
@@ -316,12 +151,6 @@ class RithmicService extends EventEmitter {
     }
   }
 
-  /**
-   * Connect to PNL_PLANT for balance data
-   * @param {string} username - Username
-   * @param {string} password - Password
-   * @returns {Promise<boolean>}
-   */
   async connectPnL(username, password) {
     try {
       this.pnlConn = new RithmicConnection();
@@ -360,12 +189,6 @@ class RithmicService extends EventEmitter {
     }
   }
 
-  /**
-   * Connect to TICKER_PLANT for symbol lookup
-   * @param {string} username - Username
-   * @param {string} password - Password
-   * @returns {Promise<boolean>}
-   */
   async connectTicker(username, password) {
     try {
       this.tickerConn = new RithmicConnection();
@@ -408,31 +231,17 @@ 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;
-    }
+    if (!this.orderConn || !this.loginInfo) return;
 
     return new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        log.debug('Trade routes fetch timeout');
-        resolve();
-      }, 5000);
+      const timeout = setTimeout(() => 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();
@@ -445,7 +254,7 @@ class RithmicService extends EventEmitter {
         this.orderConn.send('RequestTradeRoutes', {
           templateId: REQ.TRADE_ROUTES,
           userMsg: ['HQX'],
-          subscribeForUpdates: true, // Required by Rithmic API
+          subscribeForUpdates: true,
         });
       } catch (e) {
         clearTimeout(timeout);
@@ -455,11 +264,6 @@ class RithmicService extends EventEmitter {
     });
   }
 
-  /**
-   * 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;
   }
@@ -477,67 +281,22 @@ class RithmicService extends EventEmitter {
   async flattenAll(accountId) { return flattenAll(this, accountId); }
   async emergencyStop(accountId) { return emergencyStop(this, accountId); }
 
-  // ==================== FAST SCALPING (Ultra-Low Latency) ====================
+  // ==================== FAST SCALPING ====================
 
-  /**
-   * Ultra-fast market order entry - fire-and-forget
-   * Target latency: < 5ms local processing (network latency separate)
-   * @param {Object} orderData - { accountId, symbol, exchange, size, side }
-   * @returns {{ success: boolean, orderTag: string, entryTime: number, latencyMs: number }}
-   */
   fastEntry(orderData) { return fastEntry(this, orderData); }
-
-  /**
-   * Ultra-fast market exit - fire-and-forget
-   * @param {Object} orderData - { accountId, symbol, exchange, size, side }
-   * @returns {{ success: boolean, orderTag: string, exitTime: number, latencyMs: number }}
-   */
   fastExit(orderData) { return fastExit(this, orderData); }
 
-  /**
-   * Warmup connections for minimum latency
-   * Call after login but before trading starts
-   * @returns {Promise<boolean>}
-   */
   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,
-    });
-    
+    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);
   }
 
-  /**
-   * Get latency statistics from order fills
-   * @returns {Object} Latency stats: min, max, avg, p50, p99, samples
-   */
-  getLatencyStats() {
-    return LatencyTracker.getStats();
-  }
-
-  /**
-   * Get recent latency samples
-   * @param {number} n - Number of samples to return
-   * @returns {number[]}
-   */
-  getRecentLatencies(n = 10) {
-    return LatencyTracker.getRecent(n);
-  }
+  getLatencyStats() { return LatencyTracker.getStats(); }
+  getRecentLatencies(n = 10) { return LatencyTracker.getRecent(n); }
 
-  /**
-   * Get connection diagnostics
-   * @returns {Object}
-   */
   getDiagnostics() {
     return {
       orderConn: this.orderConn?.getDiagnostics() || null,
@@ -554,210 +313,14 @@ class RithmicService extends EventEmitter {
   async getUser() { return this.user; }
   async getLifetimeStats() { return { success: true, stats: null }; }
   async getDailyStats() { return { success: true, stats: [] }; }
-  
-  /**
-   * Get trade history from Rithmic API
-   * Uses RequestShowOrderHistory to fetch historical fills
-   * @param {string} accountId - Optional account filter
-   * @param {number} days - Number of days to fetch (default: 30)
-   * @returns {Promise<{success: boolean, trades: Array}>}
-   */
-  async getTradeHistory(accountId, days = 30) {
-    if (!this.orderConn || !this.loginInfo) {
-      return { success: true, trades: this.completedTrades || [] };
-    }
-
-    return new Promise((resolve) => {
-      const trades = [];
-      const historyOrders = [];
-      let resolved = false;
-      
-      // Timeout after 5 seconds
-      const timeout = setTimeout(() => {
-        if (!resolved) {
-          resolved = true;
-          cleanup();
-          // Combine API history with session trades
-          const allTrades = [...this._processHistoryToTrades(historyOrders), ...this.completedTrades];
-          resolve({ success: true, trades: allTrades });
-        }
-      }, 5000);
-      
-      // Listen for order history snapshots (RithmicOrderNotification with is_snapshot=true)
-      const onOrderNotification = (data) => {
-        try {
-          // Check if this is a historical order (snapshot)
-          if (data.isSnapshot || data.status === 'complete' || data.status === 'Complete') {
-            const order = {
-              orderId: data.orderId || data.orderTag,
-              accountId: data.accountId,
-              symbol: data.symbol,
-              exchange: data.exchange,
-              side: data.transactionType === 1 ? 0 : 1, // 1=BUY->0, 2=SELL->1
-              quantity: data.quantity || data.totalFillQuantity || 0,
-              fillPrice: data.avgFillPrice || data.lastFillPrice || 0,
-              timestamp: data.ssboe ? data.ssboe * 1000 : Date.now(),
-              status: data.status,
-            };
-            
-            if (order.quantity > 0 && order.fillPrice > 0) {
-              historyOrders.push(order);
-            }
-          }
-        } catch (e) {
-          // Ignore parse errors
-        }
-      };
-      
-      // Listen for history complete response
-      const onHistoryComplete = () => {
-        if (!resolved) {
-          resolved = true;
-          cleanup();
-          const allTrades = [...this._processHistoryToTrades(historyOrders), ...this.completedTrades];
-          resolve({ success: true, trades: allTrades });
-        }
-      };
-      
-      const cleanup = () => {
-        clearTimeout(timeout);
-        this.removeListener('orderNotification', onOrderNotification);
-        this.removeListener('orderHistoryComplete', onHistoryComplete);
-      };
-      
-      this.on('orderNotification', onOrderNotification);
-      this.on('orderHistoryComplete', onHistoryComplete);
-      
-      // Request order history for each account
-      try {
-        const accounts = accountId 
-          ? this.accounts.filter(a => a.accountId === accountId)
-          : this.accounts;
-        
-        for (const acc of accounts) {
-          this.orderConn.send('RequestShowOrderHistory', {
-            templateId: 324, // REQ.SHOW_ORDER_HISTORY
-            userMsg: ['HQX-HISTORY'],
-            fcmId: acc.fcmId || this.loginInfo.fcmId,
-            ibId: acc.ibId || this.loginInfo.ibId,
-            accountId: acc.accountId,
-          });
-        }
-      } catch (e) {
-        if (!resolved) {
-          resolved = true;
-          cleanup();
-          resolve({ success: false, error: e.message, trades: this.completedTrades || [] });
-        }
-      }
-    });
-  }
-  
-  /**
-   * Process historical orders into trades with P&L
-   * Matches entries and exits to calculate P&L
-   * @private
-   */
-  _processHistoryToTrades(orders) {
-    const trades = [];
-    const openPositions = new Map(); // key: accountId:symbol
-    
-    // Sort by timestamp (oldest first)
-    const sorted = [...orders].sort((a, b) => a.timestamp - b.timestamp);
-    
-    for (const order of sorted) {
-      const key = `${order.accountId}:${order.symbol}`;
-      const open = openPositions.get(key);
-      
-      if (open && open.side !== order.side) {
-        // Closing trade - calculate P&L
-        const closeQty = Math.min(order.quantity, open.quantity);
-        let pnl;
-        
-        if (open.side === 0) {
-          // Was long (bought), now selling
-          pnl = (order.fillPrice - open.price) * closeQty;
-        } else {
-          // Was short (sold), now buying
-          pnl = (open.price - order.fillPrice) * closeQty;
-        }
-        
-        // Estimate tick value (futures typically $12.50-$50 per tick)
-        // For indices like ES/NQ, multiply by contract multiplier
-        const tickMultiplier = this._getTickMultiplier(order.symbol);
-        pnl = pnl * tickMultiplier;
-        
-        trades.push({
-          id: order.orderId,
-          accountId: order.accountId,
-          symbol: order.symbol,
-          exchange: order.exchange,
-          side: open.side,
-          size: closeQty,
-          entryPrice: open.price,
-          exitPrice: order.fillPrice,
-          price: order.fillPrice,
-          timestamp: order.timestamp,
-          creationTimestamp: new Date(order.timestamp).toISOString(),
-          status: 'CLOSED',
-          profitAndLoss: pnl,
-          pnl: pnl,
-          fees: 0,
-        });
-        
-        // Update or remove open position
-        const remaining = open.quantity - closeQty;
-        if (remaining <= 0) {
-          openPositions.delete(key);
-        } else {
-          open.quantity = remaining;
-        }
-      } else if (open && open.side === order.side) {
-        // Adding to position
-        const totalQty = open.quantity + order.quantity;
-        open.price = ((open.price * open.quantity) + (order.fillPrice * order.quantity)) / totalQty;
-        open.quantity = totalQty;
-      } else {
-        // Opening new position
-        openPositions.set(key, {
-          side: order.side,
-          quantity: order.quantity,
-          price: order.fillPrice,
-          timestamp: order.timestamp,
-        });
-      }
-    }
-    
-    return trades;
-  }
-  
-  /**
-   * Get tick multiplier for P&L calculation
-   * @private
-   */
-  _getTickMultiplier(symbol) {
-    const sym = (symbol || '').toUpperCase();
-    if (sym.startsWith('ES')) return 50;      // E-mini S&P 500: $50 per point
-    if (sym.startsWith('NQ')) return 20;      // E-mini Nasdaq: $20 per point
-    if (sym.startsWith('YM')) return 5;       // E-mini Dow: $5 per point
-    if (sym.startsWith('RTY')) return 50;     // E-mini Russell: $50 per point
-    if (sym.startsWith('MES')) return 5;      // Micro E-mini S&P: $5 per point
-    if (sym.startsWith('MNQ')) return 2;      // Micro E-mini Nasdaq: $2 per point
-    if (sym.startsWith('GC')) return 100;     // Gold: $100 per point
-    if (sym.startsWith('SI')) return 5000;    // Silver: $5000 per point
-    if (sym.startsWith('CL')) return 1000;    // Crude Oil: $1000 per point
-    if (sym.startsWith('NG')) return 10000;   // Natural Gas: $10000 per point
-    if (sym.startsWith('ZB') || sym.startsWith('ZN')) return 1000; // Bonds
-    if (sym.startsWith('6E')) return 125000;  // Euro FX
-    if (sym.startsWith('6J')) return 12500000; // Japanese Yen
-    return 1; // Default
-  }
+  async getTradeHistory(accountId, days = 30) { return getTradeHistory(this, accountId, days); }
 
   async getMarketStatus() {
-    const status = this.checkMarketHours();
+    const status = checkMarketHours();
     return { success: true, isOpen: status.isOpen, message: status.message };
   }
 
+  checkMarketHours() { return checkMarketHours(); }
   getToken() { return this.loginInfo ? 'connected' : null; }
   getPropfirm() { return this.propfirmKey || 'apex'; }
 
@@ -773,264 +336,17 @@ class RithmicService extends EventEmitter {
 
   // ==================== CONTRACTS ====================
 
-  /**
-   * Get all available contracts from Rithmic API
-   * @returns {Promise<{success: boolean, contracts: Array, source?: string, error?: string}>}
-   */
-  async getContracts() {
-    // Check cache
-    if (this._contractsCache && Date.now() - this._contractsCacheTime < CACHE.CONTRACTS_TTL) {
-      return { success: true, contracts: this._contractsCache, source: 'cache' };
-    }
-
-    if (!this.credentials) {
-      return { success: false, error: 'Not logged in' };
-    }
-
-    try {
-      // Connect to TICKER_PLANT if needed
-      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' };
-      }
-
-      // Cache results
-      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 };
-    }
-  }
-
-  /**
-   * Search contracts
-   * @param {string} searchText - Search text
-   * @returns {Promise<Array>}
-   */
-  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)
-    );
-  }
-
-  /**
-   * Fetch all front month contracts from API
-   * @private
-   */
-  async _fetchAllFrontMonths() {
-    if (!this.tickerConn) {
-      throw new Error('TICKER_PLANT not connected');
-    }
-
-    return new Promise((resolve) => {
-      const contracts = new Map();
-      const productsToCheck = new Map();
-
-      // Handler for ProductCodes responses
-      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,
-          });
-        }
-      };
-
-      // Handler for FrontMonth responses
-      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);
-
-      // Request all product codes
-      this.tickerConn.send('RequestProductCodes', {
-        templateId: 111,
-        userMsg: ['get-products'],
-      });
-
-      // After timeout, request front months
-      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,
-          });
-        }
-
-        // Collect results after timeout
-        setTimeout(() => {
-          this.tickerConn.removeListener('message', frontMonthHandler);
-
-          const results = [];
-          for (const [baseSymbol, contract] of contracts) {
-            const productKey = `${baseSymbol}:${contract.exchange}`;
-            const product = productsToCheck.get(productKey);
-
-            // API data + CME contract specs (technical constants)
-            const specs = CME_CONTRACT_SPECS[baseSymbol] || null;
-            // Use CME spec name first, then API productName, then baseSymbol as fallback
-            const productName = specs?.name || product?.productName || baseSymbol;
-            
-            results.push({
-              symbol: contract.symbol,
-              baseSymbol,
-              name: contract.symbol, // Use trading symbol as name
-              description: productName, // Product name as description
-              exchange: contract.exchange,
-              // CME contract specifications (official exchange constants)
-              tickSize: specs?.tickSize ?? null,
-              tickValue: specs?.tickValue ?? null,
-            });
-          }
-
-          // Sort alphabetically by base symbol
-          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);
-    });
-  }
-
-  /**
-   * Decode ProductCodes response
-   * @private
-   */
-  _decodeProductCodes(buffer) {
-    const result = {};
-    let offset = 0;
-
-    const readVarint = (buf, off) => {
-      let value = 0;
-      let 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;
-  }
-
-  // ==================== 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' };
-  }
+  async getContracts() { return getContracts(this); }
+  async searchContracts(searchText) { return searchContracts(this, searchText); }
 
   // ==================== CLEANUP ====================
 
-  /**
-   * Disconnect all connections
-   */
   async disconnect() {
     const connections = [this.orderConn, this.pnlConn, this.tickerConn];
     
     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 }); }
       }
     }