hedgequantx 2.9.88 → 2.9.90

package/dist/lib/m/hqx-2b.js

@@ -736,6 +736,47 @@ var require_core = __commonJS({
           message: `[HQX-2B] Reset state for ${contractId}`
         });
       }
+      /**
+       * Preload historical bars to warm up the strategy
+       * @param {string} contractId - Contract ID
+       * @param {Array} bars - Array of bars {timestamp, open, high, low, close, volume}
+       */
+      preloadBars(contractId, bars) {
+        if (!bars || bars.length === 0) {
+          this.emit("log", {
+            type: "debug",
+            message: `[HQX-2B] No historical bars to preload`
+          });
+          return;
+        }
+        if (!this.barHistory.has(contractId)) {
+          this.initialize(contractId);
+        }
+        const sortedBars = [...bars].sort((a, b) => a.timestamp - b.timestamp);
+        this.emit("log", {
+          type: "info",
+          message: `[HQX-2B] Preloading ${sortedBars.length} historical bars...`
+        });
+        let signalCount = 0;
+        for (const bar of sortedBars) {
+          const signal = this.processBar(contractId, bar);
+          if (signal) signalCount++;
+        }
+        const history = this.barHistory.get(contractId) || [];
+        const swings = this.swingPoints.get(contractId) || [];
+        const zones = this.liquidityZones.get(contractId) || [];
+        this.emit("log", {
+          type: "info",
+          message: `[HQX-2B] Preload complete: ${history.length} bars, ${swings.length} swings, ${zones.length} zones`
+        });
+        if (signalCount > 0) {
+          this.emit("log", {
+            type: "debug",
+            message: `[HQX-2B] ${signalCount} historical signals detected (ignored)`
+          });
+        }
+        this.lastSignalTime = 0;
+      }
     };
     module2.exports = { HQX2BLiquiditySweep: HQX2BLiquiditySweep2 };
   }

package/package.json

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

package/src/lib/data.js

@@ -16,7 +16,7 @@
 const EventEmitter = require('events');
 const { RithmicConnection } = require('../services/rithmic/connection');
 const { proto } = require('../services/rithmic/protobuf');
-const { REQ, RES, STREAM, RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS } = require('../services/rithmic/constants');
+const { REQ, RES, STREAM, RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS, INFRA_TYPE } = require('../services/rithmic/constants');
 
 // =============================================================================
 // MARKET DATA FEED CLASS (Rithmic TICKER_PLANT)
@@ -170,6 +170,99 @@ class MarketDataFeed extends EventEmitter {
     this.emit('disconnected');
   }
 
+  /**
+   * Get historical bars from HISTORY_PLANT
+   * @param {string} symbol - Symbol (e.g., 'MNQH5')
+   * @param {string} exchange - Exchange (default: 'CME')
+   * @param {number} barCount - Number of bars to fetch (default: 30)
+   * @returns {Promise<Array>} Array of bar objects {timestamp, open, high, low, close, volume}
+   */
+  async getHistoricalBars(symbol, exchange = 'CME', barCount = 30) {
+    if (!this.credentials) {
+      throw new Error('Not connected - call connect() first');
+    }
+
+    // Create a separate connection to HISTORY_PLANT
+    const historyConn = new RithmicConnection();
+    const historyConfig = {
+      ...this.config,
+      infraType: INFRA_TYPE.HISTORY_PLANT,
+    };
+
+    try {
+      await historyConn.connect(historyConfig);
+      
+      return new Promise((resolve, reject) => {
+        const bars = [];
+        const timeout = setTimeout(() => {
+          historyConn.disconnect();
+          if (bars.length > 0) {
+            resolve(bars);
+          } else {
+            reject(new Error('History request timeout'));
+          }
+        }, 10000);
+
+        // Listen for bar data
+        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;
+              
+              if (barObj.openPrice !== undefined) {
+                bars.push({
+                  timestamp: barObj.dataBarSsboe ? barObj.dataBarSsboe[0] * 1000 : Date.now(),
+                  open: Number(barObj.openPrice),
+                  high: Number(barObj.highPrice),
+                  low: Number(barObj.lowPrice),
+                  close: Number(barObj.closePrice),
+                  volume: Number(barObj.volume) || 0,
+                });
+              }
+              
+              // Check if this is the last bar (rpCode contains "end" or empty)
+              if (barObj.rpCode && barObj.rpCode.includes('0')) {
+                clearTimeout(timeout);
+                historyConn.disconnect();
+                resolve(bars);
+              }
+            } catch (e) {
+              this.emit('debug', `History decode error: ${e.message}`);
+            }
+          }
+        });
+
+        // Login to HISTORY_PLANT
+        historyConn.once('loggedIn', () => {
+          // Request tick bar replay (1-minute bars)
+          historyConn.send('RequestTickBarReplay', {
+            templateId: REQ.TICK_BAR_REPLAY,
+            symbol: symbol,
+            exchange: exchange,
+            barType: 1,           // TICK_BAR
+            barSubType: 1,        // REGULAR
+            barTypeSpecifier: '1', // 1-minute
+            userMaxCount: barCount,
+            direction: 2,         // LAST (most recent)
+            timeOrder: 2,         // BACKWARDS
+          });
+        });
+
+        historyConn.once('loginFailed', (data) => {
+          clearTimeout(timeout);
+          historyConn.disconnect();
+          reject(new Error(`HISTORY_PLANT login failed: ${data.message}`));
+        });
+
+        historyConn.login('HISTORY_PLANT');
+      });
+    } catch (e) {
+      historyConn.disconnect();
+      throw e;
+    }
+  }
+
   /**
    * Handle incoming messages from TICKER_PLANT
    */

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

@@ -410,6 +410,23 @@ 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)
+    if (strategyId === 'hqx-2b' && strategy.preloadBars) {
+      ui.addLog('system', 'Loading historical bars...');
+      try {
+        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 - strategy ready!`);
+        } else {
+          ui.addLog('system', 'No historical bars - collecting live data...');
+        }
+      } catch (histErr) {
+        ui.addLog('debug', `Historical data unavailable: ${histErr.message}`);
+        ui.addLog('system', 'Collecting live data...');
+      }
+    }
   } catch (e) {
     ui.addLog('error', `Failed to connect: ${e.message}`);
   }

package/src/services/rithmic/constants.js

@@ -60,6 +60,7 @@ const REQ = {
   MARKET_DATA: 100,
   PRODUCT_CODES: 111,
   FRONT_MONTH_CONTRACT: 113,
+  TICK_BAR_REPLAY: 200,    // History plant - request bar data
   LOGIN_INFO: 300,
   ACCOUNT_LIST: 302,
   ACCOUNT_RMS: 304,
@@ -88,6 +89,7 @@ const RES = {
   MARKET_DATA: 101,
   PRODUCT_CODES: 112,
   FRONT_MONTH_CONTRACT: 114,
+  TICK_BAR_REPLAY: 201,    // History plant - bar data response
   LOGIN_INFO: 301,
   ACCOUNT_LIST: 303,
   ACCOUNT_RMS: 305,
@@ -134,6 +136,8 @@ const PROTO_FILES = [
   'response_login_info.proto',
   'request_account_list.proto',
   'response_account_list.proto',
+  'request_tick_bar_replay.proto',
+  'response_tick_bar_replay.proto',
   'request_trade_routes.proto',
   'response_trade_routes.proto',
   'request_subscribe_for_order_updates.proto',