The NY "Silver Bullet": How Smart Money Exploits the 10 AM Window

[PTScalper]

If you are tired of indicator lag and want to trade like institutional algorithms, you need to look into Smart Money Concepts (SMC). One of the most effective and highly regarded forex scalping strategies in this space is known as the ICT Silver Bullet.
Instead of staring at the charts all day, the Silver Bullet strategy dictates that you only trade during a highly specific one-hour window when institutional order flow is the most predictable. The best window? The New York AM Session (10:00 AM – 11:00 AM EST).
The Core Concept: Sweeps and Fair Value Gaps (FVG)
This strategy relies on two things: trapping retail traders and filling market imbalances.
Here is exactly how the 10 AM EST setup works on a 1-minute or 5-minute chart:
1. The Trap (Liquidity Sweep): Right around 10:00 AM EST, institutions often push the price past a recent, obvious swing high or swing low. Retail traders see a "breakout" and jump in, or their stop-losses get triggered.
2. The Shift (Market Structure Shift): Immediately after triggering those stops, the market violently reverses direction, breaking the short-term market structure (a previous micro swing point).
3. The Imbalance (Fair Value Gap): This rapid reversal leaves behind a Fair Value Gap (FVG). An FVG is a three-candle pattern where the massive middle candle moves so fast that the wicks of the first and third candles do not overlap. This leaves a "void" or imbalance in the price.
How to Execute the Scalp
Once you spot the FVG forming after a liquidity sweep between 10:00 AM and 11:00 AM EST:
Entry: Place a pending limit order right at the edge of the Fair Value Gap. The algorithm will frequently retrace to "fill" this void before continuing the new trend.
Stop Loss: Place your stop safely on the other side of the FVG, or just beyond the initial sweep wick.
Take Profit: Target the next opposing liquidity pool (the nearest obvious swing high or low), aiming for a fast 10 to 20 pips.
Why This is the Ultimate Forex Scalping Strategy
Because you are trading purely on precise time windows and naked price action, you are front-running the delayed signals of traditional indicators like moving averages. However, this strategy happens fast. Because you are entering on 1-minute chart retracements, a high-speed ECN broker with near-zero spreads is mandatory. If your broker slips your entry by even one pip, the risk-to-reward ratio of this micro-setup is severely damaged.
Give the 10 AM EST window a try tomorrow on the EUR/USD or GBP/USD. Wait for the trap, spot the gap, and trade the reversal.

[LondonScalper]

ICT Silver Bullet... New York AM Session (10:00 AM – 11:00 AM EST)... liquidity sweep ... Fair Value Gap

Time-boxing a window is sensible. Wrapping it in destiny language is optional.

A one-hour focus block around mid-morning NY can be high quality because liquidity and news residue often create cleaner sweeps than the overnight dribble. I treat it as: known hour, known checklist, limited shots — not as smart-money cosplay.

Operational version without the mythology:

• Mark prior liquidity pools before the window
• Wait for the sweep and the displacement
• Use a fair-value / imbalance zone only as a location, not a religion
• Hard stop if the first idea fails — no “Silver Bullet 2.0” inventing

If the hour is quiet, stand down. The edge is selectivity inside the window, not attendance. Are you strictly 10–11 ET only, or do you also run an equivalent London hour with the same rules?

[PropScalpDesk]

Silver Bullet window: rules before SMC poetry

Timed windows can help focus. They can also become superstition. If I engage a late-morning New York liquidity window on EURUSD, I still need my usual stack: level, sweep/reclaim or continuation trigger, cost OK, invalidation clear. Branding it Silver Bullet does not replace that.

From Frankfurt my primary edge sits earlier; NY is optional and smaller. I refuse to force a trade because the clock says a famous model is “active.” No setup, no ticket. Time stop stays honest — these windows expire.

SMC language is fine as a map. Live risk is still R and rules.

I also refuse to combine Silver Bullet timing with news residual volatility just because the clock matches. Timing windows do not cancel calendar risk.

If the window opens and my level is far away, I wait or skip. Clocks do not pull price to me.

Do you treat the 10 AM window as mandatory hunting time, or only as a permission window when a pre-marked level is actually in play?

[PTScalper]

If you are tired of indicator lag and want to trade like institutional algorithms, you need to look into Smart Money Concepts (SMC). One of the most effective and highly regarded forex scalping strategies in this space is known as the ICT Silver Bullet.
Instead of staring at the charts all day, the Silver Bullet strategy dictates that you only trade during a highly specific one-hour window when institutional order flow is the most predictable. The best window? The New York AM Session (10:00 AM – 11:00 AM EST).
The Core Concept: Sweeps and Fair Value Gaps (FVG)
This strategy relies on two things: trapping retail traders and filling market imbalances.
Here is exactly how the 10 AM EST setup works on a 1-minute or 5-minute chart:
1. The Trap (Liquidity Sweep): Right around 10:00 AM EST, institutions often push the price past a recent, obvious swing high or swing low. Retail traders see a "breakout" and jump in, or their stop-losses get triggered.
2. The Shift (Market Structure Shift): Immediately after triggering those stops, the market violently reverses direction, breaking the short-term market structure (a previous micro swing point).
3. The Imbalance (Fair Value Gap): This rapid reversal leaves behind a Fair Value Gap (FVG). An FVG is a three-candle pattern where the massive middle candle moves so fast that the wicks of the first and third candles do not overlap. This leaves a "void" or imbalance in the price.
How to Execute the Scalp
Once you spot the FVG forming after a liquidity sweep between 10:00 AM and 11:00 AM EST:
Entry: Place a pending limit order right at the edge of the Fair Value Gap. The algorithm will frequently retrace to "fill" this void before continuing the new trend.
Stop Loss: Place your stop safely on the other side of the FVG, or just beyond the initial sweep wick.
Take Profit: Target the next opposing liquidity pool (the nearest obvious swing high or low), aiming for a fast 10 to 20 pips.
Why This is the Ultimate Forex Scalping Strategy
Because you are trading purely on precise time windows and naked price action, you are front-running the delayed signals of traditional indicators like moving averages. However, this strategy happens fast. Because you are entering on 1-minute chart retracements, a high-speed ECN broker with near-zero spreads is mandatory. If your broker slips your entry by even one pip, the risk-to-reward ratio of this micro-setup is severely damaged.
Give the 10 AM EST window a try tomorrow on the EUR/USD or GBP/USD. Wait for the trap, spot the gap, and trade the reversal.

Here is a complete TradingView Pine Script (v5) that programmatically replicates the ICT Silver Bullet strategy based on your rules.

Because Smart Money Concepts (like sweeps and Market Structure Shifts) are highly visual and discretionary, this script uses mechanical proxies: it looks for local swing extremes (the trap/sweep) followed immediately by a Fair Value Gap (the shift/imbalance) inside the strict 10:00 AM – 11:00 AM EST window.

[PTScalper]

The ICT Silver Bullet Strategy Script

Code: Select all

//@version=5
strategy("ICT Silver Bullet (10 AM EST)", overlay=true, initial_capital=1000, default_qty_type=strategy.percent_of_equity, default_qty_value=2, margin_long=100, margin_short=100, calc_on_every_tick=true)

// =========================================================================
// INPUTS
// =========================================================================
grp_time    = "Time Window"
sessionTime = input.session("1000-1100", title="Trading Session", group=grp_time, tooltip="Defaults to New York AM Session")
sessionZone = input.string("America/New_York", title="Timezone", group=grp_time)

grp_strat   = "Strategy Parameters"
riskReward  = input.float(2.0, title="Risk/Reward Ratio", step=0.5, group=grp_strat)
swingLen    = input.int(10, title="Sweep Lookback Length", group=grp_strat, tooltip="Lookback period to determine if a recent high/low was swept")

// =========================================================================
// SESSION LOGIC
// =========================================================================
inSession    = not na(time(timeframe.period, sessionTime, sessionZone))
sessionStart = inSession and not inSession[1]
sessionEnd   = not inSession and inSession[1]

// Highlight the Silver Bullet Window on the chart
bgcolor(inSession ? color.new(color.blue, 90) : na, title="Silver Bullet Window")

// Track if a trade has already been taken in this session to prevent overtrading
var bool tradeTaken = false
if sessionStart
    tradeTaken := false

// =========================================================================
// LIQUIDITY SWEEP (TRAP) DETECTION
// =========================================================================
// Track the highest highs and lowest lows over the lookback period
recentHigh = ta.highest(high, swingLen)[1]
recentLow  = ta.lowest(low, swingLen)[1]

// A sweep occurs if the current or previous candle pierces the recent extreme
sweptHigh = high >= recentHigh or high[1] >= recentHigh[1]
sweptLow  = low <= recentLow or low[1] <= recentLow[1]

// =========================================================================
// FVG (IMBALANCE) DETECTION
// =========================================================================
// Bullish FVG: First candle high is lower than third candle low (gap created)
isBullishFVG = low[0] > high[2] and close[1] > open[1] 
// Bearish FVG: First candle low is higher than third candle high (gap created)
isBearishFVG = high[0] < low[2] and close[1] < open[1]

// =========================================================================
// SETUP & EXECUTION LOGIC
// =========================================================================
var float entryLimit = na
var float stopLoss   = na
var float takeProfit = na

// valid Long Setup: Inside session, swept a low, formed Bull FVG, no trade taken yet
validLong = inSession and sweptLow and isBullishFVG and not tradeTaken and strategy.position_size == 0

if validLong
    entryLimit := high[2] // Top of the Bullish FVG (the entry target)
    stopLoss   := ta.lowest(low, 3) // Stop loss below the swing that created the sweep
    risk       = entryLimit - stopLoss
    takeProfit := entryLimit + (risk * riskReward)
    
    // Draw the FVG Box
    box.new(left=bar_index[2], top=low[0], right=bar_index+5, bottom=high[2], border_color=color.green, bgcolor=color.new(color.green, 80))
    
    // Place Orders
    strategy.entry("Long", strategy.long, limit=entryLimit)
    strategy.exit("Exit Long", "Long", stop=stopLoss, limit=takeProfit)
    tradeTaken := true

// valid Short Setup: Inside session, swept a high, formed Bear FVG, no trade taken yet
validShort = inSession and sweptHigh and isBearishFVG and not tradeTaken and strategy.position_size == 0

if validShort
    entryLimit := low[2] // Bottom of the Bearish FVG (the entry target)
    stopLoss   := ta.highest(high, 3) // Stop loss above the swing that created the sweep
    risk       = stopLoss - entryLimit
    takeProfit := entryLimit - (risk * riskReward)
    
    // Draw the FVG Box
    box.new(left=bar_index[2], top=low[2], right=bar_index+5, bottom=high[0], border_color=color.red, bgcolor=color.new(color.red, 80))
    
    // Place Orders
    strategy.entry("Short", strategy.short, limit=entryLimit)
    strategy.exit("Exit Short", "Short", stop=stopLoss, limit=takeProfit)
    tradeTaken := true

// =========================================================================
// END OF SESSION CLEANUP
// =========================================================================
// Cancel any unfilled pending limit orders when the 11:00 AM window closes
if sessionEnd
    strategy.cancel_all()

[PTScalper]

How to Use and Configure the Script

Add to TradingView: Open TradingView, click the Pine Editor tab at the bottom, paste this code, and click Add to Chart.

Chart Setup: Switch to a 1-minute or 5-minute timeframe. The script works best on major forex pairs like EURUSD or GBPUSD.

Visual Cues:

Blue Background: Highlights the strict 10:00 AM to 11:00 AM EST trading window.

Green/Red Boxes: Highlights the exact Fair Value Gaps (FVG) forming after a liquidity sweep during the session.

Execution Rules Programmed:

The script places a limit order at the edge of the FVG immediately after the 3-candle pattern closes.

It calculates the Stop Loss based on the extreme wick of the sweep.

It calculates Take Profit automatically using a default 2.0 Risk/Reward ratio (adjustable in the settings).

It cancels any un-triggered limit orders exactly at 11:00 AM.

It limits trades to one setup per session to avoid over-trading chop.

[PTScalper]

To filter out counter-trend setups, you can use Pine Script's request.security() function to pull data from a higher timeframe (like the 4-Hour or Daily chart) down to your 1-minute execution chart.

The most objective way to program a "daily bias" is by comparing the higher timeframe's price to an Exponential Moving Average (EMA). If the 4H price is above the 4H 20 EMA, the script will only take long FVG setups.

Here is the fully updated script with the integrated Higher Timeframe (HTF) filter:

Code: Select all

//@version=5
strategy("ICT Silver Bullet (10 AM EST) + HTF Bias", overlay=true, initial_capital=1000, default_qty_type=strategy.percent_of_equity, default_qty_value=2, margin_long=100, margin_short=100, calc_on_every_tick=true)

// =========================================================================
// INPUTS
// =========================================================================
grp_time    = "Time Window"
sessionTime = input.session("1000-1100", title="Trading Session", group=grp_time, tooltip="Defaults to New York AM Session")
sessionZone = input.string("America/New_York", title="Timezone", group=grp_time)

grp_strat   = "Strategy Parameters"
riskReward  = input.float(2.0, title="Risk/Reward Ratio", step=0.5, group=grp_strat)
swingLen    = input.int(10, title="Sweep Lookback Length", group=grp_strat, tooltip="Lookback period to determine if a recent high/low was swept")

grp_htf     = "Higher Timeframe Filter (Bias)"
useHTF      = input.bool(true, title="Enable HTF Trend Filter", group=grp_htf)
htfRes      = input.timeframe("240", title="Higher Timeframe", group=grp_htf, tooltip="'240' = 4-Hour, 'D' = Daily")
htfLen      = input.int(20, title="HTF EMA Length", group=grp_htf)

// =========================================================================
// SESSION LOGIC
// =========================================================================
inSession    = not na(time(timeframe.period, sessionTime, sessionZone))
sessionStart = inSession and not inSession[1]
sessionEnd   = not inSession and inSession[1]

// Track if a trade has already been taken in this session
var bool tradeTaken = false
if sessionStart
    tradeTaken := false

// =========================================================================
// HIGHER TIMEFRAME BIAS
// =========================================================================
// Request the previous HTF closed bar to prevent repainting in backtesting
htfEma   = request.security(syminfo.tickerid, htfRes, ta.ema(close, htfLen)[1], lookahead=barmerge.lookahead_on)
htfClose = request.security(syminfo.tickerid, htfRes, close[1], lookahead=barmerge.lookahead_on)

// Determine directional bias
bullishBias = not useHTF or (htfClose > htfEma)
bearishBias = not useHTF or (htfClose < htfEma)

// Highlight the Silver Bullet Window, colored by current bias
sessionColor = useHTF ? (bullishBias ? color.new(color.green, 90) : bearishBias ? color.new(color.red, 90) : color.new(color.gray, 90)) : color.new(color.blue, 90)
bgcolor(inSession ? sessionColor : na, title="Silver Bullet Window")

// =========================================================================
// LIQUIDITY SWEEP (TRAP) DETECTION
// =========================================================================
recentHigh = ta.highest(high, swingLen)[1]
recentLow  = ta.lowest(low, swingLen)[1]

sweptHigh = high >= recentHigh or high[1] >= recentHigh[1]
sweptLow  = low <= recentLow or low[1] <= recentLow[1]

// =========================================================================
// FVG (IMBALANCE) DETECTION
// =========================================================================
isBullishFVG = low[0] > high[2] and close[1] > open[1] 
isBearishFVG = high[0] < low[2] and close[1] < open[1]

// =========================================================================
// SETUP & EXECUTION LOGIC
// =========================================================================
var float entryLimit = na
var float stopLoss   = na
var float takeProfit = na

// Valid Long Setup: Requires bullish bias from the higher timeframe
validLong = inSession and sweptLow and isBullishFVG and bullishBias and not tradeTaken and strategy.position_size == 0

if validLong
    entryLimit := high[2] 
    stopLoss   := ta.lowest(low, 3) 
    risk       = entryLimit - stopLoss
    takeProfit := entryLimit + (risk * riskReward)
    
    box.new(left=bar_index[2], top=low[0], right=bar_index+5, bottom=high[2], border_color=color.green, bgcolor=color.new(color.green, 80))
    
    strategy.entry("Long", strategy.long, limit=entryLimit)
    strategy.exit("Exit Long", "Long", stop=stopLoss, limit=takeProfit)
    tradeTaken := true

// Valid Short Setup: Requires bearish bias from the higher timeframe
validShort = inSession and sweptHigh and isBearishFVG and bearishBias and not tradeTaken and strategy.position_size == 0

if validShort
    entryLimit := low[2] 
    stopLoss   := ta.highest(high, 3) 
    risk       = stopLoss - entryLimit
    takeProfit := entryLimit - (risk * riskReward)
    
    box.new(left=bar_index[2], top=low[2], right=bar_index+5, bottom=high[0], border_color=color.red, bgcolor=color.new(color.red, 80))
    
    strategy.entry("Short", strategy.short, limit=entryLimit)
    strategy.exit("Exit Short", "Short", stop=stopLoss, limit=takeProfit)
    tradeTaken := true

// =========================================================================
// END OF SESSION CLEANUP
// =========================================================================
if sessionEnd
    strategy.cancel_all()

[PTScalper]

What Changed in the Configuration

Dynamic Bias Execution: The script now checks bullishBias before allowing a Long entry and bearishBias before allowing a Short entry. If the market forms a beautiful bullish FVG setup, but the 4-hour trend is bearish, the script will intentionally ignore the trap.

Repaint Protection: The script requests the [1] (historical) data point of the higher timeframe combined with lookahead=barmerge.lookahead_on. This is the required Pine Script standard to ensure your backtesting data matches real-time live trading data without repainting the moving average on current open bars.

Visual Bias Indicator: The 10:00 AM session background color will now automatically turn light green if the major trend is bullish, or light red if the major trend is bearish, making it instantly obvious which side of the market you should be looking at.

Customizable Timeframes: In the script settings, you can change the HTF timeframe to 240 (4-hour chart), 60 (1-hour chart), or D (Daily chart) depending on how macro you want your filter to be.

[PTScalper]

The implementations below translate the strict time windows, liquidity sweeps, and Fair Value Gap (FVG) detection directly into automated MQL execution. While the Silver Bullet setup isolates micro-structure on the 1-minute or 5-minute charts, mapping the higher timeframe filter to the 15-minute or Daily chart ensures these setups align with the broader trend context. The EMA filter serves as a programmatic proxy for this, though it can easily be swapped out for a raw price action Break of Structure (BoS) check if you prefer to avoid lagging technicals entirely.

MQL5 Expert Advisor (MT5)

This version leverages the modern CTrade class for execution and arrays structured as timeseries (ArraySetAsSeries) to perfectly mirror the [0], [1], [2] bar indexing of Pine Script.

Code: Select all

//+------------------------------------------------------------------+
//|                                       ICT_SilverBullet_MT5.mq5   |
//+------------------------------------------------------------------+
#property strict

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

input string   InpSessionStart = "10:00"; // Session Start (Broker Time HH:MM)
input string   InpSessionEnd   = "11:00"; // Session End (Broker Time HH:MM)
input double   InpRiskReward   = 2.0;     // Risk/Reward Ratio
input int      InpSwingLength  = 10;      // Sweep Lookback Length
input bool     InpUseHTF       = true;    // Enable HTF Trend Filter
input ENUM_TIMEFRAMES InpHTFTimeframe = PERIOD_H4; // Higher Timeframe Filter
input int      InpHTF_EmaLen   = 20;      // HTF EMA Length
input double   InpRiskPercent  = 2.0;     // Risk per trade (%)
input ulong    InpMagicNumber  = 777777;  // Magic Number

int htfEmaHandle;
bool tradeTakenThisSession = false;
bool wasInSession = false;

//+------------------------------------------------------------------+
int OnInit() {
    trade.SetExpertMagicNumber(InpMagicNumber);
    if(InpUseHTF) {
        htfEmaHandle = iMA(_Symbol, InpHTFTimeframe, InpHTF_EmaLen, 0, MODE_EMA, PRICE_CLOSE);
        if(htfEmaHandle == INVALID_HANDLE) return INIT_FAILED;
    }
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
void OnTick() {
    bool inSession = CheckInSession();
    
    if(inSession && !wasInSession) {
        tradeTakenThisSession = false; 
    }
    
    if(!inSession && wasInSession) {
        CancelAllPending();
    }
    wasInSession = inSession;

    if(!inSession || tradeTakenThisSession || IsTradeActive()) return;
    
    // 1. Higher Timeframe Bias
    bool bullishBias = true, bearishBias = true;
    if(InpUseHTF) {
        double emaBuffer[1], htfClose[1];
        if(CopyBuffer(htfEmaHandle, 0, 1, 1, emaBuffer) <= 0) return;
        if(CopyClose(_Symbol, InpHTFTimeframe, 1, 1, htfClose) <= 0) return;
        
        bullishBias = (htfClose[0] > emaBuffer[0]);
        bearishBias = (htfClose[0] < emaBuffer[0]);
    }
    
    // Get recent candle data
    MqlRates rates[];
    ArraySetAsSeries(rates, true);
    if(CopyRates(_Symbol, _Period, 0, InpSwingLength + 3, rates) <= 0) return;
    
    // 2. Liquidity Sweep Detection
    double recentHigh = 0, recentLow = 999999;
    for(int i = 3; i < 3 + InpSwingLength; i++) {
        if(rates[i].high > recentHigh) recentHigh = rates[i].high;
        if(rates[i].low < recentLow) recentLow = rates[i].low;
    }
    
    bool sweptHigh = rates[1].high >= recentHigh || rates[0].high >= recentHigh;
    bool sweptLow  = rates[1].low <= recentLow || rates[0].low <= recentLow;
    
    // 3. FVG (Imbalance) Detection
    bool isBullishFVG = rates[0].low > rates[2].high && rates[1].close > rates[1].open;
    bool isBearishFVG = rates[0].high < rates[2].low && rates[1].close < rates[1].open;
    
    // 4. Execution Logic
    if(sweptLow && isBullishFVG && bullishBias) {
        double entryLimit = rates[2].high;
        double stopLoss = MathMin(rates[0].low, MathMin(rates[1].low, rates[2].low));
        ExecuteLimitOrder(ORDER_TYPE_BUY_LIMIT, entryLimit, stopLoss);
    }
    
    if(sweptHigh && isBearishFVG && bearishBias) {
        double entryLimit = rates[2].low;
        double stopLoss = MathMax(rates[0].high, MathMax(rates[1].high, rates[2].high));
        ExecuteLimitOrder(ORDER_TYPE_SELL_LIMIT, entryLimit, stopLoss);
    }
}

//+------------------------------------------------------------------+
void ExecuteLimitOrder(ENUM_ORDER_TYPE type, double entryLimit, double stopLoss) {
    double risk = MathAbs(entryLimit - stopLoss);
    if(risk <= 0) return;
    
    double takeProfit = (type == ORDER_TYPE_BUY_LIMIT) ? 
                        entryLimit + (risk * InpRiskReward) : 
                        entryLimit - (risk * InpRiskReward);
                        
    double lotSize = CalculateLotSize(risk);
    if(lotSize <= 0) return;
    
    double entryNorm = NormalizeDouble(entryLimit, _Digits);
    double slNorm    = NormalizeDouble(stopLoss, _Digits);
    double tpNorm    = NormalizeDouble(takeProfit, _Digits);
    
    if(type == ORDER_TYPE_BUY_LIMIT) {
        if(trade.BuyLimit(lotSize, entryNorm, _Symbol, slNorm, tpNorm, ORDER_TIME_GTC, 0, "Silver Bullet Long")) {
            tradeTakenThisSession = true;
        }
    } else {
        if(trade.SellLimit(lotSize, entryNorm, _Symbol, slNorm, tpNorm, ORDER_TIME_GTC, 0, "Silver Bullet Short")) {
            tradeTakenThisSession = true;
        }
    }
}

bool CheckInSession() {
    string timeStr = TimeToString(TimeCurrent(), TIME_MINUTES);
    return (timeStr >= InpSessionStart && timeStr < InpSessionEnd);
}

double CalculateLotSize(double slDistance) {
    double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
    double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
    if(tickSize <= 0) return 0.0;
    
    double lossPerLot = (slDistance / tickSize) * tickValue;
    if(lossPerLot <= 0) return 0.0;
    
    double lots = (AccountInfoDouble(ACCOUNT_BALANCE) * (InpRiskPercent / 100.0)) / lossPerLot;
    double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
    lots = MathFloor(lots / lotStep) * lotStep;
    
    return MathMax(SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN), 
           MathMin(lots, SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX)));
}

bool IsTradeActive() {
    for(int i = PositionsTotal() - 1; i >= 0; i--) {
        if(PositionGetTicket(i) > 0 && PositionGetInteger(POSITION_MAGIC) == InpMagicNumber && PositionGetString(POSITION_SYMBOL) == _Symbol) return true;
    }
    for(int i = OrdersTotal() - 1; i >= 0; i--) {
        if(OrderGetTicket(i) > 0 && OrderGetInteger(ORDER_MAGIC) == InpMagicNumber && OrderGetString(ORDER_SYMBOL) == _Symbol) return true;
    }
    return false;
}

void CancelAllPending() {
    for(int i = OrdersTotal() - 1; i >= 0; i--) {
        ulong ticket = OrderGetTicket(i);
        if(OrderSelect(ticket) && OrderGetInteger(ORDER_MAGIC) == InpMagicNumber && OrderGetString(ORDER_SYMBOL) == _Symbol) {
            trade.OrderDelete(ticket);
        }
    }
}

[PTScalper]

MQL4 Expert Advisor (MT4)

Because MT4 does not handle timeseries indexing inside arrays automatically the way MQL5 does, this implementation relies directly on the native High[] and Low[] historical arrays.

Code: Select all

//+------------------------------------------------------------------+
//|                                       ICT_SilverBullet_MT4.mq4   |
//+------------------------------------------------------------------+
#property strict

input string   InpSessionStart = "10:00"; // Session Start (Broker Time HH:MM)
input string   InpSessionEnd   = "11:00"; // Session End (Broker Time HH:MM)
input double   InpRiskReward   = 2.0;     // Risk/Reward Ratio
input int      InpSwingLength  = 10;      // Sweep Lookback Length
input bool     InpUseHTF       = true;    // Enable HTF Trend Filter
input ENUM_TIMEFRAMES InpHTFTimeframe = PERIOD_H4; // Higher Timeframe
input int      InpHTF_EmaLen   = 20;      // HTF EMA Length
input double   InpRiskPercent  = 2.0;     // Risk per trade (%)
input int      InpMagicNumber  = 777777;

bool tradeTakenThisSession = false;
bool wasInSession = false;

//+------------------------------------------------------------------+
void OnTick() {
    bool inSession = CheckInSession();
    
    if(inSession && !wasInSession) tradeTakenThisSession = false; 
    if(!inSession && wasInSession) CancelAllPending();
    wasInSession = inSession;

    if(!inSession || tradeTakenThisSession || IsTradeActive()) return;
    
    // 1. Higher Timeframe Bias
    bool bullishBias = true, bearishBias = true;
    if(InpUseHTF) {
        double htfEMA = iMA(Symbol(), InpHTFTimeframe, InpHTF_EmaLen, 0, MODE_EMA, PRICE_CLOSE, 1);
        double htfClose = iClose(Symbol(), InpHTFTimeframe, 1);
        if(htfEMA > 0) {
            bullishBias = (htfClose > htfEMA);
            bearishBias = (htfClose < htfEMA);
        }
    }
    
    // 2. Liquidity Sweep (Scanning from Bar 3 to SwingLength)
    int highestIdx = iHighest(Symbol(), 0, MODE_HIGH, InpSwingLength, 3);
    int lowestIdx  = iLowest(Symbol(), 0, MODE_LOW, InpSwingLength, 3);
    double recentHigh = High[highestIdx];
    double recentLow  = Low[lowestIdx];
    
    bool sweptHigh = High[1] >= recentHigh || High[0] >= recentHigh;
    bool sweptLow  = Low[1] <= recentLow || Low[0] <= recentLow;
    
    // 3. FVG Detection (Bars 2, 1, 0)
    bool isBullishFVG = Low[0] > High[2] && Close[1] > Open[1];
    bool isBearishFVG = High[0] < Low[2] && Close[1] < Open[1];
    
    // 4. Execution Logic
    if(sweptLow && isBullishFVG && bullishBias) {
        double entryLimit = High[2];
        double stopLoss = MathMin(Low[0], MathMin(Low[1], Low[2]));
        ExecuteLimitOrder(OP_BUYLIMIT, entryLimit, stopLoss);
    }
    
    if(sweptHigh && isBearishFVG && bearishBias) {
        double entryLimit = Low[2];
        double stopLoss = MathMax(High[0], MathMax(High[1], High[2]));
        ExecuteLimitOrder(OP_SELLLIMIT, entryLimit, stopLoss);
    }
}

//+------------------------------------------------------------------+
void ExecuteLimitOrder(int opType, double entryLimit, double stopLoss) {
    double risk = MathAbs(entryLimit - stopLoss);
    if(risk <= 0) return;
    
    double takeProfit = (opType == OP_BUYLIMIT) ? 
                        entryLimit + (risk * InpRiskReward) : 
                        entryLimit - (risk * InpRiskReward);
                        
    double lotSize = CalculateLotSize(risk);
    if(lotSize <= 0) return;
    
    double entryNorm = NormalizeDouble(entryLimit, Digits);
    double slNorm    = NormalizeDouble(stopLoss, Digits);
    double tpNorm    = NormalizeDouble(takeProfit, Digits);
    
    color arrColor = (opType == OP_BUYLIMIT) ? clrGreen : clrRed;
    int ticket = OrderSend(Symbol(), opType, lotSize, entryNorm, 3, slNorm, tpNorm, "Silver Bullet", InpMagicNumber, 0, arrColor);
    
    if(ticket > 0) tradeTakenThisSession = true;
}

bool CheckInSession() {
    string timeStr = TimeToString(TimeCurrent(), TIME_MINUTES);
    return (timeStr >= InpSessionStart && timeStr < InpSessionEnd);
}

double CalculateLotSize(double slDistance) {
    double tickSize = MarketInfo(Symbol(), MODE_TICKSIZE);
    double tickValue = MarketInfo(Symbol(), MODE_TICKVALUE);
    if(tickSize <= 0) return 0.0;
    
    double lossPerLot = (slDistance / tickSize) * tickValue;
    if(lossPerLot <= 0) return 0.0;
    
    double lots = (AccountBalance() * (InpRiskPercent / 100.0)) / lossPerLot;
    double lotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
    lots = MathFloor(lots / lotStep) * lotStep;
    
    return MathMax(MarketInfo(Symbol(), MODE_MINLOT), 
           MathMin(lots, MarketInfo(Symbol(), MODE_MAXLOT)));
}

bool IsTradeActive() {
    for(int i = OrdersTotal() - 1; i >= 0; i--) {
        if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
            if(OrderMagicNumber() == InpMagicNumber && OrderSymbol() == Symbol()) return true;
        }
    }
    return false;
}

void CancelAllPending() {
    for(int i = OrdersTotal() - 1; i >= 0; i--) {
        if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
            if(OrderMagicNumber() == InpMagicNumber && OrderSymbol() == Symbol()) {
                if(OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLLIMIT) {
                    OrderDelete(OrderTicket());
                }
            }
        }
    }
}