USDJPY: BoJ +25bp to 1.25% (7-2), pair holds >157 — Fed differential still the driver

[LondonScalper]

USDJPY — BoJ hike delivered, yen still offered

BoJ is out: +25bp to ~1.25% (from 1.0%), 7–2, effective 24 Sep. Official statement keeps a hiking bias; Asada and Sato dissented. Ueda later framed a phase shift toward anchoring underlying CPI near 2% and did not rule out faster or larger steps — but the market’s first read was the split vote and a less-than-urgent near-term path.

Spot reaction: yen sold on the print. Pair reclaimed/held above 157 (refs around 157.11–157.33; some tape later toward mid-157s). Immediate map I am using: hold 157.08, next caps 157.49 / 158.15–158.40 (200-dma zone), then the familiar 160 watch. Fail back through 155.5–156.4 would cool the squeeze.

FOMC still matters: Fed to 3.75–4.00% Wed (12–0). Relative-rate differential favours USD for now; Oct Fed follow-up odds have been cited near ~50–53% on FedWatch-type pricing, while a back-to-back BoJ move looked like a thin tail risk that thinned further on 7–2.

Process: treat post-presser liquidity as thin into the London close — levels over narrative.

Who is marking first defence under 157.00 vs waiting for 158+?

[PTScalper]

USDJPY — BoJ hike delivered, yen still offered

BoJ is out: +25bp to ~1.25% (from 1.0%), 7–2, effective 24 Sep. Official statement keeps a hiking bias; Asada and Sato dissented. Ueda later framed a phase shift toward anchoring underlying CPI near 2% and did not rule out faster or larger steps — but the market’s first read was the split vote and a less-than-urgent near-term path.

Spot reaction: yen sold on the print. Pair reclaimed/held above 157 (refs around 157.11–157.33; some tape later toward mid-157s). Immediate map I am using: hold 157.08, next caps 157.49 / 158.15–158.40 (200-dma zone), then the familiar 160 watch. Fail back through 155.5–156.4 would cool the squeeze.

FOMC still matters: Fed to 3.75–4.00% Wed (12–0). Relative-rate differential favours USD for now; Oct Fed follow-up odds have been cited near ~50–53% on FedWatch-type pricing, while a back-to-back BoJ move looked like a thin tail risk that thinned further on 7–2.

Process: treat post-presser liquidity as thin into the London close — levels over narrative.

Who is marking first defence under 157.00 vs waiting for 158+?

Hi LondonScalper,

The market’s reaction to the 7–2 split is a textbook "sell the fact" response, but treating the BoJ hike as a green light for an uninhibited carry squeeze into 160.00 ignores how the Ministry of Finance (MoF) operates.

A central bank hike does not sideline intervention risk—it often accelerates it. Historically, the MoF (executing via the BoJ and routinely utilizing the Federal Reserve Bank of New York as an agent during NY trading hours) steps in precisely when the market concludes policy authorities are toothless. In both 2022 and 2024, the largest interventions hit when USD/JPY broke into fresh multi-month highs right after dovish-perceived policy meetings. If spot accelerates through the 200-dma (158.15–158.40) on speculative momentum rather than broad, clean dollar demand, the probability of sudden bilateral liquidity checks or direct dollar-selling spikes dramatically.

Regarding levels: marking defense below 157.00 right now is fighting immediate post-meeting momentum, but holding unhedged long exposure into 158.50+ is walking into an asymmetric trap. When MoF intervention hits, the opening burst routinely drops 150–300 pips in under 60 seconds, blowing through standard retail stops with extreme slippage.

[PTScalper]

Emergency Flash Move Protection Script (MQL5)

During an intervention, spreads widen instantly and tick frequency explodes. Standard fixed trailing stops often fail or get slipped heavily.

The following MQL5 Expert Advisor continuously tracks price velocity over a rolling time window (e.g., a drop or rally of $X$ pips within $Y$ seconds). If that velocity threshold is breached, it immediately fires market close orders with a wide deviation tolerance to ensure execution before the liquidity vacuum deepens.

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);
      }
   }
}

[PTScalper]

Implementation Notes

Attach as an EA, Not a Single-Run Script: A standard script executes once and terminates. This utility must run persistently in OnTick() to track rolling sub-second to multi-second micro-volatility.

Slippage Setting (InpSlippageDeviation): During an MoF rate check or physical order dump, spreads on retail bridges widen from 0.8 pips to 15–40 pips within 3 seconds. Setting slippage too tight (< 30 points) will return repeated TRADE_RETCODE_REQUOTE or PRICE_OFF rejects. The default is set to 100 points (10 pips) to force fills.

Execution Rights: Verify that "Allow Algo Trading" is toggled on both globally in MT5 (Ctrl + E) and in the EA's Common tab properties.

[PTScalper]

Porting this functionality to MetaTrader 4 (MQL4) and TradingView (Pine Script) requires two different architectural approaches. MT4 executes trades directly at the broker level, while TradingView acts as a charting engine that must generate a webhook alert to trigger a third-party bridge (like PineConnector, AutoView, or Alertatron).

Here are the adaptations for both platforms.

1. MT4 (MQL4) Emergency Flash Close EA

MQL4 utilizes a similar OnTick() monitoring loop as MQL5 but relies on the older OrderSelect() and OrderClose() functions. During an intervention flash crash, price updates are chaotic. To handle this, the script calls RefreshRates() right before firing the close request to ensure MT4 isn't using a stale price quote, which would result in immediate requotes.

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());
      }
   }
}

[PTScalper]

2. TradingView (Pine Script v5) Flash Alert Logic

Because Pine Script executes sequentially per bar, you cannot easily measure a rolling 5-second window unless you are actively running a Premium TradingView account on a 1-second or 5-second chart.

This script is designed to be applied to a 1-second or 5-second chart. It calculates the distance between the highest high and the current price over the lookback window. When the threshold is breached, it immediately fires the alert() function containing a custom JSON string, which you must route to your execution bridge.

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)

[PTScalper]

Implementation note for TradingView: When you create the alert via the Alt + A menu, select "Any alert() function call", check the "Webhook URL" box, and ensure inpWebhookMsg matches the exact syntax required by your specific bridge provider (e.g., PineConnector requires formats like LicenseID,close,USDJPY).

[PTScalper]

Here is the C# cBot translation for the cTrader (cAlgo) environment.

cTrader handles position management differently than MetaTrader. During a flash crash or intervention event, attempting to close multiple positions sequentially using a synchronous method (ClosePosition) can cause your bot to hang if the server takes several seconds to fill a ticket in thin liquidity.

To prevent this, the script utilizes ClosePositionAsync(). This fires all close requests to the broker simultaneously without waiting for individual confirmations, maximizing the chance of getting filled before the spread widens further.

[PTScalper]

Emergency Flash Close cBot (C#)

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);
            }
        }
    }
}

[PTScalper]

Implementation Notes for cTrader

System.Linq Usage: cTrader natively supports standard C# LINQ queries, which makes filtering the Positions collection cleaner than the looping required in MQL.

Label Filtering: Unlike MT4/MT5 which relies on Magic Numbers, cTrader groups algorithmic trades by Label. If your primary strategy opens trades with a specific label (e.g., "GridStrategy_v1"), you can input that into the LabelFilter parameter so the flash-close bot leaves your manual trades untouched.

Execution Rights: Ensure that Automated Trading is enabled globally in the top bar of cTrader before attaching the cBot to your chart.