hedgequantx 2.6.161 → 2.6.162

package/src/services/hqx-server.js

@@ -1,13 +1,7 @@
 /**
- * @fileoverview HQX Server Service - Ultra Low Latency WebSocket for Scalping
+ * HQX Server Service - Ultra Low Latency WebSocket for Scalping
+ * Optimized for sub-ms message handling with TCP_NODELAY and binary format
  * @module services/hqx-server
- * 
- * Optimized for sub-millisecond message handling:
- * - Binary message format (MessagePack)
- * - TCP_NODELAY enabled
- * - Pre-allocated buffers
- * - Zero-copy message handling
- * - Adaptive heartbeat
  */
 
 const WebSocket = require('ws');
@@ -16,63 +10,27 @@ const os = require('os');
 const { request } = require('../utils/http');
 const { HQX_SERVER, TIMEOUTS, SECURITY } = require('../config/settings');
 const { logger } = require('../utils/logger');
+const latencyMgr = require('./hqx-server-latency');
+const eventMgr = require('./hqx-server-events');
+const handlers = require('./hqx-server-handlers');
 
 const log = logger.scope('HQX');
 
-// ==================== CONSTANTS ====================
-
-/** Message types as bytes for faster switching */
-const MSG_TYPE = {
-  // Outgoing
-  PING: 0x01,
-  START_ALGO: 0x10,
-  STOP_ALGO: 0x11,
-  START_COPY: 0x12,
-  ORDER: 0x20,
-  
-  // Incoming
-  PONG: 0x81,
-  SIGNAL: 0x90,
-  TRADE: 0x91,
-  FILL: 0x92,
-  LOG: 0xA0,
-  STATS: 0xA1,
-  ERROR: 0xFF,
-};
+// Re-export MSG_TYPE from handlers
+const { MSG_TYPE } = handlers;
 
 /** Pre-allocated ping buffer */
 const PING_BUFFER = Buffer.alloc(9);
 PING_BUFFER.writeUInt8(MSG_TYPE.PING, 0);
 
-// ==================== FAST JSON ====================
-
-/**
- * Fast JSON stringify with pre-check
- * @param {Object} obj 
- * @returns {string}
- */
+/** Fast JSON stringify */
 const fastStringify = (obj) => {
-  // For simple objects, manual is faster than JSON.stringify
   if (obj === null) return 'null';
   if (typeof obj !== 'object') return JSON.stringify(obj);
   return JSON.stringify(obj);
 };
 
-/**
- * Fast JSON parse with type hint
- * @param {string|Buffer} data 
- * @returns {Object}
- */
-const fastParse = (data) => {
-  const str = typeof data === 'string' ? data : data.toString('utf8');
-  return JSON.parse(str);
-};
-
-// ==================== SERVICE ====================
-
-/**
- * HQX Server Service - Ultra Low Latency
- */
+/** HQX Server Service - Ultra Low Latency */
 class HQXServerService {
   constructor() {
     // Connection
@@ -111,12 +69,7 @@ class HQXServerService {
     this.bytesReceived = 0;
   }
 
-  // ==================== DEVICE ID ====================
-
-  /**
-   * Get cached device fingerprint
-   * @returns {string}
-   */
+  /** Get cached device fingerprint */
   _getDeviceId() {
     if (this._deviceId) return this._deviceId;
     
@@ -125,14 +78,7 @@ class HQXServerService {
     return this._deviceId;
   }
 
-  // ==================== AUTH ====================
-
-  /**
-   * Authenticate with HQX Server
-   * @param {string} userId 
-   * @param {string} [propfirm='unknown']
-   * @returns {Promise<{success: boolean, sessionId?: string, error?: string}>}
-   */
+  /** Authenticate with HQX Server */
   async authenticate(userId, propfirm = 'unknown') {
     const start = process.hrtime.bigint();
     
@@ -171,12 +117,7 @@ class HQXServerService {
     }
   }
 
-  // ==================== WEBSOCKET ====================
-
-  /**
-   * Connect with ultra-low latency settings
-   * @returns {Promise<{success: boolean, error?: string}>}
-   */
+  /** Connect with ultra-low latency settings */
   async connect() {
     if (!this.token) {
       return { success: false, error: 'Not authenticated' };
@@ -258,10 +199,7 @@ class HQXServerService {
     });
   }
 
-  /**
-   * Apply TCP socket optimizations
-   * @private
-   */
+  /** Apply TCP socket optimizations */
   _optimizeSocket() {
     try {
       const socket = this.ws._socket;
@@ -283,166 +221,22 @@ class HQXServerService {
     }
   }
 
-  // ==================== MESSAGE HANDLING ====================
-
-  /**
-   * Ultra-fast message handler
-   * @private
-   */
+  /** Ultra-fast message handler */
   _handleMessage(data) {
-    const receiveTime = process.hrtime.bigint();
-    this.messagesReceived++;
-    this.bytesReceived += data.length;
-    
-    try {
-      // Try binary format first (faster)
-      if (Buffer.isBuffer(data) && data.length > 0) {
-        const msgType = data.readUInt8(0);
-        
-        // Fast path for pong
-        if (msgType === MSG_TYPE.PONG) {
-          this._handlePong(data, receiveTime);
-          return;
-        }
-        
-        // Binary signal (fastest path)
-        if (msgType === MSG_TYPE.SIGNAL) {
-          this._handleBinarySignal(data);
-          return;
-        }
-      }
-      
-      // JSON fallback
-      const message = fastParse(data);
-      this._handleJsonMessage(message, receiveTime);
-      
-    } catch (err) {
-      log.warn('Message parse error', { error: err.message });
-    }
-  }
-
-  /**
-   * Handle pong with latency calculation
-   * @private
-   */
-  _handlePong(data, receiveTime) {
-    if (this.lastPingTime > 0) {
-      // Use high-resolution timer
-      const latency = Number(receiveTime - this.lastPingTime) / 1e6; // ns to ms
-      this._updateLatency(latency);
-    }
-  }
-
-  /**
-   * Handle binary trading signal (zero-copy)
-   * @private
-   */
-  _handleBinarySignal(data) {
-    // Binary format: [type:1][timestamp:8][side:1][price:8][qty:4]
-    if (data.length >= 22) {
-      const signal = {
-        timestamp: data.readBigInt64LE(1),
-        side: data.readUInt8(9),
-        price: data.readDoubleLE(10),
-        quantity: data.readUInt32LE(18),
-      };
-      this._emit('signal', signal);
-    }
-  }
-
-  /**
-   * Handle JSON message
-   * @private
-   */
-  _handleJsonMessage(message, receiveTime) {
-    // Calculate latency from server timestamp
-    if (message.timestamp) {
-      const latency = Date.now() - message.timestamp;
-      if (latency >= 0 && latency < 5000) {
-        this._updateLatency(latency);
-      }
-    }
-    
-    // Fast dispatch
-    switch (message.type) {
-      case 'signal':
-        this._emit('signal', message.data);
-        break;
-      case 'trade':
-        this._emit('trade', message.data);
-        break;
-      case 'fill':
-        this._emit('fill', message.data);
-        break;
-      case 'log':
-        this._emit('log', message.data);
-        break;
-      case 'stats':
-        this._emit('stats', message.data);
-        break;
-      case 'error':
-        this._emit('error', message.data);
-        break;
-      case 'pong':
-        // Already handled in binary path
-        break;
-      default:
-        this._emit('message', message);
-    }
+    handlers.processMessage(
+      this,
+      data,
+      (event, payload) => this._emit(event, payload),
+      (latency) => this._updateLatency(latency)
+    );
   }
 
-  /**
-   * Update latency statistics
-   * @private
-   */
+  /** Update latency statistics */
   _updateLatency(latency) {
-    this.latency = latency;
-    this.minLatency = Math.min(this.minLatency, latency);
-    this.maxLatency = Math.max(this.maxLatency, latency);
-    
-    // Rolling average (last 100 samples)
-    this.latencySamples.push(latency);
-    if (this.latencySamples.length > 100) {
-      this.latencySamples.shift();
-    }
-    this.avgLatency = this.latencySamples.reduce((a, b) => a + b, 0) / this.latencySamples.length;
-    
-    // Adapt heartbeat based on latency
-    this._adaptHeartbeat();
-    
-    this._emit('latency', { 
-      current: latency, 
-      min: this.minLatency, 
-      max: this.maxLatency, 
-      avg: this.avgLatency 
-    });
+    latencyMgr.updateLatency.call(this, latency);
   }
 
-  /**
-   * Adapt heartbeat interval based on connection quality
-   * @private
-   */
-  _adaptHeartbeat() {
-    // Good connection: slower heartbeat (less overhead)
-    // Poor connection: faster heartbeat (detect issues quickly)
-    if (this.avgLatency < 10) {
-      this.adaptiveHeartbeat = 2000;  // <10ms: 2s heartbeat
-    } else if (this.avgLatency < 50) {
-      this.adaptiveHeartbeat = 1000;  // <50ms: 1s heartbeat
-    } else if (this.avgLatency < 100) {
-      this.adaptiveHeartbeat = 500;   // <100ms: 500ms heartbeat
-    } else {
-      this.adaptiveHeartbeat = 250;   // High latency: 250ms heartbeat
-    }
-  }
-
-  // ==================== SENDING ====================
-
-  /**
-   * Send message with minimal overhead
-   * @param {string} type - Message type
-   * @param {Object} data - Payload
-   */
+  /** Send message with minimal overhead */
   send(type, data) {
     const message = {
       type,
@@ -459,10 +253,7 @@ class HQXServerService {
     }
   }
 
-  /**
-   * Send raw data (no JSON overhead)
-   * @private
-   */
+  /** Send raw data */
   _sendRaw(data) {
     try {
       this.ws.send(data);
@@ -471,10 +262,7 @@ class HQXServerService {
     }
   }
 
-  /**
-   * Send binary ping for lowest latency measurement
-   * @private
-   */
+  /** Send binary ping for lowest latency measurement */
   _sendBinaryPing() {
     if (!this.connected || this.ws?.readyState !== WebSocket.OPEN) return;
     
@@ -490,10 +278,7 @@ class HQXServerService {
     }
   }
 
-  /**
-   * Flush message queue
-   * @private
-   */
+  /** Flush message queue */
   _flushQueue() {
     while (this.messageQueue.length > 0 && this.ws?.readyState === WebSocket.OPEN) {
       const message = this.messageQueue.shift();
@@ -502,153 +287,50 @@ class HQXServerService {
     }
   }
 
-  // ==================== ALGO CONTROL ====================
-
-  /**
-   * Start algo trading session
-   * @param {Object} config 
-   */
+  /** Start algo trading session */
   startAlgo(config) {
     log.info('Starting algo', { symbol: config.symbol, contracts: config.contracts });
-    
-    this.send('start_algo', {
-      accountId: config.accountId,
-      contractId: config.contractId,
-      symbol: config.symbol,
-      contracts: config.contracts,
-      dailyTarget: config.dailyTarget,
-      maxRisk: config.maxRisk,
-      propfirm: config.propfirm,
-      propfirmToken: config.propfirmToken,
-      rithmicCredentials: config.rithmicCredentials || null,
-      copyTrading: config.copyTrading || false,
-      followerSymbol: config.followerSymbol,
-      followerContracts: config.followerContracts,
-    });
+    this.send('start_algo', handlers.buildAlgoPayload(config));
   }
 
-  /**
-   * Stop algo trading
-   */
+  /** Stop algo trading */
   stopAlgo() {
     log.info('Stopping algo');
     this.send('stop_algo', {});
   }
 
-  /**
-   * Start copy trading
-   * @param {Object} config 
-   */
+  /** Start copy trading */
   startCopyTrading(config) {
     log.info('Starting copy trading');
-    
-    this.send('start_copy_trading', {
-      // Lead
-      leadAccountId: config.leadAccountId,
-      leadContractId: config.leadContractId,
-      leadSymbol: config.leadSymbol,
-      leadContracts: config.leadContracts,
-      leadPropfirm: config.leadPropfirm,
-      leadToken: config.leadToken,
-      leadRithmicCredentials: config.leadRithmicCredentials,
-      // Follower
-      followerAccountId: config.followerAccountId,
-      followerContractId: config.followerContractId,
-      followerSymbol: config.followerSymbol,
-      followerContracts: config.followerContracts,
-      followerPropfirm: config.followerPropfirm,
-      followerToken: config.followerToken,
-      followerRithmicCredentials: config.followerRithmicCredentials,
-      // Targets
-      dailyTarget: config.dailyTarget,
-      maxRisk: config.maxRisk,
-    });
+    this.send('start_copy_trading', handlers.buildCopyTradingPayload(config));
   }
 
-  // ==================== EVENTS ====================
-
-  /**
-   * Register event listener
-   * @param {string} event 
-   * @param {Function} callback 
-   */
+  /** Register event listener */
   on(event, callback) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, []);
-    }
-    this.listeners.get(event).push(callback);
+    eventMgr.on(this.listeners, event, callback);
   }
 
-  /**
-   * Remove event listener
-   * @param {string} event 
-   * @param {Function} callback 
-   */
+  /** Remove event listener */
   off(event, callback) {
-    const callbacks = this.listeners.get(event);
-    if (callbacks) {
-      const index = callbacks.indexOf(callback);
-      if (index > -1) callbacks.splice(index, 1);
-    }
+    eventMgr.off(this.listeners, event, callback);
   }
 
-  /**
-   * Emit event (inlined for speed)
-   * @private
-   */
+  /** Emit event */
   _emit(event, data) {
-    const callbacks = this.listeners.get(event);
-    if (!callbacks) return;
-    
-    for (let i = 0; i < callbacks.length; i++) {
-      try {
-        callbacks[i](data);
-      } catch {
-        // Don't let callback errors break the loop
-      }
-    }
+    eventMgr.emit(this.listeners, event, data);
   }
 
-  // ==================== HEARTBEAT ====================
-
-  /**
-   * Start adaptive heartbeat
-   * @private
-   */
+  /** Start adaptive heartbeat */
   _startHeartbeat() {
-    this._stopHeartbeat();
-    
-    const heartbeat = () => {
-      if (this.connected) {
-        this._sendBinaryPing();
-        
-        // Schedule next with adaptive interval
-        this.pingInterval = setTimeout(heartbeat, this.adaptiveHeartbeat);
-      }
-    };
-    
-    // First ping immediately
-    this._sendBinaryPing();
-    this.pingInterval = setTimeout(heartbeat, this.adaptiveHeartbeat);
+    latencyMgr.startHeartbeat.call(this, () => this._sendBinaryPing());
   }
 
-  /**
-   * Stop heartbeat
-   * @private
-   */
+  /** Stop heartbeat */
   _stopHeartbeat() {
-    if (this.pingInterval) {
-      clearTimeout(this.pingInterval);
-      this.pingInterval = null;
-    }
+    latencyMgr.stopHeartbeat.call(this);
   }
 
-  // ==================== RECONNECT ====================
-
-  /**
-   * Attempt reconnection with exponential backoff
-   * @private
-   */
+  /** Attempt reconnection with exponential backoff */
   _attemptReconnect() {
     if (this.reconnectAttempts >= SECURITY.MAX_RECONNECT_ATTEMPTS) {
       log.error('Max reconnect attempts reached');
@@ -676,50 +358,22 @@ class HQXServerService {
     }, delay);
   }
 
-  // ==================== STATS ====================
-
-  /**
-   * Get latency statistics
-   * @returns {Object}
-   */
+  /** Get latency statistics */
   getLatencyStats() {
-    return {
-      current: this.latency,
-      min: this.minLatency === Infinity ? 0 : this.minLatency,
-      max: this.maxLatency,
-      avg: this.avgLatency,
-      samples: this.latencySamples.length,
-    };
+    return latencyMgr.getLatencyStats.call(this);
   }
 
-  /**
-   * Get connection statistics
-   * @returns {Object}
-   */
+  /** Get connection statistics */
   getStats() {
-    return {
-      connected: this.connected,
-      messagesSent: this.messagesSent,
-      messagesReceived: this.messagesReceived,
-      bytesReceived: this.bytesReceived,
-      heartbeatInterval: this.adaptiveHeartbeat,
-      latency: this.getLatencyStats(),
-    };
+    return latencyMgr.getConnectionStats.call(this);
   }
 
-  /**
-   * Get current latency
-   * @returns {number}
-   */
+  /** Get current latency */
   getLatency() {
     return this.latency;
   }
 
-  // ==================== CLEANUP ====================
-
-  /**
-   * Disconnect and cleanup
-   */
+  /** Disconnect and cleanup */
   disconnect() {
     log.info('Disconnecting');
     
@@ -734,19 +388,13 @@ class HQXServerService {
     this.token = null;
     this.sessionId = null;
     this.messageQueue = [];
-    this.listeners.clear();
+    eventMgr.clearAll(this.listeners);
     
     // Reset stats
-    this.latencySamples = [];
-    this.minLatency = Infinity;
-    this.maxLatency = 0;
-    this.avgLatency = 0;
+    latencyMgr.resetLatencyStats.call(this);
   }
 
-  /**
-   * Check if connected
-   * @returns {boolean}
-   */
+  /** Check if connected */
   isConnected() {
     return this.connected && this.ws?.readyState === WebSocket.OPEN;
   }

package/src/services/position-constants.js

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Position Manager Constants
+ * Momentum thresholds and weights for position management
+ * 
+ * Data source: Calibrated from backtesting and live trading analysis
+ */
+
+// =============================================================================
+// MOMENTUM THRESHOLDS (from analysis)
+// =============================================================================
+const MOMENTUM = {
+  STRONG_FAVORABLE: 0.5,   // momentum > 0.5 + profit → HOLD
+  WEAK_THRESHOLD: 0.2,     // momentum < 0.2 + profit → EXIT with profit
+  ADVERSE_THRESHOLD: -0.3, // momentum < -0.3 → EXIT immediately
+  VPIN_DANGER: 0.7,        // VPIN > 0.7 → informed traders = EXIT
+};
+
+// Momentum weights
+const WEIGHTS = {
+  OFI: 0.50,      // Order Flow Imbalance - 50%
+  KALMAN: 0.25,   // Kalman Velocity - 25%
+  ZSCORE: 0.25,   // Z-Score progression - 25%
+};
+
+module.exports = {
+  MOMENTUM,
+  WEIGHTS,
+};