hedgequantx 2.6.23 → 2.6.25

package/package.json

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

package/src/pages/algo/one-account.js

@@ -19,6 +19,7 @@ const { PositionManager } = require('../../services/position-manager');
 // Strategy & Market Data (obfuscated)
 const { M1 } = require('../../../dist/lib/m/s1');
 const { MarketDataFeed } = require('../../../dist/lib/data');
+const { RithmicMarketDataFeed } = require('../../services/rithmic/market-data');
 const { algoLogger } = require('./logger');
 
 // AI Strategy Supervisor - observes, learns, and optimizes the strategy
@@ -335,8 +336,10 @@ const launchAlgo = async (service, account, contract, config) => {
   
   // Initialize AI Strategy Supervisor - agents observe, learn & optimize
   // Only if user enabled AI in config
+  let aiAgentCount = 0;
   if (config.enableAI) {
     const aiAgents = aiService.getAgents();
+    aiAgentCount = aiAgents.length;
     if (aiAgents.length > 0) {
       const supervisorResult = StrategySupervisor.initialize(strategy, aiAgents, service, account.accountId);
       stats.aiSupervision = supervisorResult.success;
@@ -345,7 +348,11 @@ const launchAlgo = async (service, account, contract, config) => {
   }
   
   // Initialize Market Data Feed
-  const marketFeed = new MarketDataFeed({ propfirm: account.propfirm });
+  // Use RithmicMarketDataFeed for Rithmic accounts (fast path), MarketDataFeed for ProjectX
+  const isRithmic = useFastPath && service.tickerConn;
+  const marketFeed = isRithmic 
+    ? new RithmicMarketDataFeed(service)
+    : new MarketDataFeed({ propfirm: account.propfirm });
   
   // Smart startup logs (same as HQX-TG)
   const market = checkMarketHours();
@@ -358,7 +365,7 @@ const launchAlgo = async (service, account, contract, config) => {
   
   // Log AI supervision status
   if (stats.aiSupervision) {
-    algoLogger.info(ui, 'AI SUPERVISION', `${aiAgents.length} agent(s) - ${stats.aiMode} mode - LEARNING ACTIVE`);
+    algoLogger.info(ui, 'AI SUPERVISION', `${aiAgentCount} agent(s) - ${stats.aiMode} mode - LEARNING ACTIVE`);
   }
   
   // Log execution path
@@ -603,29 +610,49 @@ const launchAlgo = async (service, account, contract, config) => {
   
   // Connect to market data
   try {
-    const propfirmKey = (account.propfirm || 'topstep').toLowerCase().replace(/\s+/g, '_');
-    
-    // CRITICAL: Get a fresh token for WebSocket connection
-    // TopStep invalidates WebSocket sessions for old tokens
-    algoLogger.info(ui, 'REFRESHING AUTH TOKEN...');
-    const token = await service.getFreshToken?.() || service.token || service.getToken?.();
-    
-    if (!token) {
-      algoLogger.error(ui, 'NO AUTH TOKEN', 'Please reconnect');
-    } else {
-      algoLogger.info(ui, 'TOKEN OK', `${token.length} chars`);
-      algoLogger.info(ui, 'CONNECTING', `${propfirmKey.toUpperCase()} | ${contractId}`);
+    if (isRithmic) {
+      // Rithmic: Use existing tickerConn from RithmicService
+      algoLogger.info(ui, 'CONNECTING', `RITHMIC TICKER | ${symbolName}`);
       
-      await marketFeed.connect(token, propfirmKey);
+      await marketFeed.connect();
       
       // Wait for connection to stabilize
-      await new Promise(r => setTimeout(r, 2000));
+      await new Promise(r => setTimeout(r, 1000));
       
       if (marketFeed.isConnected()) {
-        await marketFeed.subscribe(symbolName, contractId);
-        algoLogger.info(ui, 'SUBSCRIBED', `${symbolName} real-time feed active`);
+        // Use contract exchange or default to CME
+        const exchange = contract.exchange || 'CME';
+        marketFeed.subscribe(symbolName, exchange);
+        algoLogger.info(ui, 'SUBSCRIBED', `${symbolName} Rithmic real-time feed active`);
       } else {
-        algoLogger.error(ui, 'CONNECTION LOST', 'Before subscribe');
+        algoLogger.error(ui, 'CONNECTION LOST', 'Rithmic ticker not ready');
+      }
+    } else {
+      // ProjectX: Use HTTP token-based WebSocket
+      const propfirmKey = (account.propfirm || 'topstep').toLowerCase().replace(/\s+/g, '_');
+      
+      // CRITICAL: Get a fresh token for WebSocket connection
+      // TopStep invalidates WebSocket sessions for old tokens
+      algoLogger.info(ui, 'REFRESHING AUTH TOKEN...');
+      const token = await service.getFreshToken?.() || service.token || service.getToken?.();
+      
+      if (!token) {
+        algoLogger.error(ui, 'NO AUTH TOKEN', 'Please reconnect');
+      } else {
+        algoLogger.info(ui, 'TOKEN OK', `${token.length} chars`);
+        algoLogger.info(ui, 'CONNECTING', `${propfirmKey.toUpperCase()} | ${contractId}`);
+        
+        await marketFeed.connect(token, propfirmKey);
+        
+        // Wait for connection to stabilize
+        await new Promise(r => setTimeout(r, 2000));
+        
+        if (marketFeed.isConnected()) {
+          await marketFeed.subscribe(symbolName, contractId);
+          algoLogger.info(ui, 'SUBSCRIBED', `${symbolName} real-time feed active`);
+        } else {
+          algoLogger.error(ui, 'CONNECTION LOST', 'Before subscribe');
+        }
       }
     }
   } catch (e) {

package/src/services/rithmic/index.js

@@ -24,6 +24,63 @@ const { logger } = require('../../utils/logger');
 
 const log = logger.scope('Rithmic');
 
+/**
+ * CME Contract Specifications - Official exchange tick sizes and values
+ * 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 },    // E-mini S&P 500
+  NQ: { tickSize: 0.25, tickValue: 5.00 },     // E-mini NASDAQ-100
+  RTY: { tickSize: 0.10, tickValue: 5.00 },    // E-mini Russell 2000
+  YM: { tickSize: 1.00, tickValue: 5.00 },     // E-mini Dow ($5)
+  
+  // Micro Index Futures (CME)
+  MES: { tickSize: 0.25, tickValue: 1.25 },    // Micro E-mini S&P 500
+  MNQ: { tickSize: 0.25, tickValue: 0.50 },    // Micro E-mini NASDAQ-100
+  M2K: { tickSize: 0.10, tickValue: 0.50 },    // Micro E-mini Russell 2000
+  MYM: { tickSize: 1.00, tickValue: 0.50 },    // Micro E-mini Dow
+  
+  // Energy Futures (NYMEX)
+  CL: { tickSize: 0.01, tickValue: 10.00 },    // Crude Oil
+  QM: { tickSize: 0.025, tickValue: 12.50 },   // E-mini Crude Oil
+  MCL: { tickSize: 0.01, tickValue: 1.00 },    // Micro Crude Oil
+  NG: { tickSize: 0.001, tickValue: 10.00 },   // Natural Gas
+  QG: { tickSize: 0.005, tickValue: 12.50 },   // E-mini Natural Gas
+  
+  // Metal Futures (COMEX)
+  GC: { tickSize: 0.10, tickValue: 10.00 },    // Gold
+  MGC: { tickSize: 0.10, tickValue: 1.00 },    // Micro Gold
+  SI: { tickSize: 0.005, tickValue: 25.00 },   // Silver
+  SIL: { tickSize: 0.005, tickValue: 2.50 },   // Micro Silver (1000oz)
+  HG: { tickSize: 0.0005, tickValue: 12.50 },  // Copper
+  MHG: { tickSize: 0.0005, tickValue: 1.25 },  // Micro Copper
+  
+  // Treasury Futures (CBOT)
+  ZB: { tickSize: 0.03125, tickValue: 31.25 }, // 30-Year T-Bond
+  ZN: { tickSize: 0.015625, tickValue: 15.625 }, // 10-Year T-Note
+  ZF: { tickSize: 0.0078125, tickValue: 7.8125 }, // 5-Year T-Note
+  ZT: { tickSize: 0.0078125, tickValue: 15.625 }, // 2-Year T-Note
+  
+  // Agricultural Futures (CBOT)
+  ZC: { tickSize: 0.25, tickValue: 12.50 },    // Corn
+  ZS: { tickSize: 0.25, tickValue: 12.50 },    // Soybeans
+  ZW: { tickSize: 0.25, tickValue: 12.50 },    // Wheat
+  ZL: { tickSize: 0.01, tickValue: 6.00 },     // Soybean Oil
+  ZM: { tickSize: 0.10, tickValue: 10.00 },    // Soybean Meal
+  
+  // Currency Futures (CME)
+  '6E': { tickSize: 0.00005, tickValue: 6.25 }, // Euro FX
+  '6J': { tickSize: 0.0000005, tickValue: 6.25 }, // Japanese Yen
+  '6B': { tickSize: 0.0001, tickValue: 6.25 }, // British Pound
+  '6A': { tickSize: 0.0001, tickValue: 10.00 }, // Australian Dollar
+  '6C': { tickSize: 0.00005, tickValue: 5.00 }, // Canadian Dollar
+  
+  // VIX Futures (CFE)
+  VX: { tickSize: 0.05, tickValue: 50.00 },    // VIX Futures
+};
+
 /** PropFirm configurations */
 const PROPFIRM_CONFIGS = {
   apex: { name: 'Apex Trader Funding', systemName: 'Apex', gateway: RITHMIC_ENDPOINTS.CHICAGO },
@@ -767,15 +824,19 @@ class RithmicService extends EventEmitter {
             const productKey = `${baseSymbol}:${contract.exchange}`;
             const product = productsToCheck.get(productKey);
 
-            // 100% API data - no static symbol info
+            // API data + CME contract specs (technical constants)
             const productName = product?.productName || baseSymbol;
+            const specs = CME_CONTRACT_SPECS[baseSymbol] || null;
+            
             results.push({
               symbol: contract.symbol,
               baseSymbol,
               name: contract.symbol, // Use trading symbol as name
               description: productName, // Product name as description (like ProjectX)
               exchange: contract.exchange,
-              // All other data comes from API at runtime
+              // CME contract specifications (official exchange constants)
+              tickSize: specs?.tickSize ?? null,
+              tickValue: specs?.tickValue ?? null,
             });
           }
 

package/src/services/rithmic/market-data.js

@@ -0,0 +1,528 @@
+/**
+ * =============================================================================
+ * Rithmic Market Data Feed
+ * =============================================================================
+ * Handles real-time quotes and trades streaming via Rithmic WebSocket
+ * 
+ * Based on HQX-TG RithmicMarketData implementation
+ * 
+ * IMPORTANT: Use continuous/front-month symbols for subscriptions:
+ * - ES, NQ, MES, MNQ (NOT ESH25, NQH25, etc.)
+ * - Rithmic automatically routes to the current front-month contract
+ */
+
+const EventEmitter = require('events');
+const { logger } = require('../../utils/logger');
+
+const log = logger.scope('RithmicMD');
+
+// Template IDs for Rithmic messages
+const TEMPLATE_IDS = {
+  // Request
+  MARKET_DATA_UPDATE: 100,
+  // Response/Stream
+  LAST_TRADE: 150,
+  BEST_BID_OFFER: 151,
+};
+
+// Rithmic field IDs for LastTrade (from protobuf)
+const LAST_TRADE_FIELDS = {
+  TEMPLATE_ID: 154467,
+  SYMBOL: 110100,
+  EXCHANGE: 110101,
+  TRADE_PRICE: 100006,
+  TRADE_SIZE: 100178,
+  AGGRESSOR: 112003,  // 1=BUY, 2=SELL
+  SSBOE: 150100,
+  USECS: 150101,
+};
+
+// Rithmic field IDs for BestBidOffer (from protobuf)
+const BBO_FIELDS = {
+  TEMPLATE_ID: 154467,
+  SYMBOL: 110100,
+  EXCHANGE: 110101,
+  BID_PRICE: 100022,
+  BID_SIZE: 100030,
+  ASK_PRICE: 100025,
+  ASK_SIZE: 100031,
+  SSBOE: 150100,
+  USECS: 150101,
+};
+
+/**
+ * Read a varint from buffer starting at offset
+ * Uses BigInt internally to handle large field IDs correctly
+ * @param {Buffer} buffer 
+ * @param {number} offset 
+ * @returns {[number, number]} [value, newOffset]
+ */
+function readVarint(buffer, offset) {
+  let result = BigInt(0);
+  let shift = BigInt(0);
+  let pos = offset;
+
+  while (pos < buffer.length) {
+    const byte = buffer[pos++];
+    result |= BigInt(byte & 0x7f) << shift;
+    if ((byte & 0x80) === 0) {
+      return [Number(result), pos];
+    }
+    shift += BigInt(7);
+    if (shift > BigInt(63)) {
+      throw new Error('Varint too large');
+    }
+  }
+
+  throw new Error('Incomplete varint');
+}
+
+/**
+ * Read a length-delimited field (string/bytes)
+ * @param {Buffer} buffer 
+ * @param {number} offset 
+ * @returns {[string, number]} [value, newOffset]
+ */
+function readLengthDelimited(buffer, offset) {
+  const [length, newOffset] = readVarint(buffer, offset);
+  const value = buffer.slice(newOffset, newOffset + length).toString('utf8');
+  return [value, newOffset + length];
+}
+
+/**
+ * Skip a field based on wire type
+ * @param {Buffer} buffer 
+ * @param {number} offset 
+ * @param {number} wireType 
+ * @returns {number} newOffset
+ */
+function skipField(buffer, offset, wireType) {
+  switch (wireType) {
+    case 0: // Varint
+      const [, newOffset] = readVarint(buffer, offset);
+      return newOffset;
+    case 1: // 64-bit
+      return offset + 8;
+    case 2: // Length-delimited
+      const [length, lenOffset] = readVarint(buffer, offset);
+      return lenOffset + length;
+    case 5: // 32-bit
+      return offset + 4;
+    default:
+      throw new Error(`Unknown wire type: ${wireType}`);
+  }
+}
+
+/**
+ * Manually decode LastTrade message from Rithmic
+ * Required because protobufjs can't handle field IDs > 100000
+ * @param {Buffer} buffer 
+ * @returns {Object}
+ */
+function decodeLastTrade(buffer) {
+  const result = {};
+  let offset = 0;
+
+  while (offset < buffer.length) {
+    try {
+      const [tag, newOffset] = readVarint(buffer, offset);
+      const fieldNumber = tag >>> 3;
+      const wireType = tag & 0x7;
+      offset = newOffset;
+
+      switch (fieldNumber) {
+        case LAST_TRADE_FIELDS.SYMBOL:
+          if (wireType === 2) {
+            const [val, next] = readLengthDelimited(buffer, offset);
+            result.symbol = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case LAST_TRADE_FIELDS.EXCHANGE:
+          if (wireType === 2) {
+            const [val, next] = readLengthDelimited(buffer, offset);
+            result.exchange = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case LAST_TRADE_FIELDS.TRADE_PRICE:
+          if (wireType === 1) {
+            result.tradePrice = buffer.readDoubleLE(offset);
+            offset += 8;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case LAST_TRADE_FIELDS.TRADE_SIZE:
+          if (wireType === 0) {
+            const [val, next] = readVarint(buffer, offset);
+            result.tradeSize = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case LAST_TRADE_FIELDS.AGGRESSOR:
+          if (wireType === 0) {
+            const [val, next] = readVarint(buffer, offset);
+            result.aggressor = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case LAST_TRADE_FIELDS.SSBOE:
+          if (wireType === 0) {
+            const [val, next] = readVarint(buffer, offset);
+            result.ssboe = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case LAST_TRADE_FIELDS.USECS:
+          if (wireType === 0) {
+            const [val, next] = readVarint(buffer, offset);
+            result.usecs = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        default:
+          offset = skipField(buffer, offset, wireType);
+      }
+    } catch {
+      break;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Manually decode BestBidOffer message from Rithmic
+ * Required because protobufjs can't handle field IDs > 100000
+ * @param {Buffer} buffer 
+ * @returns {Object}
+ */
+function decodeBestBidOffer(buffer) {
+  const result = {};
+  let offset = 0;
+
+  while (offset < buffer.length) {
+    try {
+      const [tag, newOffset] = readVarint(buffer, offset);
+      const fieldNumber = tag >>> 3;
+      const wireType = tag & 0x7;
+      offset = newOffset;
+
+      switch (fieldNumber) {
+        case BBO_FIELDS.SYMBOL:
+          if (wireType === 2) {
+            const [val, next] = readLengthDelimited(buffer, offset);
+            result.symbol = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case BBO_FIELDS.EXCHANGE:
+          if (wireType === 2) {
+            const [val, next] = readLengthDelimited(buffer, offset);
+            result.exchange = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case BBO_FIELDS.BID_PRICE:
+          if (wireType === 1) {
+            result.bidPrice = buffer.readDoubleLE(offset);
+            offset += 8;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case BBO_FIELDS.BID_SIZE:
+          if (wireType === 0) {
+            const [val, next] = readVarint(buffer, offset);
+            result.bidSize = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case BBO_FIELDS.ASK_PRICE:
+          if (wireType === 1) {
+            result.askPrice = buffer.readDoubleLE(offset);
+            offset += 8;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case BBO_FIELDS.ASK_SIZE:
+          if (wireType === 0) {
+            const [val, next] = readVarint(buffer, offset);
+            result.askSize = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case BBO_FIELDS.SSBOE:
+          if (wireType === 0) {
+            const [val, next] = readVarint(buffer, offset);
+            result.ssboe = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        case BBO_FIELDS.USECS:
+          if (wireType === 0) {
+            const [val, next] = readVarint(buffer, offset);
+            result.usecs = val;
+            offset = next;
+          } else {
+            offset = skipField(buffer, offset, wireType);
+          }
+          break;
+        default:
+          offset = skipField(buffer, offset, wireType);
+      }
+    } catch {
+      break;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Rithmic Market Data Feed
+ * Provides real-time market data via Rithmic WebSocket connection
+ */
+class RithmicMarketDataFeed extends EventEmitter {
+  constructor(rithmicService) {
+    super();
+    this.service = rithmicService;
+    this.subscriptions = new Set();
+    this.connected = false;
+    this.messageHandler = null;
+    
+    // Stats for debugging
+    this.tradeCount = 0;
+    this.quoteCount = 0;
+    this.lastLogTime = 0;
+  }
+
+  /**
+   * Check if connected
+   * @returns {boolean}
+   */
+  isConnected() {
+    return this.connected && this.service?.tickerConn?.isConnected;
+  }
+
+  /**
+   * Connect to market data (uses existing tickerConn from RithmicService)
+   * @returns {Promise<boolean>}
+   */
+  async connect() {
+    if (!this.service || !this.service.tickerConn) {
+      throw new Error('RithmicService or tickerConn not available');
+    }
+
+    // Check if ticker connection is ready
+    if (!this.service.tickerConn.isConnected) {
+      throw new Error('Ticker connection not established');
+    }
+
+    // Setup message handler
+    this.messageHandler = ({ templateId, data }) => {
+      if (templateId === TEMPLATE_IDS.LAST_TRADE) {
+        this._handleTrade(data);
+      } else if (templateId === TEMPLATE_IDS.BEST_BID_OFFER) {
+        this._handleQuote(data);
+      }
+    };
+
+    this.service.tickerConn.on('message', this.messageHandler);
+    this.connected = true;
+    
+    log.info('Market data feed connected');
+    this.emit('connected');
+    
+    return true;
+  }
+
+  /**
+   * Disconnect from market data
+   */
+  disconnect() {
+    if (this.messageHandler && this.service?.tickerConn) {
+      this.service.tickerConn.removeListener('message', this.messageHandler);
+    }
+    
+    // Unsubscribe all
+    for (const key of this.subscriptions) {
+      const [exchange, symbol] = key.split(':');
+      this._sendUnsubscribe(exchange, symbol);
+    }
+    
+    this.subscriptions.clear();
+    this.connected = false;
+    this.messageHandler = null;
+    
+    log.info('Market data feed disconnected');
+    this.emit('disconnected');
+  }
+
+  /**
+   * Subscribe to market data for a symbol
+   * @param {string} symbol - Trading symbol (e.g., ESH6, NQH6)
+   * @param {string} [exchange='CME'] - Exchange
+   */
+  subscribe(symbol, exchange = 'CME') {
+    const key = `${exchange}:${symbol}`;
+    if (this.subscriptions.has(key)) return;
+
+    if (!this.service?.tickerConn?.isConnected) {
+      log.warn('Cannot subscribe - ticker connection not ready');
+      return;
+    }
+
+    // Extract base symbol for subscription (ES from ESH6)
+    // Rithmic uses continuous symbols for subscriptions
+    const baseSymbol = symbol.replace(/[A-Z]\d+$/, '');
+    
+    this.service.tickerConn.send('RequestMarketDataUpdate', {
+      templateId: TEMPLATE_IDS.MARKET_DATA_UPDATE,
+      userMsg: ['HQX-CLI'],
+      symbol: baseSymbol,
+      exchange,
+      request: 1,  // SUBSCRIBE
+      updateBits: 3, // LAST_TRADE | BBO
+    });
+
+    this.subscriptions.add(key);
+    log.info(`Subscribed to ${key} (base: ${baseSymbol})`);
+  }
+
+  /**
+   * Unsubscribe from market data for a symbol
+   * @param {string} symbol 
+   * @param {string} [exchange='CME'] 
+   */
+  unsubscribe(symbol, exchange = 'CME') {
+    const key = `${exchange}:${symbol}`;
+    if (!this.subscriptions.has(key)) return;
+
+    this._sendUnsubscribe(exchange, symbol);
+    this.subscriptions.delete(key);
+    log.info(`Unsubscribed from ${key}`);
+  }
+
+  /**
+   * Send unsubscribe request
+   * @private
+   */
+  _sendUnsubscribe(exchange, symbol) {
+    if (!this.service?.tickerConn?.isConnected) return;
+
+    const baseSymbol = symbol.replace(/[A-Z]\d+$/, '');
+    
+    this.service.tickerConn.send('RequestMarketDataUpdate', {
+      templateId: TEMPLATE_IDS.MARKET_DATA_UPDATE,
+      userMsg: ['HQX-CLI'],
+      symbol: baseSymbol,
+      exchange,
+      request: 2, // UNSUBSCRIBE
+      updateBits: 3,
+    });
+  }
+
+  /**
+   * Handle incoming trade data
+   * @private
+   */
+  _handleTrade(data) {
+    const t = decodeLastTrade(data);
+
+    if (!t.symbol || t.tradePrice === undefined || t.tradeSize === undefined) {
+      return;
+    }
+
+    this.tradeCount++;
+    
+    // Log periodically
+    const now = Date.now();
+    if (now - this.lastLogTime > 30000) {
+      this.lastLogTime = now;
+      log.debug(`Stats: ${this.tradeCount} trades, ${this.quoteCount} quotes`);
+    }
+
+    // First trade and every 500th
+    if (this.tradeCount === 1 || this.tradeCount % 500 === 0) {
+      log.info(`Trade #${this.tradeCount}: ${t.symbol} ${t.tradeSize}@${t.tradePrice}`);
+    }
+
+    const trade = {
+      symbol: t.symbol,
+      exchange: t.exchange || 'CME',
+      price: t.tradePrice,
+      lastPrice: t.tradePrice,
+      size: t.tradeSize,
+      volume: t.tradeSize,
+      side: t.aggressor === 1 ? 'BUY' : 'SELL',
+      lastTradeSide: t.aggressor === 1 ? 'BUY' : 'SELL',
+      timestamp: (t.ssboe || 0) * 1000 + Math.floor((t.usecs || 0) / 1000),
+    };
+
+    this.emit('tick', trade);
+    this.emit('trade', trade);
+  }
+
+  /**
+   * Handle incoming quote data
+   * @private
+   */
+  _handleQuote(data) {
+    const q = decodeBestBidOffer(data);
+
+    if (!q.symbol) return;
+
+    this.quoteCount++;
+
+    const quote = {
+      symbol: q.symbol,
+      exchange: q.exchange || 'CME',
+      bid: q.bidPrice || 0,
+      bidPrice: q.bidPrice || 0,
+      bidSize: q.bidSize || 0,
+      ask: q.askPrice || 0,
+      askPrice: q.askPrice || 0,
+      askSize: q.askSize || 0,
+      timestamp: (q.ssboe || 0) * 1000 + Math.floor((q.usecs || 0) / 1000),
+    };
+
+    // Emit as tick with mid price
+    if (quote.bid && quote.ask) {
+      const tick = {
+        ...quote,
+        price: (quote.bid + quote.ask) / 2,
+        lastPrice: (quote.bid + quote.ask) / 2,
+      };
+      this.emit('tick', tick);
+    }
+    
+    this.emit('quote', quote);
+  }
+}
+
+module.exports = { RithmicMarketDataFeed };