Español ES
Ver en GitHub

Inverse Reaction Strategy

Overview

The Inverse Reaction strategy is a mean-reversion system inspired by the original MetaTrader expert advisor "IREA". It reacts to unusually large single-bar moves and anticipates an inverse reaction on the next bar. The strategy computes a dynamic confidence level from recent candle ranges and only trades when price swings exceed that level but stay within user-defined bounds. Only one position can be open at any time.

Trading Logic

  1. Inverse Reaction indicator – For every finished candle the strategy measures the open/close change and feeds its absolute value into a simple moving average of length MaPeriod. The averaged change is multiplied by Coefficient to form a dynamic threshold similar to the original indicator's Dynamic Confidence Level (DCL).
  2. Signal validation – The absolute open/close change of the latest candle must be greater than the dynamic threshold, greater than MinCriteriaPoints * PriceStep, and smaller than MaxCriteriaPoints * PriceStep. Signals are ignored if the previous candle already met the same condition, which mirrors the original expert advisor.
  3. Direction – A negative change (bearish candle) suggests a rebound to the upside, so a long position is opened. A positive change implies a bearish reversal expectation and triggers a short position. New trades are sent only when there is no existing position.
  4. Risk management – After entry, the strategy monitors subsequent candles. If the price touches the predefined stop-loss or take-profit levels (converted from points into absolute prices using the instrument's PriceStep), it immediately closes the open position using market orders. StartProtection() is also enabled to support built-in StockSharp protections.

Parameters

Parameter Description
StopLossPoints Stop-loss distance in points (multiplied by PriceStep).
TakeProfitPoints Take-profit distance in points.
TradeVolume Volume used for every market order.
SlippagePoints Informational setting that mirrors the MQL version; currently not applied to orders.
MinCriteriaPoints Minimum open/close distance (in points) required for a valid signal.
MaxCriteriaPoints Maximum allowed open/close distance (in points).
Coefficient Multiplier used to build the dynamic confidence threshold.
MaPeriod Length of the moving average used inside the indicator. Must be at least 3.
CandleType Timeframe of the processed candles (default: 1 hour).

Usage Guidelines

  • Ensure the selected instrument has a valid PriceStep. When unavailable, the strategy falls back to a step of 1.0, which may distort thresholds.
  • Adjust MinCriteriaPoints and MaxCriteriaPoints to match the volatility of the chosen timeframe. Too narrow a window will filter out most signals, while too wide a window will allow extremely large moves that may not revert.
  • The default Coefficient of 1.618 replicates the golden-ratio scaling from the original indicator. Higher values demand larger outlier candles before trading.
  • Because positions are closed by market orders on the next candle close that breaches the stop or target levels, real execution may differ from the exact limit levels. Consider testing with intraday data for more precise control if necessary.
  • Only one position is held at a time. The strategy will wait for the current trade to close before reacting to a new signal.

Notes

  • Backtest the configuration on historical data before using it live. The original EA was designed for FX markets; parameter tuning may be required for other assets.
  • The SlippagePoints parameter is preserved for completeness but intentionally unused because StockSharp handles slippage differently from MetaTrader.
  • Make sure that MaPeriod stays at or above 3; smaller values were prohibited in the original implementation and may lead to unstable thresholds.
using System;
using System.Linq;
using System.Collections.Generic;

using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Strategy that reacts to large single-bar moves expecting a mean reversion.
/// </summary>
public class InverseReactionStrategy : Strategy
{
	private readonly StrategyParam<decimal> _stopLossPoints;
	private readonly StrategyParam<decimal> _takeProfitPoints;
	private readonly StrategyParam<decimal> _coefficient;
	private readonly StrategyParam<int> _maPeriod;
	private readonly StrategyParam<DataType> _candleType;

	private readonly List<decimal> _absChanges = new();

	public decimal StopLossPoints { get => _stopLossPoints.Value; set => _stopLossPoints.Value = value; }
	public decimal TakeProfitPoints { get => _takeProfitPoints.Value; set => _takeProfitPoints.Value = value; }
	public decimal Coefficient { get => _coefficient.Value; set => _coefficient.Value = value; }
	public int MaPeriod { get => _maPeriod.Value; set => _maPeriod.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public InverseReactionStrategy()
	{
		_stopLossPoints = Param(nameof(StopLossPoints), 1000m)
			.SetGreaterThanZero()
			.SetDisplay("Stop Loss", "Stop-loss distance in points", "Risk");

		_takeProfitPoints = Param(nameof(TakeProfitPoints), 250m)
			.SetGreaterThanZero()
			.SetDisplay("Take Profit", "Take-profit distance in points", "Risk");

		_coefficient = Param(nameof(Coefficient), 1.618m)
			.SetGreaterThanZero()
			.SetDisplay("Coefficient", "Confidence coefficient", "Signal");

		_maPeriod = Param(nameof(MaPeriod), 3)
			.SetGreaterThanZero()
			.SetDisplay("MA Period", "Moving average length", "Signal");

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

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	protected override void OnReseted()
	{
		base.OnReseted();
		_absChanges.Clear();
	}

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

		var step = Security?.PriceStep ?? 1m;
		if (step <= 0m) step = 1m;

		StartProtection(
			takeProfit: new Unit(TakeProfitPoints * step, UnitTypes.Absolute),
			stopLoss: new Unit(StopLossPoints * step, UnitTypes.Absolute),
			useMarketOrders: true);

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

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

		var change = candle.ClosePrice - candle.OpenPrice;
		var absChange = Math.Abs(change);

		_absChanges.Add(absChange);
		if (_absChanges.Count > MaPeriod)
			_absChanges.RemoveAt(0);

		if (_absChanges.Count < MaPeriod)
			return;

		var avg = 0m;
		for (int i = 0; i < _absChanges.Count; i++)
			avg += _absChanges[i];
		avg /= _absChanges.Count;

		var threshold = avg * Coefficient;

		if (Position != 0)
			return;

		if (absChange > threshold && absChange > 0m)
		{
			if (change < 0m)
			{
				// Large bearish bar => expect reversion upward
				BuyMarket();
			}
			else
			{
				// Large bullish bar => expect reversion downward
				SellMarket();
			}
		}
	}
}