| //+------------------------------------------------------------------+
|
| //| TradeExecutor_Impl.mqh |
|
| //| Implementation of CTradeExecutor methods |
|
| //+------------------------------------------------------------------+
|
| #property strict
|
|
|
| #include "TradeExecutor.mqh" // include header for class definition
|
|
|
| // NOTE: This file contains implementations of CTradeExecutor methods
|
| // Only method implementations should be in this file - no class definitions.
|
|
|
| //+------------------------------------------------------------------+
|
| //| Check if trading is allowed |
|
| //+------------------------------------------------------------------+
|
| bool CTradeExecutor::IsTradingAllowed()
|
| {
|
| if(!m_isInitialized)
|
| {
|
| m_lastError = "Trade executor not initialized";
|
| return false;
|
| }
|
| if(!m_isTradingAllowed)
|
| {
|
| m_lastError = "Trading is disabled by configuration";
|
| return false;
|
| }
|
| if(m_circuitBroken)
|
| {
|
| if(TimeCurrent() - m_circuitBreakTime < m_circuitBreakPeriod)
|
| {
|
| m_lastError = "Circuit breaker active";
|
| return false;
|
| }
|
| else
|
| {
|
| m_circuitBroken = false;
|
| m_consecutiveErrors = 0;
|
| }
|
| }
|
|
|
| // Rate limit check
|
| datetime currentTime = TimeCurrent();
|
| if(TimeMinute(currentTime) != TimeMinute(m_currentMinute))
|
| {
|
| m_currentMinute = currentTime - (currentTime % 60);
|
| m_ordersThisMinute = 0;
|
| }
|
|
|
| if(m_ordersThisMinute >= m_maxOrdersPerMinute)
|
| {
|
| m_lastError = "Rate limit exceeded";
|
| return false;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Constructor |
|
| //+------------------------------------------------------------------+
|
| CTradeExecutor::CTradeExecutor() :
|
| m_totalTrades(0),
|
| m_successfulTrades(0),
|
| m_failedTrades(0),
|
| m_totalSlippage(0.0),
|
| m_avgExecutionTime(0.0),
|
| m_isInitialized(false),
|
| m_isTradingAllowed(false),
|
| m_riskManager(NULL),
|
| m_retryDelay(1000), // 1 second default retry delay
|
| m_maxSlippage(10), // 10 points default slippage
|
| m_useCircuitBreaker(true),
|
| m_checkMarketConditions(true)
|
| {
|
| // Initialize trade object with default settings
|
| m_trade.SetDeviationInPoints(m_maxSlippage);
|
| m_trade.SetExpertMagicNumber(0);
|
| m_trade.SetMarginMode();
|
| m_trade.SetTypeFilling(ORDER_FILLING_FOK);
|
|
|
| // Initialize arrays
|
| m_tradeHistory = new CArrayObj();
|
| m_pendingOrders = new CArrayObj();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Destructor |
|
| //+------------------------------------------------------------------+
|
| CTradeExecutor::~CTradeExecutor()
|
| {
|
| // Clean up trade history
|
| if(CheckPointer(m_tradeHistory) == POINTER_DYNAMIC)
|
| delete m_tradeHistory;
|
|
|
| // Clean up pending orders
|
| if(CheckPointer(m_pendingOrders) == POINTER_DYNAMIC)
|
| delete m_pendingOrders;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Reset circuit breaker |
|
| //+------------------------------------------------------------------+
|
| void CTradeExecutor::ResetCircuitBreaker()
|
| {
|
| m_circuitBreakTime = 0;
|
| m_consecutiveErrors = 0;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Clean up old trade records |
|
| //+------------------------------------------------------------------+
|
| void CTradeExecutor::CleanupOldRecords()
|
| {
|
| datetime cutoff = TimeCurrent() - 7 * 24 * 60 * 60; // 1 week
|
|
|
| for(int i = m_tradeHistory.Total() - 1; i >= 0; i--)
|
| {
|
| CTradeRecord* record = m_tradeHistory.At(i);
|
| if(record != NULL && record.time < cutoff)
|
| {
|
| m_tradeHistory.Delete(i);
|
| }
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update circuit breaker state |
|
| //+------------------------------------------------------------------+
|
| void CTradeExecutor::UpdateCircuitBreaker(bool errorOccurred)
|
| {
|
| if(errorOccurred)
|
| {
|
| m_consecutiveErrors++;
|
|
|
| // If we've hit the maximum consecutive errors, activate circuit breaker
|
| if(m_consecutiveErrors >= m_maxConsecutiveErrors)
|
| {
|
| m_circuitBreakTime = TimeCurrent() + 300; // 5 minutes cooldown
|
| m_isTradingAllowed = false;
|
| Print("Circuit breaker activated! Trading paused for 5 minutes.");
|
| }
|
| }
|
| else
|
| {
|
| // Reset error counter on successful operation
|
| m_consecutiveErrors = 0;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize |
|
| //+------------------------------------------------------------------+
|
| bool CTradeExecutor::Initialize(CRiskManager *riskManager)
|
| {
|
| if(m_isInitialized)
|
| return true;
|
| m_trade.SetExpertMagicNumber(0);
|
| m_trade.SetDeviationInPoints(m_maxSlippage);
|
| m_trade.SetAsyncMode(true);
|
| m_riskManager = riskManager;
|
| if(!m_security.Initialize())
|
| {
|
| m_lastError = "Failed to initialize security enhancements: "+m_security.GetLastError();
|
| return false;
|
| }
|
| ResetCircuitBreaker();
|
| m_totalTrades = m_successfulTrades = m_failedTrades = 0;
|
| m_totalSlippage = m_avgExecutionTime = 0.0;
|
| m_trade.SetDeviationInPoints(InpMaxSlippage);
|
| CleanupOldRecords();
|
| m_isInitialized = true;
|
| m_isTradingAllowed = true;
|
| Print("TradeExecutor: Initialized successfully");
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Deinitialize |
|
| //+------------------------------------------------------------------+
|
| void CTradeExecutor::Deinitialize(void)
|
| {
|
| if(!m_isInitialized)
|
| return;
|
| m_tradeHistory.Clear();
|
| m_activeTrades.Clear();
|
| m_hasPendingOrder = false;
|
| ZeroMemory(m_pendingOrder);
|
| m_circuitBroken = false;
|
| m_consecutiveErrors = 0;
|
| m_circuitBreakTime = 0;
|
| s_ordersThisMinute = 0;
|
| s_currentMinute = 0;
|
| m_totalTrades = m_successfulTrades = m_failedTrades = 0;
|
| m_totalSlippage = m_avgExecutionTime = 0.0;
|
| m_lastError = "";
|
| 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 <= InpMaxRetries; 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(InpRetryDelay * (int)MathPow(2, attempt-1), 5000); // Exponential backoff, max 5s
|
| PrintFormat("TradeExecutor: Retry attempt %d of %d after %d ms",
|
| attempt, InpMaxRetries, 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 >= InpMaxRetries - 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)
|
| {
|
| UpdateCircuitBreaker(true);
|
| }
|
|
|
| return result;
|
| }
|
|
|
| // Static member definitions --------------------------------------------------
|
| int CTradeExecutor::s_ordersThisMinute = 0;
|
| datetime CTradeExecutor::s_currentMinute = 0;
|
|
|
| //---------------------------------------------------------------------------
|
| // END MOVED IMPLEMENTATIONS
|
| //---------------------------------------------------------------------------
|
