hedgequantx 2.6.63 → 2.6.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.6.63",
+  "version": "2.6.64",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/pages/algo/one-account.js

@@ -961,6 +961,21 @@ const launchAlgo = async (service, account, contract, config) => {
   clearInterval(refreshInterval);
   clearInterval(pnlInterval);
   
+  // EMERGENCY STOP: Cancel all orders and flatten all positions
+  if (useFastPath && service && account.rithmicAccountId) {
+    try {
+      ui.addLog('warning', 'EMERGENCY STOP - Cancelling orders & flattening positions...');
+      const stopResult = await service.emergencyStop(account.rithmicAccountId);
+      if (stopResult.success) {
+        ui.addLog('success', 'All orders cancelled, positions flattened');
+      } else {
+        ui.addLog('error', 'Emergency stop partial - check positions manually');
+      }
+    } catch (e) {
+      ui.addLog('error', `Emergency stop failed: ${e.message}`);
+    }
+  }
+  
   // Stop Position Manager (fast path)
   if (positionManager) {
     positionManager.stop();

package/src/services/rithmic/index.js

@@ -17,7 +17,7 @@ const {
   getPositions,
   hashAccountId,
 } = require('./accounts');
-const { placeOrder, cancelOrder, getOrders, getOrderHistory, closePosition, fastEntry, fastExit } = require('./orders');
+const { placeOrder, cancelOrder, cancelAllOrders, getOrders, getOrderHistory, closePosition, flattenAll, emergencyStop, fastEntry, fastExit } = require('./orders');
 const { decodeFrontMonthContract } = require('./protobuf');
 const { TIMEOUTS, CACHE } = require('../../config/settings');
 const { logger } = require('../../utils/logger');
@@ -472,7 +472,10 @@ class RithmicService extends EventEmitter {
   async getOrderHistory(date) { return getOrderHistory(this, date); }
   async placeOrder(orderData) { return placeOrder(this, orderData); }
   async cancelOrder(orderId) { return cancelOrder(this, orderId); }
+  async cancelAllOrders(accountId) { return cancelAllOrders(this, accountId); }
   async closePosition(accountId, symbol) { return closePosition(this, accountId, symbol); }
+  async flattenAll(accountId) { return flattenAll(this, accountId); }
+  async emergencyStop(accountId) { return emergencyStop(this, accountId); }
 
   // ==================== FAST SCALPING (Ultra-Low Latency) ====================
 

package/src/services/rithmic/orders.js

@@ -16,6 +16,9 @@ const { REQ } = require('./constants');
 const { proto } = require('./protobuf');
 const { LatencyTracker } = require('./handlers');
 const { performance } = require('perf_hooks');
+const { logger } = require('../../utils/logger');
+
+const log = logger.scope('RithmicOrders');
 
 // Debug mode - use no-op function when disabled for zero overhead
 const DEBUG = process.env.HQX_DEBUG === '1';
@@ -447,12 +450,98 @@ const closePosition = async (service, accountId, symbol) => {
   });
 };
 
+/**
+ * Cancel all open orders for an account
+ * @param {RithmicService} service - The Rithmic service instance
+ * @param {string} accountId - Account ID
+ */
+const cancelAllOrders = async (service, accountId) => {
+  if (!service.orderConn || !service.loginInfo) {
+    return { success: false, error: 'Not connected' };
+  }
+
+  try {
+    // Use RequestCancelAllOrders template
+    service.orderConn.send('RequestCancelAllOrders', {
+      templateId: 346, // CANCEL_ALL_ORDERS
+      userMsg: ['HQX-STOP'],
+      fcmId: service.loginInfo.fcmId,
+      ibId: service.loginInfo.ibId,
+      accountId: accountId,
+    });
+
+    log.info('Cancel all orders sent', { accountId });
+    return { success: true };
+  } catch (error) {
+    log.error('Cancel all orders failed', { error: error.message });
+    return { success: false, error: error.message };
+  }
+};
+
+/**
+ * Flatten all positions for an account (close all positions)
+ * @param {RithmicService} service - The Rithmic service instance
+ * @param {string} accountId - Account ID
+ */
+const flattenAll = async (service, accountId) => {
+  const results = [];
+  const positions = Array.from(service.positions.values());
+  const accountPositions = positions.filter(p => p.accountId === accountId && p.quantity !== 0);
+
+  log.info('Flattening all positions', { accountId, count: accountPositions.length });
+
+  for (const position of accountPositions) {
+    try {
+      const result = await placeOrder(service, {
+        accountId,
+        symbol: position.symbol,
+        exchange: position.exchange,
+        size: Math.abs(position.quantity),
+        side: position.quantity > 0 ? 1 : 0, // Sell if long, Buy if short
+        type: 2, // Market
+      });
+      results.push({ symbol: position.symbol, ...result });
+    } catch (error) {
+      results.push({ symbol: position.symbol, success: false, error: error.message });
+    }
+  }
+
+  return { success: true, results };
+};
+
+/**
+ * Emergency stop - Cancel all orders and flatten all positions
+ * @param {RithmicService} service - The Rithmic service instance
+ * @param {string} accountId - Account ID
+ */
+const emergencyStop = async (service, accountId) => {
+  log.warn('EMERGENCY STOP initiated', { accountId });
+
+  // 1. Cancel all orders first
+  const cancelResult = await cancelAllOrders(service, accountId);
+
+  // 2. Wait a moment for cancellations to process
+  await new Promise(r => setTimeout(r, 500));
+
+  // 3. Flatten all positions
+  const flattenResult = await flattenAll(service, accountId);
+
+  return {
+    success: cancelResult.success && flattenResult.success,
+    cancelled: cancelResult,
+    flattened: flattenResult,
+  };
+};
+
 module.exports = {
   placeOrder,
   cancelOrder,
+  cancelAllOrders,
   getOrders,
   getOrderHistory,
   closePosition,
+  flattenAll,
+  emergencyStop,
   // Fast scalping - ultra-low latency
   fastEntry,
   fastExit,