Plugin

Power of Three

ICT's Power of Three from the market structure blocks: the Asian range, a London sweep of it, and the trade the other way until the London close.

Strategy templateNo networkDesktop onlyv1.0.0

Get early access Plugin API documentation

About

Power of Three is ICT's picture of a trading day in three phases: accumulation, when price builds a range; manipulation, a false move out of that range that takes the stops beyond it; and distribution, the real move the other way. This template builds each phase from the market structure group of the indicator catalogue:

Accumulation is the Asian range: the high and low of the Asia kill zone, 20:00 to 24:00 New York, from killzones.
Manipulation is a sweep of that range in the London open kill zone, 02:00 to 05:00 New York: a bar trades below the Asian low and closes back above it (above the high and back below, for a short). With useMidnightOpen the long also needs its close below the midnight open from midnight_open, buying at a discount to the true day open.
Distribution is the trade, opened at the close of that bar, at most one a day. The stop sits a buffer beyond London's extreme so far, the target at a multiple of the stop distance or, with targetR 0, at the other side of the Asian range. Whatever is still open is closed when the London close kill zone ends, 12:00 New York.

The kill zones follow New York's clock through its daylight saving changes. This template has not been measured on market data and makes no claim about results.

Parameters

Name	Type	Default	Range or options	Description
`stopBufferPips`	float	`2`	min 0, max 100	Pips beyond London's low (high, for a short) so far where the stop sits.
`targetR`	float	`2`	min 0, max 10	The target as a multiple of the stop distance; 0 aims at the other side of the Asian range.
`useMidnightOpen`	int	`1`	min 0, max 1	1 buys only below the midnight open and sells only above it, 0 ignores it.
`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 manipulation in your own strategy: a London bar that sweeps the Asian low
# and closes back inside, below the true day open.
k = ctx.ind("killzones")
m = ctx.ind("midnight_open")
bar = ctx.bars(1)[-1]
if k.london_open == 1 and k.asia_low is not None and m.open is not None:
    if bar.low < k.asia_low < bar.close < m.open:
        ctx.signal("LONG", sl_pips=20, tp_pips=40)

To run the whole template, install it, switch it on and pick Power of Three under Plugins in the strategy list. Run it on M5, M15 or M30 bars.

What it provides

power_of_three/power_of_threeStrategy The strategy, with its parameters: the stop buffer, the target, the midnight open filter, the risk per trade and the short side.

When values are known

The Asian range is complete at 24:00 New York, hours before London opens; a sweep is known at the close of its bar, and the trade opens at the next bar's open. 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 sweep is judged on one bar, beyond the range and back inside at its close; a sweep spread over several bars needs a change in the code.
Days without an Asia session in the data use the last Asian range there is.
Bank holidays and news are not known to the template. Spreads are wider in the Asian hours.

Preview

json{
  "asianRange": {
    "high": 1.0868,
    "low": 1.0841
  },
  "closeAt": "12:00 New York",
  "manipulation": "03:15 New York: low 1.0834, close 1.0846, below the midnight open 1.0852",
  "note": "Made-up example, not a real trade",
  "stop": 1.0832,
  "trade": "LONG at the next open"
}

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"""Power of Three: accumulation in Asia, manipulation in London, distribution in New York.

ICT's daily cycle, built from the market structure group of the indicator
catalogue (#546), each phase a catalogue element read with ctx.ind:

- Accumulation: the Asian range, the high and low of the Asia kill zone
  (20:00 to 24:00 New York), from `killzones`.
- Manipulation: in the London open kill zone (02:00 to 05:00 New York) a bar
  trades below the Asian low and closes back above it, a sweep of the range's
  sell side (the mirror, above the Asian high and back below, for a short).
  With `useMidnightOpen` the long also needs the close below the midnight open
  (`midnight_open`), so it buys at a discount to the true day open; a short
  needs it above.
- Distribution: the trade is opened at the close of that bar, at most one a
  day, with the stop `stopBufferPips` beyond the London low (high) so far and
  the target `targetR` times the stop distance, or with 0 the other side of
  the Asian range. Whatever is still open is closed when the London close kill
  zone ends, 12:00 New York.

The kill zones follow New York's clock through its daylight saving changes.
Run it on M5, M15 or M30 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.
"""

from orionquant_engine.strategy.base_strategy import Strategy

STRATEGY_ID = "power_of_three"

PARAMS = [
    {"key": "stopBufferPips", "label": "Stop beyond the London extreme (pips)", "type": "float", "default": 2.0,
     "min": 0, "max": 100},
    {"key": "targetR", "label": "Target (R, 0 the other side of the Asian range)", "type": "float", "default": 2.0,
     "min": 0, "max": 10},
    {"key": "useMidnightOpen", "label": "Buy below, sell above the midnight open (1 on, 0 off)", "type": "int",
     "default": 1, "min": 0, "max": 1},
    {"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 _target_pips(target_r, sl_pips, room, pip):
    """The target in pips: `targetR` times the stop, or with 0 the room to the
    other side of the Asian range; None when that side is not ahead."""
    if target_r > 0:
        return target_r * sl_pips
    if room > 0:
        return room / pip
    return None


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

    def __init__(self, params):
        # Each parameter clamped to its range in PARAMS, its default when absent.
        self.buffer_pips = min(max(float(params.get("stopBufferPips", 2.0)), 0.0), 100.0)
        self.target_r = min(max(float(params.get("targetR", 2.0)), 0.0), 10.0)
        self.use_open = min(max(int(params.get("useMidnightOpen", 1)), 0), 1)
        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)

        self.in_london = False
        self.in_close = False
        self.traded = False
        self.holding = False

    def on_bar(self, ctx):
        k = ctx.ind("killzones")
        m = ctx.ind("midnight_open")
        bars = ctx.bars(1)
        if not bars:
            return  # never: the hook runs once a bar is out
        bar = bars[-1]
        london = k.london_open == 1
        closing = k.london_close == 1
        if london and not self.in_london:
            # A new London open: the day's manipulation window, against the Asian range just finished.
            self.traded = False
        if self.holding and self.in_close and not closing:
            ctx.signal("EXIT")  # distribution is over with the London close kill zone
            self.holding = False
        self.in_london, self.in_close = london, closing
        if not london or self.traded or k.asia_high is None or k.asia_low is None:
            return

        # At the close of the manipulation bar: the stop beyond London's extreme so far.
        high, low, close = k.asia_high, k.asia_low, bar.close
        day_open = m.open
        pip = ctx.pip()
        buffer = self.buffer_pips * pip
        if bar.low < low < close:
            if self.use_open == 1 and (day_open is None or not close < day_open):
                return
            sl_pips = abs(close - (k.london_open_low - buffer)) / pip
            tp_pips = _target_pips(self.target_r, sl_pips, high - close, pip)
            if sl_pips <= 0 or tp_pips is None:
                return
            if self.risk_percent > 0:
                ctx.signal("LONG", sl_pips=sl_pips, tp_pips=tp_pips, risk_percent=self.risk_percent)
            else:
                ctx.signal("LONG", sl_pips=sl_pips, tp_pips=tp_pips)
            self.traded = True
            self.holding = True
        elif self.allow_short == 1 and close < high < bar.high:
            if self.use_open == 1 and (day_open is None or not close > day_open):
                return
            sl_pips = abs(close - (k.london_open_high + buffer)) / pip
            tp_pips = _target_pips(self.target_r, sl_pips, close - low, pip)
            if sl_pips <= 0 or tp_pips is None:
                return
            if self.risk_percent > 0:
                ctx.signal("SHORT", sl_pips=sl_pips, tp_pips=tp_pips, risk_percent=self.risk_percent)
            else:
                ctx.signal("SHORT", sl_pips=sl_pips, tp_pips=tp_pips)
            self.traded = True
            self.holding = True


def register(api):
    api.register_strategy(STRATEGY_ID, "Power of Three", PowerOfThree, PARAMS)