forex-scalping.com

Code: Select all

//+------------------------------------------------------------------+
//| Class: CExecutionDragFilter                                      |
//| Purpose: Intercepts and rejects execution during liquidity voids |
//|          by calculating live spread + commission in native ticks.|
//+------------------------------------------------------------------+
class CExecutionDragFilter
  {
private:
   string            m_symbol;
   double            m_commission_rt;      // Round-turn commission in account currency
   double            m_max_drag_ticks;     // Maximum allowable total drag in ticks
   double            m_tick_size;

public:
                     CExecutionDragFilter(void);
                    ~CExecutionDragFilter(void);
   
   // Initialize the filter parameters
   bool              Init(const string symbol, const double commission, const double max_drag_ticks);
   
   // Calculate current live execution drag
   double            GetLiveDrag(void);
   
   // Main validation check to wrap around your EA's entry logic
   bool              IsExecutionSafe(void);
  };

//+------------------------------------------------------------------+
//| Constructor & Destructor                                         |
//+------------------------------------------------------------------+
CExecutionDragFilter::CExecutionDragFilter(void) : m_symbol(""), m_commission_rt(0.0), m_max_drag_ticks(0.0), m_tick_size(0.0) {}
CExecutionDragFilter::~CExecutionDragFilter(void) {}

//+------------------------------------------------------------------+
//| Initialization                                                   |
//+------------------------------------------------------------------+
bool CExecutionDragFilter::Init(const string symbol, const double commission, const double max_drag_ticks)
  {
   m_symbol = (symbol == "") ? _Symbol : symbol;
   m_commission_rt = commission;
   m_max_drag_ticks = max_drag_ticks;
   
   m_tick_size = SymbolInfoDouble(m_symbol, SYMBOL_TRADE_TICK_SIZE);
   
   if(m_tick_size == 0)
     {
      Print("Error: Failed to retrieve tick size for ", m_symbol);
      return false;
     }
     
   return true;
  }

//+------------------------------------------------------------------+
//| Core Calculation: Live Spread + Dynamic Commission Tick Value    |
//+------------------------------------------------------------------+
double CExecutionDragFilter::GetLiveDrag(void)
  {
   double ask = SymbolInfoDouble(m_symbol, SYMBOL_ASK);
   double bid = SymbolInfoDouble(m_symbol, SYMBOL_BID);
   
   // We pull tick value dynamically here rather than caching it in Init() 
   // because cross-pair tick values fluctuate with live exchange rates.
   double current_tick_value = SymbolInfoDouble(m_symbol, SYMBOL_TRADE_TICK_VALUE);
   
   // Failsafe for missing quotes or zero-divide errors
   if(ask == 0 || bid == 0 || current_tick_value == 0) return 99999.9; 
   
   double spread_ticks = (ask - bid) / m_tick_size;
   double comm_ticks = m_commission_rt / current_tick_value;
   
   return spread_ticks + comm_ticks;
  }

//+------------------------------------------------------------------+
//| Execution Validator & Rejection Logger                           |
//+------------------------------------------------------------------+
bool CExecutionDragFilter::IsExecutionSafe(void)
  {
   double live_drag = GetLiveDrag();
   
   if(live_drag > m_max_drag_ticks)
     {
      double ask = SymbolInfoDouble(m_symbol, SYMBOL_ASK);
      double bid = SymbolInfoDouble(m_symbol, SYMBOL_BID);
      double spread_ticks = (ask - bid) / m_tick_size;
      double current_tick_value = SymbolInfoDouble(m_symbol, SYMBOL_TRADE_TICK_VALUE);
      double comm_ticks = m_commission_rt / current_tick_value;

      // Log the exact microstructural breakdown for post-session auditing
      PrintFormat("[REJECT] Order Blocked on %s. Drag: %.1f ticks > Max Allowable: %.1f | Spread: %.1f, Comm_Eq: %.1f", 
                  m_symbol, live_drag, m_max_drag_ticks, spread_ticks, comm_ticks);
                  
      return false;
     }
     
   return true;
  }

Code: Select all

#include "ExecutionDragFilter.mqh"

// Instantiate the filter
CExecutionDragFilter DragFilter;

int OnInit()
  {
   // Initialize: Current Symbol, $6.00 Round-Turn Commission, Max 15.0 Ticks Drag
   if(!DragFilter.Init(_Symbol, 6.0, 15.0))
     {
      Print("Failed to initialize Execution Drag Filter.");
      return INIT_FAILED;
     }
     
   return INIT_SUCCEEDED;
  }

void OnTick()
  {
   // 1. Your algorithmic signal generation logic goes here
   bool isBuySignal = CheckForBuySetup();
   
   if(isBuySignal)
     {
      // 2. Intercept the signal with the Drag Filter before sending to the broker
      if(!DragFilter.IsExecutionSafe()) 
        {
         // The class automatically logs the rejection details to the terminal.
         // Exit OnTick() until the next incoming tick.
         return; 
        }
        
      // 3. Execution is safe. Proceed to OrderSend...
      ExecuteBuyOrder();
     }
  }

Code: Select all

using cAlgo.API;
using System;

namespace cAlgo.Robots
{
    //+------------------------------------------------------------------+
    //| Class: ExecutionDragFilter                                       |
    //| Purpose: Intercepts and rejects execution during liquidity voids |
    //|          by calculating live spread + commission in native ticks.|
    //+------------------------------------------------------------------+
    public class ExecutionDragFilter
    {
        private readonly Algo _algo;
        private readonly Symbol _symbol;
        private readonly double _commissionRoundTurn;
        private readonly double _maxDragTicks;

        // Inject the Algo context (for logging) and Symbol data
        public ExecutionDragFilter(Algo algo, Symbol symbol, double commissionRoundTurn, double maxDragTicks)
        {
            _algo = algo;
            _symbol = symbol;
            _commissionRoundTurn = commissionRoundTurn;
            _maxDragTicks = maxDragTicks;
        }

        //+------------------------------------------------------------------+
        //| Core Calculation: Live Spread + Dynamic Commission Tick Value    |
        //+------------------------------------------------------------------+
        public double GetLiveDrag()
        {
            // Failsafe for missing market data or zero-divide
            if (_symbol.Ask == 0 || _symbol.Bid == 0 || _symbol.TickValue == 0 || _symbol.TickSize == 0)
                return double.MaxValue;

            // Calculate spread in ticks
            double spreadTicks = (_symbol.Ask - _symbol.Bid) / _symbol.TickSize;

            // Convert fiat commission to tick equivalent dynamically
            double commTicks = _commissionRoundTurn / _symbol.TickValue;

            return spreadTicks + commTicks;
        }

        //+------------------------------------------------------------------+
        //| Execution Validator & Rejection Logger                           |
        //+------------------------------------------------------------------+
        public bool IsExecutionSafe()
        {
            double liveDrag = GetLiveDrag();

            if (liveDrag > _maxDragTicks)
            {
                double spreadTicks = (_symbol.Ask - _symbol.Bid) / _symbol.TickSize;
                double commTicks = _commissionRoundTurn / _symbol.TickValue;

                // Log the exact microstructural breakdown to the cTrader log
                _algo.Print($"[REJECT] Order Blocked on {_symbol.Name}. Drag: {liveDrag:F1} ticks > Max Allowable: {_maxDragTicks:F1} | Spread: {spreadTicks:F1}, Comm_Eq: {commTicks:F1}");
                
                return false;
            }

            return true;
        }
    }
}

Code: Select all

using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class PriceActionScalper : Robot
    {
        [Parameter("Round-Turn Commission ($)", Group = "Execution Constraints", DefaultValue = 6.0)]
        public double Commission { get; set; }

        [Parameter("Max Allowable Drag (Ticks)", Group = "Execution Constraints", DefaultValue = 15.0)]
        public double MaxDrag { get; set; }

        private ExecutionDragFilter _dragFilter;

        protected override void OnStart()
        {
            // Initialize the filter, passing 'this' (the Algo instance) and the current Symbol
            _dragFilter = new ExecutionDragFilter(this, Symbol, Commission, MaxDrag);
        }

        protected override void OnTick()
        {
            // 1. Your algorithmic signal generation logic goes here
            bool isBuySignal = CheckForBuySetup();

            if (isBuySignal)
            {
                // 2. Intercept the signal with the Drag Filter
                if (!_dragFilter.IsExecutionSafe())
                {
                    // The class automatically logs the rejection parameters.
                    // Return out of OnTick to prevent execution on this tick.
                    return; 
                }

                // 3. Execution is safe. Proceed to MarketOrder...
                Print("Safe liquidity confirmed. Sending Market Order...");
                ExecuteMarketOrder(TradeType.Buy, SymbolName, 100000, "Scalp Entry");
            }
        }

        private bool CheckForBuySetup()
        {
            // Placeholder for 15m price action / liquidity sweep logic
            return false;
        }
    }
}