hedgequantx 2.9.112 → 2.9.113

package/package.json

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

package/src/lib/data.js

@@ -171,11 +171,12 @@ class MarketDataFeed extends EventEmitter {
   }
 
   /**
-   * Get historical tick bars from HISTORY_PLANT
+   * Get historical 1-minute bars from HISTORY_PLANT
+   * Fetches raw ticks and aggregates them into 1-minute OHLCV bars
    * @param {string} symbol - Symbol (e.g., 'MNQH6')
    * @param {string} exchange - Exchange (default: 'CME')
-   * @param {number} barCount - Number of bars to fetch (default: 30)
-   * @returns {Promise<Array>} Array of tick bar objects {timestamp, open, high, low, close, volume}
+   * @param {number} barCount - Number of 1-min bars to return (default: 30)
+   * @returns {Promise<Array>} Array of 1-min bar objects {timestamp, open, high, low, close, volume}
    */
   async getHistoricalBars(symbol, exchange = 'CME', barCount = 30) {
     if (!this.credentials) {
@@ -193,51 +194,55 @@ class MarketDataFeed extends EventEmitter {
       await historyConn.connect(historyConfig);
       
       return new Promise((resolve, reject) => {
-        const bars = [];
+        const ticks = [];
         let isComplete = false;
         
+        // Request more ticks to cover barCount minutes (estimate ~1500 ticks/min for MNQ)
+        const ticksToRequest = Math.min(50000, barCount * 2000);
+        
         const timeout = setTimeout(() => {
           if (!isComplete) {
             historyConn.disconnect();
-            // Return what we have even on timeout
-            resolve(bars);
+            // Aggregate what we have and return
+            const aggregatedBars = this._aggregateTicksTo1MinBars(ticks, barCount);
+            resolve(aggregatedBars);
           }
-        }, 15000);
+        }, 20000);
 
-        // Listen for bar data (template 207)
+        // Listen for tick data (template 207)
         historyConn.on('message', (msg) => {
           if (msg.templateId === RES.TICK_BAR_REPLAY) {
             try {
               const data = proto.decode('ResponseTickBarReplay', msg.data);
-              const barObj = data.toJSON ? data.toJSON() : data;
+              const tickObj = data.toJSON ? data.toJSON() : data;
               
               // Check for error response
-              if (barObj.rpCode && barObj.rpCode[0] !== '0') {
+              if (tickObj.rpCode && tickObj.rpCode[0] !== '0') {
                 clearTimeout(timeout);
                 isComplete = true;
                 historyConn.disconnect();
-                reject(new Error(`History request failed: ${barObj.rpCode.join(' - ')}`));
+                reject(new Error(`History request failed: ${tickObj.rpCode.join(' - ')}`));
                 return;
               }
               
-              // Add bar if it has price data (OHLCV format)
-              if (barObj.closePrice !== undefined) {
-                bars.push({
-                  timestamp: barObj.ssboe ? barObj.ssboe * 1000 : Date.now(),
-                  open: Number(barObj.openPrice) || Number(barObj.closePrice),
-                  high: Number(barObj.highPrice) || Number(barObj.closePrice),
-                  low: Number(barObj.lowPrice) || Number(barObj.closePrice),
-                  close: Number(barObj.closePrice),
-                  volume: Number(barObj.volume) || 1,
+              // Add tick if it has price data
+              if (tickObj.closePrice !== undefined) {
+                ticks.push({
+                  timestamp: tickObj.ssboe ? tickObj.ssboe * 1000 : Date.now(),
+                  price: Number(tickObj.closePrice),
+                  volume: Number(tickObj.volume) || 1,
                 });
               }
               
               // Check if this is the final response (rpCode = ['0'])
-              if (barObj.rpCode && barObj.rpCode[0] === '0' && barObj.closePrice === undefined) {
+              if (tickObj.rpCode && tickObj.rpCode[0] === '0' && tickObj.closePrice === undefined) {
                 clearTimeout(timeout);
                 isComplete = true;
                 historyConn.disconnect();
-                resolve(bars);
+                
+                // Aggregate ticks into 1-minute bars
+                const aggregatedBars = this._aggregateTicksTo1MinBars(ticks, barCount);
+                resolve(aggregatedBars);
               }
             } catch (e) {
               this.emit('debug', `History decode error: ${e.message}`);
@@ -247,25 +252,22 @@ class MarketDataFeed extends EventEmitter {
 
         // Login to HISTORY_PLANT
         historyConn.once('loggedIn', () => {
-          // Request tick bar replay - limited count, most recent bars
-          // startIndex/finishIndex are required, but userMaxCount + direction=LAST
-          // will return only the most recent barCount bars
           const now = Math.floor(Date.now() / 1000);
-          const startTime = now - (24 * 60 * 60);  // 24 hours ago (wide range)
+          const startTime = now - (barCount * 2 * 60);  // Request 2x the time needed
           
           historyConn.send('RequestTickBarReplay', {
             templateId: REQ.TICK_BAR_REPLAY,  // 206
             userMsg: ['hqx-history'],
             symbol: symbol,
             exchange: exchange,
-            barType: 1,              // TICK_BAR
+            barType: 1,              // TICK_BAR (only option for raw ticks)
             barSubType: 1,           // REGULAR
             barTypeSpecifier: '1',   // 1 tick per bar
-            startIndex: startTime,   // Required by Rithmic
-            finishIndex: now,        // Required by Rithmic
-            userMaxCount: barCount,  // Limit to barCount bars
-            direction: 2,            // LAST (most recent bars first)
-            timeOrder: 1,            // FORWARDS (return in chronological order)
+            startIndex: startTime,   // Start time
+            finishIndex: now,        // End time
+            userMaxCount: ticksToRequest,  // Request enough ticks
+            direction: 2,            // LAST (most recent first)
+            timeOrder: 1,            // FORWARDS (chronological order)
           });
         });
 
@@ -283,6 +285,50 @@ class MarketDataFeed extends EventEmitter {
     }
   }
 
+  /**
+   * Aggregate raw ticks into 1-minute OHLCV bars
+   * @param {Array} ticks - Array of {timestamp, price, volume}
+   * @param {number} maxBars - Maximum number of bars to return
+   * @returns {Array} Array of 1-min bars {timestamp, open, high, low, close, volume}
+   */
+  _aggregateTicksTo1MinBars(ticks, maxBars) {
+    if (!ticks || ticks.length === 0) return [];
+
+    // Sort ticks by timestamp (oldest first)
+    const sortedTicks = [...ticks].sort((a, b) => a.timestamp - b.timestamp);
+
+    // Group ticks by minute
+    const barMap = new Map();
+    const barIntervalMs = 60000; // 1 minute
+
+    for (const tick of sortedTicks) {
+      const barStartTime = Math.floor(tick.timestamp / barIntervalMs) * barIntervalMs;
+      
+      if (!barMap.has(barStartTime)) {
+        barMap.set(barStartTime, {
+          timestamp: barStartTime,
+          open: tick.price,
+          high: tick.price,
+          low: tick.price,
+          close: tick.price,
+          volume: tick.volume,
+        });
+      } else {
+        const bar = barMap.get(barStartTime);
+        bar.high = Math.max(bar.high, tick.price);
+        bar.low = Math.min(bar.low, tick.price);
+        bar.close = tick.price;
+        bar.volume += tick.volume;
+      }
+    }
+
+    // Convert to array and sort by timestamp
+    const bars = Array.from(barMap.values()).sort((a, b) => a.timestamp - b.timestamp);
+
+    // Return only the last maxBars bars
+    return bars.slice(-maxBars);
+  }
+
   /**
    * Handle incoming messages from TICKER_PLANT
    */

package/src/pages/algo/algo-executor.js

@@ -409,22 +409,11 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     await marketFeed.connect(rithmicCredentials);
     await marketFeed.subscribe(symbolCode, contract.exchange || 'CME');
     
-    // Preload historical bars for HQX-2B strategy only (bar-based strategy)
-    // Note: HISTORY_PLANT may not be available on all accounts (e.g., paper trading)
-    if (strategyId === 'hqx-2b' && strategy.preloadBars) {
-      try {
-        ui.addLog('system', 'Loading historical bars...');
-        const historicalBars = await marketFeed.getHistoricalBars(symbolCode, contract.exchange || 'CME', 30);
-        if (historicalBars && historicalBars.length > 0) {
-          strategy.preloadBars(contractId, historicalBars);
-          ui.addLog('system', `Loaded ${historicalBars.length} bars - ready!`);
-        } else {
-          ui.addLog('system', 'No historical data - warming up with live bars...');
-        }
-      } catch (histErr) {
-        // HISTORY_PLANT not available (common on paper accounts)
-        ui.addLog('system', 'Historical data not available - warming up with live bars...');
-      }
+    // HQX-2B strategy warmup message
+    // Note: HISTORY_PLANT returns limited ticks (10k max = ~1 second of data)
+    // which is not enough for 1-min bar aggregation. Strategy warms up with live data.
+    if (strategyId === 'hqx-2b') {
+      ui.addLog('system', 'HQX-2B warming up - needs ~3 min for first signals...');
     }
   } catch (e) {
     ui.addLog('error', `Failed to connect: ${e.message}`);