hedgequantx 2.6.162 → 2.7.0

package/src/lib/data2.js

@@ -0,0 +1,492 @@
+/**
+ * Rithmic Market Data Feed
+ * Connects to Rithmic via WebSocket/Protobuf for real-time market data
+ * Used for Apex, TopstepTrader (Rithmic), Bulenox (Rithmic), etc.
+ */
+
+const EventEmitter = require('events');
+const WebSocket = require('ws');
+const protobuf = require('protobufjs');
+const path = require('path');
+
+// Rithmic Gateway Endpoints
+const RITHMIC_GATEWAYS = {
+  CHICAGO: 'wss://rprotocol.rithmic.com:443',
+  EUROPE: 'wss://rprotocol-ie.rithmic.com:443',
+  FRANKFURT: 'wss://rprotocol-de.rithmic.com:443',
+  SINGAPORE: 'wss://rprotocol-sg.rithmic.com:443',
+  SYDNEY: 'wss://rprotocol-au.rithmic.com:443',
+  TOKYO: 'wss://rprotocol-jp.rithmic.com:443',
+  TEST: 'wss://rituz00100.rithmic.com:443',
+  PAPER: 'wss://ritpa11120.11.rithmic.com:443'
+};
+
+// Rithmic System Names for PropFirms
+const RITHMIC_SYSTEMS = {
+  'apex': 'Apex',
+  'apex_rithmic': 'Apex',
+  'topsteptrader': 'TopstepTrader',
+  'topstep_r': 'TopstepTrader',
+  'bulenox_r': 'Bulenox',
+  'mescapital': 'MES Capital',
+  'earn2trade': 'Earn2Trade',
+  'tradefundrr': 'TradeFundrr',
+  'thetradingpit': 'TheTradingPit',
+  'fundedfutures': 'FundedFuturesNetwork',
+  'propshop': 'PropShopTrader',
+  '4proptrader': '4PropTrader',
+  'daytraders': 'DayTraders.com',
+  '10xfutures': '10XFutures',
+  'lucidtrading': 'LucidTrading',
+  'thrivetrading': 'ThriveTrading',
+  'legendstrading': 'LegendsTrading'
+};
+
+// Proto path
+const PROTO_PATH = path.join(__dirname, '../../protos/rithmic');
+
+class RithmicMarketDataFeed extends EventEmitter {
+  constructor(config) {
+    super();
+    
+    this.config = config;
+    this.ws = null;
+    this.isConnected = false;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+    this.subscriptions = new Set();
+    this.protoRoot = null;
+    
+    // Message types
+    this.RequestLogin = null;
+    this.ResponseLogin = null;
+    this.RequestMarketDataUpdate = null;
+    this.LastTrade = null;
+    this.BestBidOffer = null;
+    
+    // Data state
+    this.lastTick = new Map();
+    this.lastBid = 0;
+    this.lastAsk = 0;
+    this.lastPrice = 0;
+  }
+
+  /**
+   * Load protobuf definitions
+   */
+  async _loadProtos() {
+    if (this.protoRoot) return;
+    
+    try {
+      this.protoRoot = await protobuf.load([
+        path.join(PROTO_PATH, 'request_login.proto'),
+        path.join(PROTO_PATH, 'response_login.proto'),
+        path.join(PROTO_PATH, 'request_market_data_update.proto'),
+        path.join(PROTO_PATH, 'last_trade.proto'),
+        path.join(PROTO_PATH, 'best_bid_offer.proto'),
+        path.join(PROTO_PATH, 'request_heartbeat.proto'),
+        path.join(PROTO_PATH, 'response_heartbeat.proto')
+      ]);
+      
+      this.RequestLogin = this.protoRoot.lookupType('rti.RequestLogin');
+      this.ResponseLogin = this.protoRoot.lookupType('rti.ResponseLogin');
+      this.RequestMarketDataUpdate = this.protoRoot.lookupType('rti.RequestMarketDataUpdate');
+      this.LastTrade = this.protoRoot.lookupType('rti.LastTrade');
+      this.BestBidOffer = this.protoRoot.lookupType('rti.BestBidOffer');
+      this.RequestHeartbeat = this.protoRoot.lookupType('rti.RequestHeartbeat');
+      this.ResponseHeartbeat = this.protoRoot.lookupType('rti.ResponseHeartbeat');
+      
+      console.log('[RITHMIC] Protos loaded successfully');
+    } catch (error) {
+      console.error('[RITHMIC] Failed to load protos:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Connect to Rithmic market data feed
+   * @param {Object} credentials - { userId, password, systemName, gateway }
+   */
+  async connect(credentials) {
+    await this._loadProtos();
+    
+    const { userId, password, systemName, gateway } = credentials;
+    const gatewayUrl = gateway || RITHMIC_GATEWAYS.CHICAGO;
+    
+    console.log(`[RITHMIC] Connecting to ${gatewayUrl} as ${userId} on ${systemName}`);
+    
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(gatewayUrl, {
+        rejectUnauthorized: false
+      });
+      
+      const timeout = setTimeout(() => {
+        this.ws.close();
+        reject(new Error('Connection timeout'));
+      }, 15000);
+      
+      this.ws.on('open', async () => {
+        console.log('[RITHMIC] WebSocket connected, sending login...');
+        
+        try {
+          await this._sendLogin(userId, password, systemName);
+        } catch (error) {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      });
+      
+      this.ws.on('message', (data) => {
+        // Debug: log raw message receipt
+        this.rawMsgCount = (this.rawMsgCount || 0) + 1;
+        if (this.rawMsgCount <= 5 || this.rawMsgCount % 50 === 0) {
+          console.log(`[RITHMIC] Raw message #${this.rawMsgCount} received: ${data.length || data.byteLength} bytes`);
+        }
+        
+        this._handleMessage(data, (success, error) => {
+          if (success !== undefined) {
+            clearTimeout(timeout);
+            if (success) {
+              this.isConnected = true;
+              this.reconnectAttempts = 0;
+              this._startHeartbeat();
+              this.emit('connected');
+              resolve(true);
+            } else {
+              reject(new Error(error || 'Login failed'));
+            }
+          }
+        });
+      });
+      
+      this.ws.on('error', (error) => {
+        console.error('[RITHMIC] WebSocket error:', error.message);
+        this.emit('error', error);
+        clearTimeout(timeout);
+        reject(error);
+      });
+      
+      this.ws.on('close', (code, reason) => {
+        console.log(`[RITHMIC] WebSocket closed: ${code} - ${reason}`);
+        this.isConnected = false;
+        this._stopHeartbeat();
+        this.emit('disconnected', { code, reason: reason.toString() });
+        this._attemptReconnect(credentials);
+      });
+    });
+  }
+
+  /**
+   * Send login request
+   */
+  async _sendLogin(userId, password, systemName) {
+    // Template ID 10 = RequestLogin
+    // Field names must match proto (snake_case): template_id, template_version, etc.
+    const loginRequest = this.RequestLogin.create({
+      templateId: 10,           // template_id = 154467, value = 10
+      templateVersion: '3.9',   // template_version = 153634
+      user: userId,             // user = 131003
+      password: password,       // password = 130004
+      appName: 'App',    // app_name = 130002
+      appVersion: '1.0.0',      // app_version = 131803
+      systemName: systemName,   // system_name = 153628
+      infraType: 1              // infra_type = 153621, TICKER_PLANT = 1
+    });
+    
+    console.log('[RITHMIC] Login message:', JSON.stringify(loginRequest));
+    
+    const buffer = this.RequestLogin.encode(loginRequest).finish();
+    console.log('[RITHMIC] Login buffer size:', buffer.length);
+    console.log('[RITHMIC] Login buffer hex:', Buffer.from(buffer).toString('hex').slice(0, 100) + '...');
+    
+    this.ws.send(buffer);
+    console.log('[RITHMIC] Login request sent');
+  }
+
+  /**
+   * Handle incoming message
+   */
+  _handleMessage(data, loginCallback) {
+    try {
+      const buffer = new Uint8Array(data);
+      
+      // Log message count
+      this.msgCount = (this.msgCount || 0) + 1;
+      if (this.msgCount <= 20 || this.msgCount % 100 === 0) {
+        console.log(`[RITHMIC] Message #${this.msgCount}: ${buffer.length} bytes`);
+      }
+      
+      // Try to decode as ResponseLogin first
+      try {
+        const response = this.ResponseLogin.decode(buffer);
+        console.log(`[RITHMIC] Decoded response - templateId: ${response.templateId}, rpCode: ${JSON.stringify(response.rpCode)}`);
+        
+        // Template ID 11 is ResponseLogin
+        if (response.templateId === 11) {
+          const rpCode = Array.isArray(response.rpCode) ? response.rpCode[0] : response.rpCode;
+          
+          if (rpCode === '0') {
+            console.log('[RITHMIC] Login successful!');
+            console.log(`[RITHMIC] FCM: ${response.fcmId}, IB: ${response.ibId}`);
+            loginCallback(true);
+          } else {
+            console.log(`[RITHMIC] Login failed: ${response.textMsg || rpCode}`);
+            loginCallback(false, response.textMsg || `Error code: ${rpCode}`);
+          }
+          return;
+        }
+        
+        // Template ID 75 is RejectRequest (error)
+        if (response.templateId === 75) {
+          const errorMsg = Array.isArray(response.rpCode) ? response.rpCode.join(' - ') : response.rpCode;
+          console.log(`[RITHMIC] Request rejected: ${errorMsg}`);
+          loginCallback(false, errorMsg);
+          return;
+        }
+      } catch (e) {
+        // Not a login response, try other decoders
+      }
+      
+      // Use manual decoder for market data (protobufjs can't handle large field IDs)
+      const { getTemplateId, decodeLastTrade, decodeBestBidOffer } = require('./decoder');
+      const nodeBuffer = Buffer.from(buffer);
+      const templateId = getTemplateId(nodeBuffer);
+      
+      // LastTrade (template_id = 150)
+      if (templateId === 150) {
+        const trade = decodeLastTrade(nodeBuffer);
+        this._handleTrade(trade);
+        return;
+      }
+      
+      // BestBidOffer (template_id = 151)
+      if (templateId === 151) {
+        const quote = decodeBestBidOffer(nodeBuffer);
+        this._handleQuote(quote);
+        return;
+      }
+      
+      // Try heartbeat response
+      try {
+        const heartbeat = this.ResponseHeartbeat.decode(buffer);
+        if (heartbeat.templateId === 19) {
+          // Heartbeat acknowledged
+          return;
+        }
+      } catch (e) {
+        // Not a heartbeat
+      }
+      
+    } catch (error) {
+      console.error('[RITHMIC] Message decode error:', error.message);
+    }
+  }
+
+  /**
+   * Handle trade data
+   */
+  _handleTrade(trade) {
+    const price = trade.tradePrice || 0;
+    const size = trade.tradeSize || 1;
+    
+    // Determine side from aggressor field, or infer from bid/ask
+    let side = 'unknown';
+    if (trade.aggressor === 1) {
+      side = 'buy';
+    } else if (trade.aggressor === 2) {
+      side = 'sell';
+    } else if (this.lastBid > 0 && this.lastAsk > 0) {
+      // Infer from price vs bid/ask
+      if (price >= this.lastAsk) {
+        side = 'buy';  // Bought at ask (aggressor buyer)
+      } else if (price <= this.lastBid) {
+        side = 'sell'; // Sold at bid (aggressor seller)
+      }
+    }
+    
+    // Debug log every 500th trade
+    this.tradeCount = (this.tradeCount || 0) + 1;
+    if (this.tradeCount % 500 === 1) {
+      console.log(`[RITHMIC:MarketData] Trade #${this.tradeCount}: ${trade.symbol} @ ${price} x ${size} (${side})`);
+    }
+    
+    if (price > 0) {
+      this.lastPrice = price;
+      
+      const tradeData = {
+        type: 'trade',
+        symbol: trade.symbol || this.config.symbol,
+        price: price,
+        size: size,
+        side: side,
+        volume: size,
+        timestamp: Date.now()
+      };
+      
+      this.emit('trade', tradeData);
+      this.emit('tick', {
+        price: price,
+        bid: this.lastBid,
+        ask: this.lastAsk,
+        volume: size,
+        timestamp: Date.now()
+      });
+    }
+  }
+
+  /**
+   * Handle quote data
+   */
+  _handleQuote(quote) {
+    const bid = quote.bidPrice || 0;
+    const ask = quote.askPrice || 0;
+    
+    if (bid > 0) this.lastBid = bid;
+    if (ask > 0) this.lastAsk = ask;
+    
+    // Only emit if we have valid bid AND ask
+    if (this.lastBid <= 0 || this.lastAsk <= 0) return;
+    
+    const quoteData = {
+      type: 'quote',
+      symbol: quote.symbol || this.config.symbol,
+      bid: this.lastBid,
+      ask: this.lastAsk,
+      bidSize: quote.bidSize || 0,
+      askSize: quote.askSize || 0,
+      spread: this.lastAsk - this.lastBid,
+      price: this.lastPrice || this.lastBid, // Use last trade price, fallback to bid
+      timestamp: Date.now()
+    };
+    
+    this.emit('quote', quoteData);
+    this.emit('tick', {
+      price: quoteData.price,
+      bid: this.lastBid,
+      ask: this.lastAsk,
+      spread: quoteData.spread,
+      timestamp: Date.now()
+    });
+  }
+
+  /**
+   * Subscribe to symbol market data
+   */
+  async subscribe(symbol, exchange = 'CME') {
+    if (!this.isConnected || !this.ws) {
+      throw new Error('Not connected');
+    }
+    
+    console.log(`[RITHMIC] Subscribing to ${symbol} on ${exchange}`);
+    
+    // Template ID 100 = RequestMarketDataUpdate
+    const request = this.RequestMarketDataUpdate.create({
+      templateId: 100,
+      symbol: symbol,
+      exchange: exchange,
+      request: 1, // Subscribe
+      updateBits: 3 // LAST_TRADE (1) + BBO (2)
+    });
+    
+    const buffer = this.RequestMarketDataUpdate.encode(request).finish();
+    this.ws.send(buffer);
+    
+    this.subscriptions.add(`${symbol}:${exchange}`);
+    console.log(`[RITHMIC] Subscribed to ${symbol}`);
+    
+    return true;
+  }
+
+  /**
+   * Unsubscribe from symbol
+   */
+  async unsubscribe(symbol, exchange = 'CME') {
+    if (!this.isConnected || !this.ws) return;
+    
+    const request = this.RequestMarketDataUpdate.create({
+      templateId: 100,
+      symbol: symbol,
+      exchange: exchange,
+      request: 2 // Unsubscribe
+    });
+    
+    const buffer = this.RequestMarketDataUpdate.encode(request).finish();
+    this.ws.send(buffer);
+    
+    this.subscriptions.delete(`${symbol}:${exchange}`);
+  }
+
+  /**
+   * Start heartbeat
+   */
+  _startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      if (this.isConnected && this.ws && this.RequestHeartbeat) {
+        const heartbeat = this.RequestHeartbeat.create({
+          templateId: 18
+        });
+        const buffer = this.RequestHeartbeat.encode(heartbeat).finish();
+        this.ws.send(buffer);
+      }
+    }, 30000);
+  }
+
+  /**
+   * Stop heartbeat
+   */
+  _stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+
+  /**
+   * Attempt reconnection
+   */
+  _attemptReconnect(credentials) {
+    // Don't reconnect if intentionally disconnected
+    if (this.intentionalDisconnect) {
+      this.intentionalDisconnect = false;
+      return;
+    }
+    
+    if (this.reconnectAttempts < this.maxReconnectAttempts) {
+      this.reconnectAttempts++;
+      const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+      
+      console.log(`[RITHMIC] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+      
+      setTimeout(() => {
+        this.connect(credentials).catch(err => {
+          console.error('[RITHMIC] Reconnect failed:', err.message);
+        });
+      }, delay);
+    } else {
+      console.error('[RITHMIC] Max reconnect attempts reached');
+      this.emit('error', new Error('Max reconnect attempts reached'));
+    }
+  }
+
+  /**
+   * Disconnect
+   */
+  async disconnect() {
+    this._stopHeartbeat();
+    this.subscriptions.clear();
+    this.intentionalDisconnect = true; // Prevent reconnect attempts
+    
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    
+    this.isConnected = false;
+  }
+}
+
+module.exports = {
+  RithmicMarketDataFeed,
+  RITHMIC_GATEWAYS,
+  RITHMIC_SYSTEMS
+};