| //+------------------------------------------------------------------+
|
| //| TradeExecutor.mqh |
|
| //| Copyright 2025, EscapeEA |
|
| //| https://www.escapeea.com |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2025, EscapeEA"
|
| #property link "https://www.escapeea.com"
|
| #property version "2.00" // Major version bump for security enhancements
|
| #property strict
|
|
|
| /**
|
| * @file TradeExecutor.mqh
|
| * @brief Advanced trade execution module with security and risk management features
|
| *
|
| * This module provides a robust trade execution system with the following features:
|
| * - Secure order execution with validation and retry logic
|
| * - Circuit breaker pattern to prevent excessive losses
|
| * - Rate limiting to prevent order flooding
|
| * - Comprehensive trade logging and performance tracking
|
| * - Integration with RiskManager for position sizing and risk control
|
| * - Paper trading simulation capabilities
|
| *
|
| * Security Features:
|
| * - Input validation for all trade parameters
|
| * - Market condition verification
|
| * - Anomaly detection for suspicious trading patterns
|
| * - Secure order filling policies
|
| * - Comprehensive error handling and logging
|
| *
|
| * @see CRiskManager.h For risk management integration
|
| * @see SecurityEnhancements.h For additional security features
|
| */
|
|
|
| #include <Trade\Trade.mqh>
|
| #include <Trade\PositionInfo.mqh>
|
| #include <Trade\OrderInfo.mqh>
|
| #include <Arrays\ArrayObj.mqh>
|
| #include "RiskManager.mqh"
|
| #include "SecurityEnhancements.mqh"
|
| #include "SecurityManager.mqh"
|
|
|
| // Execution limits and constraints
|
| #define MAX_ORDER_AGE_SEC 60 // Maximum age of an order in seconds before considering it stale
|
| #define PRICE_VALIDATION_RANGE 0.0005 // Price validation range (0.05%) for market order validation
|
|
|
| // Custom error codes for trade execution (using high numbers to avoid conflicts with MQL5 built-in codes)
|
| #define ESCAPE_ERR_TRADE_DISABLED 10027 // Trade is disabled
|
| #define ESCAPE_ERR_TRADE_POSITION_NOT_FOUND 4753 // Position not found
|
| #define ESCAPE_ERR_TRADE_ORDER_NOT_FOUND 4752 // Order not found
|
| #define ESCAPE_ERR_TRADE_WRONG_SYMBOL 4751 // Wrong symbol
|
| #define ESCAPE_ERR_TRADE_INVALID_VOLUME 131 // Invalid volume
|
| #define ESCAPE_ERR_TRADE_INVALID_PRICE 4106 // Invalid price
|
| #define ESCAPE_ERR_TRADE_SPREAD_TOO_WIDE 135 // Market is too far away
|
| #define ESCAPE_ERR_TRADE_TOO_MANY_ORDERS 148 // Too many orders
|
| #define ESCAPE_ERR_TRADE_LIMIT_REACHED 162 // Trading is prohibited
|
| #define ESCAPE_ERR_INVALID_STOPS 130 // Invalid stops
|
|
|
| // Forward declaration of CRiskManager to resolve circular dependency
|
| class CRiskManager;
|
|
|
| // Order execution constants - using standard ENUM_ORDER_TYPE_FILLING values
|
| #define FILL_DEFAULT ORDER_FILLING_FOK // Default fill policy (Fill or Kill)
|
| #define FILL_IOC ORDER_FILLING_IOC // Immediate or Cancel
|
| #define FILL_RETURN ORDER_FILLING_RETURN // Return partial fills
|
|
|
| // Trade execution result codes - using standard TRADE_RETCODE values with custom extensions
|
| #define TRADE_EXECUTION_SUCCESS TRADE_RETCODE_DONE
|
| #define TRADE_EXECUTION_FAILED TRADE_RETCODE_ERROR
|
| #define TRADE_EXECUTION_REJECTED TRADE_RETCODE_REJECT
|
| #define TRADE_EXECUTION_TIMEOUT TRADE_RETCODE_TIMEOUT
|
| #define TRADE_EXECUTION_VALIDATION_ERROR TRADE_RETCODE_INVALID
|
| #define TRADE_EXECUTION_CIRCUIT_BROKEN TRADE_RETCODE_OFF_QUOTES
|
| #define TRADE_EXECUTION_RATE_LIMITED TRADE_RETCODE_TOO_MANY_REQUESTS
|
|
|
| //+------------------------------------------------------------------+
|
| //| Trade Execution Configuration |
|
| //+------------------------------------------------------------------+
|
| /**
|
| * Execution Settings
|
| * These parameters control the behavior of trade execution
|
| */
|
| // Removed: input group "=== Execution Settings ==="
|
| // Removed: input int InpMaxRetries = 3; // Declare only in main EA (.mq5)
|
| // Removed: input int InpRetryDelay = 100; // Declare only in main EA (.mq5)
|
| // Removed: input int InpMaxSlippage = 10; // Declare only in main EA (.mq5)
|
| // Removed: input ENUM_ORDER_FILL_POLICY InpFillPolicy = FILL_DEFAULT; // Declare only in main EA (.mq5)
|
|
|
| /**
|
| * Circuit Breaker Settings
|
| * Circuit breaker halts trading after consecutive errors to prevent excessive losses
|
| */
|
| // Removed: input group "=== Circuit Breaker Settings ==="
|
| // Removed: input bool InpUseCircuitBreaker = true; // Declare only in main EA (.mq5)
|
| // Removed: input int InpMaxErrors = 5; // Declare only in main EA (.mq5)
|
| // Removed: input int InpCircuitBreakTime = 300; // Declare only in main EA (.mq5)
|
|
|
| /**
|
| * Security and Logging Settings
|
| * These parameters control security features and logging verbosity
|
| */
|
| // Removed: input group "=== Security Settings ==="
|
| // Removed: input bool InpEnableAnomalyDetection = true; // Declare only in main EA (.mq5)
|
| // Removed: input bool InpVerifyOrderFills = true; // Declare only in main EA (.mq5)
|
| // Removed: input bool InpCheckMarketConditions = true; // Declare only in main EA (.mq5)
|
| // Removed: input bool InpLogAllTrades = true; // Declare only in main EA (.mq5)
|
| // Removed: input int InpMaxOrdersPerMinute = 10; // Declare only in main EA (.mq5)
|
| // Removed: input bool InpEnableTradeSignals = true; // Declare only in main EA (.mq5)
|
|
|
| //+------------------------------------------------------------------+
|
| //| Trade Execution Record |
|
| //+------------------------------------------------------------------+
|
| class CTradeRecord : public CObject
|
| {
|
| public:
|
| ulong ticket; // Trade ticket
|
| string symbol; // Symbol
|
| ENUM_ORDER_TYPE type; // Order type
|
| double volume; // Trade volume
|
| double price; // Execution price
|
| double sl; // Stop loss
|
| double tp; // Take profit
|
| datetime time; // Execution time
|
| double slippage; // Slippage in points
|
| bool isClosed; // Is position closed
|
| string comment; // Trade comment
|
|
|
| CTradeRecord() {}
|
| ~CTradeRecord() {}
|
|
|
| void Set(ulong t, string s, ENUM_ORDER_TYPE ty, double v, double p,
|
| double sll, double tpp, double slp, string cmt = "")
|
| {
|
| ticket = t;
|
| symbol = s;
|
| type = ty;
|
| volume = v;
|
| price = p;
|
| sl = sll;
|
| tp = tpp;
|
| slippage = slp;
|
| time = TimeCurrent();
|
| isClosed = false;
|
| comment = cmt;
|
| }
|
|
|
| void Close() { isClosed = true; }
|
|
|
| virtual int Compare(const CObject *node, const int mode=0) const
|
| {
|
| const CTradeRecord *other = node;
|
| if(this.ticket < other.ticket) return -1;
|
| if(this.ticket > other.ticket) return 1;
|
| return 0;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| CTradeExecutor Class with Enhanced Security |
|
| //+------------------------------------------------------------------+
|
| class CTradeExecutor : public CObject
|
| {
|
| private:
|
| // Trade statistics
|
| int m_totalTrades;
|
| int m_successfulTrades;
|
| int m_failedTrades;
|
| double m_totalSlippage;
|
| double m_avgExecutionTime;
|
|
|
| // State flags
|
| bool m_isInitialized;
|
| bool m_isTradingAllowed;
|
| string m_lastError;
|
|
|
| // Trade objects
|
| CTrade m_trade;
|
| CRiskManager *m_riskManager;
|
| CPositionInfo m_position;
|
| COrderInfo m_order;
|
|
|
| // Configuration
|
| int m_maxRetries;
|
| bool m_verifyOrderFills;
|
| bool m_logAllTrades;
|
|
|
| // Trade history and state tracking
|
| CArrayObj m_tradeHistory; // Trade execution history
|
| CArrayObj m_activeTrades; // Currently active trades
|
|
|
| // Circuit breaker state
|
| int m_consecutiveErrors; // Number of consecutive errors for circuit breaker
|
| datetime m_circuitBreakTime; // When the circuit breaker was activated
|
| bool m_circuitBroken; // Whether the circuit breaker is active
|
|
|
| // Rate limiting
|
| static int s_ordersThisMinute; // Orders in current minute
|
| static datetime s_currentMinute; // Current minute for rate limiting
|
|
|
| // Performance metrics
|
| int m_ordersThisMinute; // Number of orders in the current minute
|
|
|
| // Order tracking
|
| struct SOrderRequest
|
| {
|
| ulong ticket; // Order ticket
|
| string symbol; // Trading symbol
|
| ENUM_ORDER_TYPE type; // Order type
|
| double volume; // Order volume
|
| double price; // Order price
|
| double sl; // Stop loss
|
| double tp; // Take profit
|
| double deviation; // Maximum price deviation
|
| ulong magic; // Magic number
|
| string comment; // Order comment
|
| datetime expiration; // Order expiration time
|
| datetime timestamp; // Order creation timestamp
|
| int retryCount; // Number of retry attempts (0 = first attempt)
|
| bool isProcessed; // Whether the order has been processed
|
| MqlTradeRequest request; // Trade request
|
| MqlTradeResult result; // Trade result
|
| int errorCode; // Last error code
|
| string errorMessage; // Last error message
|
| };
|
|
|
| SOrderRequest m_pendingOrder; // Pending order request
|
| bool m_hasPendingOrder; // Has pending order flag
|
|
|
| // Security state
|
| bool m_isInitialized; // Initialization flag
|
|
|
| // Security manager
|
| CSecurityManager* m_securityManager; // Security manager instance
|
|
|
| // Private methods for security and validation
|
| bool ValidateOrder(const string symbol, ENUM_ORDER_TYPE type, double volume, double price, double sl, double tp, int magic, double slippage, string comment);
|
| bool CheckMarketConditions(const string symbol);
|
| bool CheckRateLimit();
|
| bool VerifyOrderFill(const MqlTradeRequest &request, const MqlTradeResult &result);
|
| void UpdateCircuitBreaker(const bool errorOccurred);
|
| void LogTradeExecution(const MqlTradeRequest &request, const MqlTradeResult &result, const ulong durationMs);
|
| void CleanupOldRecords();
|
| void AddToHistory(CTradeRecord *record);
|
| void UpdateTradeStatus(const ulong ticket, const bool isClosed);
|
|
|
| public:
|
| // Constructor/Destructor
|
| CTradeExecutor(void);
|
| ~CTradeExecutor(void);
|
|
|
| // Initialization
|
| bool Initialize(CRiskManager *riskManager, int maxRetries = 3,
|
| bool verifyOrderFills = true, bool logAllTrades = true);
|
| void Deinitialize(void);
|
|
|
| // Order execution
|
| bool OpenPosition(string symbol, ENUM_ORDER_TYPE type, double volume, double price, double sl, double tp, string comment = "", int magic = 0, datetime expiration = 0, double maxSlippage = 0.0);
|
| bool ClosePosition(ulong ticket, double volume = 0);
|
| bool ModifyPosition(ulong ticket, double sl, double tp);
|
|
|
| // Pending order management
|
| bool PlacePendingOrder(string symbol, ENUM_ORDER_TYPE type, double volume, double price, double sl, double tp, string comment = "", int magic = 0, datetime expiration = 0);
|
| bool ProcessPendingOrders(void);
|
|
|
| // Circuit breaker control
|
| bool IsCircuitBroken(void) const { return m_circuitBroken; }
|
| void ResetCircuitBreaker(void);
|
|
|
| // Performance metrics
|
| double GetSuccessRate(void) const;
|
| int GetTotalTrades(void) const { return m_totalTrades; }
|
| int GetSuccessfulTrades(void) const { return m_successfulTrades; }
|
| int GetFailedTrades(void) const { return m_failedTrades; }
|
|
|
| // Error handling
|
| string GetLastError(void) const { return m_lastError; }
|
|
|
| // Trading status
|
| bool IsTradingAllowed(void) const { return m_isTradingAllowed; }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize the trade executor |
|
| //+------------------------------------------------------------------+
|
| bool CTradeExecutor::Initialize(CRiskManager *riskManager, int maxRetries,
|
| bool verifyOrderFills, bool logAllTrades)
|
| {
|
| if(riskManager == NULL)
|
| {
|
| m_lastError = "Risk manager cannot be NULL";
|
| return false;
|
| }
|
|
|
| m_riskManager = riskManager;
|
| m_maxRetries = maxRetries;
|
| m_verifyOrderFills = verifyOrderFills;
|
| m_logAllTrades = logAllTrades;
|
| m_isInitialized = true;
|
| m_isTradingAllowed = true;
|
|
|
| // Initialize trade statistics
|
| m_totalTrades = 0;
|
| m_successfulTrades = 0;
|
| m_failedTrades = 0;
|
| m_totalSlippage = 0.0;
|
| m_avgExecutionTime = 0.0;
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Deinitialize trade executor and clean up resources |
|
| //+------------------------------------------------------------------+
|
|
|
| void CTradeExecutor::Deinitialize(void)
|
| {
|
| if(!m_isInitialized)
|
| return;
|
|
|
| // Save any necessary state before deinitializing
|
| // ...
|
|
|
| // Close any open positions if needed (configurable)
|
| // ...
|
|
|
| // Clean up trade history
|
| m_tradeHistory.Clear();
|
| m_activeTrades.Clear();
|
|
|
| // Reset state
|
| m_hasPendingOrder = false;
|
| ZeroMemory(m_pendingOrder);
|
|
|
| // Reset circuit breaker
|
| m_circuitBroken = false;
|
| m_consecutiveErrors = 0;
|
| m_circuitBreakTime = 0;
|
|
|
| // Reset rate limiting
|
| s_ordersThisMinute = 0;
|
| s_currentMinute = 0;
|
|
|
| // Reset metrics
|
| m_totalTrades = 0;
|
| m_successfulTrades = 0;
|
| m_failedTrades = 0;
|
| m_totalSlippage = 0.0;
|
| m_avgExecutionTime = 0.0;
|
|
|
| // Clear last error
|
| m_lastError = "";
|
|
|
| // Mark as uninitialized
|
| m_isInitialized = false;
|
| m_isTradingAllowed = false;
|
|
|
| Print("TradeExecutor: Deinitialized");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Open a new market position with comprehensive security checks |
|
| //+------------------------------------------------------------------+
|
|
|
| bool CTradeExecutor::OpenPosition(string symbol, ENUM_ORDER_TYPE type, double volume,
|
| double price, double sl, double tp, string comment,
|
| int magic, datetime expiration, double maxSlippage)
|
| {
|
| // Check if trading is allowed
|
| if(!m_isInitialized || !m_isTradingAllowed)
|
| {
|
| m_lastError = "Trading is not allowed. Check initialization.";
|
| Print("TradeExecutor Error: ", m_lastError);
|
| return false;
|
| }
|
|
|
| // Check circuit breaker
|
| if(m_circuitBroken)
|
| {
|
| if(TimeCurrent() >= m_circuitBreakTime + m_circuitBreakTime)
|
| {
|
| Print("Circuit breaker cooldown period ended. Resuming normal operations.");
|
| ResetCircuitBreaker();
|
| }
|
| else
|
| {
|
| int remaining = (int)(m_circuitBreakTime + m_circuitBreakTime - TimeCurrent());
|
| m_lastError = "Circuit breaker active. Trading suspended for " + IntegerToString(remaining) + " seconds";
|
| Print("TradeExecutor Error: ", m_lastError);
|
| return false;
|
| }
|
| }
|
|
|
| // Check rate limiting
|
| if(!CheckRateLimit())
|
| {
|
| m_lastError = "Rate limit exceeded";
|
| return false;
|
| }
|
|
|
| // Check market conditions if enabled
|
| if(m_checkMarketConditions && !CheckMarketConditions(symbol))
|
| {
|
| m_lastError = "Market conditions check failed for " + symbol;
|
| Print("TradeExecutor Error: ", m_lastError);
|
| return false;
|
| }
|
|
|
| // Prepare order request with additional security parameters
|
| SOrderRequest request = {};
|
| request.symbol = symbol;
|
| request.type = type;
|
| request.volume = volume;
|
| request.price = price;
|
| request.sl = sl;
|
| request.tp = tp;
|
| request.comment = comment;
|
| request.magic = (magic > 0) ? magic : m_trade.RequestMagic();
|
| request.expiration = expiration;
|
| request.attempts = 0;
|
| request.reqId = IntegerToString(GetTickCount()) + "_" + IntegerToString(OrdersTotal());
|
| request.maxSlippage = (maxSlippage > 0) ? maxSlippage : InpMaxSlippage;
|
| request.requireVerification = InpVerifyOrderFills;
|
|
|
| // Log the trade attempt
|
| if(InpLogAllTrades)
|
| {
|
| string orderType = (type == ORDER_TYPE_BUY) ? "BUY" : "SELL";
|
| PrintFormat("TradeExecutor: Attempting %s %s %.2f lots @ %s (SL: %s, TP: %s)",
|
| orderType, symbol, volume, DoubleToString(price, _Digits),
|
| DoubleToString(sl, _Digits), DoubleToString(tp, _Digits));
|
| }
|
|
|
| // Execute the order with retry logic
|
| bool result = false;
|
| MqlTradeRequest tradeRequest = {};
|
| MqlTradeResult tradeResult = {};
|
|
|
| // Prepare trade request
|
| tradeRequest.action = TRADE_ACTION_DEAL;
|
| tradeRequest.symbol = symbol;
|
| tradeRequest.volume = volume;
|
| tradeRequest.type = type;
|
| tradeRequest.price = price;
|
| tradeRequest.sl = sl;
|
| tradeRequest.tp = tp;
|
| tradeRequest.deviation = (ushort)request.maxSlippage;
|
| tradeRequest.magic = request.magic;
|
| tradeRequest.comment = comment;
|
| tradeRequest.type_filling = ORDER_FILLING_FOK;
|
|
|
| // Validate the request using the unified validator
|
| if(!ValidateOrder(symbol, type, volume, price, sl, tp, request.magic, request.maxSlippage, comment))
|
| {
|
| m_lastError = "Trade request validation failed: " + m_lastError;
|
| Print("TradeExecutor Error: ", m_lastError);
|
| UpdateCircuitBreaker(true);
|
| return false;
|
| }
|
|
|
| // Execute the trade with retry logic
|
| ulong startTime = GetTickCount();
|
| for(int attempt = 0; attempt <= m_maxRetries; attempt++)
|
| {
|
| // Check for user break
|
| if(IsStopped())
|
| {
|
| m_lastError = "Operation canceled by user";
|
| Print("TradeExecutor: ", m_lastError);
|
| return false;
|
| }
|
|
|
| // Add delay between retries (except first attempt)
|
| if(attempt > 0)
|
| {
|
| int delay = MathMin(m_retryDelay * (int)MathPow(2, attempt-1), 5000); // Exponential backoff, max 5s
|
| PrintFormat("TradeExecutor: Retry attempt %d of %d after %d ms",
|
| attempt, m_maxRetries, delay);
|
| Sleep(delay);
|
| }
|
|
|
| // Execute the trade
|
| ZeroMemory(tradeResult);
|
| bool success = OrderSend(tradeRequest, tradeResult);
|
|
|
| // Log the execution
|
| ulong duration = GetTickCount() - startTime;
|
| LogTradeExecution(tradeRequest, tradeResult, duration);
|
|
|
| // Check the result
|
| if(success && tradeResult.retcode == TRADE_RETCODE_DONE)
|
| {
|
| // Verify the order fill if required
|
| if(!request.requireVerification || VerifyOrderFill(tradeRequest, tradeResult))
|
| {
|
| // Create trade record
|
| CTradeRecord *record = new CTradeRecord();
|
| record.Set(tradeResult.order, symbol, type, volume, tradeResult.price,
|
| sl, tp, tradeResult.deviation, comment);
|
| AddToHistory(record);
|
|
|
| // Update metrics
|
| m_successfulTrades++;
|
| m_totalSlippage += tradeResult.deviation;
|
| m_avgExecutionTime = (m_avgExecutionTime * (m_successfulTrades - 1) + duration) / m_successfulTrades;
|
|
|
| if(InpLogAllTrades)
|
| {
|
| PrintFormat("TradeExecutor: Order #%d executed successfully in %d ms. Slippage: %.1f pips",
|
| tradeResult.order, duration, tradeResult.deviation);
|
| }
|
|
|
| result = true;
|
| break;
|
| }
|
| else
|
| {
|
| // Verification failed
|
| m_lastError = "Order fill verification failed";
|
| Print("TradeExecutor Error: ", m_lastError);
|
| UpdateCircuitBreaker(true);
|
| return false;
|
| }
|
| }
|
| else
|
| {
|
| // Log the error
|
| string errorDesc = GetRetcodeDescription(tradeResult.retcode);
|
| m_lastError = StringFormat("OrderSend failed: %s (code: %d)", errorDesc, tradeResult.retcode);
|
| Print("TradeExecutor Error: ", m_lastError);
|
|
|
| // Update error tracking
|
| m_failedTrades++;
|
| m_consecutiveErrors++;
|
|
|
| // Check if we should continue retrying
|
| if(attempt >= m_maxRetries - 1)
|
| {
|
| UpdateCircuitBreaker(true);
|
| return false;
|
| }
|
| }
|
| }
|
|
|
| // Update metrics
|
| m_totalTrades++;
|
|
|
| // Update last order time for rate limiting
|
| m_lastOrderTime = TimeCurrent();
|
|
|
| // Check if we need to trigger circuit breaker
|
| if(!result)
|
| else
|
| {
|
| //+------------------------------------------------------------------+
|
| //| Check if market conditions are suitable for trading |
|
| //+------------------------------------------------------------------+
|
| bool CTradeExecutor::CheckMarketConditions(const string symbol)
|
| {
|
| // Implementation here
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Static member initialization |
|
| //+------------------------------------------------------------------+
|
| int CTradeExecutor::s_ordersThisMinute = 0;
|
| datetime CTradeExecutor::s_currentMinute = 0;
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get the number of open positions for a given symbol and magic |
|
| //+------------------------------------------------------------------+
|
| int CTradeExecutor::GetOpenPositionsCount(const string symbol, int magic)
|
| {
|
| int count = 0;
|
|
|
| for(int i = PositionsTotal() - 1; i >= 0; i--)
|
| {
|
| if(m_position.SelectByIndex(i))
|
| {
|
| if((symbol == "" || m_position.Symbol() == symbol) &&
|
| (magic == 0 || m_position.Magic() == magic))
|
| {
|
| count++;
|
| }
|
| }
|
| }
|
|
|
| return count;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate position size based on risk percentage |
|
| //+------------------------------------------------------------------+
|
|
|
| double CTradeExecutor::CalculatePositionSize(const string symbol, double riskPercent, double stopLossPips)
|
| {
|
| if(riskPercent <= 0 || stopLossPips <= 0)
|
| return 0.0;
|
|
|
| double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
|
| double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
|
| double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
|
| double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
|
| double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
|
|
|
| if(tickSize == 0 || tickValue == 0 || lotStep == 0)
|
| {
|
| Print("Error: Invalid symbol parameters for position size calculation");
|
| return 0.0;
|
| }
|
|
|
| // Calculate position size based on risk percentage
|
| double riskAmount = AccountInfoDouble(ACCOUNT_BALANCE) * riskPercent / 100.0;
|
| double pipValue = tickValue / (tickSize / SymbolInfoDouble(symbol, SYMBOL_POINT));
|
| double stopLossValue = stopLossPips * pipValue;
|
|
|
| if(stopLossValue <= 0)
|
| {
|
| Print("Error: Invalid stop loss value for position size calculation");
|
| return 0.0;
|
| }
|
|
|
| double positionSize = NormalizeDouble(riskAmount / stopLossValue, 2);
|
|
|
| // Round to nearest lot step
|
| positionSize = MathFloor(positionSize / lotStep) * lotStep;
|
|
|
| // Ensure position size is within allowed range
|
| positionSize = MathMax(minLot, MathMin(maxLot, positionSize));
|
|
|
| return positionSize;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate take profit level based on risk/reward ratio |
|
| //+------------------------------------------------------------------+
|
| double CTradeExecutor::CalculateTakeProfitLevel(double entryPrice, double stopLoss, double riskRewardRatio, bool isBuy)
|
| {
|
| double priceDiff = MathAbs(entryPrice - stopLoss) * riskRewardRatio;
|
|
|
| if(isBuy)
|
| return entryPrice + priceDiff;
|
| else
|
| return entryPrice - priceDiff;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Send a trade signal to external systems |
|
| //+------------------------------------------------------------------+
|
|
|
| void CTradeExecutor::SendTradeSignal(const string symbol, ENUM_ORDER_TYPE type, double volume,
|
| double price, double sl, double tp, const string comment)
|
| {
|
| if(!InpEnableTradeSignals)
|
| return;
|
|
|
| string signal = StringFormat(
|
| "TRADE_SIGNAL|%s|%s|%s|%.2f|%.5f|%.5f|%.5f|%s",
|
| TimeToString(TimeCurrent(), TIME_DATE|TIME_SECONDS),
|
| symbol,
|
| (type == ORDER_TYPE_BUY) ? "BUY" : "SELL",
|
| volume,
|
| price,
|
| sl,
|
| tp,
|
| comment
|
| );
|
|
|
| // In a real implementation, this could send the signal to a webhook, MQ, etc.
|
| Print("Trade Signal: ", signal);
|
|
|
| // Example: Send to a global variable for EA communication
|
| GlobalVariableSet("LastTradeSignal_" + symbol, TimeCurrent());
|
| GlobalVariableSet("LastTradeSignal_Data_" + symbol, StringToDouble(signal));
|
| }
|
|
|
| #include "TradeExecutor_Impl.mqh"
|
| // Reset circuit breaker
|
| ResetCircuitBreaker();
|
|
|
| // Reset metrics
|
| m_totalTrades = 0;
|
| m_successfulTrades = 0;
|
| m_failedTrades = 0;
|
| m_totalSlippage = 0.0;
|
| m_avgExecutionTime = 0.0;
|
|
|
| // Initialize trade object with current settings
|
| m_trade.SetDeviationInPoints(InpMaxSlippage);
|
|
|
| // Load any persisted state if needed
|
| // ...
|
|
|
| // Clean up any old records
|
| CleanupOldRecords();
|
|
|
| m_isInitialized = true;
|
| m_isTradingAllowed = true;
|
|
|
| Print("TradeExecutor: Initialized successfully");
|
| return true;
|
| }
|
