hedgequantx 2.6.162 → 2.7.0

package/src/config/propfirms.js

@@ -1,194 +1,12 @@
 /**
- * @fileoverview PropFirm API Configurations - Synced with Admin Dashboard
+ * @fileoverview PropFirm API Configurations - Rithmic Only
  * @module config/propfirms
  */
 
 /**
- * PropFirm configurations
- * Synced with: /root/HQX-Dev/hqx_tg/src/propfirms/config.ts
+ * PropFirm configurations (Rithmic platform only)
  */
 const PROPFIRMS = {
-  // ==================== ProjectX Platform ====================
-  topstep: {
-    id: 'topstepx',
-    name: 'TopStep',
-    displayName: 'TopStep',
-    platform: 'ProjectX',
-    userApi: 'userapi.topstepx.com',
-    gatewayApi: 'api.topstepx.com'
-  },
-  alpha_futures: {
-    id: 'alphafutures',
-    name: 'Alpha Futures',
-    displayName: 'Alpha Futures',
-    platform: 'ProjectX',
-    userApi: 'userapi.alphafutures.projectx.com',
-    gatewayApi: 'api.alphafutures.projectx.com'
-  },
-  tickticktrader: {
-    id: 'tickticktrader',
-    name: 'TickTickTrader',
-    displayName: 'TickTickTrader',
-    platform: 'ProjectX',
-    userApi: 'userapi.tickticktrader.projectx.com',
-    gatewayApi: 'api.tickticktrader.projectx.com'
-  },
-  bulenox: {
-    id: 'bulenox',
-    name: 'Bulenox',
-    displayName: 'Bulenox',
-    platform: 'ProjectX',
-    userApi: 'userapi.bulenox.projectx.com',
-    gatewayApi: 'api.bulenox.projectx.com'
-  },
-  tradeday: {
-    id: 'tradeday',
-    name: 'TradeDay',
-    displayName: 'TradeDay',
-    platform: 'ProjectX',
-    userApi: 'userapi.tradeday.projectx.com',
-    gatewayApi: 'api.tradeday.projectx.com'
-  },
-  blusky: {
-    id: 'blusky',
-    name: 'Blusky',
-    displayName: 'Blusky',
-    platform: 'ProjectX',
-    userApi: 'userapi.blusky.projectx.com',
-    gatewayApi: 'api.blusky.projectx.com'
-  },
-  goat_futures: {
-    id: 'goatfutures',
-    name: 'Goat Futures',
-    displayName: 'Goat Futures',
-    platform: 'ProjectX',
-    userApi: 'userapi.goatfutures.projectx.com',
-    gatewayApi: 'api.goatfutures.projectx.com'
-  },
-  futures_desk: {
-    id: 'thefuturesdesk',
-    name: 'The Futures Desk',
-    displayName: 'The Futures Desk',
-    platform: 'ProjectX',
-    userApi: 'userapi.thefuturesdesk.projectx.com',
-    gatewayApi: 'api.thefuturesdesk.projectx.com'
-  },
-  daytraders: {
-    id: 'daytraders',
-    name: 'DayTraders',
-    displayName: 'DayTraders',
-    platform: 'ProjectX',
-    userApi: 'userapi.daytraders.projectx.com',
-    gatewayApi: 'api.daytraders.projectx.com'
-  },
-  e8_futures: {
-    id: 'e8futures',
-    name: 'E8 Futures',
-    displayName: 'E8 Futures',
-    platform: 'ProjectX',
-    userApi: 'userapi.e8futures.projectx.com',
-    gatewayApi: 'api.e8futures.projectx.com'
-  },
-  blue_guardian: {
-    id: 'blueguardianfutures',
-    name: 'Blue Guardian Futures',
-    displayName: 'Blue Guardian Futures',
-    platform: 'ProjectX',
-    userApi: 'userapi.blueguardianfutures.projectx.com',
-    gatewayApi: 'api.blueguardianfutures.projectx.com'
-  },
-  futures_elite: {
-    id: 'futureselite',
-    name: 'FuturesElite',
-    displayName: 'FuturesElite',
-    platform: 'ProjectX',
-    userApi: 'userapi.futureselite.projectx.com',
-    gatewayApi: 'api.futureselite.projectx.com'
-  },
-  fxify: {
-    id: 'fxify',
-    name: 'FXIFY',
-    displayName: 'FXIFY',
-    platform: 'ProjectX',
-    userApi: 'userapi.fxify.projectx.com',
-    gatewayApi: 'api.fxify.projectx.com'
-  },
-  hola_prime: {
-    id: 'holaprime',
-    name: 'Hola Prime',
-    displayName: 'Hola Prime',
-    platform: 'ProjectX',
-    userApi: 'userapi.holaprime.projectx.com',
-    gatewayApi: 'api.holaprime.projectx.com'
-  },
-  top_one_futures: {
-    id: 'toponefutures',
-    name: 'Top One Futures',
-    displayName: 'Top One Futures',
-    platform: 'ProjectX',
-    userApi: 'userapi.toponefutures.projectx.com',
-    gatewayApi: 'api.toponefutures.projectx.com'
-  },
-  funding_futures: {
-    id: 'fundingfutures',
-    name: 'Funding Futures',
-    displayName: 'Funding Futures',
-    platform: 'ProjectX',
-    userApi: 'userapi.fundingfutures.projectx.com',
-    gatewayApi: 'api.fundingfutures.projectx.com'
-  },
-  tx3_funding: {
-    id: 'tx3funding',
-    name: 'TX3 Funding',
-    displayName: 'TX3 Funding',
-    platform: 'ProjectX',
-    userApi: 'userapi.tx3funding.projectx.com',
-    gatewayApi: 'api.tx3funding.projectx.com'
-  },
-  lucid_trading: {
-    id: 'lucidtrading',
-    name: 'Lucid Trading',
-    displayName: 'Lucid Trading',
-    platform: 'ProjectX',
-    userApi: 'userapi.lucidtrading.projectx.com',
-    gatewayApi: 'api.lucidtrading.projectx.com'
-  },
-  tradeify: {
-    id: 'tradeify',
-    name: 'Tradeify',
-    displayName: 'Tradeify',
-    platform: 'ProjectX',
-    userApi: 'userapi.tradeify.projectx.com',
-    gatewayApi: 'api.tradeify.projectx.com'
-  },
-
-  // ==================== Tradovate Platform ====================
-  apex_tradovate: {
-    id: 'apex',
-    name: 'Apex',
-    displayName: 'Apex (Tradovate)',
-    platform: 'Tradovate',
-    userApi: 'userapi.apex.tradovate.com',
-    gatewayApi: 'api.apex.tradovate.com'
-  },
-  takeprofittrader: {
-    id: 'takeprofittrader',
-    name: 'TakeProfitTrader',
-    displayName: 'TakeProfitTrader',
-    platform: 'Tradovate',
-    userApi: 'userapi.takeprofittrader.tradovate.com',
-    gatewayApi: 'api.takeprofittrader.tradovate.com'
-  },
-  myfundedfutures: {
-    id: 'myfundedfutures',
-    name: 'MyFundedFutures',
-    displayName: 'MyFundedFutures',
-    platform: 'Tradovate',
-    userApi: 'live.tradovateapi.com',
-    gatewayApi: 'live.tradovateapi.com'
-  },
-
-  // ==================== Rithmic Platform ====================
   apex_rithmic: {
     id: 'rithmic-apex',
     name: 'Apex',
@@ -196,7 +14,6 @@ const PROPFIRMS = {
     platform: 'Rithmic',
     rithmicSystem: 'Apex',
     wsEndpoint: 'wss://ritpa11120.11.rithmic.com:443',
-
   },
   topsteptrader: {
     id: 'topsteptrader',
@@ -265,7 +82,7 @@ const PROPFIRMS = {
   daytraders_rithmic: {
     id: 'rithmic-daytraders',
     name: 'DayTraders.com',
-    displayName: 'DayTraders.com (Rithmic)',
+    displayName: 'DayTraders.com',
     platform: 'Rithmic',
     rithmicSystem: 'DayTraders.com',
     wsEndpoint: 'wss://ritpa11120.11.rithmic.com:443'
@@ -281,7 +98,7 @@ const PROPFIRMS = {
   lucidtrading_rithmic: {
     id: 'rithmic-lucidtrading',
     name: 'LucidTrading',
-    displayName: 'LucidTrading (Rithmic)',
+    displayName: 'LucidTrading',
     platform: 'Rithmic',
     rithmicSystem: 'LucidTrading',
     wsEndpoint: 'wss://ritpa11120.11.rithmic.com:443'
@@ -321,50 +138,29 @@ const PROPFIRMS = {
 };
 
 /**
- * PropFirm choices for menus (grouped by platform)
+ * PropFirm choices for menus
  */
-const PROPFIRM_CHOICES = {
-  projectx: Object.entries(PROPFIRMS)
-    .filter(([_, v]) => v.platform === 'ProjectX')
-    .map(([key, val]) => ({ name: val.displayName, value: key })),
-  
-  tradovate: Object.entries(PROPFIRMS)
-    .filter(([_, v]) => v.platform === 'Tradovate')
-    .map(([key, val]) => ({ name: val.displayName, value: key })),
-  
-  rithmic: Object.entries(PROPFIRMS)
-    .filter(([_, v]) => v.platform === 'Rithmic')
-    .map(([key, val]) => ({ name: val.displayName, value: key })),
-  
-  all: Object.entries(PROPFIRMS)
-    .map(([key, val]) => ({ name: `${val.displayName} (${val.platform})`, value: key }))
-};
+const PROPFIRM_CHOICES = Object.entries(PROPFIRMS)
+  .map(([key, val]) => ({ name: val.displayName, value: key }))
+  .sort((a, b) => a.name.localeCompare(b.name));
 
 /**
  * Gets a PropFirm by key
- * @param {string} key - PropFirm key
- * @returns {Object|undefined} PropFirm config
  */
 const getPropFirm = (key) => PROPFIRMS[key];
 
 /**
- * Gets PropFirm by ID (synced with dashboard)
- * @param {string} id - PropFirm ID
- * @returns {Object|undefined} PropFirm config
+ * Gets PropFirm by ID
  */
 const getPropFirmById = (id) => {
   return Object.values(PROPFIRMS).find(pf => pf.id === id);
 };
 
 /**
- * Gets all PropFirms for a platform
- * @param {string} platform - Platform name (ProjectX, Tradovate, Rithmic)
- * @returns {Array} PropFirm configs
+ * Gets all PropFirms
  */
-const getPropFirmsByPlatform = (platform) => {
-  return Object.entries(PROPFIRMS)
-    .filter(([_, v]) => v.platform === platform)
-    .map(([key, val]) => ({ key, ...val }));
+const getAllPropFirms = () => {
+  return Object.entries(PROPFIRMS).map(([key, val]) => ({ key, ...val }));
 };
 
 module.exports = { 
@@ -372,5 +168,5 @@ module.exports = {
   PROPFIRM_CHOICES,
   getPropFirm,
   getPropFirmById,
-  getPropFirmsByPlatform
+  getAllPropFirms
 };

package/src/config/settings.js

@@ -136,48 +136,6 @@ const CACHE = {
   STATS_TTL: 60000, // 1 minute
 };
 
-// ==================== FAST SCALPING (Ultra-Low Latency) ====================
-const FAST_SCALPING = {
-  // Hold constraints (prop firm rules - NON-NEGOTIABLE)
-  MIN_HOLD_MS: 10000,           // 10 seconds minimum hold
-  MAX_HOLD_MS: 60000,           // 60 seconds failsafe (force exit if stuck)
-  
-  // Exit targets (in ticks) - defaults, override per symbol
-  TARGET_TICKS: 16,             // Take profit target (+$80 on NQ)
-  STOP_TICKS: 20,               // Stop loss (-$100 on NQ)
-  
-  // Breakeven (BE) - move SL to entry price after profit threshold
-  BREAKEVEN_ACTIVATION_TICKS: 6, // Activate BE after +6 ticks profit (+$30 on NQ)
-  BREAKEVEN_OFFSET_TICKS: 1,     // BE at entry + 1 tick (small profit lock)
-  
-  // Trailing stop (activates after MIN_HOLD + profit threshold)
-  TRAILING_ACTIVATION_TICKS: 8, // Start trailing after +8 ticks profit (+$40 on NQ)
-  TRAILING_DISTANCE_TICKS: 4,   // Trail 4 ticks behind high/low
-  
-  // Position monitoring
-  MONITOR_INTERVAL_MS: 100,     // Check position every 100ms after hold
-  
-  // Momentum thresholds (cumulative delta over 5 seconds)
-  MOMENTUM_STRONG_THRESHOLD: 50,  // Delta > 50 = strong momentum, HOLD
-  MOMENTUM_WEAK_THRESHOLD: 20,    // Delta < 20 = weak momentum, consider EXIT
-  MOMENTUM_WINDOW_MS: 5000,       // 5 second window for momentum calc
-  
-  // Latency monitoring
-  LOG_LATENCY: true,
-  LATENCY_TARGET_MS: 50,        // Target entry latency
-  LATENCY_WARN_MS: 100,         // Warn if entry takes > 100ms
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // RECOVERY MODE - Math-based adaptive strategy when in drawdown
-  // Uses Kelly Criterion, Volatility scaling, and Win Rate adjustment
-  // ═══════════════════════════════════════════════════════════════════════════
-  RECOVERY: {
-    ENABLED: true,
-    ACTIVATION_PNL: -300,         // Activate recovery at -$300 session P&L
-    DEACTIVATION_PNL: -100,       // Deactivate when recovered to -$100
-  },
-};
-
 // ==================== DEBUG ====================
 const DEBUG = {
   get enabled() {
@@ -194,5 +152,4 @@ module.exports = {
   HQX_SERVER,
   CACHE,
   DEBUG,
-  FAST_SCALPING,
 };

package/src/lib/api.js

@@ -0,0 +1,198 @@
+/**
+ * Trading API - REAL ORDER EXECUTION
+ * Connects to ProjectX/TopstepX API for real trades
+ */
+
+const https = require('https');
+
+const PROPFIRM_APIS = {
+  topstep: 'api.topstepx.com',
+  alpha_futures: 'api.alphafutures.projectx.com',
+  tickticktrader: 'api.tickticktrader.projectx.com',
+  bulenox: 'api.bulenox.projectx.com',
+  tradeday: 'api.tradeday.projectx.com'
+};
+
+class TradingAPI {
+  constructor(token, propfirm = 'topstep') {
+    this.token = token;
+    this.apiHost = PROPFIRM_APIS[propfirm] || PROPFIRM_APIS.topstep;
+  }
+
+  async _request(path, method = 'POST', data = null) {
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: this.apiHost,
+        port: 443,
+        path: path,
+        method: method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+          'Authorization': `Bearer ${this.token}`
+        },
+        timeout: 10000
+      };
+
+      const req = https.request(options, (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            resolve({ status: res.statusCode, data: JSON.parse(body) });
+          } catch (e) {
+            resolve({ status: res.statusCode, data: body });
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+
+      if (data) req.write(JSON.stringify(data));
+      req.end();
+    });
+  }
+
+  /**
+   * Place a market order - REAL EXECUTION
+   * ProjectX API order types:
+   *   1 = Limit (requires limitPrice)
+   *   2 = Market (no price required)
+   *   3 = Stop Market (requires stopPrice)
+   *   4 = Stop Limit (requires both)
+   */
+  async placeMarketOrder(accountId, contractId, side, quantity, currentPrice = 0) {
+    // Type 2 = Market order - tested and confirmed working
+    const orderData = {
+      accountId: parseInt(accountId),
+      contractId: contractId,
+      type: 2, // Market order
+      side: side === 'buy' ? 0 : 1, // 0=Buy, 1=Sell
+      size: quantity
+    };
+
+    console.log(`[TRADING] MARKET ${side.toUpperCase()} ${quantity}x ${contractId}`);
+    
+    const response = await this._request('/api/Order/place', 'POST', orderData);
+    
+    if (response.status === 200 && response.data.success) {
+      console.log(`[TRADING] FILLED - OrderId: ${response.data.orderId}`);
+      return { success: true, order: response.data };
+    } else {
+      console.log(`[TRADING] REJECTED: ${response.data.errorMessage || 'Unknown error'}`);
+      return { success: false, error: response.data.errorMessage || 'Order failed' };
+    }
+  }
+
+  /**
+   * Place a limit order - REAL EXECUTION
+   */
+  async placeLimitOrder(accountId, contractId, side, quantity, price) {
+    const orderData = {
+      accountId: parseInt(accountId),
+      contractId: contractId,
+      type: 0, // Limit order
+      side: side === 'buy' ? 0 : 1,
+      size: quantity,
+      limitPrice: price
+    };
+
+    console.log(`[TRADING] Placing LIMIT order: ${side.toUpperCase()} ${quantity}x ${contractId} @ ${price}`);
+    
+    const response = await this._request('/api/Order/place', 'POST', orderData);
+    
+    if (response.status === 200 && response.data.success) {
+      console.log(`[TRADING] Limit order placed: ${JSON.stringify(response.data)}`);
+      return { success: true, order: response.data };
+    } else {
+      return { success: false, error: response.data.errorMessage || 'Order failed' };
+    }
+  }
+
+  /**
+   * Place a stop order - REAL EXECUTION
+   * ProjectX API: type 2 = Stop Market
+   */
+  async placeStopOrder(accountId, contractId, side, quantity, stopPrice) {
+    const orderData = {
+      accountId: parseInt(accountId),
+      contractId: contractId,
+      type: 2, // Stop Market order
+      side: side === 'buy' ? 0 : 1,
+      size: quantity,
+      stopPrice: stopPrice
+    };
+
+    console.log(`[TRADING] Placing STOP order: ${side.toUpperCase()} ${quantity}x ${contractId} @ stop ${stopPrice}`);
+    
+    const response = await this._request('/api/Order/place', 'POST', orderData);
+    
+    console.log(`[TRADING] Stop response: ${JSON.stringify(response.data)}`);
+    
+    if (response.status === 200 && response.data.success) {
+      console.log(`[TRADING] Stop order placed - OrderId: ${response.data.orderId}`);
+      return { success: true, order: response.data };
+    } else {
+      console.log(`[TRADING] Stop order REJECTED: ${response.data.errorMessage || 'Unknown error'}`);
+      return { success: false, error: response.data.errorMessage || 'Order failed' };
+    }
+  }
+
+  /**
+   * Cancel an order
+   */
+  async cancelOrder(orderId) {
+    const response = await this._request('/api/Order/cancel', 'POST', { orderId: parseInt(orderId) });
+    return { success: response.status === 200 && response.data.success };
+  }
+
+  /**
+   * Close a position - REAL EXECUTION
+   */
+  async closePosition(accountId, contractId) {
+    console.log(`[TRADING] Closing position: ${contractId}`);
+    
+    const response = await this._request('/api/Position/closeContract', 'POST', {
+      accountId: parseInt(accountId),
+      contractId: contractId
+    });
+
+    if (response.status === 200 && response.data.success) {
+      console.log(`[TRADING] Position CLOSED`);
+      return { success: true };
+    } else {
+      console.log(`[TRADING] Close FAILED: ${JSON.stringify(response.data)}`);
+      return { success: false, error: response.data.errorMessage || 'Close failed' };
+    }
+  }
+
+  /**
+   * Get open positions
+   */
+  async getPositions(accountId) {
+    const response = await this._request('/api/Position/searchOpen', 'POST', { accountId: parseInt(accountId) });
+    
+    if (response.status === 200) {
+      return { success: true, positions: response.data.positions || response.data || [] };
+    }
+    return { success: false, positions: [] };
+  }
+
+  /**
+   * Get open orders
+   */
+  async getOrders(accountId) {
+    const response = await this._request('/api/Order/searchOpen', 'POST', { accountId: parseInt(accountId) });
+    
+    if (response.status === 200) {
+      return { success: true, orders: response.data.orders || response.data || [] };
+    }
+    return { success: false, orders: [] };
+  }
+}
+
+module.exports = { TradingAPI };