Português PT
Ver no GitHub

Estratégia ScalpWiz 9001

Visão geral

ScalpWiz 9001 é um sistema de scalping de rompimento em camadas que replica o comportamento do consultor especialista MetaTrader do mesmo nome. A estratégia mede o quanto a última vela fecha além do envelope das Bandas de Bollinger e, quando a volatilidade expande bruscamente, implanta uma grade de ordens stop pendentes acima ou abaixo do mercado. O módulo de gerenciamento de dinheiro original é preservado: cada ordem pendente pode usar um lote fixo ou arriscar uma porcentagem configurável do patrimônio da conta.

Uma vez que uma das ordens stop é executada, as ordens restantes são canceladas, enquanto a posição ativa é protegida com um stop-loss tradicional, take-profit e um componente de trailing que só começa a seguir após um buffer adicional ser alcançado. A estratégia é destinada ao scalping de alta frequência em períodos mais baixos, mas pode ser executada em qualquer instrumento suportado pelo StockSharp.

Lógica de sinal

  1. Assinar o período configurado e calcular as Bandas de Bollinger de 20 períodos com fator de desvio BandsDeviation (padrão 2).
  2. Verificar o quanto o preço de fechamento está da banda superior ou inferior. Quando o fechamento supera a banda em pelo menos a distância do quarto nível (Level3Pips convertido para preço), a estratégia se prepara para desaparecer o movimento:
    • Fechamento acima da banda superior → colocar ordens sell-stop abaixo do mercado.
    • Fechamento abaixo da banda inferior → colocar ordens buy-stop acima do mercado.
  3. Quatro ordens pendentes são colocadas em distâncias crescentes (Level0Pips … Level3Pips). Cada ordem usa o volume fixo ou o percentual de risco atribuído àquela camada. As ordens expiram após ExpirationMinutes se não forem tocadas.
  4. Quando uma ordem de entrada é executada, todas as ordens pendentes são canceladas. A posição executada é gerenciada pelo stop-loss (StopLossPips), take-profit (TakeProfitPips) e parâmetros de trailing (TrailingStopPips, TrailingStepPips). O trailing só move o stop de proteção quando o preço percorre pelo menos TrailingStopPips + TrailingStepPips desde a entrada.
  5. As saídas são executadas com ordens a mercado uma vez que o trailing stop ou o alvo de lucro seja tocado em uma vela completada.

Parâmetros

  • Candle Type – período para os cálculos de Bollinger.
  • Bands Period / Bands Deviation – configuração de Bollinger.
  • Stop Loss (pips) – distância do stop de proteção em pips.
  • Take Profit (pips) – distância do alvo de lucro em pips.
  • Trailing Stop (pips) – distância do trailing stop que segue o movimento após o buffer extra.
  • Trailing Step (pips) – distância adicional necessária antes de o trailing se ativar.
  • Expiration (minutes) – vida útil das ordens stop pendentes. Definir como 0 para manter as ordens indefinidamente.
  • Management Mode – escolher entre FixedVolume e RiskPercent.
  • Level 0-3 Value – lote fixo ou percentual de risco para cada camada pendente.
  • Level 0-3 Pips – deslocamentos de entrada para cada camada pendente.

Gerenciamento de Dinheiro

Quando ManagementMode é igual a RiskPercent, a estratégia calcula o volume da ordem a partir do patrimônio da conta e da distância de stop-loss configurada:

volume de ordem = (equity × riskPercent / 100) / (stopOffset / priceStep × stepPrice)

Se os metadados do mercado (passo de preço, preço de passo ou passo de volume) não estiverem disponíveis, o tamanho da ordem cai para zero por segurança. Com FixedVolume, os valores da camada são usados diretamente e arredondados para o passo de volume e limites do instrumento.

Trailing e Proteção

  • Stop-loss e take-profit são inicializados usando distâncias em pips relativas ao preço de execução real.
  • A lógica de trailing espelha a implementação do MetaTrader: o stop não é movido até que o preço avance TrailingStop + TrailingStep, e depois mantém uma distância de TrailingStop.
  • As saídas são emitidas como ordens a mercado, garantindo compatibilidade com plataformas que não suportam ordens de proteção do lado do servidor.

Notas Práticas

  • Configurar as distâncias em pips de acordo com o tamanho do tick do instrumento. Para símbolos FX de cinco dígitos, cada pip corresponde a dez passos de preço e a estratégia se ajusta automaticamente inspeccionando os decimais do ativo.
  • Como a estratégia depende de ordens stop, verificar os requisitos de nível de stop específicos do corretor e ajustar as distâncias de nível, se necessário.
  • O dimensionamento por percentual de risco requer uma avaliação válida do portfólio e metadados de passo do ativo; caso contrário, o volume da ordem será avaliado como zero.
  • A estratégia opera em velas completadas e, portanto, reage uma vez por barra, o que suaviza o ruído em comparação com o especialista original baseado em ticks.
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>
/// Bollinger Bands breakout scalping strategy.
/// Buys when price breaks below lower band (mean reversion) and sells when price breaks above upper band.
/// Uses stop-loss and take-profit for risk management.
/// </summary>
public class ScalpWiz9001Strategy : Strategy
{
	private readonly StrategyParam<int> _bandsPeriod;
	private readonly StrategyParam<decimal> _bandsDeviation;
	private readonly StrategyParam<int> _stopLossPips;
	private readonly StrategyParam<int> _takeProfitPips;

	private BollingerBands _bollinger;

	private decimal _entryPrice;
	private int _cooldown;

	/// <summary>
	/// Bollinger Bands lookback period.
	/// </summary>
	public int BandsPeriod
	{
		get => _bandsPeriod.Value;
		set => _bandsPeriod.Value = value;
	}

	/// <summary>
	/// Bollinger Bands deviation multiplier.
	/// </summary>
	public decimal BandsDeviation
	{
		get => _bandsDeviation.Value;
		set => _bandsDeviation.Value = value;
	}

	/// <summary>
	/// Stop loss distance in price steps.
	/// </summary>
	public int StopLossPips
	{
		get => _stopLossPips.Value;
		set => _stopLossPips.Value = value;
	}

	/// <summary>
	/// Take profit distance in price steps.
	/// </summary>
	public int TakeProfitPips
	{
		get => _takeProfitPips.Value;
		set => _takeProfitPips.Value = value;
	}

	/// <summary>
	/// Initializes strategy parameters.
	/// </summary>
	public ScalpWiz9001Strategy()
	{
		_bandsPeriod = Param(nameof(BandsPeriod), 20)
			.SetGreaterThanZero()
			.SetDisplay("Bands Period", "Bollinger Bands period", "Indicator");

		_bandsDeviation = Param(nameof(BandsDeviation), 1.5m)
			.SetGreaterThanZero()
			.SetDisplay("Bands Deviation", "Bollinger Bands deviation", "Indicator");

		_stopLossPips = Param(nameof(StopLossPips), 100)
			.SetNotNegative()
			.SetDisplay("Stop Loss", "Stop-loss distance in price steps", "Risk");

		_takeProfitPips = Param(nameof(TakeProfitPips), 150)
			.SetNotNegative()
			.SetDisplay("Take Profit", "Take-profit distance in price steps", "Risk");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		yield return (Security, TimeSpan.FromMinutes(5).TimeFrame());
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();

		_bollinger = null;
		_entryPrice = 0;
		_cooldown = 0;
	}

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

		_bollinger = new BollingerBands
		{
			Length = BandsPeriod,
			Width = BandsDeviation
		};

		var subscription = SubscribeCandles(TimeSpan.FromMinutes(5).TimeFrame());
		subscription.BindEx(_bollinger, ProcessCandle);
		subscription.Start();
	}

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

		var bb = (BollingerBandsValue)value;
		if (bb.UpBand is not decimal upper ||
			bb.LowBand is not decimal lower)
			return;

		if (!_bollinger.IsFormed)
			return;

		if (_cooldown > 0)
		{
			_cooldown--;
			return;
		}

		var close = candle.ClosePrice;
		var step = Security?.PriceStep ?? 1m;

		// Check SL/TP for existing positions
		if (Position > 0 && _entryPrice > 0)
		{
			if (StopLossPips > 0 && close <= _entryPrice - StopLossPips * step)
			{
				SellMarket();
				_entryPrice = 0;
				_cooldown = 5;
				return;
			}

			if (TakeProfitPips > 0 && close >= _entryPrice + TakeProfitPips * step)
			{
				SellMarket();
				_entryPrice = 0;
				_cooldown = 5;
				return;
			}
		}
		else if (Position < 0 && _entryPrice > 0)
		{
			if (StopLossPips > 0 && close >= _entryPrice + StopLossPips * step)
			{
				BuyMarket();
				_entryPrice = 0;
				_cooldown = 5;
				return;
			}

			if (TakeProfitPips > 0 && close <= _entryPrice - TakeProfitPips * step)
			{
				BuyMarket();
				_entryPrice = 0;
				_cooldown = 5;
				return;
			}
		}

		// Entry signals
		if (Position == 0)
		{
			// Buy when price touches lower band (mean reversion up)
			if (close <= lower)
			{
				BuyMarket();
				_entryPrice = close;
				_cooldown = 5;
			}
			// Sell when price touches upper band (mean reversion down)
			else if (close >= upper)
			{
				SellMarket();
				_entryPrice = close;
				_cooldown = 5;
			}
		}
	}
}