hedgequantx 2.9.57 → 2.9.59

package/package.json

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

package/src/app.js

@@ -136,8 +136,17 @@ const banner = async () => {
 
   console.log(chalk.cyan('╠' + '═'.repeat(innerWidth) + '╣'));
   
-  const tagline = isMobile ? `HQX V${version}` : `PROP FUTURES ALGO TRADING  V${version}`;
-  console.log(chalk.cyan('║') + chalk.yellow(centerText(tagline, innerWidth)) + chalk.cyan('║'));
+  if (isMobile) {
+    const tagline = `HQX V${version}`;
+    console.log(chalk.cyan('║') + chalk.yellow(centerText(tagline, innerWidth)) + chalk.cyan('║'));
+  } else {
+    const taglineBase = 'PROP FUTURES ALGO TRADING  ';
+    const taglineVersion = `V${version}`;
+    const totalLen = taglineBase.length + taglineVersion.length;
+    const padLeft = Math.floor((innerWidth - totalLen) / 2);
+    const padRight = innerWidth - totalLen - padLeft;
+    console.log(chalk.cyan('║') + ' '.repeat(padLeft) + chalk.yellow(taglineBase) + chalk.magenta(taglineVersion) + ' '.repeat(padRight) + chalk.cyan('║'));
+  }
   
   // ALWAYS close the banner
   console.log(chalk.cyan('╚' + '═'.repeat(innerWidth) + '╝'));

package/src/lib/data.js

@@ -57,6 +57,9 @@ class MarketDataFeed extends EventEmitter {
     };
 
     try {
+      // Ensure protobuf definitions are loaded
+      await proto.load();
+      
       await this.connection.connect(this.config);
 
       // Setup message handler for market data
@@ -212,6 +215,7 @@ class MarketDataFeed extends EventEmitter {
       const tradeObj = trade.toJSON ? trade.toJSON() : trade;
       
       // protobufjs converts to camelCase and enums to strings
+      // tradePrice is a double, should come through directly
       const price = tradeObj.tradePrice;
       const size = Number(tradeObj.tradeSize) || 1;
       const volume = Number(tradeObj.volume) || size;
@@ -221,6 +225,13 @@ class MarketDataFeed extends EventEmitter {
       const side = (agg === 1 || agg === 'BUY') ? 'buy' : 
                    (agg === 2 || agg === 'SELL') ? 'sell' : 'unknown';
       
+      // Debug first few ticks
+      if (!this._tradeDebugCount) this._tradeDebugCount = 0;
+      if (this._tradeDebugCount < 3) {
+        this._tradeDebugCount++;
+        this.emit('debug', `Trade raw: price=${price}, size=${tradeObj.tradeSize}, vol=${tradeObj.volume}`);
+      }
+      
       if (price === undefined || price === null) return;
       
       const tick = {
@@ -238,7 +249,11 @@ class MarketDataFeed extends EventEmitter {
 
       this.emit('tick', tick);
     } catch (e) {
-      // Silent - don't spam errors
+      // Debug decode errors
+      if (!this._decodeErrorLogged) {
+        this._decodeErrorLogged = true;
+        this.emit('debug', `LastTrade decode error: ${e.message}`);
+      }
     }
   }
 
@@ -256,6 +271,13 @@ class MarketDataFeed extends EventEmitter {
       const bidSize = Number(bboObj.bidSize) || 0;
       const askSize = Number(bboObj.askSize) || 0;
       
+      // Debug first few BBOs
+      if (!this._bboDebugCount) this._bboDebugCount = 0;
+      if (this._bboDebugCount < 3) {
+        this._bboDebugCount++;
+        this.emit('debug', `BBO raw: bid=${bid}, ask=${ask}`);
+      }
+      
       // Calculate mid price
       const price = (bid && ask) ? (Number(bid) + Number(ask)) / 2 : (bid || ask || null);
       
@@ -277,7 +299,11 @@ class MarketDataFeed extends EventEmitter {
 
       this.emit('tick', tick);
     } catch (e) {
-      // Ignore decode errors
+      // Debug decode errors
+      if (!this._bboDecodeErrorLogged) {
+        this._bboDecodeErrorLogged = true;
+        this.emit('debug', `BBO decode error: ${e.message}`);
+      }
     }
   }
 }

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

@@ -75,7 +75,7 @@ const oneAccountMenu = async (service) => {
       console.log();
       console.log(chalk.cyan('  Last configuration found:'));
       console.log(chalk.gray(`    Account: ${lastConfig.accountName} (${lastConfig.propfirm})`));
-      console.log(chalk.gray(`    Symbol: ${lastConfig.symbol}`));
+      console.log(chalk.gray(`    Symbol: ${lastConfig.baseSymbol || lastConfig.symbol} (${lastConfig.symbol})`));
       console.log(chalk.gray(`    Strategy: ${lastConfig.strategyName}`));
       console.log(chalk.gray(`    Contracts: ${lastConfig.contracts} | Target: $${lastConfig.dailyTarget} | Risk: $${lastConfig.maxRisk}`));
       console.log();
@@ -86,10 +86,15 @@ const oneAccountMenu = async (service) => {
         selectedAccount = matchingAccount;
         accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
         
-        // Load contracts to find the saved symbol
+        // Load contracts to find the saved symbol (match by baseSymbol first, then exact symbol)
         const contractsResult = await accountService.getContracts();
         if (contractsResult.success) {
-          contract = contractsResult.contracts.find(c => c.symbol === lastConfig.symbol);
+          // Try baseSymbol match first (more stable across contract rolls)
+          contract = contractsResult.contracts.find(c => c.baseSymbol === lastConfig.baseSymbol);
+          // Fall back to exact symbol match
+          if (!contract) {
+            contract = contractsResult.contracts.find(c => c.symbol === lastConfig.symbol);
+          }
         }
         
         // Find strategy
@@ -147,12 +152,13 @@ const oneAccountMenu = async (service) => {
     config = await configureAlgo(selectedAccount, contract, strategy);
     if (!config) return;
     
-    // Save config for next time
+    // Save config for next time (include baseSymbol for stable matching across contract rolls)
     saveOneAccountConfig({
       accountId: selectedAccount.accountId || selectedAccount.rithmicAccountId,
       accountName: selectedAccount.accountName || selectedAccount.rithmicAccountId || selectedAccount.accountId,
       propfirm: selectedAccount.propfirm || selectedAccount.platform || 'Unknown',
       symbol: contract.symbol,
+      baseSymbol: contract.baseSymbol,
       strategyId: strategy.id,
       strategyName: strategy.name,
       contracts: config.contracts,

package/src/services/rithmic/protobuf-decoders.js

@@ -0,0 +1,375 @@
+/**
+ * Protobuf Decoders - Decode Rithmic protobuf messages
+ * @module services/rithmic/protobuf-decoders
+ */
+
+const { readVarint, readLengthDelimited, skipField } = require('./protobuf-utils');
+
+// PnL field IDs (Rithmic uses very large field IDs)
+const PNL_FIELDS = {
+  TEMPLATE_ID: 154467,
+  IS_SNAPSHOT: 110121,
+  FCM_ID: 154013,
+  IB_ID: 154014,
+  ACCOUNT_ID: 154008,
+  ACCOUNT_BALANCE: 156970,
+  CASH_ON_HAND: 156971,
+  MARGIN_BALANCE: 156977,
+  MIN_ACCOUNT_BALANCE: 156968,
+  OPEN_POSITION_PNL: 156961,
+  CLOSED_POSITION_PNL: 156963,
+  DAY_PNL: 157956,
+  DAY_OPEN_PNL: 157954,
+  DAY_CLOSED_PNL: 157955,
+  AVAILABLE_BUYING_POWER: 157015,
+  SSBOE: 150100,
+  USECS: 150101,
+};
+
+// Symbol/Contract field IDs (ResponseProductCodes, ResponseFrontMonthContract)
+const SYMBOL_FIELDS = {
+  TEMPLATE_ID: 154467,
+  RP_CODE: 132766,
+  EXCHANGE: 110101,
+  PRODUCT_CODE: 110102,   // Base symbol (ES, NQ, MNQ)
+  PRODUCT_NAME: 110103,   // Product name
+  SYMBOL: 110100,         // Full contract symbol (ESH26)
+  TRADING_SYMBOL: 157095, // Trading symbol
+  DESCRIPTION: 110114,    // Contract description
+  USER_MSG: 132760,
+};
+
+// Instrument PnL Position Update field IDs
+const INSTRUMENT_PNL_FIELDS = {
+  TEMPLATE_ID: 154467,
+  IS_SNAPSHOT: 110121,
+  FCM_ID: 154013,
+  IB_ID: 154014,
+  ACCOUNT_ID: 154008,
+  SYMBOL: 110100,
+  EXCHANGE: 110101,
+  PRODUCT_CODE: 100749,
+  INSTRUMENT_TYPE: 110116,
+  FILL_BUY_QTY: 154041,
+  FILL_SELL_QTY: 154042,
+  ORDER_BUY_QTY: 154037,
+  ORDER_SELL_QTY: 154038,
+  BUY_QTY: 154260,
+  SELL_QTY: 154261,
+  AVG_OPEN_FILL_PRICE: 154434,
+  DAY_OPEN_PNL: 157954,
+  DAY_CLOSED_PNL: 157955,
+  DAY_PNL: 157956,
+  OPEN_POSITION_PNL: 156961,
+  OPEN_POSITION_QUANTITY: 156962,
+  CLOSED_POSITION_PNL: 156963,
+  CLOSED_POSITION_QUANTITY: 156964,
+  NET_QUANTITY: 156967,
+  SSBOE: 150100,
+  USECS: 150101,
+};
+
+/**
+ * Manually decode AccountPnL from raw bytes
+ * Skips 4-byte length prefix if present
+ * @param {Buffer} buffer - Raw protobuf buffer
+ * @returns {Object} Decoded account PnL data
+ */
+function decodeAccountPnL(buffer) {
+  // Skip 4-byte length prefix
+  const data = buffer.length > 4 ? buffer.slice(4) : buffer;
+  
+  const result = {};
+  let offset = 0;
+
+  while (offset < data.length) {
+    try {
+      const [tag, tagOffset] = readVarint(data, offset);
+      const wireType = tag & 0x7;
+      const fieldNumber = tag >>> 3;
+      offset = tagOffset;
+
+      switch (fieldNumber) {
+        case PNL_FIELDS.TEMPLATE_ID:
+          [result.templateId, offset] = readVarint(data, offset);
+          break;
+        case PNL_FIELDS.IS_SNAPSHOT:
+          const [isSnap, snapOffset] = readVarint(data, offset);
+          result.isSnapshot = isSnap !== 0;
+          offset = snapOffset;
+          break;
+        case PNL_FIELDS.FCM_ID:
+          [result.fcmId, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.IB_ID:
+          [result.ibId, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.ACCOUNT_ID:
+          [result.accountId, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.ACCOUNT_BALANCE:
+          [result.accountBalance, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.CASH_ON_HAND:
+          [result.cashOnHand, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.MARGIN_BALANCE:
+          [result.marginBalance, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.MIN_ACCOUNT_BALANCE:
+          [result.minAccountBalance, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.OPEN_POSITION_PNL:
+          [result.openPositionPnl, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.CLOSED_POSITION_PNL:
+          [result.closedPositionPnl, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.DAY_PNL:
+          [result.dayPnl, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.DAY_OPEN_PNL:
+          [result.dayOpenPnl, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.DAY_CLOSED_PNL:
+          [result.dayClosedPnl, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.AVAILABLE_BUYING_POWER:
+          [result.availableBuyingPower, offset] = readLengthDelimited(data, offset);
+          break;
+        case PNL_FIELDS.SSBOE:
+          [result.ssboe, offset] = readVarint(data, offset);
+          break;
+        case PNL_FIELDS.USECS:
+          [result.usecs, offset] = readVarint(data, offset);
+          break;
+        default:
+          offset = skipField(data, offset, wireType);
+      }
+    } catch (error) {
+      break;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Manually decode InstrumentPnLPositionUpdate from raw bytes
+ * Skips 4-byte length prefix if present
+ * @param {Buffer} buffer - Raw protobuf buffer
+ * @returns {Object} Decoded instrument PnL data
+ */
+function decodeInstrumentPnL(buffer) {
+  // Skip 4-byte length prefix
+  const data = buffer.length > 4 ? buffer.slice(4) : buffer;
+  
+  const result = {};
+  let offset = 0;
+
+  while (offset < data.length) {
+    try {
+      const [tag, tagOffset] = readVarint(data, offset);
+      const wireType = tag & 0x7;
+      const fieldNumber = tag >>> 3;
+      offset = tagOffset;
+
+      switch (fieldNumber) {
+        case INSTRUMENT_PNL_FIELDS.TEMPLATE_ID:
+          [result.templateId, offset] = readVarint(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.IS_SNAPSHOT:
+          const [isSnap, snapOffset] = readVarint(data, offset);
+          result.isSnapshot = isSnap !== 0;
+          offset = snapOffset;
+          break;
+        case INSTRUMENT_PNL_FIELDS.FCM_ID:
+          [result.fcmId, offset] = readLengthDelimited(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.IB_ID:
+          [result.ibId, offset] = readLengthDelimited(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.ACCOUNT_ID:
+          [result.accountId, offset] = readLengthDelimited(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.SYMBOL:
+          [result.symbol, offset] = readLengthDelimited(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.EXCHANGE:
+          [result.exchange, offset] = readLengthDelimited(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.PRODUCT_CODE:
+          [result.productCode, offset] = readLengthDelimited(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.BUY_QTY:
+          [result.buyQty, offset] = readVarint(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.SELL_QTY:
+          [result.sellQty, offset] = readVarint(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.FILL_BUY_QTY:
+          [result.fillBuyQty, offset] = readVarint(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.FILL_SELL_QTY:
+          [result.fillSellQty, offset] = readVarint(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.NET_QUANTITY:
+          [result.netQuantity, offset] = readVarint(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.OPEN_POSITION_QUANTITY:
+          [result.openPositionQuantity, offset] = readVarint(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.AVG_OPEN_FILL_PRICE:
+          // Double is 64-bit fixed
+          if (wireType === 1) {
+            result.avgOpenFillPrice = data.readDoubleLE(offset);
+            offset += 8;
+          } else {
+            offset = skipField(data, offset, wireType);
+          }
+          break;
+        case INSTRUMENT_PNL_FIELDS.OPEN_POSITION_PNL:
+          [result.openPositionPnl, offset] = readLengthDelimited(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.CLOSED_POSITION_PNL:
+          [result.closedPositionPnl, offset] = readLengthDelimited(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.DAY_PNL:
+          [result.dayPnl, offset] = readLengthDelimited(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.DAY_OPEN_PNL:
+          [result.dayOpenPnl, offset] = readLengthDelimited(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.DAY_CLOSED_PNL:
+          [result.dayClosedPnl, offset] = readLengthDelimited(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.SSBOE:
+          [result.ssboe, offset] = readVarint(data, offset);
+          break;
+        case INSTRUMENT_PNL_FIELDS.USECS:
+          [result.usecs, offset] = readVarint(data, offset);
+          break;
+        default:
+          offset = skipField(data, offset, wireType);
+      }
+    } catch (error) {
+      break;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Decode ResponseProductCodes (template 112) - list of available symbols
+ * @param {Buffer} buffer - Raw protobuf buffer
+ * @returns {Object} Decoded product codes
+ */
+function decodeProductCodes(buffer) {
+  const result = { rpCode: [] };
+  let offset = 0;
+
+  while (offset < buffer.length) {
+    try {
+      const [tag, tagOffset] = readVarint(buffer, offset);
+      const wireType = tag & 0x7;
+      const fieldNumber = tag >>> 3;
+      offset = tagOffset;
+
+      switch (fieldNumber) {
+        case SYMBOL_FIELDS.TEMPLATE_ID:
+          [result.templateId, offset] = readVarint(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.RP_CODE:
+          let rpCode;
+          [rpCode, offset] = readLengthDelimited(buffer, offset);
+          result.rpCode.push(rpCode);
+          break;
+        case SYMBOL_FIELDS.EXCHANGE:
+          [result.exchange, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.PRODUCT_CODE:
+          [result.productCode, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.PRODUCT_NAME:
+          [result.productName, offset] = readLengthDelimited(buffer, offset);
+          break;
+        case SYMBOL_FIELDS.USER_MSG:
+          [result.userMsg, offset] = readLengthDelimited(buffer, offset);
+          break;
+        default:
+          offset = skipField(buffer, offset, wireType);
+      }
+    } catch (error) {
+      break;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Decode ResponseFrontMonthContract (template 114) - current tradeable contract
+ * Skips 4-byte length prefix if present
+ * @param {Buffer} buffer - Raw protobuf buffer
+ * @returns {Object} Decoded front month contract
+ */
+function decodeFrontMonthContract(buffer) {
+  // Skip 4-byte length prefix
+  const data = buffer.length > 4 ? buffer.slice(4) : buffer;
+  
+  const result = { rpCode: [] };
+  let offset = 0;
+
+  while (offset < data.length) {
+    try {
+      const [tag, tagOffset] = readVarint(data, offset);
+      const wireType = tag & 0x7;
+      const fieldNumber = tag >>> 3;
+      offset = tagOffset;
+
+      switch (fieldNumber) {
+        case SYMBOL_FIELDS.TEMPLATE_ID:
+          [result.templateId, offset] = readVarint(data, offset);
+          break;
+        case SYMBOL_FIELDS.RP_CODE:
+          let rpCode;
+          [rpCode, offset] = readLengthDelimited(data, offset);
+          result.rpCode.push(rpCode);
+          break;
+        case SYMBOL_FIELDS.SYMBOL:
+          [result.symbol, offset] = readLengthDelimited(data, offset);
+          break;
+        case SYMBOL_FIELDS.EXCHANGE:
+          [result.exchange, offset] = readLengthDelimited(data, offset);
+          break;
+        case SYMBOL_FIELDS.TRADING_SYMBOL:
+          [result.tradingSymbol, offset] = readLengthDelimited(data, offset);
+          break;
+        case SYMBOL_FIELDS.DESCRIPTION:
+          [result.description, offset] = readLengthDelimited(data, offset);
+          break;
+        case SYMBOL_FIELDS.USER_MSG:
+          [result.userMsg, offset] = readLengthDelimited(data, offset);
+          break;
+        default:
+          offset = skipField(data, offset, wireType);
+      }
+    } catch (error) {
+      break;
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  decodeAccountPnL,
+  decodeInstrumentPnL,
+  decodeProductCodes,
+  decodeFrontMonthContract,
+  // Export field constants for reference
+  PNL_FIELDS,
+  SYMBOL_FIELDS,
+  INSTRUMENT_PNL_FIELDS,
+};

package/src/services/rithmic/protobuf-utils.js

@@ -0,0 +1,71 @@
+/**
+ * Protobuf Utilities - Low-level protobuf parsing functions
+ * @module services/rithmic/protobuf-utils
+ */
+
+/**
+ * Read a varint from buffer
+ * @param {Buffer} buffer - Input buffer
+ * @param {number} offset - Start 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 - Input buffer
+ * @param {number} offset - Start 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 - Input buffer
+ * @param {number} offset - Start offset
+ * @param {number} wireType - Protobuf wire type
+ * @returns {number} New offset
+ */
+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}`);
+  }
+}
+
+module.exports = {
+  readVarint,
+  readLengthDelimited,
+  skipField,
+};