hedgequantx 1.8.49 → 2.3.1

package/src/services/rithmic/index.js

@@ -1,52 +1,71 @@
 /**
- * Rithmic Service
- * Main service for Rithmic prop firm connections
+ * @fileoverview Rithmic Service - Main service for Rithmic prop firm connections
+ * @module services/rithmic
+ * 
+ * NO FAKE DATA - Only real values from Rithmic API
  */
 
 const EventEmitter = require('events');
 const { RithmicConnection } = require('./connection');
-const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS, getSymbolInfo, getCategoryOrder } = require('./constants');
+const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS, getSymbolInfo } = require('./constants');
 const { createOrderHandler, createPnLHandler } = require('./handlers');
-const { fetchAccounts, getTradingAccounts, requestPnLSnapshot, subscribePnLUpdates, getPositions, hashAccountId } = require('./accounts');
+const {
+  fetchAccounts,
+  getTradingAccounts,
+  requestPnLSnapshot,
+  subscribePnLUpdates,
+  getPositions,
+  hashAccountId,
+} = require('./accounts');
 const { placeOrder, cancelOrder, getOrders, getOrderHistory, closePosition } = require('./orders');
-const { decodeFrontMonthContract, readVarint, readLengthDelimited, skipField } = require('./protobuf');
+const { decodeFrontMonthContract } = require('./protobuf');
+const { TIMEOUTS, CACHE } = require('../../config/settings');
+const { logger } = require('../../utils/logger');
 
-// Debug mode
-const DEBUG = process.env.HQX_DEBUG === '1';
-const debug = (...args) => DEBUG && console.log('[Rithmic:Service]', ...args);
+const log = logger.scope('Rithmic');
 
-// PropFirm configurations - NO FAKE DATA
+/** 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 },
+  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 },
+  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 },
+  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
+ */
 class RithmicService extends EventEmitter {
+  /**
+   * @param {string} propfirmKey - PropFirm identifier
+   */
   constructor(propfirmKey) {
     super();
     this.propfirmKey = propfirmKey;
-    this.propfirm = PROPFIRM_CONFIGS[propfirmKey] || { 
-      name: propfirmKey, 
-      systemName: 'Rithmic Paper Trading', 
-      gateway: RITHMIC_ENDPOINTS.PAPER 
+    this.propfirm = PROPFIRM_CONFIGS[propfirmKey] || {
+      name: propfirmKey,
+      systemName: 'Rithmic Paper Trading',
+      gateway: RITHMIC_ENDPOINTS.PAPER,
     };
+    
+    // Connections
     this.orderConn = null;
     this.pnlConn = null;
-    this.tickerConn = null; // TICKER_PLANT for symbol lookup
+    this.tickerConn = null;
+    
+    // State
     this.loginInfo = null;
     this.accounts = [];
     this.accountPnL = new Map();
@@ -54,24 +73,31 @@ class RithmicService extends EventEmitter {
     this.orders = [];
     this.user = null;
     this.credentials = null;
-    this.cachedContracts = null; // Cache contracts to avoid repeated API calls
+    
+    // Cache
+    this._contractsCache = null;
+    this._contractsCacheTime = 0;
   }
 
+  // ==================== 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();
-      const gateway = this.propfirm.gateway || RITHMIC_ENDPOINTS.CHICAGO;
       
       const config = {
-        uri: gateway,
+        uri: this.propfirm.gateway || RITHMIC_ENDPOINTS.CHICAGO,
         systemName: this.propfirm.systemName,
         userId: username,
-        password: password,
+        password,
         appName: 'HQX-CLI',
-        appVersion: '1.0.0',
+        appVersion: '2.0.0',
       };
 
       await this.orderConn.connect(config);
@@ -80,88 +106,83 @@ class RithmicService extends EventEmitter {
       return new Promise((resolve) => {
         const timeout = setTimeout(() => {
           resolve({ success: false, error: 'Login timeout - server did not respond' });
-        }, 30000);
+        }, TIMEOUTS.RITHMIC_LOGIN);
 
         this.orderConn.once('loggedIn', async (data) => {
           clearTimeout(timeout);
           this.loginInfo = data;
           this.user = { userName: username, fcmId: data.fcmId, ibId: data.ibId };
           
-          try { 
-            await fetchAccounts(this); 
-            debug('Fetched accounts:', this.accounts.map(a => a.accountId));
-          } catch (e) {
-            debug('fetchAccounts error:', e.message);
+          // Fetch accounts
+          try {
+            await fetchAccounts(this);
+            log.debug('Fetched accounts', { count: this.accounts.length });
+          } catch (err) {
+            log.warn('Failed to fetch accounts', { error: err.message });
           }
           
-          // NO FAKE ACCOUNTS - only real from Rithmic API
-          
+          // Store credentials for reconnection
           this.credentials = { username, password };
           
-          debug('Accounts found:', this.accounts.length);
-          debug('Account IDs:', this.accounts.map(a => a.accountId));
-          
-          // Connect to PNL_PLANT for balance/P&L data
+          // Connect to PNL_PLANT
           try {
-            debug('Connecting to PNL_PLANT...');
             const pnlConnected = await this.connectPnL(username, password);
-            debug('PNL_PLANT connected:', pnlConnected, 'pnlConn:', !!this.pnlConn);
-            
-            if (this.pnlConn) {
-              debug('Requesting P&L snapshot...');
+            if (pnlConnected && this.pnlConn) {
               await requestPnLSnapshot(this);
-              debug('accountPnL map size after snapshot:', this.accountPnL.size);
               subscribePnLUpdates(this);
             }
-          } catch (e) {
-            debug('PnL connection failed:', e.message);
+          } catch (err) {
+            log.warn('PnL connection failed', { error: err.message });
           }
           
-          // Get accounts with P&L data (if available)
           const result = await getTradingAccounts(this);
-          debug('Final accounts:', result.accounts.length);
+          log.info('Login successful', { accounts: result.accounts.length });
           
           resolve({ success: true, user: this.user, accounts: result.accounts });
         });
 
         this.orderConn.once('loginFailed', (data) => {
           clearTimeout(timeout);
+          log.warn('Login failed', { error: data.message });
           resolve({ success: false, error: data.message || 'Login failed' });
         });
 
         this.orderConn.login('ORDER_PLANT');
       });
-
-    } catch (error) {
-      return { success: false, error: error.message };
+    } catch (err) {
+      log.error('Login error', { error: err.message });
+      return { success: false, error: err.message };
     }
   }
 
   /**
    * 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();
-      const gateway = this.propfirm.gateway || RITHMIC_ENDPOINTS.CHICAGO;
-
+      
       const config = {
-        uri: gateway,
+        uri: this.propfirm.gateway || RITHMIC_ENDPOINTS.CHICAGO,
         systemName: this.propfirm.systemName,
         userId: username,
-        password: password,
+        password,
         appName: 'HQX-CLI',
-        appVersion: '1.0.0',
+        appVersion: '2.0.0',
       };
 
       await this.pnlConn.connect(config);
       this.pnlConn.on('message', createPnLHandler(this));
 
       return new Promise((resolve) => {
-        const timeout = setTimeout(() => resolve(false), 10000);
+        const timeout = setTimeout(() => resolve(false), TIMEOUTS.RITHMIC_PNL);
 
         this.pnlConn.once('loggedIn', () => {
           clearTimeout(timeout);
+          log.debug('PNL_PLANT connected');
           resolve(true);
         });
 
@@ -172,247 +193,219 @@ class RithmicService extends EventEmitter {
 
         this.pnlConn.login('PNL_PLANT');
       });
-    } catch (e) {
+    } catch (err) {
+      log.warn('PNL connection error', { error: err.message });
       return false;
     }
   }
 
-  // Delegate to modules
-  async getTradingAccounts() { return getTradingAccounts(this); }
-  async getPositions() { return getPositions(this); }
-  async getOrders() { return getOrders(this); }
-  async getOrderHistory(date) { return getOrderHistory(this, date); }
-  async placeOrder(orderData) { return placeOrder(this, orderData); }
-  async cancelOrder(orderId) { return cancelOrder(this, orderId); }
-  async closePosition(accountId, symbol) { return closePosition(this, accountId, symbol); }
-
-  // Stubs for API compatibility
-  async getUser() { return this.user; }
-  async getLifetimeStats() { return { success: true, stats: null }; }
-  async getDailyStats() { return { success: true, stats: [] }; }
-  async getTradeHistory() { return { success: true, trades: [] }; }
-  
-  async getMarketStatus() {
-    const status = this.checkMarketHours();
-    return { success: true, isOpen: status.isOpen, message: status.message };
-  }
-
-  getToken() { return this.loginInfo ? 'connected' : null; }
-  getPropfirm() { return this.propfirmKey || 'apex'; }
-
-  getRithmicCredentials() {
-    if (!this.credentials) return null;
-    return {
-      userId: this.credentials.username,
-      password: this.credentials.password,
-      systemName: this.propfirm.systemName,
-      gateway: this.propfirm.gateway || 'wss://rprotocol.rithmic.com:443'
-    };
-  }
-
   /**
    * 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();
-      const gateway = this.propfirm.gateway || RITHMIC_ENDPOINTS.CHICAGO;
-
+      
       const config = {
-        uri: gateway,
+        uri: this.propfirm.gateway || RITHMIC_ENDPOINTS.CHICAGO,
         systemName: this.propfirm.systemName,
         userId: username,
-        password: password,
+        password,
         appName: 'HQX-CLI',
-        appVersion: '1.0.0',
+        appVersion: '2.0.0',
       };
 
       await this.tickerConn.connect(config);
 
       return new Promise((resolve) => {
         const timeout = setTimeout(() => {
-          debug('TICKER_PLANT login timeout');
+          log.debug('TICKER_PLANT timeout');
           resolve(false);
-        }, 10000);
+        }, TIMEOUTS.RITHMIC_TICKER);
 
         this.tickerConn.once('loggedIn', () => {
           clearTimeout(timeout);
-          debug('TICKER_PLANT connected');
+          log.debug('TICKER_PLANT connected');
           resolve(true);
         });
 
         this.tickerConn.once('loginFailed', () => {
           clearTimeout(timeout);
-          debug('TICKER_PLANT login failed');
           resolve(false);
         });
 
         this.tickerConn.login('TICKER_PLANT');
       });
-    } catch (e) {
-      debug('TICKER_PLANT connection error:', e.message);
+    } catch (err) {
+      log.warn('TICKER connection error', { error: err.message });
       return false;
     }
   }
 
-  /**
-   * Get front month contracts for multiple symbols at once - batch request
-   */
-  async getFrontMonthsBatch(products) {
-    if (!this.tickerConn) {
-      throw new Error('TICKER_PLANT not connected');
-    }
+  // ==================== DELEGATED METHODS ====================
 
-    return new Promise((resolve) => {
-      const results = new Map();
-      const pending = new Set(products.map(p => p.productCode));
+  async getTradingAccounts() { return getTradingAccounts(this); }
+  async getPositions() { return getPositions(this); }
+  async getOrders() { return getOrders(this); }
+  async getOrderHistory(date) { return getOrderHistory(this, date); }
+  async placeOrder(orderData) { return placeOrder(this, orderData); }
+  async cancelOrder(orderId) { return cancelOrder(this, orderId); }
+  async closePosition(accountId, symbol) { return closePosition(this, accountId, symbol); }
 
-      const handler = (msg) => {
-        if (msg.templateId === 114) {  // ResponseFrontMonthContract
-          const decoded = decodeFrontMonthContract(msg.data);
-          const baseSymbol = decoded.userMsg;
-          
-          if (pending.has(baseSymbol)) {
-            pending.delete(baseSymbol);
-            
-            if (decoded.rpCode[0] === '0' && decoded.tradingSymbol) {
-              results.set(baseSymbol, {
-                symbol: decoded.tradingSymbol,
-                baseSymbol: baseSymbol,
-                exchange: decoded.exchange,
-              });
-            }
-          }
-        }
-      };
+  // ==================== STUBS ====================
 
-      this.tickerConn.on('message', handler);
+  async getUser() { return this.user; }
+  async getLifetimeStats() { return { success: true, stats: null }; }
+  async getDailyStats() { return { success: true, stats: [] }; }
+  async getTradeHistory() { return { success: true, trades: [] }; }
 
-      // Send all requests
-      for (const product of products) {
-        this.tickerConn.send('RequestFrontMonthContract', {
-          templateId: 113,
-          userMsg: [product.productCode],
-          symbol: product.productCode,
-          exchange: product.exchange,
-        });
-      }
+  async getMarketStatus() {
+    const status = this.checkMarketHours();
+    return { success: true, isOpen: status.isOpen, message: status.message };
+  }
 
-      // Wait for responses (with timeout)
-      setTimeout(() => {
-        this.tickerConn.removeListener('message', handler);
-        resolve(Array.from(results.values()));
-      }, 5000);
-    });
+  getToken() { return this.loginInfo ? 'connected' : null; }
+  getPropfirm() { return this.propfirmKey || 'apex'; }
+
+  getRithmicCredentials() {
+    if (!this.credentials) return null;
+    return {
+      userId: this.credentials.username,
+      password: this.credentials.password,
+      systemName: this.propfirm.systemName,
+      gateway: this.propfirm.gateway || RITHMIC_ENDPOINTS.CHICAGO,
+    };
   }
 
+  // ==================== CONTRACTS ====================
+
   /**
-   * Decode ProductCodes response (template 112) - field IDs from Rithmic API
+   * Get all available contracts from Rithmic API
+   * @returns {Promise<{success: boolean, contracts: Array, source?: string, error?: string}>}
    */
-  decodeProductCodesResponse(buffer) {
-    const result = {};
-    let offset = 0;
+  async getContracts() {
+    // Check cache
+    if (this._contractsCache && Date.now() - this._contractsCacheTime < CACHE.CONTRACTS_TTL) {
+      return { success: true, contracts: this._contractsCache, source: 'cache' };
+    }
 
-    while (offset < buffer.length) {
-      try {
-        const [tag, tagOffset] = readVarint(buffer, offset);
-        const wireType = tag & 0x7;
-        const fieldNumber = tag >>> 3;
-        offset = tagOffset;
+    if (!this.credentials) {
+      return { success: false, error: 'Not logged in' };
+    }
 
-        if (wireType === 0) {
-          const [val, newOff] = readVarint(buffer, offset);
-          offset = newOff;
-          if (fieldNumber === 154467) result.templateId = val;
-        } else if (wireType === 2) {
-          const [val, newOff] = readLengthDelimited(buffer, offset);
-          offset = newOff;
-          if (fieldNumber === 110101) result.exchange = val;        // exchange
-          if (fieldNumber === 100749) result.productCode = val;     // product_code (base symbol)
-          if (fieldNumber === 100003) result.productName = val;     // symbol_name
-          if (fieldNumber === 132760) result.userMsg = val;         // user_msg
-          if (fieldNumber === 132764) result.rpCode = val;          // rp_code
-        } else {
-          offset = skipField(buffer, offset, wireType);
+    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' };
         }
-      } catch (e) { break; }
+      }
+
+      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 };
     }
+  }
 
-    return result;
+  /**
+   * 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)
+    );
   }
 
   /**
-   * Get all tradeable futures from Rithmic API - 100% REAL DATA
-   * Sends RequestFrontMonthContract for known futures and gets real trading symbols
+   * Fetch all front month contracts from API
+   * @private
    */
-  async fetchAllFrontMonths() {
+  async _fetchAllFrontMonths() {
     if (!this.tickerConn) {
       throw new Error('TICKER_PLANT not connected');
     }
 
-    // Request front months for ALL products that might be futures
-    // The API will return the current trading symbol for each
     return new Promise((resolve) => {
       const contracts = new Map();
-      const productsToCheck = new Map(); // Will collect from ProductCodes
+      const productsToCheck = new Map();
 
       // Handler for ProductCodes responses
       const productHandler = (msg) => {
-        if (msg.templateId === 112) {
-          const decoded = this.decodeProductCodesResponse(msg.data);
-          if (!decoded.productCode || !decoded.exchange) return;
-          
-          // Only main futures exchanges
-          const validExchanges = ['CME', 'CBOT', 'NYMEX', 'COMEX', 'NYBOT', 'CFE'];
-          if (!validExchanges.includes(decoded.exchange)) return;
-          
-          // Skip obvious non-futures
-          const name = (decoded.productName || '').toLowerCase();
-          if (name.includes('option')) return;
-          if (name.includes('swap')) return;
-          if (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,
-            });
-          }
+        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) {
-          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,
-            });
-          }
+        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);
 
-      // Step 1: Get all product codes
+      // Request all product codes
       this.tickerConn.send('RequestProductCodes', {
         templateId: 111,
         userMsg: ['get-products'],
       });
 
-      // After 5 seconds, request front months for all collected products
+      // After timeout, request front months
       setTimeout(() => {
         this.tickerConn.removeListener('message', productHandler);
-        debug(`Collected ${productsToCheck.size} products, requesting front months...`);
+        log.debug('Collected products', { count: productsToCheck.size });
 
-        // Send front month requests for all products
-        for (const [key, product] of productsToCheck) {
+        for (const product of productsToCheck.values()) {
           this.tickerConn.send('RequestFrontMonthContract', {
             templateId: 113,
             userMsg: [product.productCode],
@@ -421,20 +414,19 @@ class RithmicService extends EventEmitter {
           });
         }
 
-        // After another 5 seconds, collect results
+        // Collect results after timeout
         setTimeout(() => {
           this.tickerConn.removeListener('message', frontMonthHandler);
-          
-          // Merge with product names and add category info
+
           const results = [];
           for (const [baseSymbol, contract] of contracts) {
             const productKey = `${baseSymbol}:${contract.exchange}`;
             const product = productsToCheck.get(productKey);
             const symbolInfo = getSymbolInfo(baseSymbol);
-            
+
             results.push({
               symbol: contract.symbol,
-              baseSymbol: baseSymbol,
+              baseSymbol,
               name: symbolInfo.name || product?.productName || baseSymbol,
               exchange: contract.exchange,
               category: symbolInfo.category,
@@ -445,7 +437,7 @@ class RithmicService extends EventEmitter {
             });
           }
 
-          // Sort by category order, then by symbol name within category
+          // Sort by category order
           results.sort((a, b) => {
             if (a.categoryOrder !== b.categoryOrder) {
               return a.categoryOrder - b.categoryOrder;
@@ -453,72 +445,72 @@ class RithmicService extends EventEmitter {
             return a.baseSymbol.localeCompare(b.baseSymbol);
           });
 
-          debug(`Got ${results.length} tradeable contracts from API`);
+          log.debug('Got contracts from API', { count: results.length });
           resolve(results);
-        }, 8000);
-      }, 5000);
+        }, TIMEOUTS.RITHMIC_PRODUCTS);
+      }, TIMEOUTS.RITHMIC_CONTRACTS);
     });
   }
 
   /**
-   * Get all available contracts - 100% REAL DATA from Rithmic API
-   * Fetches product codes and front months directly from the API
+   * Decode ProductCodes response
+   * @private
    */
-  async getContracts() {
-    // Return cached if available and fresh (5 min cache)
-    if (this.cachedContracts && this.cachedContracts.timestamp > Date.now() - 300000) {
-      return { success: true, contracts: this.cachedContracts.data, source: 'cache' };
-    }
-
-    // Need credentials to fetch real data
-    if (!this.credentials) {
-      return { success: false, error: 'Not logged in - cannot fetch contracts from API' };
-    }
+  _decodeProductCodes(buffer) {
+    const result = {};
+    let offset = 0;
 
-    try {
-      // Connect to TICKER_PLANT if not connected
-      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' };
-        }
+    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];
+    };
 
-      // Increase max listeners to avoid warnings
-      this.tickerConn.setMaxListeners(5000);
+    const readString = (buf, off) => {
+      const [len, newOff] = readVarint(buf, off);
+      return [buf.slice(newOff, newOff + len).toString('utf8'), newOff + len];
+    };
 
-      debug('Fetching all tradeable contracts from Rithmic API...');
-      const contracts = await this.fetchAllFrontMonths();
+    while (offset < buffer.length) {
+      try {
+        const [tag, tagOff] = readVarint(buffer, offset);
+        const wireType = tag & 0x7;
+        const fieldNumber = tag >>> 3;
+        offset = tagOff;
 
-      if (contracts.length === 0) {
-        return { success: false, error: 'No tradeable contracts found' };
+        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;
       }
-
-      // Cache the results
-      this.cachedContracts = { data: contracts, timestamp: Date.now() };
-      return { success: true, contracts, source: 'api' };
-
-    } catch (e) {
-      debug('getContracts error:', e.message);
-      return { success: false, error: e.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)
-    );
+    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()
@@ -531,22 +523,31 @@ class RithmicService extends EventEmitter {
     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 ====================
+
+  /**
+   * Disconnect all connections
+   */
   async disconnect() {
-    if (this.orderConn) {
-      await this.orderConn.disconnect();
-      this.orderConn = null;
-    }
-    if (this.pnlConn) {
-      await this.pnlConn.disconnect();
-      this.pnlConn = null;
-    }
-    if (this.tickerConn) {
-      await this.tickerConn.disconnect();
-      this.tickerConn = null;
+    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 });
+        }
+      }
     }
+
+    this.orderConn = null;
+    this.pnlConn = null;
+    this.tickerConn = null;
     this.accounts = [];
     this.accountPnL.clear();
     this.positions.clear();
@@ -554,7 +555,9 @@ class RithmicService extends EventEmitter {
     this.loginInfo = null;
     this.user = null;
     this.credentials = null;
-    this.cachedContracts = null;
+    this._contractsCache = null;
+
+    log.info('Disconnected');
   }
 }