hedgequantx 2.6.161 → 2.6.163

package/src/services/position-momentum.js

@@ -0,0 +1,206 @@
+/**
+ * @fileoverview Position Momentum Calculator
+ * Calculates momentum using strategy's math models (OFI, Kalman, Z-Score)
+ * 
+ * Data sources:
+ * - OFI: Strategy's computeOrderFlowImbalance()
+ * - Kalman: Strategy's kalmanStates
+ * - Z-Score: Strategy's computeZScore()
+ * - VPIN: Strategy's computeVPIN()
+ */
+
+const { logger } = require('../utils/logger');
+const { WEIGHTS } = require('./position-constants');
+
+const log = logger.scope('PositionMomentum');
+
+/**
+ * Get OFI (Order Flow Imbalance) from strategy
+ * @param {Object} strategy - Strategy instance
+ * @param {string} contractId - Contract identifier
+ * @returns {number|null} OFI value [-1, 1] or null if unavailable
+ */
+const getOFI = (strategy, contractId) => {
+  if (!strategy) return null;
+  
+  // Try strategy's computeOrderFlowImbalance (direct calculation from bars)
+  if (typeof strategy.computeOrderFlowImbalance === 'function') {
+    const bars = strategy.getBarHistory?.(contractId);
+    if (bars && bars.length >= 20) {
+      try {
+        return strategy.computeOrderFlowImbalance(bars);
+      } catch (error) {
+        log.debug('OFI calculation failed', { error: error.message });
+      }
+    }
+  }
+  
+  // Try getModelValues (pre-calculated values)
+  const modelValues = strategy.getModelValues?.(contractId);
+  if (modelValues && modelValues.rawOfi !== undefined) {
+    return modelValues.rawOfi;
+  }
+  
+  return null;
+};
+
+/**
+ * Get Kalman velocity from strategy's Kalman filter
+ * @param {Object} strategy - Strategy instance
+ * @param {string} contractId - Contract identifier
+ * @param {number} currentPrice - Latest price
+ * @returns {number|null} Velocity value or null if unavailable
+ */
+const getKalmanVelocity = (strategy, contractId, currentPrice) => {
+  if (!strategy) return null;
+  
+  // Try to access kalmanStates from strategy
+  if (strategy.kalmanStates) {
+    const state = strategy.kalmanStates.get(contractId);
+    if (state && typeof state.estimate === 'number') {
+      if (currentPrice !== undefined && currentPrice !== null) {
+        return currentPrice - state.estimate;
+      }
+    }
+  }
+  
+  return null;
+};
+
+/**
+ * Get Z-Score from strategy
+ * @param {Object} strategy - Strategy instance
+ * @param {string} contractId - Contract identifier
+ * @returns {number|null} Z-Score value or null if unavailable
+ */
+const getZScore = (strategy, contractId) => {
+  if (!strategy) return null;
+  
+  // Try strategy's computeZScore (direct calculation from price buffer)
+  if (typeof strategy.computeZScore === 'function') {
+    const prices = strategy.priceBuffer?.get(contractId);
+    if (prices && prices.length >= 50) {
+      try {
+        return strategy.computeZScore(prices);
+      } catch (error) {
+        log.debug('Z-Score calculation failed', { error: error.message });
+      }
+    }
+  }
+  
+  return null;
+};
+
+/**
+ * Get VPIN from strategy
+ * @param {Object} strategy - Strategy instance
+ * @param {string} contractId - Contract identifier
+ * @returns {number|null} VPIN value [0, 1] or null if unavailable
+ */
+const getVPIN = (strategy, contractId) => {
+  if (!strategy) return null;
+  
+  // Try strategy's computeVPIN (direct calculation from volume buffer)
+  if (typeof strategy.computeVPIN === 'function') {
+    const volumes = strategy.volumeBuffer?.get(contractId);
+    if (volumes && volumes.length >= 50) {
+      try {
+        return strategy.computeVPIN(volumes);
+      } catch (error) {
+        log.debug('VPIN calculation failed', { error: error.message });
+      }
+    }
+  }
+  
+  // Try getModelValues (pre-calculated, stored as 1 - vpin for scoring)
+  const modelValues = strategy.getModelValues?.(contractId);
+  if (modelValues && typeof modelValues.vpin === 'number') {
+    return 1 - modelValues.vpin;
+  }
+  
+  return null;
+};
+
+/**
+ * Calculate momentum score using strategy's existing math models
+ * Weighted: OFI (50%) + Kalman Velocity (25%) + Z-Score (25%)
+ * 
+ * @param {Object} params - Parameters
+ * @param {Object} params.strategy - Strategy instance
+ * @param {string} params.contractId - Contract identifier
+ * @param {number} params.side - Position side (0=Long, 1=Short)
+ * @param {number} params.currentPrice - Latest price
+ * @param {number|null} params.tickSize - Tick size from API
+ * @returns {number|null} Momentum score [-1 to 1], positive = favorable, null if insufficient data
+ */
+const calculateMomentum = ({ strategy, contractId, side, currentPrice, tickSize }) => {
+  if (!strategy) {
+    return null;
+  }
+  
+  // Get individual model values (all from API/strategy, not invented)
+  const ofi = getOFI(strategy, contractId);
+  const velocity = getKalmanVelocity(strategy, contractId, currentPrice);
+  const zscore = getZScore(strategy, contractId);
+  
+  // Count how many models have data
+  let availableModels = 0;
+  let totalWeight = 0;
+  let weightedSum = 0;
+  
+  // 1. OFI (50%) - Order Flow Imbalance
+  if (ofi !== null) {
+    // For long: positive OFI = favorable, For short: negative OFI = favorable
+    const favorableOfi = side === 0 ? ofi : -ofi;
+    const ofiScore = Math.min(1, Math.max(-1, favorableOfi));
+    weightedSum += ofiScore * WEIGHTS.OFI;
+    totalWeight += WEIGHTS.OFI;
+    availableModels++;
+  }
+  
+  // 2. Kalman Velocity (25%)
+  if (velocity !== null && tickSize !== null) {
+    // Normalize velocity: favorable direction = positive
+    const favorableVelocity = side === 0 ? velocity : -velocity;
+    // Normalize to [-1, 1]: 4 ticks of velocity = 1.0 score
+    const normalizedVelocity = favorableVelocity / (tickSize * 4);
+    const velocityScore = Math.min(1, Math.max(-1, normalizedVelocity));
+    weightedSum += velocityScore * WEIGHTS.KALMAN;
+    totalWeight += WEIGHTS.KALMAN;
+    availableModels++;
+  }
+  
+  // 3. Z-Score (25%) - Progression toward mean
+  if (zscore !== null) {
+    let zscoreScore;
+    if (side === 0) {
+      // Long: entered when Z < -threshold, improving = Z moving toward 0
+      zscoreScore = zscore > -0.5 ? 0.5 : -0.5;
+    } else {
+      // Short: entered when Z > threshold, improving = Z moving toward 0
+      zscoreScore = zscore < 0.5 ? 0.5 : -0.5;
+    }
+    weightedSum += zscoreScore * WEIGHTS.ZSCORE;
+    totalWeight += WEIGHTS.ZSCORE;
+    availableModels++;
+  }
+  
+  // Need at least 1 model with data to calculate momentum
+  if (availableModels === 0 || totalWeight === 0) {
+    return null;
+  }
+  
+  // Normalize by actual total weight (in case some models unavailable)
+  const momentum = weightedSum / totalWeight;
+  
+  // Clamp to [-1, 1]
+  return Math.min(1, Math.max(-1, momentum));
+};
+
+module.exports = {
+  getOFI,
+  getKalmanVelocity,
+  getZScore,
+  getVPIN,
+  calculateMomentum,
+};

package/src/services/projectx/accounts.js

@@ -0,0 +1,142 @@
+/**
+ * ProjectX Account Management
+ * @module services/projectx/accounts
+ * 
+ * Account enrichment and P&L calculations.
+ */
+
+const { logger } = require('../../utils/logger');
+
+const log = logger.scope('ProjectX');
+
+/**
+ * Enrich account with P&L data from API
+ * @param {Function} request - Request function
+ * @param {Object} propfirm - Propfirm config
+ * @param {Object} account - Account object
+ * @param {Array} templates - Account templates
+ */
+async function enrichAccount(request, propfirm, account, templates) {
+  const template = templates.find(t =>
+    account.accountName && (
+      account.accountName.includes(t.title) ||
+      t.title.includes(account.accountName)
+    )
+  );
+
+  const enriched = {
+    accountId: account.accountId,
+    accountName: account.accountName,
+    balance: account.balance,
+    status: account.status,
+    type: account.type,
+    startingBalance: template?.startingBalance || null,
+    platform: 'ProjectX',
+    propfirm: propfirm.name,
+    openPnL: null,
+    todayPnL: null,
+    profitAndLoss: null,
+  };
+
+  // Only fetch P&L for active accounts
+  if (account.status !== 0) {
+    return enriched;
+  }
+
+  // Get unrealized P&L from open positions
+  let openPnL = 0;
+  try {
+    const posRes = await request(
+      propfirm.userApi,
+      `/Position?accountId=${account.accountId}`,
+      'GET'
+    );
+    
+    if (posRes.statusCode === 200 && Array.isArray(posRes.data)) {
+      for (const pos of posRes.data) {
+        if (pos.profitAndLoss != null) {
+          openPnL += pos.profitAndLoss;
+        }
+      }
+    }
+  } catch {
+    log.debug('Failed to get positions', { accountId: account.accountId });
+  }
+
+  // Get realized P&L from today's trades
+  let todayPnL = 0;
+  try {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    
+    const tradesRes = await request(
+      propfirm.gatewayApi,
+      '/api/Trade/search',
+      'POST',
+      {
+        accountId: account.accountId,
+        startTimestamp: today.toISOString(),
+        endTimestamp: new Date().toISOString(),
+      }
+    );
+    
+    if (tradesRes.statusCode === 200) {
+      const trades = Array.isArray(tradesRes.data) ? tradesRes.data : (tradesRes.data.trades || []);
+      for (const trade of trades) {
+        if (trade.profitAndLoss != null) {
+          todayPnL += trade.profitAndLoss;
+        }
+      }
+    }
+  } catch {
+    log.debug('Failed to get today trades', { accountId: account.accountId });
+  }
+
+  enriched.openPnL = openPnL;
+  enriched.todayPnL = todayPnL;
+  enriched.profitAndLoss = openPnL + todayPnL;
+
+  return enriched;
+}
+
+/**
+ * Get trading accounts with REAL P&L from API
+ * @param {Function} request - Request function
+ * @param {Object} propfirm - Propfirm config
+ */
+async function getTradingAccounts(request, propfirm) {
+  try {
+    const response = await request(propfirm.userApi, '/TradingAccount', 'GET');
+    
+    if (response.statusCode !== 200) {
+      return { success: false, accounts: [], error: 'Failed to get accounts' };
+    }
+
+    const accounts = Array.isArray(response.data) ? response.data : [];
+    
+    // Get account templates for startingBalance
+    let templates = [];
+    try {
+      const templateRes = await request(propfirm.userApi, '/AccountTemplate/userTemplates', 'GET');
+      if (templateRes.statusCode === 200 && Array.isArray(templateRes.data)) {
+        templates = templateRes.data;
+      }
+    } catch {
+      log.debug('Failed to get templates');
+    }
+
+    const enrichedAccounts = await Promise.all(
+      accounts.map(account => enrichAccount(request, propfirm, account, templates))
+    );
+
+    return { success: true, accounts: enrichedAccounts };
+  } catch (err) {
+    log.error('Failed to get accounts', { error: err.message });
+    return { success: false, accounts: [], error: err.message };
+  }
+}
+
+module.exports = {
+  enrichAccount,
+  getTradingAccounts,
+};