hedgequantx 2.6.162 → 2.7.0

package/src/services/position-momentum.js

@@ -1,206 +0,0 @@
-/**
- * @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

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