Português PT
Ver no GitHub

Gerenciador Breakeven V3

Visão Geral

O Gerenciador Breakeven V3 é uma conversão do consultor especializado MetaTrader 5 Breakeven v3 (edição de barabashkakvn). O script original não abre trades. Em vez disso, calcula continuamente o nível de break-even do portfólio para o símbolo selecionado e move as ordens de proteção (stop-loss ou take-profit) para cada posição comprada e vendida aberta, de modo que todo o livro seja fechado em torno desse preço de break-even com um buffer opcional.

Lógica da estratégia

  • Reconstrução do break-even – cada vez que um trade é executado ou chegam novas cotações, a estratégia reconstrói o preço médio ponderado de abertura para exposição comprada e vendida separadamente. Inclui as comissões por posição que o StockSharp relata nos objetos MyTrade para refletir a implementação MQL.
  • Cálculo do preço alvo – o preço de break-even é deslocado por Delta (points) pontos MetaTrader. O deslocamento é adicionado quando a exposição líquida é comprada e subtraído quando é vendida, replicando o parâmetro "Delta" original.
  • Colocação de ordens de proteção –
    • Quando a exposição líquida é comprada, um sell limit de take-profit é colocado para o volume comprado total e um buy stop de stop-loss é anexado ao volume vendido agregado no mesmo preço.
    • Quando a exposição líquida é vendida, um buy limit de take-profit é colocado para o volume vendido completo e um sell stop de stop-loss protege quaisquer coberturas compradas.
    • Se ambos os lados estiverem zerados, todas as ordens de proteção são canceladas.
  • Monitoramento de cotações e diagnósticos – a estratégia assina atualizações de Nível 1. O bid/ask mais recente é usado para calcular estatísticas de distância ao alvo e um lucro flutuante estimado. Quando Enable Logging é true, esses valores são escritos no log da estratégia para emular os comentários no gráfico da versão MQL.

Parâmetros

  • Delta (points) – offset aplicado ao preço de break-even calculado. O valor é expresso em pontos MetaTrader, ou seja, um décimo de pip em símbolos FX de cinco dígitos. Padrão: 100.
  • Enable Logging – alterna a saída de log detalhada descrevendo o nível de break-even atual, a distância ao alvo e o PnL flutuante. Padrão: true.

Notas de uso

  • A estratégia é um gerenciador de trades. Deve ser lançada sobre uma estratégia existente ou posição manual. Ela não abrirá ordens de mercado por si mesma.
  • Na inicialização, o código inspeciona o portfólio e reconstrói um único lote sintético para cada lado da posição usando o preço médio informado pelo StockSharp. Para maior precisão, manter a estratégia em execução sempre que novos trades forem abertos.
  • As cobranças de swap não estão disponíveis no StockSharp, portanto apenas as informações de comissão são incluídas ao reconstruir o preço de break-even. Se o corretor aplica swaps noturnos, eles devem ser tratados manualmente.
  • O script assume que a conta permite hedge (posições compradas e vendidas simultâneas). Se o corretor liquida posições, os agregados comprado e vendido se reduzirão a uma única exposição líquida assim como no MetaTrader.
  • Não há versão Python deste port. Apenas a implementação C# é fornecida.
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>
/// Break-even management strategy that enters on EMA crossover and moves
/// the exit level to break-even once price moves a configurable distance in favor.
/// </summary>
public class BreakevenV3Strategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<int> _activationPoints;
	private readonly StrategyParam<int> _deltaPoints;

	private ExponentialMovingAverage _fast;
	private ExponentialMovingAverage _slow;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _entryPrice;
	private decimal _breakEvenPrice;
	private bool _breakEvenActivated;
	private int _cooldown;

	public int FastPeriod { get => _fastPeriod.Value; set => _fastPeriod.Value = value; }
	public int SlowPeriod { get => _slowPeriod.Value; set => _slowPeriod.Value = value; }
	public int ActivationPoints { get => _activationPoints.Value; set => _activationPoints.Value = value; }
	public int DeltaPoints { get => _deltaPoints.Value; set => _deltaPoints.Value = value; }

	public BreakevenV3Strategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 14).SetGreaterThanZero().SetDisplay("Fast Period", "Fast EMA period", "Indicator");
		_slowPeriod = Param(nameof(SlowPeriod), 50).SetGreaterThanZero().SetDisplay("Slow Period", "Slow EMA period", "Indicator");
		_activationPoints = Param(nameof(ActivationPoints), 200).SetNotNegative().SetDisplay("Activation", "Distance price must move before break-even activates", "Risk");
		_deltaPoints = Param(nameof(DeltaPoints), 100).SetNotNegative().SetDisplay("Delta", "Offset from entry for break-even stop", "Risk");
	}

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

	protected override void OnReseted()
	{
		base.OnReseted();
		_fast = null; _slow = null;
		_prevFast = 0; _prevSlow = 0; _entryPrice = 0; _breakEvenPrice = 0;
		_breakEvenActivated = false; _cooldown = 0;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_fast = new ExponentialMovingAverage { Length = FastPeriod };
		_slow = new ExponentialMovingAverage { Length = SlowPeriod };
		var subscription = SubscribeCandles(TimeSpan.FromMinutes(5).TimeFrame());
		subscription.Bind(_fast, _slow, ProcessCandle);
		subscription.Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal fastValue, decimal slowValue)
	{
		if (candle.State != CandleStates.Finished) return;
		if (!_fast.IsFormed || !_slow.IsFormed) { _prevFast = fastValue; _prevSlow = slowValue; return; }
		if (_cooldown > 0) { _cooldown--; _prevFast = fastValue; _prevSlow = slowValue; return; }

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

		// Manage break-even for open position
		if (Position != 0 && _entryPrice > 0)
		{
			var activationDistance = ActivationPoints * step;
			var deltaOffset = DeltaPoints * step;

			if (Position > 0)
			{
				if (!_breakEvenActivated && activationDistance > 0 && close >= _entryPrice + activationDistance)
				{
					_breakEvenActivated = true;
					_breakEvenPrice = _entryPrice + deltaOffset;
				}
				if (_breakEvenActivated && close <= _breakEvenPrice)
				{
					SellMarket();
					_entryPrice = 0; _breakEvenPrice = 0; _breakEvenActivated = false;
					_cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue;
					return;
				}
			}
			else if (Position < 0)
			{
				if (!_breakEvenActivated && activationDistance > 0 && close <= _entryPrice - activationDistance)
				{
					_breakEvenActivated = true;
					_breakEvenPrice = _entryPrice - deltaOffset;
				}
				if (_breakEvenActivated && close >= _breakEvenPrice)
				{
					BuyMarket();
					_entryPrice = 0; _breakEvenPrice = 0; _breakEvenActivated = false;
					_cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue;
					return;
				}
			}
		}

		// Entry: EMA crossover
		if (_prevFast <= _prevSlow && fastValue > slowValue && Position <= 0)
		{
			if (Position < 0) BuyMarket();
			BuyMarket();
			_entryPrice = close; _breakEvenActivated = false; _cooldown = 100;
		}
		else if (_prevFast >= _prevSlow && fastValue < slowValue && Position >= 0)
		{
			if (Position > 0) SellMarket();
			SellMarket();
			_entryPrice = close; _breakEvenActivated = false; _cooldown = 100;
		}

		_prevFast = fastValue; _prevSlow = slowValue;
	}
}