hedgequantx 2.6.162 → 2.6.163

package/src/services/rithmic/protobuf.js

@@ -6,15 +6,12 @@
 const protobuf = require('protobufjs');
 const path = require('path');
 const { PROTO_FILES } = require('./constants');
+const { 
+  readVarint, readLengthDelimited, skipField,
+  decodeAccountPnL, decodeInstrumentPnL, decodeProductCodes, decodeFrontMonthContract 
+} = require('./proto-decoders');
 
-// ==================== BUFFER POOL ====================
-// Pre-allocated buffer pool for zero-allocation hot path
-// Avoids GC pressure during high-frequency trading
-
-/**
- * High-performance buffer pool for zero-allocation encoding
- * Uses ring buffer pattern for O(1) acquire/release
- */
+/** High-performance buffer pool for zero-allocation encoding */
 class BufferPool {
   constructor(poolSize = 16, bufferSize = 512) {
     this._pool = new Array(poolSize);
@@ -24,370 +21,32 @@ class BufferPool {
     this._head = 0;
     this._tail = 0;
     this._count = poolSize;
-    
-    // Pre-allocate all buffers
     for (let i = 0; i < poolSize; i++) {
       this._pool[i] = Buffer.allocUnsafe(bufferSize);
       this._available[i] = i;
     }
   }
   
-  /**
-   * Acquire a buffer from the pool
-   * @returns {Buffer|null} Buffer or null if pool exhausted
-   */
   acquire() {
-    if (this._count === 0) {
-      // Pool exhausted - allocate new (fallback)
-      return Buffer.allocUnsafe(this._bufferSize);
-    }
+    if (this._count === 0) return Buffer.allocUnsafe(this._bufferSize);
     const idx = this._available[this._head];
     this._head = (this._head + 1) % this._size;
     this._count--;
     return this._pool[idx];
   }
   
-  /**
-   * Release a buffer back to pool
-   * Only releases buffers that belong to the pool
-   * @param {Buffer} buffer 
-   */
   release(buffer) {
-    // Find if this buffer is from our pool
     const idx = this._pool.indexOf(buffer);
     if (idx !== -1 && this._count < this._size) {
       this._available[this._tail] = idx;
       this._tail = (this._tail + 1) % this._size;
       this._count++;
     }
-    // If not from pool, let GC handle it
   }
   
-  /**
-   * Get pool stats
-   */
   getStats() {
-    return {
-      size: this._size,
-      available: this._count,
-      bufferSize: this._bufferSize,
-    };
-  }
-}
-
-// 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,
-};
-
-/**
- * Read a varint from buffer
- */
-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)
- */
-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
- */
-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}`);
-  }
-}
-
-/**
- * Manually decode AccountPnL from raw bytes
- */
-function decodeAccountPnL(buffer) {
-  const result = {};
-  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 PNL_FIELDS.TEMPLATE_ID:
-          [result.templateId, offset] = readVarint(buffer, offset);
-          break;
-        case PNL_FIELDS.IS_SNAPSHOT:
-          const [isSnap, snapOffset] = readVarint(buffer, offset);
-          result.isSnapshot = isSnap !== 0;
-          offset = snapOffset;
-          break;
-        case PNL_FIELDS.FCM_ID:
-          [result.fcmId, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.IB_ID:
-          [result.ibId, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.ACCOUNT_ID:
-          [result.accountId, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.ACCOUNT_BALANCE:
-          [result.accountBalance, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.CASH_ON_HAND:
-          [result.cashOnHand, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.MARGIN_BALANCE:
-          [result.marginBalance, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.MIN_ACCOUNT_BALANCE:
-          [result.minAccountBalance, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.OPEN_POSITION_PNL:
-          [result.openPositionPnl, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.CLOSED_POSITION_PNL:
-          [result.closedPositionPnl, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.DAY_PNL:
-          [result.dayPnl, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.DAY_OPEN_PNL:
-          [result.dayOpenPnl, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.DAY_CLOSED_PNL:
-          [result.dayClosedPnl, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.AVAILABLE_BUYING_POWER:
-          [result.availableBuyingPower, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case PNL_FIELDS.SSBOE:
-          [result.ssboe, offset] = readVarint(buffer, offset);
-          break;
-        case PNL_FIELDS.USECS:
-          [result.usecs, offset] = readVarint(buffer, offset);
-          break;
-        default:
-          offset = skipField(buffer, offset, wireType);
-      }
-    } catch (error) {
-      break;
-    }
+    return { size: this._size, available: this._count, bufferSize: this._bufferSize };
   }
-
-  return result;
-}
-
-/**
- * Manually decode InstrumentPnLPositionUpdate from raw bytes
- */
-function decodeInstrumentPnL(buffer) {
-  const result = {};
-  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 INSTRUMENT_PNL_FIELDS.TEMPLATE_ID:
-          [result.templateId, offset] = readVarint(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.IS_SNAPSHOT:
-          const [isSnap, snapOffset] = readVarint(buffer, offset);
-          result.isSnapshot = isSnap !== 0;
-          offset = snapOffset;
-          break;
-        case INSTRUMENT_PNL_FIELDS.FCM_ID:
-          [result.fcmId, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.IB_ID:
-          [result.ibId, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.ACCOUNT_ID:
-          [result.accountId, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.SYMBOL:
-          [result.symbol, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.EXCHANGE:
-          [result.exchange, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.PRODUCT_CODE:
-          [result.productCode, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.BUY_QTY:
-          [result.buyQty, offset] = readVarint(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.SELL_QTY:
-          [result.sellQty, offset] = readVarint(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.FILL_BUY_QTY:
-          [result.fillBuyQty, offset] = readVarint(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.FILL_SELL_QTY:
-          [result.fillSellQty, offset] = readVarint(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.NET_QUANTITY:
-          [result.netQuantity, offset] = readVarint(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.OPEN_POSITION_QUANTITY:
-          [result.openPositionQuantity, offset] = readVarint(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.AVG_OPEN_FILL_PRICE:
-          // Double is 64-bit fixed
-          if (wireType === 1) {
-            result.avgOpenFillPrice = buffer.readDoubleLE(offset);
-            offset += 8;
-          } else {
-            offset = skipField(buffer, offset, wireType);
-          }
-          break;
-        case INSTRUMENT_PNL_FIELDS.OPEN_POSITION_PNL:
-          [result.openPositionPnl, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.CLOSED_POSITION_PNL:
-          [result.closedPositionPnl, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.DAY_PNL:
-          // DAY_PNL is a double (wireType 1 = 64-bit fixed)
-          if (wireType === 1) {
-            result.dayPnl = buffer.readDoubleLE(offset);
-            offset += 8;
-          } else {
-            // Fallback: try string
-            [result.dayPnl, offset] = readLengthDelimited(buffer, offset);
-          }
-          break;
-        case INSTRUMENT_PNL_FIELDS.DAY_OPEN_PNL:
-          // DAY_OPEN_PNL is a double (wireType 1 = 64-bit fixed)
-          if (wireType === 1) {
-            result.dayOpenPnl = buffer.readDoubleLE(offset);
-            offset += 8;
-          } else {
-            // Fallback: try string
-            [result.dayOpenPnl, offset] = readLengthDelimited(buffer, offset);
-          }
-          break;
-        case INSTRUMENT_PNL_FIELDS.DAY_CLOSED_PNL:
-          // DAY_CLOSED_PNL is a double (wireType 1 = 64-bit fixed)
-          if (wireType === 1) {
-            result.dayClosedPnl = buffer.readDoubleLE(offset);
-            offset += 8;
-          } else {
-            // Fallback: try string
-            [result.dayClosedPnl, offset] = readLengthDelimited(buffer, offset);
-          }
-          break;
-        case INSTRUMENT_PNL_FIELDS.SSBOE:
-          [result.ssboe, offset] = readVarint(buffer, offset);
-          break;
-        case INSTRUMENT_PNL_FIELDS.USECS:
-          [result.usecs, offset] = readVarint(buffer, offset);
-          break;
-        default:
-          offset = skipField(buffer, offset, wireType);
-      }
-    } catch (error) {
-      break;
-    }
-  }
-
-  return result;
 }
 
 /**
@@ -580,101 +239,6 @@ class ProtobufHandler {
   }
 }
 
-/**
- * Decode ResponseProductCodes (template 112) - list of available symbols
- */
-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
- */
-function decodeFrontMonthContract(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.SYMBOL:
-          [result.symbol, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case SYMBOL_FIELDS.EXCHANGE:
-          [result.exchange, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case SYMBOL_FIELDS.TRADING_SYMBOL:
-          [result.tradingSymbol, offset] = readLengthDelimited(buffer, offset);
-          break;
-        case SYMBOL_FIELDS.DESCRIPTION:
-          [result.description, 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;
-}
-
 // Singleton
 const proto = new ProtobufHandler();
 

package/src/services/strategy/hft-signal-calc.js

@@ -0,0 +1,147 @@
+/**
+ * HFT Signal Calculation
+ * @module services/strategy/hft-signal-calc
+ * 
+ * Signal generation and building logic for HFT strategy
+ */
+
+/**
+ * Calculate trading signal from all models
+ * @param {Object} state - Strategy state
+ * @param {Object} config - Strategy config
+ * @returns {Object} {direction, confidence, scores}
+ */
+function calculateSignal(state, config) {
+  let direction = 'none';
+  let confidence = 0;
+  
+  const { ofiValue, zscore, momentum, buyVolume, sellVolume, cumulativeDelta } = state;
+  const { ofiThreshold, zscoreThreshold, momentumThreshold, minConfidence } = config;
+  
+  const scores = {
+    ofi: 0,
+    zscore: 0,
+    momentum: 0,
+    delta: 0,
+    composite: 0,
+  };
+  
+  // === MODEL 1: OFI ===
+  const absOfi = Math.abs(ofiValue);
+  if (absOfi > ofiThreshold) {
+    scores.ofi = Math.min(1.0, absOfi / 0.6);
+  }
+  
+  // === MODEL 2: Z-Score Mean Reversion ===
+  const absZ = Math.abs(zscore);
+  if (absZ > zscoreThreshold) {
+    scores.zscore = Math.min(1.0, absZ / 3.0);
+  }
+  
+  // === MODEL 3: Momentum ===
+  const absMom = Math.abs(momentum);
+  if (absMom > momentumThreshold) {
+    scores.momentum = Math.min(1.0, absMom / 3.0);
+  }
+  
+  // === MODEL 4: Delta ===
+  const totalVol = buyVolume + sellVolume;
+  if (totalVol > 0) {
+    const deltaRatio = cumulativeDelta / totalVol;
+    scores.delta = Math.min(1.0, Math.abs(deltaRatio) * 2);
+  }
+  
+  // === COMPOSITE SCORE ===
+  scores.composite = 
+    scores.ofi * 0.35 +       // OFI: 35%
+    scores.zscore * 0.25 +    // Z-Score: 25%
+    scores.momentum * 0.20 +  // Momentum: 20%
+    scores.delta * 0.20;      // Delta: 20%
+  
+  confidence = scores.composite;
+  
+  // === DETERMINE DIRECTION ===
+  if (scores.composite >= minConfidence) {
+    // Primary: Mean reversion
+    if (absZ > zscoreThreshold) {
+      direction = zscore > 0 ? 'short' : 'long';
+      
+      // Confirm with OFI
+      const ofiConfirms = 
+        (direction === 'long' && ofiValue > 0) ||
+        (direction === 'short' && ofiValue < 0);
+      
+      if (ofiConfirms) {
+        confidence += 0.1;
+      } else if (Math.abs(ofiValue) > 0.2) {
+        confidence -= 0.15;
+      }
+    }
+    // Fallback: Momentum breakout
+    else if (absMom > momentumThreshold * 2 && absOfi > ofiThreshold) {
+      direction = momentum > 0 ? 'long' : 'short';
+      if ((direction === 'long' && ofiValue < 0) ||
+          (direction === 'short' && ofiValue > 0)) {
+        direction = 'none';
+      }
+    }
+  }
+  
+  confidence = Math.min(1.0, Math.max(0, confidence));
+  
+  return { direction, confidence, scores };
+}
+
+/**
+ * Build signal object
+ * @param {string} direction
+ * @param {number} confidence
+ * @param {Object} scores
+ * @param {Object} tick
+ * @param {Object} state
+ * @param {Object} config
+ * @returns {Object} Signal object
+ */
+function buildSignal(direction, confidence, scores, tick, state, config) {
+  const entry = tick.price;
+  const isLong = direction === 'long';
+  
+  const { std, ofiValue, zscore, momentum, cumulativeDelta, tickCount, signalCount, contractId, tickSize } = state;
+  const { baseStopTicks, baseTargetTicks } = config;
+  
+  // Adaptive stops based on volatility
+  const volMult = Math.max(0.5, Math.min(2.0, std / tickSize / 4));
+  const stopTicks = Math.round(baseStopTicks * volMult);
+  const targetTicks = Math.round(baseTargetTicks * volMult);
+  
+  const stopLoss = isLong 
+    ? entry - stopTicks * tickSize
+    : entry + stopTicks * tickSize;
+    
+  const takeProfit = isLong
+    ? entry + targetTicks * tickSize
+    : entry - targetTicks * tickSize;
+  
+  return {
+    id: `hft-${Date.now()}-${signalCount}`,
+    timestamp: Date.now(),
+    contractId,
+    direction,
+    side: isLong ? 0 : 1,
+    entry,
+    stopLoss,
+    takeProfit,
+    confidence,
+    scores,
+    ofi: ofiValue,
+    zscore,
+    momentum,
+    delta: cumulativeDelta,
+    tickCount,
+  };
+}
+
+module.exports = {
+  calculateSignal,
+  buildSignal,
+};