Español ES
Ver en GitHub

Gap Reversion Strategy

Overview

The Gap Reversion Strategy is a direct port of the MetaTrader 4 expert advisor gaps.mq4. The system monitors 15-minute candles and loo ks for opening gaps that occur outside the previous candle's high/low range. When such a gap appears, the strategy immediately e nters the market in the direction of the expected mean reversion move.

The StockSharp version follows the original logic while relying on the high-level candle subscription API. All trade management is done with market orders and no fixed protective orders are placed, mirroring the behaviour found in the MQL code.

Trading Rules

  1. Subscribe to 15-minute candles (configurable through the CandleType parameter).
  2. Keep the previous completed candle's high and low.
  3. When a new candle starts:
    • Calculate the gap buffer: (MinGapSize + spreadInSteps) * pointValue.
    • If the open price is above previousHigh + gapBuffer, open a short position.
    • If the open price is below previousLow - gapBuffer, open a long position.
  4. Only one trade per candle is allowed. Once an order is placed, the strategy waits for the next candle before generating a new s ignal.

The spread component uses the current best bid/ask if available. When no quote data is provided, the strategy falls back to a sin gle price step as a conservative buffer.

Parameters

Parameter Default Description
MinGapSize 1 Minimum gap size in price steps that must be exceeded before sending an order.
GapVolume 0.1 Order volume for market entries triggered by gaps.
CandleType 15m TimeFrame Candle type used for calculations (defaults to 15-minute candles).

All parameters are registered as StrategyParam<T> and support optimisation inside StockSharp Designer or other tools.

Implementation Notes

  • Uses SubscribeCandles with Bind to process finished candles only.
  • Remembers the previous candle's range to avoid recalculating data series.
  • Blocks duplicate orders on the same candle by tracking the open time of the bar that triggered the trade.
  • Chart output draws the subscribed candles and the strategy trades for quick visual inspection.

Differences from the MQL Version

  • Take-profit and stop-loss levels were not set correctly in the original EA (the MQL code passed values to the wrong parameters) . The StockSharp port therefore keeps the behaviour of running without protective orders.
  • Spread handling now checks real-time bid/ask quotes when available, providing a more adaptive buffer.

Requirements

  • StockSharp API with access to candle data for the selected instrument.
  • Level1 quotes are optional but improve spread detection.
using System;
using System.Collections.Generic;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Gap Reversion strategy - detects gap openings and trades mean reversion.
/// Buys when candle opens below previous low (gap down reversion).
/// Sells when candle opens above previous high (gap up reversion).
/// Uses EMA as trend filter for exits.
/// </summary>
public class GapReversionStrategy : Strategy
{
	private readonly StrategyParam<int> _emaPeriod;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _prevHigh;
	private decimal _prevLow;
	private bool _hasPrev;

	public int EmaPeriod { get => _emaPeriod.Value; set => _emaPeriod.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public GapReversionStrategy()
	{
		_emaPeriod = Param(nameof(EmaPeriod), 20)
			.SetDisplay("EMA Period", "EMA trend filter", "Indicators");

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Candle Type", "Candle timeframe", "General");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities() => [(Security, CandleType)];
	protected override void OnReseted() { base.OnReseted(); _prevHigh = 0m; _prevLow = 0m; _hasPrev = false; }

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_hasPrev = false;

		var ema = new ExponentialMovingAverage { Length = EmaPeriod };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(ema, ProcessCandle)
			.Start();

		StartProtection(
			takeProfit: new Unit(2, UnitTypes.Percent),
			stopLoss: new Unit(1, UnitTypes.Percent)
		);
	}

	private void ProcessCandle(ICandleMessage candle, decimal ema)
	{
		if (candle.State != CandleStates.Finished)
			return;

		if (!_hasPrev)
		{
			_prevHigh = candle.HighPrice;
			_prevLow = candle.LowPrice;
			_hasPrev = true;
			return;
		}

		var open = candle.OpenPrice;
		var close = candle.ClosePrice;

		// Gap down reversion - open below previous low, expect bounce
		if (open < _prevLow && close > ema && Position == 0)
			BuyMarket();
		// Gap up reversion - open above previous high, expect pullback
		else if (open > _prevHigh && close < ema && Position == 0)
			SellMarket();

		_prevHigh = candle.HighPrice;
		_prevLow = candle.LowPrice;
	}
}