hedgequantx 2.6.162 → 2.7.0

package/src/services/projectx/index.js

@@ -1,443 +0,0 @@
-/**
- * @fileoverview ProjectX API Service
- * @module services/projectx
- * 
- * STRICT RULE: Display ONLY values returned by API. No estimation, no simulation.
- */
-
-const { request } = require('../../utils/http');
-const { PROPFIRMS } = require('../../config');
-const { TIMEOUTS, DEBUG } = require('../../config/settings');
-const { getLimiter } = require('../../security/rateLimit');
-const {
-  validateUsername,
-  validatePassword,
-  validateApiKey,
-  validateAccountId,
-  sanitizeString,
-  maskSensitive,
-} = require('../../security');
-const { getMarketHolidays, checkHoliday, checkMarketHours } = require('./market');
-const { calculateLifetimeStats, calculateDailyPnL, formatTrades } = require('./stats');
-const { logger } = require('../../utils/logger');
-const trading = require('./trading');
-const accounts = require('./accounts');
-
-const log = logger.scope('ProjectX');
-
-/**
- * ProjectX API Service for prop firm connections
- */
-class ProjectXService {
-  /**
-   * @param {string} [propfirmKey='topstep'] - PropFirm identifier
-   */
-  constructor(propfirmKey = 'topstep') {
-    this.propfirm = PROPFIRMS[propfirmKey] || PROPFIRMS.topstep;
-    this.propfirmKey = propfirmKey;
-    this.token = null;
-    this.user = null;
-    this._limiters = {
-      api: getLimiter('api'),
-      login: getLimiter('login'),
-      orders: getLimiter('orders'),
-    };
-  }
-
-  // ==================== GETTERS ====================
-  
-  getToken() { return this.token; }
-  getPropfirm() { return this.propfirmKey; }
-  
-  /**
-   * Store credentials for token refresh
-   * @param {string} userName - Username
-   * @param {string} password - Password
-   */
-  storeCredentials(userName, password) {
-    this._credentials = { userName, password };
-  }
-  
-  /**
-   * Get a fresh token by re-authenticating
-   * Required for WebSocket connections as TopStep invalidates old sessions
-   * @returns {Promise<string|null>} Fresh token or null if failed
-   */
-  async getFreshToken() {
-    if (this._credentials) {
-      const result = await this.login(this._credentials.userName, this._credentials.password);
-      if (result.success) {
-        return this.token;
-      }
-    }
-    return this.token; // Fallback to existing token
-  }
-
-  // ==================== HTTP ====================
-
-  /**
-   * Make an API request with rate limiting
-   * @private
-   */
-  async _request(host, path, method = 'GET', data = null, limiterType = 'api') {
-    const limiter = this._limiters[limiterType] || this._limiters.api;
-    return limiter.execute(() => this._doRequest(host, path, method, data));
-  }
-
-  /**
-   * Execute the actual HTTP request
-   * @private
-   */
-  async _doRequest(host, path, method, data) {
-    const url = `https://${host}${path}`;
-    
-    try {
-      const response = await request(url, {
-        method,
-        body: data,
-        token: this.token,
-        timeout: TIMEOUTS.API_REQUEST,
-      });
-      
-      return response;
-    } catch (err) {
-      log.error('Request failed', { path, error: err.message });
-      throw err;
-    }
-  }
-
-  // ==================== AUTH ====================
-
-  /**
-   * Login with username and password
-   * @param {string} userName - Username
-   * @param {string} password - Password
-   * @returns {Promise<{success: boolean, token?: string, error?: string}>}
-   */
-  async login(userName, password) {
-    try {
-      validateUsername(userName);
-      validatePassword(password, { requireUppercase: false, requireNumber: false });
-      
-      const response = await this._request(
-        this.propfirm.userApi, '/Login', 'POST',
-        { userName: sanitizeString(userName), password },
-        'login'
-      );
-      
-      if (response.statusCode === 200 && response.data.token) {
-        this.token = response.data.token;
-        this.storeCredentials(userName, password); // Store for token refresh
-        log.info('Login successful', { user: sanitizeString(userName) });
-        return { success: true, token: maskSensitive(this.token) };
-      }
-      
-      const error = response.data.errorMessage || 'Invalid credentials';
-      log.warn('Login failed', { error });
-      return { success: false, error };
-    } catch (err) {
-      log.error('Login error', { error: err.message });
-      return { success: false, error: err.message };
-    }
-  }
-
-  /**
-   * Login with API key
-   * @param {string} userName - Username
-   * @param {string} apiKey - API key
-   * @returns {Promise<{success: boolean, token?: string, error?: string}>}
-   */
-  async loginWithApiKey(userName, apiKey) {
-    try {
-      validateUsername(userName);
-      validateApiKey(apiKey);
-      
-      const response = await this._request(
-        this.propfirm.userApi, '/Login/key', 'POST',
-        { userName: sanitizeString(userName), apiKey },
-        'login'
-      );
-      
-      if (response.statusCode === 200 && response.data.token) {
-        this.token = response.data.token;
-        log.info('API key login successful');
-        return { success: true, token: maskSensitive(this.token) };
-      }
-      
-      return { success: false, error: response.data.errorMessage || 'Invalid API key' };
-    } catch (err) {
-      log.error('API key login error', { error: err.message });
-      return { success: false, error: err.message };
-    }
-  }
-
-  /**
-   * Logout and clear token
-   */
-  logout() {
-    this.token = null;
-    this.user = null;
-    log.debug('Logged out');
-  }
-
-  // ==================== USER ====================
-
-  /**
-   * Get user information
-   * @returns {Promise<{success: boolean, user?: Object, error?: string}>}
-   */
-  async getUser() {
-    try {
-      const response = await this._request(this.propfirm.userApi, '/User', 'GET');
-      
-      if (response.statusCode === 200) {
-        this.user = response.data;
-        return { success: true, user: response.data };
-      }
-      
-      return { success: false, error: 'Failed to get user info' };
-    } catch (err) {
-      return { success: false, error: err.message };
-    }
-  }
-
-  // ==================== ACCOUNTS ====================
-
-  /**
-   * Get trading accounts with REAL P&L from API
-   * @returns {Promise<{success: boolean, accounts: Array, error?: string}>}
-   */
-  async getTradingAccounts() {
-    return accounts.getTradingAccounts(
-      (host, path, method, data) => this._request(host, path, method, data),
-      this.propfirm
-    );
-  }
-
-  // ==================== TRADING ====================
-
-  /** Get open positions */
-  async getPositions(accountId) {
-    return trading.getPositions(
-      (host, path, method, data) => this._request(host, path, method, data),
-      this.propfirm.gatewayApi, accountId
-    );
-  }
-
-  /** Get open orders */
-  async getOrders(accountId) {
-    return trading.getOrders(
-      (host, path, method, data) => this._request(host, path, method, data),
-      this.propfirm.gatewayApi, accountId
-    );
-  }
-
-  /** Get trades for today */
-  async getTrades(accountId) {
-    return trading.getTrades(
-      (host, path, method, data) => this._request(host, path, method, data),
-      this.propfirm.gatewayApi, accountId
-    );
-  }
-
-  /** Place an order */
-  async placeOrder(orderData) {
-    return trading.placeOrder(
-      (host, path, method, data, limiter) => this._request(host, path, method, data, limiter),
-      this.propfirm.gatewayApi, orderData
-    );
-  }
-
-  /** Cancel an order */
-  async cancelOrder(orderId) {
-    return trading.cancelOrder(
-      (host, path, method, data, limiter) => this._request(host, path, method, data, limiter),
-      this.propfirm.gatewayApi, orderId
-    );
-  }
-
-  /** Cancel all open orders */
-  async cancelAllOrders(accountId) {
-    return trading.cancelAllOrders(
-      (host, path, method, data, limiter) => this._request(host, path, method, data, limiter),
-      this.propfirm.gatewayApi, accountId
-    );
-  }
-
-  /** Close a position */
-  async closePosition(accountId, contractId) {
-    return trading.closePosition(
-      (host, path, method, data, limiter) => this._request(host, path, method, data, limiter),
-      this.propfirm.gatewayApi, accountId, contractId
-    );
-  }
-
-  // ==================== TRADES & STATS ====================
-
-  /**
-   * Get trade history
-   * @param {number|string} accountId - Account ID
-   * @param {number} [days=30] - Days of history
-   * @returns {Promise<{success: boolean, trades: Array, error?: string}>}
-   */
-  async getTradeHistory(accountId, days = 30) {
-    try {
-      const id = validateAccountId(accountId);
-      const endDate = new Date();
-      const startDate = new Date();
-      startDate.setDate(startDate.getDate() - days);
-
-      const response = await this._request(
-        this.propfirm.gatewayApi,
-        '/api/Trade/search',
-        'POST',
-        {
-          accountId: id,
-          startTimestamp: startDate.toISOString(),
-          endTimestamp: endDate.toISOString(),
-        }
-      );
-
-      if (response.statusCode === 200 && response.data) {
-        const trades = Array.isArray(response.data) ? response.data : (response.data.trades || []);
-        return { success: true, trades: formatTrades(trades) };
-      }
-
-      return { success: true, trades: [] };
-    } catch (err) {
-      return { success: true, trades: [], error: err.message };
-    }
-  }
-
-  /**
-   * Get daily statistics
-   * @param {number|string} accountId - Account ID
-   * @returns {Promise<{success: boolean, stats: Array, error?: string}>}
-   */
-  async getDailyStats(accountId) {
-    try {
-      const id = validateAccountId(accountId);
-      const now = new Date();
-      const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
-
-      const response = await this._request(
-        this.propfirm.gatewayApi,
-        '/api/Trade/search',
-        'POST',
-        {
-          accountId: id,
-          startTimestamp: startOfMonth.toISOString(),
-          endTimestamp: now.toISOString(),
-        }
-      );
-
-      if (response.statusCode === 200 && response.data) {
-        const trades = Array.isArray(response.data) ? response.data : (response.data.trades || []);
-        return { success: true, stats: calculateDailyPnL(trades) };
-      }
-
-      return { success: false, stats: [] };
-    } catch (err) {
-      return { success: false, stats: [], error: err.message };
-    }
-  }
-
-  /**
-   * Get lifetime statistics
-   * @param {number|string} accountId - Account ID
-   * @returns {Promise<{success: boolean, stats: Object|null, error?: string}>}
-   */
-  async getLifetimeStats(accountId) {
-    try {
-      const tradesResult = await this.getTradeHistory(accountId, 90);
-      
-      if (!tradesResult.success || !tradesResult.trades.length) {
-        return { success: true, stats: null };
-      }
-      
-      return { success: true, stats: calculateLifetimeStats(tradesResult.trades) };
-    } catch (err) {
-      return { success: false, stats: null, error: err.message };
-    }
-  }
-
-  // ==================== CONTRACTS ====================
-
-  /**
-   * Get available contracts from Gateway API
-   * Returns RAW data from API - NO static mapping, NO mock data
-   * 
-   * @returns {Promise<{success: boolean, contracts: Array, error?: string}>}
-   */
-  async getContracts() {
-    try {
-      const response = await this._request(
-        this.propfirm.gatewayApi,
-        '/api/Contract/available',
-        'POST',
-        { live: false }
-      );
-      
-      if (response.statusCode === 200) {
-        const rawContracts = response.data.contracts || response.data || [];
-        
-        // Return active contracts with RAW API data only
-        const contracts = rawContracts
-          .filter(c => c.activeContract === true)
-          .sort((a, b) => {
-            const grpA = a.contractGroup || '';
-            const grpB = b.contractGroup || '';
-            if (grpA !== grpB) return grpA.localeCompare(grpB);
-            return (a.name || '').localeCompare(b.name || '');
-          });
-        
-        return { success: true, contracts };
-      }
-      
-      return { success: false, contracts: [], error: 'Failed to fetch contracts' };
-    } catch (err) {
-      return { success: false, contracts: [], error: err.message };
-    }
-  }
-
-  /**
-   * Search contracts
-   * @param {string} searchText - Search text
-   * @returns {Promise<{success: boolean, contracts: Array, error?: string}>}
-   */
-  async searchContracts(searchText) {
-    try {
-      const response = await this._request(
-        this.propfirm.gatewayApi,
-        '/api/Contract/search',
-        'POST',
-        { searchText: sanitizeString(searchText), live: false }
-      );
-      
-      if (response.statusCode === 200) {
-        return { success: true, contracts: response.data.contracts || response.data || [] };
-      }
-      
-      return { success: false, contracts: [] };
-    } catch (err) {
-      return { success: false, contracts: [], error: err.message };
-    }
-  }
-
-  // ==================== MARKET STATUS ====================
-
-  getMarketHolidays() { return getMarketHolidays(); }
-  checkHoliday() { return checkHoliday(); }
-  checkMarketHours() { return checkMarketHours(); }
-
-  /**
-   * Get market status
-   * @returns {Promise<{success: boolean, isOpen: boolean, message: string}>}
-   */
-  async getMarketStatus() {
-    const hours = checkMarketHours();
-    return { success: true, isOpen: hours.isOpen, message: hours.message };
-  }
-}
-
-module.exports = { ProjectXService };

package/src/services/projectx/market.js

@@ -1,172 +0,0 @@
-/**
- * ProjectX Market Hours & Holidays
- * CME Futures trading hours and US market holidays
- */
-
-/**
- * Get nth weekday of a month
- */
-const getNthWeekday = (year, month, weekday, n) => {
-  let count = 0;
-  for (let day = 1; day <= 31; day++) {
-    const d = new Date(year, month, day);
-    if (d.getMonth() !== month) break;
-    if (d.getDay() === weekday) {
-      count++;
-      if (count === n) return d.toISOString().split('T')[0];
-    }
-  }
-  return null;
-};
-
-/**
- * Get last weekday of a month
- */
-const getLastWeekday = (year, month, weekday) => {
-  const lastDay = new Date(year, month + 1, 0);
-  for (let day = lastDay.getDate(); day >= 1; day--) {
-    const d = new Date(year, month, day);
-    if (d.getDay() === weekday) return d.toISOString().split('T')[0];
-  }
-  return null;
-};
-
-/**
- * Get Good Friday (Friday before Easter)
- */
-const getGoodFriday = (year) => {
-  const a = year % 19;
-  const b = Math.floor(year / 100);
-  const c = year % 100;
-  const d = Math.floor(b / 4);
-  const e = b % 4;
-  const f = Math.floor((b + 8) / 25);
-  const g = Math.floor((b - f + 1) / 3);
-  const h = (19 * a + b - d - g + 15) % 30;
-  const i = Math.floor(c / 4);
-  const k = c % 4;
-  const l = (32 + 2 * e + 2 * i - h - k) % 7;
-  const m = Math.floor((a + 11 * h + 22 * l) / 451);
-  const month = Math.floor((h + l - 7 * m + 114) / 31) - 1;
-  const day = ((h + l - 7 * m + 114) % 31) + 1;
-  
-  const easter = new Date(year, month, day);
-  const goodFriday = new Date(easter);
-  goodFriday.setDate(easter.getDate() - 2);
-  return goodFriday.toISOString().split('T')[0];
-};
-
-/**
- * Get day after a date
- */
-const getDayAfter = (dateStr) => {
-  const d = new Date(dateStr);
-  d.setDate(d.getDate() + 1);
-  return d.toISOString().split('T')[0];
-};
-
-/**
- * Get US market holidays for the current year
- */
-const getMarketHolidays = () => {
-  const year = new Date().getFullYear();
-  
-  return [
-    { date: `${year}-01-01`, name: "New Year's Day", earlyClose: false },
-    { date: getNthWeekday(year, 0, 1, 3), name: 'MLK Day', earlyClose: false },
-    { date: getNthWeekday(year, 1, 1, 3), name: "Presidents' Day", earlyClose: false },
-    { date: getGoodFriday(year), name: 'Good Friday', earlyClose: false },
-    { date: getLastWeekday(year, 4, 1), name: 'Memorial Day', earlyClose: false },
-    { date: `${year}-06-19`, name: 'Juneteenth', earlyClose: false },
-    { date: `${year}-07-04`, name: 'Independence Day', earlyClose: false },
-    { date: `${year}-07-03`, name: 'Independence Day Eve', earlyClose: true },
-    { date: getNthWeekday(year, 8, 1, 1), name: 'Labor Day', earlyClose: false },
-    { date: getNthWeekday(year, 10, 4, 4), name: 'Thanksgiving', earlyClose: false },
-    { date: getDayAfter(getNthWeekday(year, 10, 4, 4)), name: 'Black Friday', earlyClose: true },
-    { date: `${year}-12-25`, name: 'Christmas Day', earlyClose: false },
-    { date: `${year}-12-24`, name: 'Christmas Eve', earlyClose: true },
-    { date: `${year}-12-31`, name: "New Year's Eve", earlyClose: true },
-  ];
-};
-
-/**
- * Check if today is a market holiday
- */
-const checkHoliday = () => {
-  const today = new Date().toISOString().split('T')[0];
-  const holidays = getMarketHolidays();
-  const holiday = holidays.find(h => h.date === today);
-  
-  if (holiday) {
-    return { isHoliday: !holiday.earlyClose, holiday };
-  }
-  return { isHoliday: false };
-};
-
-/**
- * Get current trading session based on ET time
- * Sessions (in ET):
- * - ASIA: 6:00 PM - 2:00 AM (18:00-02:00)
- * - LONDON: 2:00 AM - 8:00 AM (02:00-08:00)
- * - AMERICAN: 8:00 AM - 5:00 PM (08:00-17:00)
- * - MAINTENANCE: 5:00 PM - 6:00 PM (17:00-18:00)
- */
-const getTradingSession = () => {
-  const now = new Date();
-  // Convert to ET (UTC-5 or UTC-4 for DST)
-  const etOptions = { timeZone: 'America/New_York', hour: 'numeric', hour12: false };
-  const etHour = parseInt(new Intl.DateTimeFormat('en-US', etOptions).format(now));
-  
-  // Determine session based on ET hour
-  if (etHour >= 18 || etHour < 2) {
-    return 'ASIA';
-  } else if (etHour >= 2 && etHour < 8) {
-    return 'LONDON';
-  } else if (etHour >= 8 && etHour < 17) {
-    return 'AMERICAN';
-  } else {
-    return 'MAINTENANCE';
-  }
-};
-
-/**
- * Check if futures market is open based on CME hours and holidays
- */
-const checkMarketHours = () => {
-  const now = new Date();
-  const utcDay = now.getUTCDay();
-  const utcHour = now.getUTCHours();
-  
-  const holidayCheck = checkHoliday();
-  if (holidayCheck.isHoliday) {
-    return { isOpen: false, message: `Market closed - ${holidayCheck.holiday.name}`, session: null };
-  }
-  if (holidayCheck.holiday && holidayCheck.holiday.earlyClose && utcHour >= 18) {
-    return { isOpen: false, message: `Market closed early - ${holidayCheck.holiday.name}`, session: null };
-  }
-  
-  if (utcDay === 6) {
-    return { isOpen: false, message: 'Market closed - Weekend (Saturday)', session: null };
-  }
-  
-  if (utcDay === 0 && utcHour < 23) {
-    return { isOpen: false, message: 'Market closed - Opens Sunday 6:00 PM ET', session: null };
-  }
-  
-  if (utcDay === 5 && utcHour >= 22) {
-    return { isOpen: false, message: 'Market closed - Weekend', session: null };
-  }
-  
-  if (utcHour === 22 && utcDay !== 5) {
-    return { isOpen: false, message: 'Market closed - Daily maintenance (5:00-6:00 PM ET)', session: 'MAINTENANCE' };
-  }
-  
-  const session = getTradingSession();
-  return { isOpen: true, message: 'Market is open', session };
-};
-
-module.exports = {
-  getMarketHolidays,
-  checkHoliday,
-  checkMarketHours
-};