Português
Ver no GitHub

Estratégia de Scalper de Tendências (API/3858)

Visão geral

O TrendScalperStrategy é uma conversão C# do MetaTrader 4 consultor especialista Currencyprofits_01_1.mq4. O robô original é um scalper leve que segue tendências que combina um filtro cruzado EMA/SMA de curto prazo com entradas de breakout em torno dos máximos e mínimos de oscilação mais recentes. A porta StockSharp mantém as mesmas regras de decisão enquanto adota a assinatura de vela de alto nível e o pipeline de indicadores da estrutura.

Lógica de negociação

  1. Indicadores
    • EMA rápida (padrão 6) em preços de fechamento.
    • Lento SMA (padrão 12) em preços de fechamento.
    • Máximo mais alto (janela padrão 6) e Mínimo mais baixo (janela padrão 6) calculados a partir dos máximos e mínimos da vela.
  2. Condições de entrada
    • Longo: o preço atinge a banda baixa recente (Lowest Low) enquanto o EMA rápida está acima do lento SMA. A estratégia envia uma ordem de compra a mercado com o volume definido pela regra de gestão de dinheiro.
    • Venda: o preço toca a banda alta recente (Highest High) enquanto a rápida EMA está abaixo da lenta SMA. Uma ordem de venda a mercado é colocada usando o mesmo cálculo de volume.
    • O sistema permanece estável enquanto uma posição está aberta, refletindo o comportamento de ordem única da versão MQL.
  3. Exit Conditions
    • Saída longa: quando uma posição longa aberta vê a máxima da vela quebrar o registrado Highest High, a posição é fechada no mercado.
    • Saída curta: quando uma posição curta aberta observa a queda da mínima da vela através do Lowest Low, a venda é coberta no mercado.
    • Um stop-loss protetor gerenciado por StartProtection é anexado a cada negociação quando StopLossPoints é maior que zero.

Gestão de capital

A lógica de dimensionamento de lote reproduz os três modos expostos no script MQL:

Modo Descrição Comportamento no porto
0 Lotes fixos (LotsIfNoMM). Retorna o FixedVolume configurado.
<0 Lotes fracionários calculados a partir do saldo da conta e do fator de risco. Calcula ceil(balance * risk / 10000) / 10, limitado a 100 lotes.
>0 Dimensionamento total a partir do equilíbrio e do fator de risco. Usa a mesma fórmula base, mas o resultado é arredondado para o próximo número inteiro, com limite mínimo de 1 lote e limite de 100.

O saldo é retirado de Portfolio.CurrentValue (voltando para BeginValue). Caso o valor da carteira não esteja disponível, a estratégia reverte para o volume fixo para que as ordens ainda sejam emitidas durante os backtests.

Gestão de risco

  • Stop-loss: o parâmetro StopLossPoints é expresso em pontos de preço (pips). Durante OnStarted a distância é multiplicada por Security.PriceStep e passada para StartProtection, permitindo que StockSharp mantenha a ordem de proteção.
  • Posição única: a lógica aplica Position == 0 antes de abrir uma nova negociação, evitando posições sobrepostas exatamente como o especialista MT4.

Parâmetros

Nome Padrão Descrição
CandleType Período de 15 minutos Série de velas usada para cálculos de indicadores e sinais.
FastLength 6 Período do EMA rápida.
SlowLength 12 Período da lentidão SMA.
BreakoutWindow 6 Número de velas inspecionadas para o filtro de fuga mais alto/mais baixo.
FixedVolume 0,1 lote Volume quando o gerenciamento de dinheiro está desativado ou é necessário um substituto.
MoneyManagementMode 0 Seleciona entre tamanho de lote fixo, fracionário ou arredondado.
MoneyManagementRisk 40 Multiplicador de fator de risco usado no dimensionamento de lote baseado em saldo.
StopLossPoints 50 Distância de stop-loss em pontos de preço (convertido em preço absoluto antes de chamar StartProtection).

Notas de implementação

  • O encadeamento de indicadores depende do fluxo de trabalho de alto nível SubscribeCandles().Bind(...); nenhum buffer de série manual é necessário.
  • Comentários no código foram adicionados em inglês para corresponder às diretrizes do repositório.
  • Nenhum teste unitário foi modificado; o foco desta conversão é a estratégia e a documentação que a acompanha.

Dicas de uso

  • Selecione um intervalo de velas que corresponda ao ambiente de negociação original (por exemplo, prazos intradiários curtos para scalping).
  • Certifique-se de que o portfólio tenha um PriceStep válido para que a conversão de stop loss em preço absoluto funcione corretamente.
  • Ajuste MoneyManagementRisk com cuidado: valores mais altos levam a posições maiores devido ao cálculo ceil(balance * risk / 10000) herdado do especialista MQL.

Janela exata de sinal: o maior máximo e o menor mínimo vêm dos anteriores BreakoutWindow candles concluídos, excluindo o atual. Compra: EMA(FastLength) > SMA(SlowLength) e currentLow <= previousWindowLow; venda: tendência oposta e currentHigh >= previousWindowHigh. Fecha long em currentHigh > previousWindowHigh e short em currentLow < previousWindowLow. É necessário aquecimento completo de ambos indicadores e canal. Com StopLossPoints > 0, StartProtection configura proteção efetiva.

namespace StockSharp.Samples.Strategies;

using System;
using System.Collections.Generic;
using System.Linq;

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

/// <summary>
/// Fast EMA versus slow SMA direction filtered by a sweep of the previous
/// candle-high/low band. Independent natural exits and a native stop protect fills.
/// </summary>
public class TrendScalperStrategy : Strategy
{
	private readonly StrategyParam<int> _fastLength;
	private readonly StrategyParam<int> _slowLength;
	private readonly StrategyParam<int> _breakoutWindow;
	private readonly StrategyParam<decimal> _fixedVolume;
	private readonly StrategyParam<int> _moneyManagementMode;
	private readonly StrategyParam<decimal> _moneyManagementRisk;
	private readonly StrategyParam<decimal> _stopLossPoints;
	private readonly StrategyParam<DataType> _candleType;

	private readonly Queue<decimal> _fastSeed = new();
	private readonly Queue<decimal> _slowCloses = new();
	private readonly Queue<decimal> _highs = new();
	private readonly Queue<decimal> _lows = new();
	private decimal? _fastEma;
	private Order _pendingOrder;

	public int FastLength { get => _fastLength.Value; set => _fastLength.Value = value; }
	public int SlowLength { get => _slowLength.Value; set => _slowLength.Value = value; }
	public int BreakoutWindow { get => _breakoutWindow.Value; set => _breakoutWindow.Value = value; }
	public decimal FixedVolume { get => _fixedVolume.Value; set => _fixedVolume.Value = value; }
	public int MoneyManagementMode { get => _moneyManagementMode.Value; set => _moneyManagementMode.Value = value; }
	public decimal MoneyManagementRisk { get => _moneyManagementRisk.Value; set => _moneyManagementRisk.Value = value; }
	public decimal StopLossPoints { get => _stopLossPoints.Value; set => _stopLossPoints.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public TrendScalperStrategy()
	{
		_fastLength = Param(nameof(FastLength), 6).SetGreaterThanZero();
		_slowLength = Param(nameof(SlowLength), 12).SetGreaterThanZero();
		_breakoutWindow = Param(nameof(BreakoutWindow), 6).SetGreaterThanZero();
		_fixedVolume = Param(nameof(FixedVolume), 0.1m).SetGreaterThanZero();
		_moneyManagementMode = Param(nameof(MoneyManagementMode), 0);
		_moneyManagementRisk = Param(nameof(MoneyManagementRisk), 40m).SetNotNegative();
		_stopLossPoints = Param(nameof(StopLossPoints), 50m).SetNotNegative();
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(15).TimeFrame());
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
		=> [(Security, CandleType), (Security, DataType.Level1)];

	protected override void OnReseted()
	{
		base.OnReseted();
		ClearState();
	}

	private void ClearState()
	{
		_fastSeed.Clear();
		_slowCloses.Clear();
		_highs.Clear();
		_lows.Clear();
		_fastEma = null;
		_pendingOrder = null;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		ClearState();
		var step = Security?.PriceStep ?? 0m;
		if (step <= 0m)
			throw new InvalidOperationException("Trend Scalper requires a positive PriceStep.");

		if (StopLossPoints > 0m)
		{
			StartProtection(new Unit(), new Unit(StopLossPoints * step, UnitTypes.Absolute),
				useMarketOrders: true, isLocalStop: true);
			foreach (var field in new[] { Level1Fields.BestBidPrice, Level1Fields.BestAskPrice })
			{
				var quotes = new Subscription(DataType.Level1, Security);
				quotes.MarketData.BuildField = field;
				SubscribeLevel1(quotes).Bind(ObserveQuote).Start();
			}
		}
		SubscribeCandles(CandleType).Bind(ProcessCandle).Start();
	}

	private void ObserveQuote(Level1ChangeMessage message)
	{
		// A Level1 stream is needed for native stop processing between candle closes.
	}

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

		var hasBand = _highs.Count == BreakoutWindow;
		var bandHigh = hasBand ? _highs.Max() : 0m;
		var bandLow = hasBand ? _lows.Min() : 0m;
		_highs.Enqueue(candle.HighPrice);
		_lows.Enqueue(candle.LowPrice);
		while (_highs.Count > BreakoutWindow) _highs.Dequeue();
		while (_lows.Count > BreakoutWindow) _lows.Dequeue();

		var price = candle.ClosePrice;
		if (_fastEma is null)
		{
			_fastSeed.Enqueue(price);
			if (_fastSeed.Count == FastLength)
				_fastEma = _fastSeed.Average();
		}
		else
			_fastEma += (price - _fastEma.Value) * 2m / (FastLength + 1);

		_slowCloses.Enqueue(price);
		while (_slowCloses.Count > SlowLength)
			_slowCloses.Dequeue();
		if (!hasBand || _fastEma is null || _slowCloses.Count < SlowLength ||
			_pendingOrder is not null && _pendingOrder.State is not (OrderStates.Done or OrderStates.Failed))
			return;

		if (Position > 0m && candle.HighPrice > bandHigh)
		{
			Submit(Sides.Sell, Position, "Trend scalper band exit");
			return;
		}
		if (Position < 0m && candle.LowPrice < bandLow)
		{
			Submit(Sides.Buy, Math.Abs(Position), "Trend scalper band exit");
			return;
		}
		if (Position != 0m)
			return;

		var slow = _slowCloses.Average();
		if (_fastEma > slow && candle.LowPrice <= bandLow)
			Enter(Sides.Buy);
		else if (_fastEma < slow && candle.HighPrice >= bandHigh)
			Enter(Sides.Sell);
	}

	private void Enter(Sides side)
	{
		var volume = CalculateOrderVolume();
		if (volume > 0m)
			Submit(side, volume, "Trend scalper entry");
	}

	private decimal CalculateOrderVolume()
	{
		var volume = FixedVolume;
		if (MoneyManagementMode != 0)
		{
			var balance = Portfolio?.CurrentValue ?? Portfolio?.BeginValue ?? 0m;
			if (balance > 0m)
			{
				var fractional = Math.Ceiling(balance * MoneyManagementRisk / 10000m) / 10m;
				volume = MoneyManagementMode > 0 ? Math.Max(1m, Math.Ceiling(fractional)) : fractional;
				volume = Math.Min(volume, 100m);
			}
		}
		if (Security?.VolumeStep is decimal step && step > 0m)
			volume = decimal.Floor(volume / step) * step;
		if (Security?.MinVolume is decimal min && min > 0m)
			volume = Math.Max(volume, min);
		if (Security?.MaxVolume is decimal max && max > 0m)
			volume = Math.Min(volume, max);
		return volume;
	}

	private void Submit(Sides side, decimal volume, string comment)
	{
		_pendingOrder = new Order
		{
			Security = Security,
			Portfolio = Portfolio,
			Type = OrderTypes.Market,
			Side = side,
			Volume = volume,
			Comment = comment,
		};
		RegisterOrder(_pendingOrder);
	}
}