forex-scalping.com

Code: Select all

//@version=5
strategy("News Fade Spike Reversal", overlay=true, margin_long=100, margin_short=100, process_orders_on_close=true)

// =========================================================================
// ⚠️ WARNING: This strategy fades massive volatility spikes. 
// It is highly risky in live markets due to slippage, widened spreads, 
// and execution delays that TradingView backtesting CANNOT simulate accurately.
// =========================================================================

// --- Inputs ---
grp_logic = "Spike Detection"
atrLength = input.int(14, title="ATR Length", group=grp_logic)
spikeMultiplier = input.float(3.5, title="Spike Multiplier (x ATR)", tooltip="How much larger than average the candle body must be to trigger.", group=grp_logic)

grp_risk = "Risk & Trade Management"
sl_ticks = input.int(100, title="Stop Loss (Ticks/Points)", group=grp_risk)
tp_ticks = input.int(150, title="Take Profit (Ticks/Points)", group=grp_risk)
barsToHold = input.int(3, title="Max Bars to Hold", tooltip="Force exit after this many bars if TP/SL aren't hit (Retracement Window).", group=grp_risk)

// --- Spike Detection Logic ---
// Calculate average volatility
currentAtr = ta.atr(atrLength)

// Measure the current candle's body size
bodySize = math.abs(close - open)

// Define the "Overshoot" (A candle body significantly larger than the ATR)
isBullSpike = (close > open) and (bodySize > (currentAtr * spikeMultiplier))
isBearSpike = (close < open) and (bodySize > (currentAtr * spikeMultiplier))

// --- Entry Logic (Fading the Move) ---
// We only enter if we are not already in a trade
if strategy.position_size == 0
    if isBullSpike
        strategy.entry("Fade Short", strategy.short, comment="News Spike Up -> Short")
    if isBearSpike
        strategy.entry("Fade Long", strategy.long, comment="News Spike Down -> Long")

// --- Exit & Risk Management Logic ---
// 1. Hard Stops and Profit Targets
strategy.exit("Exit Short", "Fade Short", loss=sl_ticks, profit=tp_ticks)
strategy.exit("Exit Long", "Fade Long", loss=sl_ticks, profit=tp_ticks)

// 2. Time-Based Exit (The "First Few Minutes" rule)
// Count how many bars we have been in the current trade
var int barsInTrade = 0
if strategy.position_size != 0
    barsInTrade += 1
else
    barsInTrade := 0

// If the trade stalls and doesn't retrace quickly, cut it.
if barsInTrade >= barsToHold
    strategy.close("Fade Short", comment="Time Exit")
    strategy.close("Fade Long", comment="Time Exit")

// --- Chart Visuals ---
// Highlight the massive spikes on the chart for visual backtesting
bgcolor(isBullSpike ? color.new(color.green, 80) : na, title="Bull Spike Background")
bgcolor(isBearSpike ? color.new(color.red, 80) : na, title="Bear Spike Background")

Code: Select all

//+------------------------------------------------------------------+
//|                                            NewsFadeSpike_MT5.mq5 |
//|                                  Copyright 2026, Quant Dev Lab   |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026"
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

#include <Trade\Trade.mqh>
CTrade trade;

//--- Input Parameters
input group "=== Strategy Parameters ==="
input int      InpAtrPeriod        = 14;     // ATR Period
input double   InpSpikeMultiplier  = 3.5;    // Spike Multiplier (x ATR)
input int      InpMaxBarsToHold    = 3;      // Max Bars to Hold Position

input group "=== Risk Management ==="
input double   InpLotSize          = 0.10;   // Lot Size
input int      InpStopLossPoints   = 1000;   // Stop Loss (Points)
input int      InpTakeProfitPoints = 1500;   // Take Profit (Points)
input int      InpMaxSpreadPoints  = 500;    // Max Allowed Spread (Points)
input ulong    InpMagicNumber      = 102030; // EA Magic Number

//--- Global Variables
int      atrHandle;
datetime lastBarTime = 0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   trade.SetExpertMagicNumber(InpMagicNumber);
   
   // Initialize ATR handle
   atrHandle = iATR(_Symbol, _Period, InpAtrPeriod);
   if(atrHandle == INVALID_HANDLE)
   {
      Print("Failed to create ATR indicator handle.");
      return INIT_FAILED;
   }

   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   IndicatorRelease(atrHandle);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   // Check for time-based exit on every tick
   ManageTimeExits();

   // Only evaluate new setups once per bar close
   datetime currentBarTime = iTime(_Symbol, _Period, 0);
   if(currentBarTime == lastBarTime)
      return;

   lastBarTime = currentBarTime;

   // 1. Check if we already have an open position for this symbol/magic
   if(HasOpenPosition())
      return;

   // 2. Spread Check
   long currentSpread = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD);
   if(currentSpread > InpMaxSpreadPoints)
   {
      Print("Spread too wide (", currentSpread, " pts). Entry skipped.");
      return;
   }

   // 3. Retrieve ATR of the completed candle (Bar 1)
   double atrValues[];
   ArraySetAsSeries(atrValues, true);
   if(CopyBuffer(atrHandle, 0, 1, 1, atrValues) <= 0)
      return;
   double barAtr = atrValues[0];

   // 4. Retrieve Price Data for Bar 1
   MqlRates rates[];
   ArraySetAsSeries(rates, true);
   if(CopyRates(_Symbol, _Period, 1, 1, rates) <= 0)
      return;

   double barOpen  = rates[0].open;
   double barClose = rates[0].close;
   double bodySize = MathAbs(barClose - barOpen);
   double threshold = barAtr * InpSpikeMultiplier;

   // 5. Detect Spike and Fade
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   int digits   = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);

   // Bullish Spike -> Fade with a SELL
   if(barClose > barOpen && bodySize > threshold)
   {
      double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double sl  = (InpStopLossPoints > 0)   ? NormalizeDouble(bid + InpStopLossPoints * point, digits) : 0;
      double tp  = (InpTakeProfitPoints > 0) ? NormalizeDouble(bid - InpTakeProfitPoints * point, digits) : 0;
      
      trade.Sell(InpLotSize, _Symbol, bid, sl, tp, "News Spike Fade Short");
   }
   // Bearish Spike -> Fade with a BUY
   else if(barClose < barOpen && bodySize > threshold)
   {
      double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double sl  = (InpStopLossPoints > 0)   ? NormalizeDouble(ask - InpStopLossPoints * point, digits) : 0;
      double tp  = (InpTakeProfitPoints > 0) ? NormalizeDouble(ask + InpTakeProfitPoints * point, digits) : 0;
      
      trade.Buy(InpLotSize, _Symbol, ask, sl, tp, "News Spike Fade Long");
   }
}

//+------------------------------------------------------------------+
//| Check if position is open                                        |
//+------------------------------------------------------------------+
bool HasOpenPosition()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_MAGIC) == InpMagicNumber)
         return true;
   }
   return false;
}

//+------------------------------------------------------------------+
//| Manage Exits Based on Bar Duration                               |
//+------------------------------------------------------------------+
void ManageTimeExits()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_MAGIC) == InpMagicNumber)
      {
         ulong ticket = PositionGetTicket(i);
         datetime openTime = (datetime)PositionGetInteger(POSITION_TIME);
         
         int barsHeld = iBarShift(_Symbol, _Period, openTime);
         if(barsHeld >= InpMaxBarsToHold)
         {
            trade.PositionClose(ticket);
            Print("Position closed by time exit (Held for ", barsHeld, " bars).");
         }
      }
   }
}