View on GitHub

MartingaleEA-5 Levels Strategy (StockSharp)

The MartingaleEA-5 Levels Strategy is a direct port of the MetaTrader 5 expert advisor "MartingaleEA-5 Levels" to the StockSharp high-level API. The system supervises an existing position and builds a five-step averaging grid whenever the market moves against it. All logic runs on finished candles, which keeps the behaviour reproducible in both historical tests and live trading.

Trading Logic

Monitoring existing exposure – the strategy expects an initial long or short position to be present. You can open the first trade manually or through any other strategy.
Adverse-move detection – on each completed candle the strategy measures how far the current price has travelled away from the worst-priced entry of the active group (highest long or lowest short).
Martingale additions – if the floating loss on the group is negative and the adverse move exceeds the configured cumulative distances, the strategy sends extra market orders. Each additional order multiplies the previous one by VolumeMultiplier. Up to five levels can be configured; the MaxAdditions parameter limits how many of them are actually used.
Profit and loss targeting – while a group is open the strategy continuously sums the unrealised PnL for that direction. Once the total reaches TakeProfitCurrency or drops below StopLossCurrency, all orders on that side are closed with a market order and the martingale counters are reset.
Volume normalisation – every order volume goes through the instrument's VolumeStep, MinVolume, and MaxVolume to avoid sending non-executable quantities.

Parameters

Name	Description	Default
`EnableMartingale`	Turns the averaging and liquidation logic on or off.	`true`
`VolumeMultiplier`	Factor applied to the previous order volume when adding a new level.	`2.0`
`MaxAdditions`	Maximum number of martingale steps per direction (up to five).	`4`
`Level1DistancePips`	Initial adverse distance (in pips) before opening the second order.	`300`
`Level2DistancePips`	Additional distance required for the third order.	`400`
`Level3DistancePips`	Additional distance required for the fourth order.	`500`
`Level4DistancePips`	Additional distance required for the fifth order.	`600`
`Level5DistancePips`	Additional distance required for the sixth order (if allowed).	`700`
`TakeProfitCurrency`	Unrealised profit (account currency) that closes the whole group.	`200`
`StopLossCurrency`	Unrealised loss (account currency) that forces an emergency exit.	`-500`
`CandleType`	Timeframe used for evaluations (default 1-minute candles).	`TimeFrame(1m)`

Pip conversion – every distance is multiplied by the instrument price step (PriceStep or MinPriceStep). For symbols quoted in fractional pips adjust the values accordingly.

Notes and Recommendations

The implementation mirrors the original EA, including its assumption that only one directional basket is active at a time. Opening positions simultaneously in both directions will cause each side to be managed independently.
Because the strategy reacts only on candle closes, choose a timeframe that matches the desired responsiveness. Lower timeframes emulate tick-level behaviour more closely.
Martingale techniques amplify risk. Always backtest with realistic slippage and commission models and define conservative stop levels before enabling the strategy on live markets.
The strategy does not create a Python port yet. Only the C# high-level implementation is included as requested.

using System;
using System.Collections.Generic;

using Ecng.Common;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Martingale averaging strategy converted from "MartingaleEA-5 Levels".
/// Opens initial position on simple momentum, then averages down with
/// increasing lot sizes up to 5 levels. Closes when floating profit
/// reaches target or stop threshold.
/// </summary>
public class MartingaleEa5LevelsStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _maPeriod;
	private readonly StrategyParam<decimal> _volumeMultiplier;
	private readonly StrategyParam<int> _maxAdditions;
	private readonly StrategyParam<decimal> _takeProfitPercent;
	private readonly StrategyParam<decimal> _stopLossPercent;

	private SimpleMovingAverage _sma;
	private decimal? _prevClose;
	private decimal? _prevMa;

	private readonly List<(decimal price, decimal vol)> _entries = new();
	private int _additions;
	private decimal _lastVolume;
	private Sides? _activeSide;
	private int _candleCount;
	private int _lastOrderCandle;

	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	public int MaPeriod
	{
		get => _maPeriod.Value;
		set => _maPeriod.Value = value;
	}

	public decimal VolumeMultiplier
	{
		get => _volumeMultiplier.Value;
		set => _volumeMultiplier.Value = value;
	}

	public int MaxAdditions
	{
		get => _maxAdditions.Value;
		set => _maxAdditions.Value = value;
	}

	public decimal TakeProfitPercent
	{
		get => _takeProfitPercent.Value;
		set => _takeProfitPercent.Value = value;
	}

	public decimal StopLossPercent
	{
		get => _stopLossPercent.Value;
		set => _stopLossPercent.Value = value;
	}

	public MartingaleEa5LevelsStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe", "General");

		_maPeriod = Param(nameof(MaPeriod), 20)
			.SetGreaterThanZero()
			.SetDisplay("MA Period", "SMA period for entry signal", "Indicators");

		_volumeMultiplier = Param(nameof(VolumeMultiplier), 2m)
			.SetGreaterThanZero()
			.SetDisplay("Volume Multiplier", "Multiplier for each martingale level", "Money Management");

		_maxAdditions = Param(nameof(MaxAdditions), 4)
			.SetDisplay("Max Additions", "Maximum martingale additions", "Money Management");

		_takeProfitPercent = Param(nameof(TakeProfitPercent), 0.5m)
			.SetGreaterThanZero()
			.SetDisplay("Take Profit %", "Floating profit % to close group", "Risk");

		_stopLossPercent = Param(nameof(StopLossPercent), 2m)
			.SetGreaterThanZero()
			.SetDisplay("Stop Loss %", "Floating loss % to close group", "Risk");
	}

	protected override void OnReseted()
	{
		base.OnReseted();
		_sma = default;
		_prevClose = null;
		_prevMa = null;
		_entries.Clear();
		_additions = 0;
		_lastVolume = 0;
		_activeSide = null;
		_candleCount = 0;
		_lastOrderCandle = 0;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_sma = new SimpleMovingAverage { Length = MaPeriod };
		_prevClose = null;
		_prevMa = null;
		_entries.Clear();
		_additions = 0;
		_lastVolume = 0;
		_activeSide = null;
		_candleCount = 0;
		_lastOrderCandle = 0;

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(_sma, ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, _sma);
			DrawOwnTrades(area);
		}
	}

	private void ProcessCandle(ICandleMessage candle, decimal smaValue)
	{
		if (candle.State != CandleStates.Finished)
			return;

		if (!_sma.IsFormed)
		{
			_prevClose = candle.ClosePrice;
			_prevMa = smaValue;
			return;
		}

		_candleCount++;

		var close = candle.ClosePrice;
		var volume = Volume;
		if (volume <= 0)
			volume = 1;

		// Cooldown: allow at most one order per 100 candles
		var cooldownPassed = (_candleCount - _lastOrderCandle) >= 100;

		// Check martingale closure first
		if (_entries.Count > 0)
		{
			var floatingPnl = CalculateFloatingPnl(close);
			var totalCost = CalculateTotalCost();

			if (totalCost > 0)
			{
				var pnlPercent = floatingPnl / totalCost * 100m;

				if (cooldownPassed && (pnlPercent >= TakeProfitPercent || pnlPercent <= -StopLossPercent))
				{
					// Close entire position
					if (Position > 0)
						SellMarket(Position);
					else if (Position < 0)
						BuyMarket(Math.Abs(Position));

					_lastOrderCandle = _candleCount;
					_entries.Clear();
					_additions = 0;
					_lastVolume = 0;
					_activeSide = null;

					_prevClose = close;
					_prevMa = smaValue;
					return;
				}
			}

			// Check for martingale additions
			if (cooldownPassed && _additions < MaxAdditions)
			{
				var avgPrice = CalculateAvgPrice();
				var adversePercent = _activeSide == Sides.Buy
					? (avgPrice - close) / avgPrice * 100m
					: (close - avgPrice) / avgPrice * 100m;

				// Add at each 0.3% adverse move beyond previous level
				var threshold = 0.3m * (_additions + 1);
				if (adversePercent >= threshold)
				{
					var nextVol = _lastVolume * VolumeMultiplier;
					if (nextVol < 1) nextVol = 1;

					if (_activeSide == Sides.Buy)
					{
						BuyMarket(nextVol);
						_entries.Add((close, nextVol));
					}
					else
					{
						SellMarket(nextVol);
						_entries.Add((close, nextVol));
					}

					_lastVolume = nextVol;
					_additions++;
					_lastOrderCandle = _candleCount;
				}
			}
		}

		// Initial entry signal: MA crossover
		if (cooldownPassed && _prevClose != null && _prevMa != null && _activeSide == null)
		{
			var buySignal = _prevClose.Value < _prevMa.Value && close > smaValue;
			var sellSignal = _prevClose.Value > _prevMa.Value && close < smaValue;

			if (buySignal)
			{
				BuyMarket(volume);
				_entries.Clear();
				_entries.Add((close, volume));
				_additions = 0;
				_lastVolume = volume;
				_activeSide = Sides.Buy;
				_lastOrderCandle = _candleCount;
			}
			else if (sellSignal)
			{
				SellMarket(volume);
				_entries.Clear();
				_entries.Add((close, volume));
				_additions = 0;
				_lastVolume = volume;
				_activeSide = Sides.Sell;
				_lastOrderCandle = _candleCount;
			}
		}

		_prevClose = close;
		_prevMa = smaValue;
	}

	private decimal CalculateFloatingPnl(decimal currentPrice)
	{
		var pnl = 0m;
		foreach (var (price, vol) in _entries)
		{
			if (_activeSide == Sides.Buy)
				pnl += (currentPrice - price) * vol;
			else
				pnl += (price - currentPrice) * vol;
		}
		return pnl;
	}

	private decimal CalculateTotalCost()
	{
		var cost = 0m;
		foreach (var (price, vol) in _entries)
			cost += price * vol;
		return cost;
	}

	private decimal CalculateAvgPrice()
	{
		var totalVol = 0m;
		var totalCost = 0m;
		foreach (var (price, vol) in _entries)
		{
			totalVol += vol;
			totalCost += price * vol;
		}
		return totalVol > 0 ? totalCost / totalVol : 0;
	}
}

import clr

clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")

from System import TimeSpan
from StockSharp.Messages import DataType, CandleStates
from StockSharp.Algo.Indicators import SimpleMovingAverage
from StockSharp.Algo.Strategies import Strategy

class martingale_ea_5_levels_strategy(Strategy):
    """
    Martingale EA 5 Levels: SMA crossover entry (simplified, no martingale averaging in Python).
    """

    def __init__(self):
        super(martingale_ea_5_levels_strategy, self).__init__()
        self._ma_period = self.Param("MaPeriod", 20).SetDisplay("MA Period", "SMA period", "Indicators")
        self._take_profit_pct = self.Param("TakeProfitPercent", 0.5).SetDisplay("TP %", "Take profit percent", "Risk")
        self._stop_loss_pct = self.Param("StopLossPercent", 2.0).SetDisplay("SL %", "Stop loss percent", "Risk")
        self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromMinutes(5))).SetDisplay("Candle Type", "Candles", "General")

        self._prev_close = None
        self._prev_ma = None
        self._entry_price = 0.0

    @property
    def candle_type(self):
        return self._candle_type.Value

    def OnReseted(self):
        super(martingale_ea_5_levels_strategy, self).OnReseted()
        self._prev_close = None
        self._prev_ma = None
        self._entry_price = 0.0

    def OnStarted2(self, time):
        super(martingale_ea_5_levels_strategy, self).OnStarted2(time)
        sma = SimpleMovingAverage()
        sma.Length = self._ma_period.Value
        subscription = self.SubscribeCandles(self.candle_type)
        subscription.Bind(sma, self._process_candle).Start()
        area = self.CreateChartArea()
        if area is not None:
            self.DrawCandles(area, subscription)
            self.DrawIndicator(area, sma)
            self.DrawOwnTrades(area)

    def _process_candle(self, candle, sma_val):
        if candle.State != CandleStates.Finished:
            return
        close = float(candle.ClosePrice)
        ma = float(sma_val)
        tp_pct = float(self._take_profit_pct.Value) / 100.0
        sl_pct = float(self._stop_loss_pct.Value) / 100.0
        if self.Position > 0 and self._entry_price > 0:
            if close >= self._entry_price * (1.0 + tp_pct) or close <= self._entry_price * (1.0 - sl_pct):
                self.SellMarket()
                self._entry_price = 0.0
                self._prev_close = close
                self._prev_ma = ma
                return
        elif self.Position < 0 and self._entry_price > 0:
            if close <= self._entry_price * (1.0 - tp_pct) or close >= self._entry_price * (1.0 + sl_pct):
                self.BuyMarket()
                self._entry_price = 0.0
                self._prev_close = close
                self._prev_ma = ma
                return
        if self._prev_close is not None and self._prev_ma is not None and self.Position == 0:
            if self._prev_close < self._prev_ma and close > ma:
                self.BuyMarket()
                self._entry_price = close
            elif self._prev_close > self._prev_ma and close < ma:
                self.SellMarket()
                self._entry_price = close
        self._prev_close = close
        self._prev_ma = ma

    def CreateClone(self):
        return martingale_ea_5_levels_strategy()