Plugin

Silver Bullet

ICT's Silver Bullet from the market structure blocks: in a kill zone a liquidity sweep, then a limit order in the fair value gap that follows.

Strategy templateNo networkDesktop onlyv1.0.0

Get early access Plugin API documentation

About

The Silver Bullet is an ICT setup for one hour of the trading day: price first runs the stops beyond a recent swing, then turns and leaves a fair value gap, and the trade is taken when price comes back into that gap. This template builds it from the market structure group of the indicator catalogue, each rule an element a strategy reads with ctx.ind:

killzones is the window. One kill zone on the New York clock is traded; the default, the London close from 10:00 to 12:00, holds ICT's AM Silver Bullet hour, 10:00 to 11:00.
liquidity_sweep is the setup. A wick below a swing low that closes back above it takes the sell side liquidity and makes the window bullish; a sweep of a swing high makes it bearish.
fvg is the trigger. The first fair value gap in the direction of the bias, formed after the sweep, gets a buy limit at its top (a sell limit at the bottom of a bearish gap).
liquidity is the target when targetR is 0: the nearest swing high no price has traded above yet, for a long.

The stop sits a buffer beyond the most extreme price since the sweep. At most one order per window; an order still unfilled when the window ends is cancelled, and a position runs to its stop or target.

The same rules in a strategy of your own read the same streams:

pythonk = ctx.ind("killzones")
sweep = ctx.ind("liquidity_sweep", length=3)
gap = ctx.ind("fvg", min_size=0.25)

This template has not been measured on market data and makes no claim about results.

Parameters

Name	Type	Default	Range or options	Description
`killzone`	int	`3`	min 0, max 3	The kill zone traded: 0 Asia (20:00 to 24:00), 1 London open (02:00 to 05:00), 2 New York open (07:00 to 10:00), 3 London close (10:00 to 12:00), all New York time.
`swingBars`	int	`3`	min 1, max 20	Bars on each side of a swing for the sweep and the liquidity target; a swing counts this many bars after its extreme.
`minGapAtr`	float	`0.25`	min 0, max 5	The smallest fair value gap that triggers, in multiples of the ATR.
`stopBufferPips`	float	`1`	min 0, max 100	Pips beyond the most extreme price since the sweep where the stop sits.
`targetR`	float	`2`	min 0, max 10	The target as a multiple of the stop distance; 0 aims at the nearest untaken liquidity instead.
`riskPercent`	float	`1`	min 0, max 10	Per cent of the balance lost if the stop is hit. 0 trades the run's lot size.
`allowShort`	int	`1`	min 0, max 1	1 trades both directions, 0 long only.

Use it in a strategy

python# The trigger in your own strategy: after a sell side sweep in the window,
# a bullish gap gets a buy limit at its top.
k = ctx.ind("killzones")
sweep = ctx.ind("liquidity_sweep", length=3)
gap = ctx.ind("fvg", min_size=0.25)
if k.london_close == 1 and sweep.down == 1:
    self.bias = 1
elif k.london_close == 1 and getattr(self, "bias", 0) == 1 and gap.bull_new == 1:
    bars = ctx.bars(3)
    ctx.order("LONG", limit=bars[-1].low, sl_pips=20, tp_pips=40)
    self.bias = 0

To run the whole template, install it, switch it on and pick Silver Bullet under Plugins in the strategy list. Run it on M1, M5 or M15 bars of a market that trades in New York hours.

What it provides

silver_bullet/silver_bulletStrategy The strategy, with its parameters: the kill zone, the swing bars, the smallest gap, the stop buffer, the target, the risk per trade and the short side.

When values are known

Every element is known at the close of its bar: a sweep needs its swing confirmed swingBars bars after the extreme, a gap shows on its third candle. The order rests from the next bar on, so no decision uses a later bar.

Limits

A template to start from, not a tested edge: it has not been measured on market data, so no result is promised. Backtest it on your markets before you trust it.
The kill zones of the catalogue are wider than ICT's one hour windows; for the 10:00 to 11:00 hour alone, change the window test in the code.
A limit order fills only when price returns into the gap; on a fast day it never does and the window passes without a trade.
Bank holidays and news are not known to the template. Spreads widen around the New York open.

Preview

json{
  "gap": [
    1.0846,
    1.0852
  ],
  "note": "Made-up example, not a real trade",
  "order": "LONG limit at 1.0852",
  "stop": 1.0837,
  "sweep": {
    "at": "10:05",
    "level": 1.0841,
    "side": "sell side"
  },
  "target": "2R",
  "window": "London close kill zone, 10:00 to 12:00 New York"
}

A made-up sample that shows the shape of the output. Not vendor data and not a result.

The code

main.py, the file the app installs.

python"""Silver Bullet: a liquidity sweep inside a kill zone, then the fair value gap.

Built from the market structure group of the indicator catalogue (#546), so
every rule is a catalogue element read with ctx.ind, the same streams the
chart draws and Blocks offers:

- `killzones`: the window. One kill zone on the New York clock is traded,
  `killzone` picks it (London close, 10:00 to 12:00, by default: it holds
  ICT's AM Silver Bullet hour, 10:00 to 11:00).
- `liquidity_sweep`: the setup. A wick below a swing low that closes back
  above it (sell side liquidity taken) makes the window bullish; a sweep of a
  swing high makes it bearish. A later sweep the other way turns it.
- `fvg`: the trigger. The first fair value gap in the direction of the bias,
  formed after the sweep, is the entry: a buy limit at the top of a bullish
  gap (a sell limit at the bottom of a bearish one), where price returns into
  it.
- `liquidity`: the target when `targetR` is 0, the nearest untaken swing high
  for a long (low for a short).

The stop sits `stopBufferPips` beyond the most extreme price since the sweep.
At most one order per window; an order still unfilled when the window ends is
cancelled on the close of the window's last bar, a position runs to its stop or
target. Finding that last bar needs the window's end in UTC: the hour on New
York's clock comes from `seasonality` (its hour bucket on the New York clock,
daylight saving included), and the bar length is learned from the gaps
between bars, counted in minutes, so bars start on whole minutes.

Every value is known at the close of its bar, so the order rests from the
next bar on. Run it on M1, M5 or M15 bars.

Written in the subset the Python to IR compiler takes (`ir/from_python.py`),
so the template exports to MetaTrader 5, cTrader, Pine and Rust as it runs
here: the parameters are read and clamped in `__init__`, every rule is in
`on_bar`, and the fields hold numbers and flags only.
"""

import math

from orionquant_engine.strategy.base_strategy import Strategy

STRATEGY_ID = "silver_bullet"
ORDER = "silver_bullet"

PARAMS = [
    {"key": "killzone", "label": "Kill zone (0 Asia, 1 London open, 2 New York open, 3 London close)",
     "type": "int", "default": 3, "min": 0, "max": 3},
    {"key": "swingBars", "label": "Swing bars each side", "type": "int", "default": 3, "min": 1, "max": 20},
    {"key": "minGapAtr", "label": "Smallest gap (ATR)", "type": "float", "default": 0.25, "min": 0, "max": 5},
    {"key": "stopBufferPips", "label": "Stop beyond the sweep (pips)", "type": "float", "default": 1.0,
     "min": 0, "max": 100},
    {"key": "targetR", "label": "Target (R, 0 the nearest liquidity)", "type": "float", "default": 2.0,
     "min": 0, "max": 10},
    {"key": "riskPercent", "label": "Risk at the stop (% of balance, 0 lot size)", "type": "float", "default": 1.0,
     "min": 0, "max": 10},
    {"key": "allowShort", "label": "Short trades (1 on, 0 off)", "type": "int", "default": 1, "min": 0, "max": 1},
]


def _day_number(year, month, day):
    """The Julian day number of a date: a count of days that runs on over
    months and years, so the times of two bars can be subtracted."""
    a = math.floor((14 - month) / 12)
    y = year + 4800 - a
    m = month + 12 * a - 3
    return (day + math.floor((153 * m + 2) / 5) + 365 * y + math.floor(y / 4) - math.floor(y / 100)
            + math.floor(y / 400) - 32045)


def _target_pips(target_r, sl_pips, room, pip):
    """The target in pips: `targetR` times the stop, or with 0 the room to the
    nearest liquidity; None when there is none left to aim at."""
    if target_r > 0:
        return target_r * sl_pips
    if room is not None and room > 0:
        return room / pip
    return None


class SilverBullet(Strategy):
    """See the module docstring."""

    def __init__(self, params):
        # Each parameter clamped to its range in PARAMS, its default when absent.
        self.zone = min(max(int(params.get("killzone", 3)), 0), 3)
        self.swing_bars = min(max(int(params.get("swingBars", 3)), 1), 20)
        self.min_gap = min(max(float(params.get("minGapAtr", 0.25)), 0.0), 5.0)
        self.buffer_pips = min(max(float(params.get("stopBufferPips", 1.0)), 0.0), 100.0)
        self.target_r = min(max(float(params.get("targetR", 2.0)), 0.0), 10.0)
        self.risk_percent = min(max(float(params.get("riskPercent", 1.0)), 0.0), 10.0)
        self.allow_short = min(max(int(params.get("allowShort", 1)), 0), 1)
        # The minute of the New York day the kill zone ends on: Asia at the
        # next midnight, London open 05:00, New York open 10:00, London close 12:00.
        self.end_minute = 1440 if self.zone == 0 else 300 if self.zone == 1 else 600 if self.zone == 2 else 720

        self.inside = False   # whether the last bar was in the window
        self.end = None       # when the window ends, in minutes since the start of the day count, UTC
        self.bias = 0         # +1 after a sweep of sell side liquidity, -1 after one of buy side
        self.extreme = None   # the lowest low (highest high) since the sweep
        self.placed = False
        self.closed = False   # the window's last bar has been seen
        self.step = None      # the bar length in minutes, the smallest gap seen between two bars
        self.last_stamp = None  # the last bar's time, in minutes

    def on_bar(self, ctx):
        k = ctx.ind("killzones")
        sweep = ctx.ind("liquidity_sweep", length=self.swing_bars)
        gaps = ctx.ind("fvg", min_size=self.min_gap)
        pools = ctx.ind("liquidity", length=self.swing_bars)
        # The hour on New York's clock: seasonality's bucket by hour on that clock.
        ny_hour = ctx.ind("seasonality", by="hour", zone="new_york").bucket
        bars = ctx.bars(1)
        if not bars:
            return  # never: the hook runs once a bar is out
        bar = bars[-1]
        now = ctx.now()
        stamp = _day_number(now.year, now.month, now.day) * 1440 + now.hour * 60 + now.minute

        # The bar length: the smallest gap seen between two bars.
        if self.last_stamp is not None:
            gap = stamp - self.last_stamp
            if gap > 0 and (self.step is None or gap < self.step):
                self.step = gap
        self.last_stamp = stamp

        if self.zone == 0:
            inside = k.asia == 1
        elif self.zone == 1:
            inside = k.london_open == 1
        elif self.zone == 2:
            inside = k.new_york_open == 1
        else:
            inside = k.london_close == 1
        if inside and not self.inside:
            # A new window: its end in UTC, and nothing seen in it yet. New
            # York's offset is whole hours, so its minute is the UTC minute,
            # and no clock change falls inside a kill zone of a trading day.
            self.end = stamp + self.end_minute - (ny_hour * 60 + now.minute)
            self.bias, self.extreme, self.placed, self.closed = 0, None, False, False
        if not inside and self.inside and self.placed and not self.closed:
            ctx.cancel(ORDER)  # the window ended without its last bar in the data
        self.inside = inside
        if not inside or self.closed:
            return
        last = self.step is not None and stamp + self.step >= self.end
        if last:
            self.closed = True
            if self.placed:
                ctx.cancel(ORDER)  # unfilled at the window's end: gone; a position stays
                return
        if self.placed:
            return

        # Prices since the sweep, this bar's too, before the gap is read.
        if self.bias == 1:
            self.extreme = min(self.extreme, bar.low)
        elif self.bias == -1:
            self.extreme = max(self.extreme, bar.high)
        # The gap against the bias of the bars before: a gap whose first candle
        # came before the sweep does not count. None on the window's last bar.
        pip = ctx.pip()
        buffer = self.buffer_pips * pip
        three = ctx.bars(3)  # the gap's three candles, the newest last
        if not last and self.bias == 1 and gaps.bull_new == 1:
            if len(three) < 3:
                return  # never: a gap takes three bars
            # A buy limit at the gap's top, the stop beyond the sweep.
            entry = three[-1].low
            stop = self.extreme - buffer
            room = None if pools.buy_side is None else pools.buy_side - entry
            sl_pips = abs(entry - stop) / pip
            tp_pips = _target_pips(self.target_r, sl_pips, room, pip)
            if sl_pips > 0 and stop < entry and tp_pips is not None:
                if self.risk_percent > 0:
                    ctx.order("LONG", limit=entry, sl_pips=sl_pips, tp_pips=tp_pips, name=ORDER,
                              risk_percent=self.risk_percent)
                else:
                    ctx.order("LONG", limit=entry, sl_pips=sl_pips, tp_pips=tp_pips, name=ORDER)
                self.placed = True
        elif not last and self.bias == -1 and gaps.bear_new == 1 and self.allow_short == 1:
            if len(three) < 3:
                return  # never: a gap takes three bars
            # A sell limit at the gap's bottom, the stop beyond the sweep.
            entry = three[-1].high
            stop = self.extreme + buffer
            room = None if pools.sell_side is None else entry - pools.sell_side
            sl_pips = abs(entry - stop) / pip
            tp_pips = _target_pips(self.target_r, sl_pips, room, pip)
            if sl_pips > 0 and stop > entry and tp_pips is not None:
                if self.risk_percent > 0:
                    ctx.order("SHORT", limit=entry, sl_pips=sl_pips, tp_pips=tp_pips, name=ORDER,
                              risk_percent=self.risk_percent)
                else:
                    ctx.order("SHORT", limit=entry, sl_pips=sl_pips, tp_pips=tp_pips, name=ORDER)
                self.placed = True
        if self.placed:
            return

        if sweep.down == 1:
            self.bias, self.extreme = 1, bar.low
        elif sweep.up == 1:
            self.bias, self.extreme = -1, bar.high


def register(api):
    api.register_strategy(STRATEGY_ID, "Silver Bullet", SilverBullet, PARAMS)