hedgequantx 2.6.162 → 2.6.163

package/src/services/strategy/hft-tick.js

@@ -20,6 +20,7 @@
 
 const EventEmitter = require('events');
 const { logger } = require('../../utils/logger');
+const { calculateSignal, buildSignal } = require('./hft-signal-calc');
 
 const log = logger.scope('HFT');
 
@@ -306,23 +307,49 @@ class HFTTickStrategy extends EventEmitter {
    * Check for trading signal
    */
   _checkSignal(tick) {
-    // Need minimum data
     if (this.tickCount < 50) return;
     
-    // Cooldown check
     const now = Date.now();
     if (now - this.lastSignalTime < this.cooldownMs) return;
     
-    // Calculate composite score
-    const { direction, confidence, scores } = this._calculateSignal();
+    const state = {
+      ofiValue: this.ofiValue,
+      zscore: this.zscore,
+      momentum: this.momentum,
+      buyVolume: this.buyVolume,
+      sellVolume: this.sellVolume,
+      cumulativeDelta: this.cumulativeDelta,
+    };
+    
+    const config = {
+      ofiThreshold: this.ofiThreshold,
+      zscoreThreshold: this.zscoreThreshold,
+      momentumThreshold: this.momentumThreshold,
+      minConfidence: this.minConfidence,
+    };
+    
+    const { direction, confidence, scores } = calculateSignal(state, config);
     
     if (direction === 'none' || confidence < this.minConfidence) return;
     
-    // Generate signal
     this.signalCount++;
     this.lastSignalTime = now;
     
-    const signal = this._buildSignal(direction, confidence, scores, tick);
+    const signalState = {
+      ...state,
+      std: this.std,
+      tickCount: this.tickCount,
+      signalCount: this.signalCount,
+      contractId: this.contractId,
+      tickSize: this.tickSize,
+    };
+    
+    const signalConfig = {
+      baseStopTicks: this.baseStopTicks,
+      baseTargetTicks: this.baseTargetTicks,
+    };
+    
+    const signal = buildSignal(direction, confidence, scores, tick, signalState, signalConfig);
     
     log.info(`SIGNAL #${this.signalCount}: ${direction.toUpperCase()} @ ${tick.price} | ` +
              `OFI=${this.ofiValue.toFixed(2)} Z=${this.zscore.toFixed(2)} Mom=${this.momentum.toFixed(1)} | ` +
@@ -331,133 +358,6 @@ class HFTTickStrategy extends EventEmitter {
     this.emit('signal', signal);
   }
 
-  /**
-   * Calculate trading signal from all models
-   */
-  _calculateSignal() {
-    let direction = 'none';
-    let confidence = 0;
-    
-    const scores = {
-      ofi: 0,
-      zscore: 0,
-      momentum: 0,
-      delta: 0,
-      composite: 0,
-    };
-    
-    // === MODEL 1: OFI ===
-    const absOfi = Math.abs(this.ofiValue);
-    if (absOfi > this.ofiThreshold) {
-      scores.ofi = Math.min(1.0, absOfi / 0.6);
-    }
-    
-    // === MODEL 2: Z-Score Mean Reversion ===
-    const absZ = Math.abs(this.zscore);
-    if (absZ > this.zscoreThreshold) {
-      scores.zscore = Math.min(1.0, absZ / 3.0);
-    }
-    
-    // === MODEL 3: Momentum ===
-    const absMom = Math.abs(this.momentum);
-    if (absMom > this.momentumThreshold) {
-      scores.momentum = Math.min(1.0, absMom / 3.0);
-    }
-    
-    // === MODEL 4: Delta ===
-    const totalVol = this.buyVolume + this.sellVolume;
-    if (totalVol > 0) {
-      const deltaRatio = this.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 ===
-    // Mean reversion: go opposite to z-score
-    // Momentum: confirm with OFI and delta
-    
-    if (scores.composite >= this.minConfidence) {
-      // Primary: Mean reversion
-      if (absZ > this.zscoreThreshold) {
-        direction = this.zscore > 0 ? 'short' : 'long';
-        
-        // Confirm with OFI
-        const ofiConfirms = 
-          (direction === 'long' && this.ofiValue > 0) ||
-          (direction === 'short' && this.ofiValue < 0);
-        
-        if (ofiConfirms) {
-          confidence += 0.1;
-        } else if (Math.abs(this.ofiValue) > 0.2) {
-          // OFI contradicts - reduce confidence
-          confidence -= 0.15;
-        }
-      }
-      // Fallback: Momentum breakout
-      else if (absMom > this.momentumThreshold * 2 && absOfi > this.ofiThreshold) {
-        direction = this.momentum > 0 ? 'long' : 'short';
-        // Must be confirmed by OFI
-        if ((direction === 'long' && this.ofiValue < 0) ||
-            (direction === 'short' && this.ofiValue > 0)) {
-          direction = 'none';
-        }
-      }
-    }
-    
-    confidence = Math.min(1.0, Math.max(0, confidence));
-    
-    return { direction, confidence, scores };
-  }
-
-  /**
-   * Build signal object
-   */
-  _buildSignal(direction, confidence, scores, tick) {
-    const entry = tick.price;
-    const isLong = direction === 'long';
-    
-    // Adaptive stops based on volatility (std dev)
-    const volMult = Math.max(0.5, Math.min(2.0, this.std / this.tickSize / 4));
-    const stopTicks = Math.round(this.baseStopTicks * volMult);
-    const targetTicks = Math.round(this.baseTargetTicks * volMult);
-    
-    const stopLoss = isLong 
-      ? entry - stopTicks * this.tickSize
-      : entry + stopTicks * this.tickSize;
-      
-    const takeProfit = isLong
-      ? entry + targetTicks * this.tickSize
-      : entry - targetTicks * this.tickSize;
-    
-    return {
-      id: `hft-${Date.now()}-${this.signalCount}`,
-      timestamp: Date.now(),
-      contractId: this.contractId,
-      direction,
-      side: isLong ? 0 : 1,
-      entry,
-      stopLoss,
-      takeProfit,
-      confidence,
-      scores,
-      // Model values for logging
-      ofi: this.ofiValue,
-      zscore: this.zscore,
-      momentum: this.momentum,
-      delta: this.cumulativeDelta,
-      // Tick count
-      tickCount: this.tickCount,
-    };
-  }
-
   /**
    * Get current model values for monitoring
    */

package/src/services/tradovate/index.js

@@ -13,6 +13,7 @@ const { TIMEOUTS } = require('../../config/settings');
 const { TRADOVATE_URLS, API_PATHS, getBaseUrl, getTradingWebSocketUrl } = require('./constants');
 const { checkMarketHours, isDST } = require('./market');
 const { connectWebSocket, wsSend, disconnectWebSocket } = require('./websocket');
+const { getOrders, placeOrder, cancelOrder, closePosition, getOrderHistory } = require('./orders');
 const { logger } = require('../../utils/logger');
 
 const log = logger.scope('Tradovate');
@@ -252,112 +253,10 @@ class TradovateService extends EventEmitter {
 
   // ==================== ORDERS ====================
 
-  /**
-   * Get orders
-   * @param {number} [accountId] - Optional account filter
-   * @returns {Promise<{success: boolean, orders: Array, error?: string}>}
-   */
-  async getOrders(accountId) {
-    try {
-      const result = await this._request(API_PATHS.ORDER_LIST, 'GET');
-      const orders = Array.isArray(result.data) ? result.data : [];
-      
-      const filtered = accountId
-        ? orders.filter(o => o.accountId === accountId)
-        : orders;
-
-      return {
-        success: true,
-        orders: filtered.map(o => ({
-          orderId: o.id,
-          accountId: o.accountId,
-          symbol: o.contractId,
-          side: o.action === 'Buy' ? 0 : 1,
-          quantity: o.orderQty,
-          filledQuantity: o.filledQty || 0,
-          price: o.price,
-          status: o.ordStatus === 'Working' ? 1 : (o.ordStatus === 'Filled' ? 2 : 0),
-          orderType: o.orderType,
-        })),
-      };
-    } catch (err) {
-      return { success: false, error: err.message, orders: [] };
-    }
-  }
-
-  /**
-   * Place an order
-   * @param {Object} orderData - Order details
-   * @returns {Promise<{success: boolean, orderId?: number, error?: string}>}
-   */
-  async placeOrder(orderData) {
-    try {
-      const result = await this._request(API_PATHS.ORDER_PLACE, 'POST', {
-        accountId: orderData.accountId,
-        action: orderData.side === 0 ? 'Buy' : 'Sell',
-        symbol: orderData.symbol,
-        orderQty: orderData.size,
-        orderType: orderData.type === 2 ? 'Market' : 'Limit',
-        price: orderData.price,
-        isAutomated: true,
-      });
-
-      if (result.data.errorText || result.data.failureReason) {
-        return { success: false, error: result.data.errorText || result.data.failureText };
-      }
-
-      log.info('Order placed', { orderId: result.data.orderId });
-      return { success: true, orderId: result.data.orderId };
-    } catch (err) {
-      return { success: false, error: err.message };
-    }
-  }
-
-  /**
-   * Cancel an order
-   * @param {number} orderId - Order ID
-   * @returns {Promise<{success: boolean, error?: string}>}
-   */
-  async cancelOrder(orderId) {
-    try {
-      const result = await this._request(API_PATHS.ORDER_CANCEL, 'POST', {
-        orderId,
-        isAutomated: true,
-      });
-
-      if (result.data.errorText) {
-        return { success: false, error: result.data.errorText };
-      }
-
-      return { success: true };
-    } catch (err) {
-      return { success: false, error: err.message };
-    }
-  }
-
-  /**
-   * Close a position
-   * @param {number} accountId - Account ID
-   * @param {number} contractId - Contract ID
-   * @returns {Promise<{success: boolean, error?: string}>}
-   */
-  async closePosition(accountId, contractId) {
-    try {
-      const result = await this._request(API_PATHS.ORDER_LIQUIDATE_POSITION, 'POST', {
-        accountId,
-        contractId,
-        isAutomated: true,
-      });
-
-      if (result.data.errorText) {
-        return { success: false, error: result.data.errorText };
-      }
-
-      return { success: true };
-    } catch (err) {
-      return { success: false, error: err.message };
-    }
-  }
+  async getOrders(accountId) { return getOrders(this, accountId); }
+  async placeOrder(orderData) { return placeOrder(this, orderData); }
+  async cancelOrder(orderId) { return cancelOrder(this, orderId); }
+  async closePosition(accountId, contractId) { return closePosition(this, accountId, contractId); }
 
   // ==================== TRADES ====================
 
@@ -404,19 +303,7 @@ class TradovateService extends EventEmitter {
     }
   }
 
-  /**
-   * Get order history
-   * @param {number} [days=30] - Days of history
-   * @returns {Promise<{success: boolean, orders: Array, error?: string}>}
-   */
-  async getOrderHistory(days = 30) {
-    try {
-      const result = await this._request(API_PATHS.ORDER_LIST, 'GET');
-      return { success: true, orders: result.data || [] };
-    } catch (err) {
-      return { success: false, error: err.message, orders: [] };
-    }
-  }
+  async getOrderHistory(days = 30) { return getOrderHistory(this, days); }
 
   // ==================== CONTRACTS ====================
 

package/src/services/tradovate/orders.js

@@ -0,0 +1,145 @@
+/**
+ * Tradovate Orders Module
+ * @module services/tradovate/orders
+ * 
+ * Order placement, cancellation, and queries
+ */
+
+const { API_PATHS } = require('./constants');
+const { logger } = require('../../utils/logger');
+
+const log = logger.scope('TradovateOrders');
+
+/**
+ * Get orders
+ * @param {TradovateService} service
+ * @param {number} [accountId]
+ * @returns {Promise<{success: boolean, orders: Array, error?: string}>}
+ */
+async function getOrders(service, accountId) {
+  try {
+    const result = await service._request(API_PATHS.ORDER_LIST, 'GET');
+    const orders = Array.isArray(result.data) ? result.data : [];
+    
+    const filtered = accountId
+      ? orders.filter(o => o.accountId === accountId)
+      : orders;
+
+    return {
+      success: true,
+      orders: filtered.map(o => ({
+        orderId: o.id,
+        accountId: o.accountId,
+        symbol: o.contractId,
+        side: o.action === 'Buy' ? 0 : 1,
+        quantity: o.orderQty,
+        filledQuantity: o.filledQty || 0,
+        price: o.price,
+        status: o.ordStatus === 'Working' ? 1 : (o.ordStatus === 'Filled' ? 2 : 0),
+        orderType: o.orderType,
+      })),
+    };
+  } catch (err) {
+    return { success: false, error: err.message, orders: [] };
+  }
+}
+
+/**
+ * Place an order
+ * @param {TradovateService} service
+ * @param {Object} orderData
+ * @returns {Promise<{success: boolean, orderId?: number, error?: string}>}
+ */
+async function placeOrder(service, orderData) {
+  try {
+    const result = await service._request(API_PATHS.ORDER_PLACE, 'POST', {
+      accountId: orderData.accountId,
+      action: orderData.side === 0 ? 'Buy' : 'Sell',
+      symbol: orderData.symbol,
+      orderQty: orderData.size,
+      orderType: orderData.type === 2 ? 'Market' : 'Limit',
+      price: orderData.price,
+      isAutomated: true,
+    });
+
+    if (result.data.errorText || result.data.failureReason) {
+      return { success: false, error: result.data.errorText || result.data.failureText };
+    }
+
+    log.info('Order placed', { orderId: result.data.orderId });
+    return { success: true, orderId: result.data.orderId };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Cancel an order
+ * @param {TradovateService} service
+ * @param {number} orderId
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function cancelOrder(service, orderId) {
+  try {
+    const result = await service._request(API_PATHS.ORDER_CANCEL, 'POST', {
+      orderId,
+      isAutomated: true,
+    });
+
+    if (result.data.errorText) {
+      return { success: false, error: result.data.errorText };
+    }
+
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Close a position
+ * @param {TradovateService} service
+ * @param {number} accountId
+ * @param {number} contractId
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function closePosition(service, accountId, contractId) {
+  try {
+    const result = await service._request(API_PATHS.ORDER_LIQUIDATE_POSITION, 'POST', {
+      accountId,
+      contractId,
+      isAutomated: true,
+    });
+
+    if (result.data.errorText) {
+      return { success: false, error: result.data.errorText };
+    }
+
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Get order history
+ * @param {TradovateService} service
+ * @param {number} [days=30]
+ * @returns {Promise<{success: boolean, orders: Array, error?: string}>}
+ */
+async function getOrderHistory(service, days = 30) {
+  try {
+    const result = await service._request(API_PATHS.ORDER_LIST, 'GET');
+    return { success: true, orders: result.data || [] };
+  } catch (err) {
+    return { success: false, error: err.message, orders: [] };
+  }
+}
+
+module.exports = {
+  getOrders,
+  placeOrder,
+  cancelOrder,
+  closePosition,
+  getOrderHistory,
+};