forex-scalping.com

Code: Select all

//+------------------------------------------------------------------+
//|                                     EmergencyFlashClose.mq5      |
//|                        Emergency Position Closer for Flash Moves |
//+------------------------------------------------------------------+
#property copyright "Trading Community"
#property link      ""
#property version   "1.00"
#property strict

#include <Trade\Trade.mqh>

//--- Inputs
input group "--- Flash Move Trigger Settings ---"
input double   InpDropThresholdPips   = 60.0;     // Trigger move in Pips
input int      InpTimeWindowSeconds   = 5;        // Rolling time window in seconds
input bool     InpTriggerOnDrop       = true;     // Trigger on rapid drop (long protection)
input bool     InpTriggerOnSpike      = false;    // Trigger on rapid spike (short protection)

input group "--- Execution Scope ---"
input bool     InpCurrentSymbolOnly   = true;     // Close current symbol only (false = all pairs)
input ulong    InpMagicNumber         = 0;        // Magic number filter (0 = all manual/EA trades)
input ulong    InpSlippageDeviation   = 100;      // Max allowed deviation/slippage in points

//--- State Struct
struct PriceTick
{
   datetime time;
   double   bid;
   double   ask;
};

PriceTick historyBuffer[];
CTrade    trade;
double    pipMultiplier;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   trade.SetDeviationInPoints(InpSlippageDeviation);
   trade.SetExpertMagicNumber(InpMagicNumber);

   // Determine pip scale for 3/5 digit brokers
   if(_Digits == 3 || _Digits == 5)
      pipMultiplier = _Point * 10;
   else
      pipMultiplier = _Point;

   ArrayResize(historyBuffer, 0);
   PrintFormat("[FlashClose] Initialized. Monitoring %s: >= %.1f pips move within %d sec.", 
               InpCurrentSymbolOnly ? _Symbol : "ALL SYMBOLS", 
               InpDropThresholdPips, 
               InpTimeWindowSeconds);
   return(INIT_SUCCEEDED);
}

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

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   MqlTick currentTick;
   if(!SymbolInfoTick(_Symbol, currentTick))
      return;

   datetime currentTime = currentTick.time;

   // 1. Append current tick to circular/rolling buffer
   int size = ArraySize(historyBuffer);
   ArrayResize(historyBuffer, size + 1);
   historyBuffer[size].time = currentTime;
   historyBuffer[size].bid  = currentTick.bid;
   historyBuffer[size].ask  = currentTick.ask;

   // 2. Prune ticks older than the monitoring window
   datetime cutoffTime = currentTime - InpTimeWindowSeconds;
   int firstValidIndex = 0;

   for(int i = 0; i < ArraySize(historyBuffer); i++)
   {
      if(historyBuffer[i].time >= cutoffTime)
      {
         firstValidIndex = i;
         break;
      }
   }

   if(firstValidIndex > 0)
   {
      int newCount = ArraySize(historyBuffer) - firstValidIndex;
      for(int i = 0; i < newCount; i++)
         historyBuffer[i] = historyBuffer[firstValidIndex + i];
      ArrayResize(historyBuffer, newCount);
   }

   // 3. Evaluate velocity relative to the oldest tick in the window
   if(ArraySize(historyBuffer) > 1)
   {
      double oldestBid = historyBuffer[0].bid;
      double deltaPrice = currentTick.bid - oldestBid;
      double deltaPips  = deltaPrice / pipMultiplier;

      // Detect rapid dump (Intervention move)
      if(InpTriggerOnDrop && deltaPips <= -InpDropThresholdPips)
      {
         PrintFormat("!!! FLASH DROP DETECTED: %.1f pips in %d sec. Emergency closing positions...", 
                     MathAbs(deltaPips), InpTimeWindowSeconds);
         ExecuteEmergencyClose();
         ExpertRemove(); // Prevent continuous re-firing
         return;
      }

      // Detect rapid spike
      if(InpTriggerOnSpike && deltaPips >= InpDropThresholdPips)
      {
         PrintFormat("!!! FLASH SPIKE DETECTED: +%.1f pips in %d sec. Emergency closing positions...", 
                     deltaPips, InpTimeWindowSeconds);
         ExecuteEmergencyClose();
         ExpertRemove();
         return;
      }
   }
}

//+------------------------------------------------------------------+
//| Close matching positions immediately                             |
//+------------------------------------------------------------------+
void ExecuteEmergencyClose()
{
   int totalPositions = PositionsTotal();
   
   // Loop backwards to cleanly handle removals
   for(int i = totalPositions - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket <= 0)
         continue;

      string posSymbol = PositionGetString(POSITION_SYMBOL);
      ulong  posMagic  = PositionGetInteger(POSITION_MAGIC);

      if(InpCurrentSymbolOnly && posSymbol != _Symbol)
         continue;

      if(InpMagicNumber != 0 && posMagic != InpMagicNumber)
         continue;

      // Send market close with generous deviation
      if(!trade.PositionClose(ticket, InpSlippageDeviation))
      {
         PrintFormat("Failed to close ticket %d: Error %d", ticket, GetLastError());
      }
      else
      {
         PrintFormat("Closed ticket %d successfully on flash trigger.", ticket);
      }
   }
}

Code: Select all

//+------------------------------------------------------------------+
//|                                     EmergencyFlashClose.mq4      |
//|                        Emergency Position Closer for Flash Moves |
//+------------------------------------------------------------------+
#property strict

//--- Inputs
input double   InpDropThresholdPips   = 60.0;     // Trigger move in Pips
input int      InpTimeWindowSeconds   = 5;        // Rolling time window in seconds
input bool     InpTriggerOnDrop       = true;     // Trigger on rapid drop
input bool     InpTriggerOnSpike      = false;    // Trigger on rapid spike
input bool     InpCurrentSymbolOnly   = true;     // Close current symbol only
input int      InpMagicNumber         = 0;        // Magic number filter (0 = all)
input int      InpSlippagePoints      = 100;      // Max deviation in points

struct PriceTick { datetime time; double bid; double ask; };
PriceTick historyBuffer[];
double pipMultiplier;

int OnInit()
{
   if(Digits == 3 || Digits == 5) pipMultiplier = Point * 10;
   else pipMultiplier = Point;
   
   ArrayResize(historyBuffer, 0);
   Print("Flash Close initialized on ", Symbol());
   return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason)
{
   ArrayFree(historyBuffer);
}

void OnTick()
{
   datetime currentTime = TimeCurrent();
   double currentBid = Bid;
   double currentAsk = Ask;

   int size = ArraySize(historyBuffer);
   ArrayResize(historyBuffer, size + 1);
   historyBuffer[size].time = currentTime;
   historyBuffer[size].bid  = currentBid;
   historyBuffer[size].ask  = currentAsk;

   // Prune ticks older than the time window
   datetime cutoffTime = currentTime - InpTimeWindowSeconds;
   int firstValidIndex = 0;

   for(int i = 0; i < ArraySize(historyBuffer); i++)
   {
      if(historyBuffer[i].time >= cutoffTime)
      {
         firstValidIndex = i;
         break;
      }
   }

   if(firstValidIndex > 0)
   {
      int newCount = ArraySize(historyBuffer) - firstValidIndex;
      for(int i = 0; i < newCount; i++) historyBuffer[i] = historyBuffer[firstValidIndex + i];
      ArrayResize(historyBuffer, newCount);
   }

   // Evaluate velocity
   if(ArraySize(historyBuffer) > 1)
   {
      double oldestBid = historyBuffer[0].bid;
      double deltaPips = (currentBid - oldestBid) / pipMultiplier;

      if(InpTriggerOnDrop && deltaPips <= -InpDropThresholdPips)
      {
         Print("FLASH DROP: ", MathAbs(deltaPips), " pips. Closing...");
         ExecuteEmergencyClose();
         ExpertRemove(); // Detach EA after firing
         return;
      }

      if(InpTriggerOnSpike && deltaPips >= InpDropThresholdPips)
      {
         Print("FLASH SPIKE: ", deltaPips, " pips. Closing...");
         ExecuteEmergencyClose();
         ExpertRemove();
         return;
      }
   }
}

void ExecuteEmergencyClose()
{
   // Loop backwards to safely manage indices during closures
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(InpCurrentSymbolOnly && OrderSymbol() != Symbol()) continue;
         if(InpMagicNumber != 0 && OrderMagicNumber() != InpMagicNumber) continue;
         
         RefreshRates(); // CRITICAL: Updates Bid/Ask cache during high volatility
         
         double closePrice = 0.0;
         if(OrderType() == OP_BUY) closePrice = MarketInfo(OrderSymbol(), MODE_BID);
         else if(OrderType() == OP_SELL) closePrice = MarketInfo(OrderSymbol(), MODE_ASK);
         else continue; // Skip pending orders

         bool res = OrderClose(OrderTicket(), OrderLots(), closePrice, InpSlippagePoints, clrRed);
         if(!res) Print("Failed to close ticket ", OrderTicket(), ": ", GetLastError());
      }
   }
}

Code: Select all

//@version=5
indicator("Flash Move Emergency Close Alert", overlay=true, calc_on_every_tick=true)

//--- Inputs
inpThresholdPips = input.float(60.0, "Flash Move Threshold (Pips)")
inpBarsWindow = input.int(5, "Lookback Window (Bars - use 1s or 5s chart)")
inpWebhookMsg = input.text_area('{"action": "close", "symbol": "USDJPY"}', "Webhook JSON Payload")

triggerDrop = input.bool(true, "Trigger on Drop")
triggerSpike = input.bool(false, "Trigger on Spike")

// Calculate pip multiplier dynamically for forex vs equities
pipMultiplier = syminfo.mintick * (syminfo.type == "forex" ? 10 : 1)

// Determine the extremes over the lookback window
highestHigh = ta.highest(high, inpBarsWindow)
lowestLow = ta.lowest(low, inpBarsWindow)

// Measure the velocity of the move relative to the extremes
dropSize = (highestHigh - close) / pipMultiplier
spikeSize = (close - lowestLow) / pipMultiplier

isFlashDrop = triggerDrop and (dropSize >= inpThresholdPips)
isFlashSpike = triggerSpike and (spikeSize >= inpThresholdPips)

// Trigger logic
if (isFlashDrop or isFlashSpike)
    // alert.freq_once_per_bar_close prevents spamming your webhook bridge during the active crash
    alert(inpWebhookMsg, alert.freq_once_per_bar_close)

Code: Select all

using System;
using System.Linq;
using System.Collections.Generic;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class EmergencyFlashClose : Robot
    {
        // --- Parameters ---
        [Parameter("Drop Threshold (Pips)", DefaultValue = 60.0)]
        public double DropThresholdPips { get; set; }

        [Parameter("Time Window (Seconds)", DefaultValue = 5)]
        public int TimeWindowSeconds { get; set; }

        [Parameter("Trigger On Drop (Long Protection)", DefaultValue = true)]
        public bool TriggerOnDrop { get; set; }

        [Parameter("Trigger On Spike (Short Protection)", DefaultValue = false)]
        public bool TriggerOnSpike { get; set; }

        [Parameter("Current Symbol Only", DefaultValue = true)]
        public bool CurrentSymbolOnly { get; set; }

        [Parameter("Label Filter (Empty = All)", DefaultValue = "")]
        public string LabelFilter { get; set; }

        // --- State ---
        private struct PriceTick
        {
            public DateTime Time;
            public double Bid;
        }

        private List<PriceTick> _historyBuffer = new List<PriceTick>();
        private bool _triggered = false;

        protected override void OnStart()
        {
            Print("Flash Close initialized on {0}. Monitoring for {1} pips move within {2}s.", 
                  CurrentSymbolOnly ? SymbolName : "ALL SYMBOLS", 
                  DropThresholdPips, TimeWindowSeconds);
        }

        protected override void OnTick()
        {
            if (_triggered) return;

            DateTime currentTime = Server.Time;

            // 1. Add current tick to the rolling buffer
            _historyBuffer.Add(new PriceTick 
            { 
                Time = currentTime, 
                Bid = Symbol.Bid 
            });

            // 2. Prune ticks older than the monitoring window
            DateTime cutoffTime = currentTime.AddSeconds(-TimeWindowSeconds);
            _historyBuffer.RemoveAll(t => t.Time < cutoffTime);

            // 3. Evaluate velocity relative to the oldest tick in the window
            if (_historyBuffer.Count > 1)
            {
                double oldestBid = _historyBuffer[0].Bid;
                double deltaPrice = Symbol.Bid - oldestBid;
                
                // cTrader provides PipSize natively, removing the need for manual digit calculation
                double deltaPips = deltaPrice / Symbol.PipSize;

                // Detect rapid dump
                if (TriggerOnDrop && deltaPips <= -DropThresholdPips)
                {
                    Print("!!! FLASH DROP DETECTED: {0} pips in {1} sec. Emergency closing positions...", 
                          Math.Abs(Math.Round(deltaPips, 1)), TimeWindowSeconds);
                    
                    ExecuteEmergencyClose();
                    _triggered = true; // Prevent re-entry
                }
                // Detect rapid spike
                else if (TriggerOnSpike && deltaPips >= DropThresholdPips)
                {
                    Print("!!! FLASH SPIKE DETECTED: +{0} pips in {1} sec. Emergency closing positions...", 
                          Math.Round(deltaPips, 1), TimeWindowSeconds);
                    
                    ExecuteEmergencyClose();
                    _triggered = true;
                }
            }
        }

        private void ExecuteEmergencyClose()
        {
            // Filter open positions based on parameters
            var positionsToClose = Positions.Where(p => 
                (!CurrentSymbolOnly || p.SymbolName == SymbolName) &&
                (string.IsNullOrEmpty(LabelFilter) || p.Label == LabelFilter)
            ).ToList();

            if (positionsToClose.Count == 0)
            {
                Print("No matching positions found to close. Stopping cBot.");
                Stop();
                return;
            }

            // Fire async close requests immediately
            foreach (var position in positionsToClose)
            {
                Print("Dispatching async close for Position PID: {0}", position.Id);
                ClosePositionAsync(position, OnPositionClosed);
            }
            
            Print("All emergency close requests dispatched. Stopping cBot.");
            Stop(); // Shuts down the cBot so it doesn't keep running after the event
        }

        // Callback executed when the server responds to the async close request
        private void OnPositionClosed(TradeResult result)
        {
            if (result.IsSuccessful)
            {
                Print("Position {0} closed successfully.", result.Position.Id);
            }
            else
            {
                Print("Failed to close position. Error: {0}", result.Error);
            }
        }
    }
}