English EN
View on GitHub

TST Pullback Reversal Strategy

Overview

The TST Pullback Reversal Strategy watches for aggressive intrabar reversals. It was converted from the original MetaTrader 4 expert advisor TST.mq4 and rebuilt using the high-level StockSharp API. The method looks for candles where price has pulled sharply away from the candle open after setting an intraday extreme, then fades that move expecting mean reversion. The strategy trades both long and short and uses static stop-loss and take-profit levels measured in price steps.

Signal Logic

  • Long setup

    1. The candle closes below its open (Open > Close).
    2. The distance between the candle high and the close is greater than GapPoints * PriceStep.
    3. No trade was executed earlier on the same bar. When satisfied, the strategy closes any short exposure and buys OrderVolume units (plus the size required to flip from a short to a long position).

  • Short setup

    1. The candle closes above its open (Close > Open).
    2. The distance between the close and the candle low is greater than GapPoints * PriceStep.
    3. No trade was executed earlier on the same bar. When satisfied, the strategy closes any long exposure and sells OrderVolume units (plus the size required to flip from a long to a short position).

Position Management

  • A new trade immediately assigns static stop-loss and take-profit levels calculated from the fill price and the StopLossPoints/TakeProfitPoints parameters.
  • On each finished candle the strategy checks the candle's high/low to see whether the stop or target was touched and exits the position if triggered. Stop-loss checks take precedence over take-profit checks.
  • After an exit the stored risk levels are cleared, but the strategy still remembers the bar time to avoid re-entering during the same candle (reproducing the NevBar() guard from the MQL4 version).

Parameters

  • StopLossPoints (default 500): distance from entry to the protective stop, expressed in price steps.
  • TakeProfitPoints (default 100): distance from entry to the profit target, expressed in price steps.
  • GapPoints (default 500): minimum pullback between the candle extreme and the close required to generate a signal.
  • OrderVolume (default 0.1): quantity sent with every new market order.
  • CandleType (default 1 hour): timeframe of the candles supplied through SubscribeCandles.

All distance-based settings are multiplied by the instrument's PriceStep. If the security does not report a step the strategy falls back to 1.

Implementation Notes

  • The conversion uses StockSharp's high-level API and does not create custom indicator collections.
  • Only finished candles are processed to stay compatible with the Strategy Designer; this approximates the intrabar decisions of the MT4 robot by using completed bar data.
  • A dedicated flag _lastSignalBarTime replicates the NevBar() guard from the MQL4 code so that only one order can be opened per candle.
  • Order volume handling mirrors the MT4 behaviour: existing opposite positions are flattened before establishing the new direction in a single market order.
  • Stop-loss and take-profit orders are simulated inside the strategy logic (instead of server-side orders) to match the original distances while keeping control within StockSharp.

Usage Tips

  • Choose GapPoints relative to the volatility of the traded instrument; larger values reduce trade frequency but filter smaller pullbacks.
  • Because stop and target checks rely on finished candles, consider using shorter candle durations if you need tighter execution.
  • Combine the strategy with additional filters (trend, time of day, volume) when deploying to live markets to reduce whipsaw trades.
using System;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// TST Pullback Reversal: buys after deep pullback from candle high,
/// sells after rally from candle low. Uses ATR for thresholds.
/// </summary>
public class TstStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _atrLength;
	private readonly StrategyParam<decimal> _pullbackMultiplier;
	private readonly StrategyParam<decimal> _stopMultiplier;
	private readonly StrategyParam<decimal> _takeMultiplier;

	private decimal _entryPrice;
	private decimal _stopPrice;
	private decimal _takePrice;

	public TstStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(15).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe.", "General");

		_atrLength = Param(nameof(AtrLength), 14)
			.SetDisplay("ATR Length", "ATR period.", "Indicators");

		_pullbackMultiplier = Param(nameof(PullbackMultiplier), 0.5m)
			.SetDisplay("Pullback Mult", "ATR multiplier for pullback threshold.", "Signals");

		_stopMultiplier = Param(nameof(StopMultiplier), 2.0m)
			.SetDisplay("Stop Mult", "ATR multiplier for stop loss.", "Risk");

		_takeMultiplier = Param(nameof(TakeMultiplier), 1.0m)
			.SetDisplay("Take Mult", "ATR multiplier for take profit.", "Risk");
	}

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

	public int AtrLength
	{
		get => _atrLength.Value;
		set => _atrLength.Value = value;
	}

	public decimal PullbackMultiplier
	{
		get => _pullbackMultiplier.Value;
		set => _pullbackMultiplier.Value = value;
	}

	public decimal StopMultiplier
	{
		get => _stopMultiplier.Value;
		set => _stopMultiplier.Value = value;
	}

	public decimal TakeMultiplier
	{
		get => _takeMultiplier.Value;
		set => _takeMultiplier.Value = value;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_entryPrice = 0;
		_stopPrice = 0;
		_takePrice = 0;

		var atr = new AverageTrueRange { Length = AtrLength };

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

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawOwnTrades(area);
		}
	}

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

		if (atrVal <= 0)
			return;

		var close = candle.ClosePrice;
		var open = candle.OpenPrice;
		var high = candle.HighPrice;
		var low = candle.LowPrice;
		var threshold = atrVal * PullbackMultiplier;
		var stopDist = atrVal * StopMultiplier;
		var takeDist = atrVal * TakeMultiplier;

		// Risk management
		if (Position > 0)
		{
			if (_stopPrice > 0 && close <= _stopPrice)
			{
				SellMarket();
				_entryPrice = 0;
				_stopPrice = 0;
				_takePrice = 0;
				return;
			}
			if (_takePrice > 0 && close >= _takePrice)
			{
				SellMarket();
				_entryPrice = 0;
				_stopPrice = 0;
				_takePrice = 0;
				return;
			}
		}
		else if (Position < 0)
		{
			if (_stopPrice > 0 && close >= _stopPrice)
			{
				BuyMarket();
				_entryPrice = 0;
				_stopPrice = 0;
				_takePrice = 0;
				return;
			}
			if (_takePrice > 0 && close <= _takePrice)
			{
				BuyMarket();
				_entryPrice = 0;
				_stopPrice = 0;
				_takePrice = 0;
				return;
			}
		}

		// Entry: deep pullback from high = buy reversal
		if (Position == 0)
		{
			if (open > close && high - close > threshold)
			{
				_entryPrice = close;
				_stopPrice = close - stopDist;
				_takePrice = close + takeDist;
				BuyMarket();
			}
			else if (close > open && close - low > threshold)
			{
				_entryPrice = close;
				_stopPrice = close + stopDist;
				_takePrice = close - takeDist;
				SellMarket();
			}
		}
	}
}