hedgequantx 2.6.163 → 2.7.0

package/src/services/hqx-server.js

@@ -1,403 +0,0 @@
-/**
- * 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
- */
-
-const WebSocket = require('ws');
-const crypto = require('crypto');
-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');
-
-// 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 stringify */
-const fastStringify = (obj) => {
-  if (obj === null) return 'null';
-  if (typeof obj !== 'object') return JSON.stringify(obj);
-  return JSON.stringify(obj);
-};
-
-/** HQX Server Service - Ultra Low Latency */
-class HQXServerService {
-  constructor() {
-    // Connection
-    this.ws = null;
-    this.connected = false;
-    this.reconnecting = false;
-    this.reconnectAttempts = 0;
-    
-    // Auth
-    this.token = null;
-    this.refreshToken = null;
-    this.apiKey = null;
-    this.sessionId = null;
-    
-    // Performance
-    this.latency = 0;
-    this.minLatency = Infinity;
-    this.maxLatency = 0;
-    this.avgLatency = 0;
-    this.latencySamples = [];
-    this.lastPingTime = 0;
-    this.pingInterval = null;
-    this.adaptiveHeartbeat = 1000; // Start at 1s, adapt based on connection
-    
-    // Message handling
-    this.listeners = new Map();
-    this.messageQueue = [];
-    this.sendBuffer = Buffer.alloc(4096); // Pre-allocated send buffer
-    
-    // Device
-    this._deviceId = null;
-    
-    // Stats
-    this.messagesSent = 0;
-    this.messagesReceived = 0;
-    this.bytesReceived = 0;
-  }
-
-  /** Get cached device fingerprint */
-  _getDeviceId() {
-    if (this._deviceId) return this._deviceId;
-    
-    const data = `${os.hostname()}-${os.platform()}-${os.arch()}-${os.cpus()[0]?.model || 'cpu'}`;
-    this._deviceId = crypto.createHash('sha256').update(data).digest('hex').slice(0, 32);
-    return this._deviceId;
-  }
-
-  /** Authenticate with HQX Server */
-  async authenticate(userId, propfirm = 'unknown') {
-    const start = process.hrtime.bigint();
-    
-    try {
-      const deviceId = this._getDeviceId();
-      const url = `http://${HQX_SERVER.host}:${HQX_SERVER.port}/${HQX_SERVER.VERSION}/auth/token`;
-      
-      const response = await request(url, {
-        method: 'POST',
-        body: {
-          userId: userId || deviceId,
-          deviceId,
-          propfirm,
-          timestamp: Date.now(),
-        },
-        timeout: 5000, // Fast timeout for auth
-      });
-
-      if (response.statusCode === 200 && response.data?.success) {
-        const { token, refreshToken, apiKey, sessionId } = response.data.data;
-        this.token = token;
-        this.refreshToken = refreshToken;
-        this.apiKey = apiKey;
-        this.sessionId = sessionId;
-        
-        const elapsed = Number(process.hrtime.bigint() - start) / 1e6;
-        log.info('Authenticated', { sessionId, latency: `${elapsed.toFixed(1)}ms` });
-        
-        return { success: true, sessionId, apiKey };
-      }
-      
-      return { success: false, error: response.data?.error || 'Authentication failed' };
-    } catch (err) {
-      log.error('Auth error', { error: err.message });
-      return { success: false, error: err.message };
-    }
-  }
-
-  /** Connect with ultra-low latency settings */
-  async connect() {
-    if (!this.token) {
-      return { success: false, error: 'Not authenticated' };
-    }
-
-    return new Promise((resolve) => {
-      const wsUrl = `${HQX_SERVER.wsUrl}?token=${this.token}&session=${this.sessionId}`;
-      
-      log.debug('Connecting', { url: HQX_SERVER.wsUrl });
-      
-      this.ws = new WebSocket(wsUrl, {
-        headers: {
-          'X-Device-Id': this._getDeviceId(),
-          'X-API-Key': this.apiKey,
-        },
-        // Performance options
-        perMessageDeflate: false,      // Disable compression for speed
-        maxPayload: 64 * 1024,         // 64KB max payload
-        handshakeTimeout: 5000,        // Fast handshake
-        // TCP optimizations applied after open
-      });
-
-      // Binary mode for speed
-      this.ws.binaryType = 'nodebuffer';
-
-      const connectTimeout = setTimeout(() => {
-        if (!this.connected) {
-          this.ws?.terminate();
-          resolve({ success: false, error: 'Connection timeout' });
-        }
-      }, 5000);
-
-      this.ws.on('open', () => {
-        clearTimeout(connectTimeout);
-        this.connected = true;
-        this.reconnectAttempts = 0;
-        
-        // Apply TCP_NODELAY for lowest latency
-        this._optimizeSocket();
-        
-        // Start adaptive heartbeat
-        this._startHeartbeat();
-        
-        // Flush queued messages
-        this._flushQueue();
-        
-        this._emit('connected', { sessionId: this.sessionId });
-        log.info('Connected with TCP_NODELAY');
-        
-        resolve({ success: true });
-      });
-
-      this.ws.on('message', (data) => {
-        this._handleMessage(data);
-      });
-
-      this.ws.on('close', (code, reason) => {
-        clearTimeout(connectTimeout);
-        this.connected = false;
-        this._stopHeartbeat();
-        
-        log.info('Disconnected', { code });
-        this._emit('disconnected', { code, reason: reason?.toString() });
-        
-        if (!this.reconnecting) {
-          this._attemptReconnect();
-        }
-      });
-
-      this.ws.on('error', (err) => {
-        log.error('WebSocket error', { error: err.message });
-        this._emit('error', { message: err.message });
-        
-        if (!this.connected) {
-          clearTimeout(connectTimeout);
-          resolve({ success: false, error: err.message });
-        }
-      });
-    });
-  }
-
-  /** Apply TCP socket optimizations */
-  _optimizeSocket() {
-    try {
-      const socket = this.ws._socket;
-      if (socket) {
-        // Disable Nagle's algorithm - critical for low latency
-        socket.setNoDelay(true);
-        
-        // Keep connection alive
-        socket.setKeepAlive(true, 10000);
-        
-        // Increase buffer sizes for throughput
-        if (socket.setRecvBufferSize) socket.setRecvBufferSize(65536);
-        if (socket.setSendBufferSize) socket.setSendBufferSize(65536);
-        
-        log.debug('Socket optimized: TCP_NODELAY enabled');
-      }
-    } catch (err) {
-      log.warn('Socket optimization failed', { error: err.message });
-    }
-  }
-
-  /** Ultra-fast message handler */
-  _handleMessage(data) {
-    handlers.processMessage(
-      this,
-      data,
-      (event, payload) => this._emit(event, payload),
-      (latency) => this._updateLatency(latency)
-    );
-  }
-
-  /** Update latency statistics */
-  _updateLatency(latency) {
-    latencyMgr.updateLatency.call(this, latency);
-  }
-
-  /** Send message with minimal overhead */
-  send(type, data) {
-    const message = {
-      type,
-      data,
-      ts: Date.now(), // Short key for speed
-      sid: this.sessionId,
-    };
-
-    if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
-      this._sendRaw(fastStringify(message));
-      this.messagesSent++;
-    } else {
-      this.messageQueue.push(message);
-    }
-  }
-
-  /** Send raw data */
-  _sendRaw(data) {
-    try {
-      this.ws.send(data);
-    } catch (err) {
-      log.warn('Send error', { error: err.message });
-    }
-  }
-
-  /** Send binary ping for lowest latency measurement */
-  _sendBinaryPing() {
-    if (!this.connected || this.ws?.readyState !== WebSocket.OPEN) return;
-    
-    this.lastPingTime = process.hrtime.bigint();
-    
-    // Write timestamp to pre-allocated buffer
-    PING_BUFFER.writeBigInt64LE(this.lastPingTime, 1);
-    
-    try {
-      this.ws.send(PING_BUFFER);
-    } catch {
-      // Ignore ping errors
-    }
-  }
-
-  /** Flush message queue */
-  _flushQueue() {
-    while (this.messageQueue.length > 0 && this.ws?.readyState === WebSocket.OPEN) {
-      const message = this.messageQueue.shift();
-      this._sendRaw(fastStringify(message));
-      this.messagesSent++;
-    }
-  }
-
-  /** Start algo trading session */
-  startAlgo(config) {
-    log.info('Starting algo', { symbol: config.symbol, contracts: config.contracts });
-    this.send('start_algo', handlers.buildAlgoPayload(config));
-  }
-
-  /** Stop algo trading */
-  stopAlgo() {
-    log.info('Stopping algo');
-    this.send('stop_algo', {});
-  }
-
-  /** Start copy trading */
-  startCopyTrading(config) {
-    log.info('Starting copy trading');
-    this.send('start_copy_trading', handlers.buildCopyTradingPayload(config));
-  }
-
-  /** Register event listener */
-  on(event, callback) {
-    eventMgr.on(this.listeners, event, callback);
-  }
-
-  /** Remove event listener */
-  off(event, callback) {
-    eventMgr.off(this.listeners, event, callback);
-  }
-
-  /** Emit event */
-  _emit(event, data) {
-    eventMgr.emit(this.listeners, event, data);
-  }
-
-  /** Start adaptive heartbeat */
-  _startHeartbeat() {
-    latencyMgr.startHeartbeat.call(this, () => this._sendBinaryPing());
-  }
-
-  /** Stop heartbeat */
-  _stopHeartbeat() {
-    latencyMgr.stopHeartbeat.call(this);
-  }
-
-  /** Attempt reconnection with exponential backoff */
-  _attemptReconnect() {
-    if (this.reconnectAttempts >= SECURITY.MAX_RECONNECT_ATTEMPTS) {
-      log.error('Max reconnect attempts reached');
-      return;
-    }
-
-    this.reconnecting = true;
-    this.reconnectAttempts++;
-    
-    // Fast initial reconnect, then backoff
-    const delay = Math.min(
-      100 * Math.pow(2, this.reconnectAttempts - 1), // Start at 100ms
-      10000 // Max 10s
-    );
-    
-    log.info('Reconnecting', { attempt: this.reconnectAttempts, delay });
-
-    setTimeout(async () => {
-      try {
-        await this.connect();
-      } catch (err) {
-        log.error('Reconnect failed', { error: err.message });
-      }
-      this.reconnecting = false;
-    }, delay);
-  }
-
-  /** Get latency statistics */
-  getLatencyStats() {
-    return latencyMgr.getLatencyStats.call(this);
-  }
-
-  /** Get connection statistics */
-  getStats() {
-    return latencyMgr.getConnectionStats.call(this);
-  }
-
-  /** Get current latency */
-  getLatency() {
-    return this.latency;
-  }
-
-  /** Disconnect and cleanup */
-  disconnect() {
-    log.info('Disconnecting');
-    
-    this._stopHeartbeat();
-    
-    if (this.ws) {
-      this.ws.close(1000, 'Client disconnect');
-      this.ws = null;
-    }
-    
-    this.connected = false;
-    this.token = null;
-    this.sessionId = null;
-    this.messageQueue = [];
-    eventMgr.clearAll(this.listeners);
-    
-    // Reset stats
-    latencyMgr.resetLatencyStats.call(this);
-  }
-
-  /** Check if connected */
-  isConnected() {
-    return this.connected && this.ws?.readyState === WebSocket.OPEN;
-  }
-}
-
-module.exports = { HQXServerService, HQX_SERVER, MSG_TYPE };

package/src/services/position-constants.js

@@ -1,28 +0,0 @@
-/**
- * @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,
-};

package/src/services/position-exit-logic.js

@@ -1,174 +0,0 @@
-/**
- * Position Exit Logic
- * @module services/position-exit-logic
- * 
- * Exit condition evaluation for fast scalping positions
- */
-
-const { FAST_SCALPING } = require('../config/settings');
-const { MOMENTUM, WEIGHTS } = require('./position-constants');
-const { calculateMomentum, getVPIN } = require('./position-momentum');
-const { logger } = require('../utils/logger');
-
-const log = logger.scope('PositionExit');
-
-/**
- * Check all exit conditions for a position
- * @param {Object} params
- * @param {Object} params.position - Position data
- * @param {number} params.currentPrice - Current market price
- * @param {number} params.pnlTicks - Current P&L in ticks
- * @param {number} params.holdDuration - Time held in ms
- * @param {Object} params.strategy - Strategy instance
- * @param {Function} params.getTickSize - Function to get tick size
- * @param {Map} params.latestPrices - Latest prices map
- * @returns {Object|null} - Exit reason or null
- */
-function checkExitConditions({
-  position,
-  currentPrice,
-  pnlTicks,
-  holdDuration,
-  strategy,
-  getTickSize,
-  latestPrices,
-}) {
-  if (pnlTicks === null) return null;
-  
-  const targetTicks = FAST_SCALPING.TARGET_TICKS;
-  const stopTicks = FAST_SCALPING.STOP_TICKS;
-  
-  // 1. TARGET HIT
-  if (pnlTicks >= targetTicks) {
-    return { type: 'target', reason: 'Target reached', pnlTicks };
-  }
-  
-  // 2. BREAKEVEN CHECK
-  if (position.breakevenActive && position.breakevenPrice !== null) {
-    const tickSize = getTickSize(position);
-    if (tickSize) {
-      if (position.side === 0 && currentPrice <= position.breakevenPrice) {
-        return { type: 'breakeven', reason: 'Breakeven stop hit', pnlTicks };
-      } else if (position.side === 1 && currentPrice >= position.breakevenPrice) {
-        return { type: 'breakeven', reason: 'Breakeven stop hit', pnlTicks };
-      }
-    }
-  }
-  
-  // 3. STOP HIT (only if BE not active)
-  if (!position.breakevenActive && pnlTicks <= -stopTicks) {
-    return { type: 'stop', reason: 'Stop loss hit', pnlTicks };
-  }
-  
-  // 4. VPIN DANGER
-  const vpin = getVPIN(strategy, position.contractId || position.symbol);
-  if (vpin !== null && vpin > MOMENTUM.VPIN_DANGER) {
-    return { type: 'vpin', reason: `VPIN spike ${(vpin * 100).toFixed(0)}% - informed traders`, pnlTicks, vpin };
-  }
-  
-  // 5. TRAILING STOP
-  if (pnlTicks >= FAST_SCALPING.TRAILING_ACTIVATION_TICKS) {
-    const trailingPnl = calculateTrailingPnl(position, currentPrice, getTickSize);
-    if (trailingPnl !== null && trailingPnl <= -FAST_SCALPING.TRAILING_DISTANCE_TICKS) {
-      return { type: 'trailing', reason: 'Trailing stop triggered', pnlTicks, trailingPnl };
-    }
-  }
-  
-  // 6. MOMENTUM-BASED EXIT
-  const momentum = calculateMomentum({
-    strategy: strategy,
-    contractId: position.contractId || position.symbol,
-    side: position.side,
-    currentPrice: latestPrices.get(position.symbol),
-    tickSize: getTickSize(position),
-  });
-  
-  if (momentum !== null) {
-    if (momentum > MOMENTUM.STRONG_FAVORABLE && pnlTicks > 4) {
-      return null; // Don't exit - momentum is strong
-    }
-    
-    if (momentum < MOMENTUM.WEAK_THRESHOLD && pnlTicks > 0) {
-      return { type: 'momentum_weak', reason: 'Weak momentum - securing profit', pnlTicks, momentum };
-    }
-    
-    if (momentum < MOMENTUM.ADVERSE_THRESHOLD) {
-      return { type: 'momentum_adverse', reason: 'Adverse momentum detected', pnlTicks, momentum };
-    }
-  }
-  
-  return null;
-}
-
-/**
- * Check and activate breakeven if conditions met
- * @param {Object} position
- * @param {number} pnlTicks
- * @param {Function} getTickSize
- * @returns {Object|null} - Breakeven activation info or null
- */
-function checkBreakevenActivation(position, pnlTicks, getTickSize) {
-  if (position.breakevenActive) return null;
-  if (pnlTicks < FAST_SCALPING.BREAKEVEN_ACTIVATION_TICKS) return null;
-  
-  const tickSize = getTickSize(position);
-  if (!tickSize || !position.entryPrice) return null;
-  
-  const offset = FAST_SCALPING.BREAKEVEN_OFFSET_TICKS * tickSize;
-  const breakevenPrice = position.side === 0 
-    ? position.entryPrice + offset 
-    : position.entryPrice - offset;
-  
-  return {
-    breakevenPrice,
-    pnlTicks,
-  };
-}
-
-/**
- * Calculate trailing P&L from high/low water mark
- * @param {Object} position
- * @param {number} currentPrice
- * @param {Function} getTickSize
- * @returns {number|null}
- */
-function calculateTrailingPnl(position, currentPrice, getTickSize) {
-  const tickSize = getTickSize(position);
-  if (tickSize === null) return null;
-  
-  if (position.side === 0) {
-    if (position.highWaterMark === null) return null;
-    const dropFromHigh = position.highWaterMark - currentPrice;
-    return -Math.round(dropFromHigh / tickSize);
-  } else {
-    if (position.lowWaterMark === null) return null;
-    const riseFromLow = currentPrice - position.lowWaterMark;
-    return -Math.round(riseFromLow / tickSize);
-  }
-}
-
-/**
- * Calculate P&L in ticks
- * @param {Object} position
- * @param {number} currentPrice
- * @param {Function} getTickSize
- * @returns {number|null}
- */
-function calculatePnlTicks(position, currentPrice, getTickSize) {
-  if (position.entryPrice === null || currentPrice === null) return null;
-  
-  const tickSize = getTickSize(position);
-  if (tickSize === null) return null;
-  
-  const priceDiff = currentPrice - position.entryPrice;
-  const signedDiff = position.side === 0 ? priceDiff : -priceDiff;
-  
-  return Math.round(signedDiff / tickSize);
-}
-
-module.exports = {
-  checkExitConditions,
-  checkBreakevenActivation,
-  calculateTrailingPnl,
-  calculatePnlTicks,
-};