hedgequantx 2.6.163 → 2.7.1

package/src/lib/data.js

@@ -0,0 +1,555 @@
+/**
+ * Market Data Feed
+ * Connects to PropFirm market data via SignalR (ProjectX Gateway API)
+ * Feeds real-time data to the algo engine
+ */
+
+const EventEmitter = require('events');
+const signalR = require('@microsoft/signalr');
+
+// ProjectX Gateway SignalR endpoints
+// Pattern: replace 'api.' with 'rtc.' in gatewayApi URL
+const PROPFIRM_RTC_ENDPOINTS = {
+  topstep: {
+    market: 'https://rtc.topstepx.com/hubs/market',
+    user: 'https://rtc.topstepx.com/hubs/user'
+  },
+  alpha_futures: {
+    market: 'https://rtc.alphafutures.projectx.com/hubs/market',
+    user: 'https://rtc.alphafutures.projectx.com/hubs/user'
+  },
+  tickticktrader: {
+    market: 'https://rtc.tickticktrader.projectx.com/hubs/market',
+    user: 'https://rtc.tickticktrader.projectx.com/hubs/user'
+  },
+  bulenox: {
+    market: 'https://rtc.bulenox.projectx.com/hubs/market',
+    user: 'https://rtc.bulenox.projectx.com/hubs/user'
+  },
+  tradeday: {
+    market: 'https://rtc.tradeday.projectx.com/hubs/market',
+    user: 'https://rtc.tradeday.projectx.com/hubs/user'
+  },
+  blusky: {
+    market: 'https://rtc.blusky.projectx.com/hubs/market',
+    user: 'https://rtc.blusky.projectx.com/hubs/user'
+  },
+  goat_futures: {
+    market: 'https://rtc.goatfutures.projectx.com/hubs/market',
+    user: 'https://rtc.goatfutures.projectx.com/hubs/user'
+  },
+  futures_desk: {
+    market: 'https://rtc.thefuturesdesk.projectx.com/hubs/market',
+    user: 'https://rtc.thefuturesdesk.projectx.com/hubs/user'
+  },
+  daytraders: {
+    market: 'https://rtc.daytraders.projectx.com/hubs/market',
+    user: 'https://rtc.daytraders.projectx.com/hubs/user'
+  },
+  e8_futures: {
+    market: 'https://rtc.e8futures.projectx.com/hubs/market',
+    user: 'https://rtc.e8futures.projectx.com/hubs/user'
+  },
+  blue_guardian: {
+    market: 'https://rtc.blueguardianfutures.projectx.com/hubs/market',
+    user: 'https://rtc.blueguardianfutures.projectx.com/hubs/user'
+  },
+  futures_elite: {
+    market: 'https://rtc.futureselite.projectx.com/hubs/market',
+    user: 'https://rtc.futureselite.projectx.com/hubs/user'
+  },
+  fxify: {
+    market: 'https://rtc.fxify.projectx.com/hubs/market',
+    user: 'https://rtc.fxify.projectx.com/hubs/user'
+  },
+  hola_prime: {
+    market: 'https://rtc.holaprime.projectx.com/hubs/market',
+    user: 'https://rtc.holaprime.projectx.com/hubs/user'
+  },
+  top_one_futures: {
+    market: 'https://rtc.toponefutures.projectx.com/hubs/market',
+    user: 'https://rtc.toponefutures.projectx.com/hubs/user'
+  },
+  funding_futures: {
+    market: 'https://rtc.fundingfutures.projectx.com/hubs/market',
+    user: 'https://rtc.fundingfutures.projectx.com/hubs/user'
+  },
+  tx3_funding: {
+    market: 'https://rtc.tx3funding.projectx.com/hubs/market',
+    user: 'https://rtc.tx3funding.projectx.com/hubs/user'
+  },
+  lucid_trading: {
+    market: 'https://rtc.lucidtrading.projectx.com/hubs/market',
+    user: 'https://rtc.lucidtrading.projectx.com/hubs/user'
+  },
+  tradeify: {
+    market: 'https://rtc.tradeify.projectx.com/hubs/market',
+    user: 'https://rtc.tradeify.projectx.com/hubs/user'
+  }
+};
+
+// Default fallback
+const DEFAULT_ENDPOINTS = PROPFIRM_RTC_ENDPOINTS.topstep;
+
+// NO STATIC CONTRACT DATA - All contract specs come from API
+// Use contract.tickSize and contract.tickValue from API response
+
+class MarketDataFeed extends EventEmitter {
+  constructor(config) {
+    super();
+    
+    this.config = config;
+    this.marketConnection = null;
+    this.userConnection = null;
+    this.isConnected = false;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+    this.subscriptions = new Set();
+    
+    // Data buffers
+    this.dataBuffers = new Map();
+    this.lastTick = new Map();
+    this.orderBook = new Map(); // DOM data
+  }
+
+  /**
+   * Connect to market data feed via SignalR
+   */
+  async connect(userToken, propfirm, contractId = null) {
+    try {
+      const endpoints = PROPFIRM_RTC_ENDPOINTS[propfirm] || DEFAULT_ENDPOINTS;
+      // // console.log(`[MARKET] Connecting to ${propfirm} RTC: ${endpoints.market}`);
+      
+      // Build URL with access_token query parameter
+      const urlWithToken = `${endpoints.market}?access_token=${encodeURIComponent(userToken)}`;
+      
+      // Build SignalR connection - NO LOGGING to prevent stdout pollution
+      this.marketConnection = new signalR.HubConnectionBuilder()
+        .withUrl(urlWithToken, {
+          skipNegotiation: true,
+          transport: signalR.HttpTransportType.WebSockets
+        })
+        .withAutomaticReconnect([0, 2000, 5000, 10000, 30000])
+        .configureLogging(signalR.LogLevel.None)
+        .build();
+      
+      // Store contractId for immediate subscription
+      this._pendingContractId = contractId;
+      
+      // Setup event handlers BEFORE starting
+      this._setupMarketEventHandlers();
+      
+      // Start connection
+      // // console.log(`[MARKET] Starting SignalR connection...`);
+      await this.marketConnection.start();
+      // // console.log(`[MARKET] Connected! State: ${this.marketConnection.state}`);
+      
+      // IMMEDIATELY subscribe if contractId provided - don't wait!
+      if (contractId && this.marketConnection.state === 'Connected') {
+        // // console.log(`[MARKET] Immediate subscribe to ${contractId}`);
+        try {
+          await this.marketConnection.invoke('SubscribeContractQuotes', contractId);
+          // // console.log(`[MARKET] Quotes OK`);
+          await this.marketConnection.invoke('SubscribeContractTrades', contractId);
+          // // console.log(`[MARKET] Trades OK`);
+          
+          const subscriptionKey = `${contractId}:${contractId}`;
+          this.subscriptions.add(subscriptionKey);
+          this.dataBuffers.set(subscriptionKey, []);
+        } catch (subError) {
+          // // console.log(`[MARKET] Immediate subscribe failed: ${subError.message}`);
+        }
+      }
+      
+      this.isConnected = true;
+      this.reconnectAttempts = 0;
+      this.emit('connected');
+      
+      return true;
+      
+    } catch (error) {
+      // // console.log(`[MARKET] Connection error: ${error.message}`);
+      this.emit('error', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Setup SignalR event handlers for market data
+   */
+  _setupMarketEventHandlers() {
+    // Quote updates (bid/ask) - args: [contractId, quoteObject]
+    this.marketConnection.on('GatewayQuote', (...args) => {
+      this._handleQuote(args);
+    });
+    
+    // Trade updates - args: [contractId, tradesArray]
+    this.marketConnection.on('GatewayTrade', (...args) => {
+      this._handleTrade(args);
+    });
+    
+    // DOM/Depth updates - args: [contractId, depthObject]
+    this.marketConnection.on('GatewayDepth', (...args) => {
+      this._handleDepth(args);
+    });
+    
+    // Gateway logout - server is kicking us out
+    this.marketConnection.on('GatewayLogout', (...args) => {
+      // // console.log(`[MARKET] GatewayLogout received:`, args);
+    });
+    
+    // Also handle lowercase version
+    this.marketConnection.on('gatewaylogout', (...args) => {
+      // // console.log(`[MARKET] gatewaylogout received:`, args);
+    });
+    
+    // Connection state changes
+    this.marketConnection.onreconnecting((error) => {
+      // // console.log(`[MARKET] Reconnecting... Error: ${error?.message || 'none'}`);
+      this.isConnected = false;
+      this.emit('reconnecting', { error: error?.message });
+    });
+    
+    this.marketConnection.onreconnected((connectionId) => {
+      // // console.log(`[MARKET] Reconnected! ConnectionId: ${connectionId}`);
+      this.isConnected = true;
+      this.emit('reconnected', { connectionId });
+      // Resubscribe to all symbols
+      this._resubscribeAll();
+    });
+    
+    this.marketConnection.onclose((error) => {
+      // // console.log(`[MARKET] Connection CLOSED! Error: ${error?.message || 'none'}`);
+      this.isConnected = false;
+      this.emit('disconnected', { error: error?.message });
+    });
+  }
+
+  /**
+   * Subscribe to symbol market data
+   * Implements retry logic for connection race conditions
+   */
+  async subscribe(symbol, contractId, retryCount = 0) {
+    // // console.log(`[MARKET] Subscribe called - symbol: ${symbol}, contractId: ${contractId}`);
+    
+    const subscriptionKey = `${symbol}:${contractId}`;
+    
+    if (this.subscriptions.has(subscriptionKey)) {
+      return true; // Already subscribed
+    }
+    
+    // Check connection state
+    const state = this.marketConnection?.state;
+    // // console.log(`[MARKET] Connection state: ${state}`);
+    
+    if (state !== 'Connected') {
+      if (retryCount < 5) {
+        // // console.log(`[MARKET] Not connected, waiting 500ms and retrying... (${retryCount + 1}/5)`);
+        await new Promise(resolve => setTimeout(resolve, 500));
+        return this.subscribe(symbol, contractId, retryCount + 1);
+      } else {
+        // // console.log(`[MARKET] ERROR: Connection not available after 5 retries`);
+        this.emit('error', new Error('Connection not available'));
+        return false;
+      }
+    }
+    
+    try {
+      // Subscribe to quotes - do it immediately, no delay
+      // // console.log(`[MARKET] Subscribing to ${contractId}...`);
+      await this.marketConnection.invoke('SubscribeContractQuotes', contractId);
+      // // console.log(`[MARKET] Quotes subscribed`);
+      
+      // Subscribe to trades
+      await this.marketConnection.invoke('SubscribeContractTrades', contractId);
+      // // console.log(`[MARKET] Trades subscribed`);
+      
+      this.subscriptions.add(subscriptionKey);
+      this.dataBuffers.set(subscriptionKey, []);
+      this.isConnected = true;
+      
+      this.emit('subscribed', { symbol, contractId });
+      return true;
+      
+    } catch (error) {
+      // // console.log(`[MARKET] Subscribe ERROR: ${error.message}`);
+      
+      // If connection was closed, try to reconnect
+      if (error.message.includes('not in the') && retryCount < 3) {
+        // // console.log(`[MARKET] Connection lost, will retry on reconnect`);
+        this.isConnected = false;
+      }
+      
+      this.emit('error', error);
+      return false;
+    }
+  }
+
+  /**
+   * Unsubscribe from symbol market data
+   */
+  async unsubscribe(symbol, contractId) {
+    const subscriptionKey = `${symbol}:${contractId}`;
+    
+    if (!this.subscriptions.has(subscriptionKey)) {
+      return true;
+    }
+    
+    try {
+      await this.marketConnection.invoke('UnsubscribeContractQuotes', contractId);
+      await this.marketConnection.invoke('UnsubscribeContractTrades', contractId);
+      await this.marketConnection.invoke('UnsubscribeContractMarketDepth', contractId);
+      
+      this.subscriptions.delete(subscriptionKey);
+      this.dataBuffers.delete(subscriptionKey);
+      
+      this.emit('unsubscribed', { symbol, contractId });
+      return true;
+      
+    } catch (error) {
+      this.emit('error', error);
+      return false;
+    }
+  }
+
+  /**
+   * Resubscribe to all symbols after reconnection
+   */
+  async _resubscribeAll() {
+    for (const subscriptionKey of this.subscriptions) {
+      const [symbol, contractId] = subscriptionKey.split(':');
+      this.subscriptions.delete(subscriptionKey); // Remove so subscribe works
+      await this.subscribe(symbol, contractId);
+    }
+  }
+
+  /**
+   * Handle quote update (bid/ask)
+   * Format: args[0] = contractId, args[1] = quote object
+   */
+  _handleQuote(args) {
+    // Debug log every 100th quote
+    if (!this._quoteCount) this._quoteCount = 0;
+    this._quoteCount++;
+    if (this._quoteCount % 100 === 1) {
+      // // console.log(`[MARKET] Quote #${this._quoteCount}:`, JSON.stringify(args).substring(0, 200));
+    }
+    
+    const contractId = args[0];
+    const quote = args[1] || {};
+    
+    const { symbol, lastPrice, bestBid, bestAsk, change, changePercent, volume, timestamp } = quote;
+    
+    // Find matching subscription
+    let subscriptionKey = null;
+    for (const key of this.subscriptions) {
+      if (key.includes(contractId)) {
+        subscriptionKey = key;
+        break;
+      }
+    }
+    
+    if (!subscriptionKey) {
+      subscriptionKey = `${contractId}:${contractId}`;
+    }
+    
+    // Calculate price - use lastPrice, or mid of bid/ask
+    const bid = parseFloat(bestBid) || 0;
+    const ask = parseFloat(bestAsk) || 0;
+    const last = parseFloat(lastPrice) || 0;
+    const price = last > 0 ? last : (bid > 0 && ask > 0 ? (bid + ask) / 2 : bid || ask);
+    
+    const quoteData = {
+      type: 'quote',
+      symbol: symbol || contractId,
+      contractId,
+      price,
+      bid,
+      ask,
+      spread: ask > 0 && bid > 0 ? ask - bid : 0,
+      mid: bid > 0 && ask > 0 ? (bid + ask) / 2 : price,
+      change: parseFloat(change) || 0,
+      changePercent: parseFloat(changePercent) || 0,
+      volume: parseInt(volume) || 0,
+      timestamp: timestamp || Date.now()
+    };
+    
+    // Update last tick - merge with existing data
+    const lastTick = this.lastTick.get(subscriptionKey) || {};
+    const updatedTick = { ...lastTick };
+    
+    // Only update fields that have valid values
+    if (price > 0) updatedTick.price = price;
+    if (bid > 0) updatedTick.bid = bid;
+    if (ask > 0) updatedTick.ask = ask;
+    if (quoteData.spread > 0) updatedTick.spread = quoteData.spread;
+    if (quoteData.mid > 0) updatedTick.mid = quoteData.mid;
+    if (quoteData.change !== 0) updatedTick.change = quoteData.change;
+    if (quoteData.changePercent !== 0) updatedTick.changePercent = quoteData.changePercent;
+    if (quoteData.volume > 0) updatedTick.volume = quoteData.volume;
+    updatedTick.timestamp = quoteData.timestamp;
+    updatedTick.type = 'quote';
+    updatedTick.symbol = quoteData.symbol;
+    updatedTick.contractId = contractId;
+    
+    this.lastTick.set(subscriptionKey, updatedTick);
+    
+    this.emit('quote', updatedTick);
+    this.emit('tick', updatedTick);
+  }
+
+  /**
+   * Handle trade update
+   * Format: args[0] = contractId, args[1] = array of trades
+   */
+  _handleTrade(args) {
+    // Debug log every 50th trade
+    if (!this._tradeCount) this._tradeCount = 0;
+    this._tradeCount++;
+    if (this._tradeCount % 50 === 1) {
+      // // console.log(`[MARKET] Trade #${this._tradeCount}:`, JSON.stringify(args).substring(0, 200));
+    }
+    
+    const contractId = args[0];
+    const trades = args[1] || [];
+    
+    // Find matching subscription
+    let subscriptionKey = null;
+    for (const key of this.subscriptions) {
+      if (key.includes(contractId)) {
+        subscriptionKey = key;
+        break;
+      }
+    }
+    
+    if (!subscriptionKey) {
+      subscriptionKey = `${contractId}:${contractId}`;
+    }
+    
+    // Process each trade in the array
+    for (const trade of trades) {
+      const { symbolId, price, timestamp, type, volume } = trade;
+      
+      const tradeData = {
+        type: 'trade',
+        symbol: symbolId || contractId,
+        contractId,
+        price: parseFloat(price),
+        size: parseInt(volume) || 1,
+        side: type === 0 ? 'buy' : type === 1 ? 'sell' : 'unknown',
+        volume: parseInt(volume) || 1,
+        timestamp: timestamp || Date.now()
+      };
+      
+      // Update last tick with trade price
+      const lastTick = this.lastTick.get(subscriptionKey) || {};
+      if (tradeData.price > 0) {
+        this.lastTick.set(subscriptionKey, { 
+          ...lastTick, 
+          price: tradeData.price,
+          lastTradeVolume: tradeData.volume,
+          lastTradeTime: tradeData.timestamp,
+          lastTradeSide: tradeData.side
+        });
+      }
+      
+      // Add to buffer
+      const buffer = this.dataBuffers.get(subscriptionKey) || [];
+      buffer.push(tradeData);
+      
+      // Keep buffer size limited (last 1000 trades)
+      if (buffer.length > 1000) {
+        buffer.shift();
+      }
+      this.dataBuffers.set(subscriptionKey, buffer);
+      
+      this.emit('trade', tradeData);
+      this.emit('tick', this.lastTick.get(subscriptionKey));
+    }
+  }
+
+  /**
+   * Handle depth/DOM update
+   * Format: args[0] = contractId, args[1] = depth data
+   */
+  _handleDepth(args) {
+    const contractId = args[0];
+    const depth = args[1] || {};
+    const { timestamp, type, price, volume, currentVolume } = depth;
+    
+    // type: 0 = bid, 1 = ask
+    const depthData = {
+      type: 'depth',
+      contractId,
+      side: type === 0 ? 'bid' : 'ask',
+      price: parseFloat(price) || 0,
+      volume: parseInt(volume) || 0,
+      currentVolume: parseInt(currentVolume) || 0,
+      timestamp: timestamp || Date.now()
+    };
+    
+    this.emit('depth', depthData);
+  }
+
+  /**
+   * Disconnect from market data feed
+   */
+  async disconnect() {
+    this.subscriptions.clear();
+    
+    if (this.marketConnection) {
+      try {
+        await this.marketConnection.stop();
+      } catch (e) {
+        // Ignore disconnect errors
+      }
+      this.marketConnection = null;
+    }
+    
+    this.isConnected = false;
+    this.emit('disconnected', { code: 1000, reason: 'User requested disconnect' });
+  }
+
+  /**
+   * Get last tick for symbol
+   */
+  getLastTick(symbol, contractId) {
+    const subscriptionKey = `${symbol}:${contractId}`;
+    return this.lastTick.get(subscriptionKey);
+  }
+
+  /**
+   * Get trade buffer for symbol
+   */
+  getTradeBuffer(symbol, contractId) {
+    const subscriptionKey = `${symbol}:${contractId}`;
+    return this.dataBuffers.get(subscriptionKey) || [];
+  }
+
+  // NO STATIC CONTRACT DATA - All specs come from API
+  // ProjectX: GET /api/Contract/available
+  // Rithmic: TICKER_PLANT API
+
+  /**
+   * Check if market is open
+   */
+  static isMarketOpen() {
+    const now = new Date();
+    const day = now.getUTCDay();
+    const hour = now.getUTCHours();
+    
+    // Futures trade Sunday 6pm - Friday 5pm ET (with daily break 5pm-6pm ET)
+    // Weekend check
+    if (day === 6) return false; // Saturday
+    if (day === 0 && hour < 23) return false; // Sunday before open
+    if (day === 5 && hour >= 22) return false; // Friday after close
+    if (hour === 22) return false; // Daily maintenance
+    
+    return true;
+  }
+}
+
+module.exports = { 
+  MarketDataFeed,
+  PROPFIRM_RTC_ENDPOINTS
+};