Português PT
Ver no GitHub

Estratégia de Margem Fixa de Dinheiro

Esta estratégia replica o exemplo "Money Fixed Margin" do MetaTrader usando a API de alto nível do StockSharp. Ela demonstra como dimensionar posições arriscando uma porcentagem fixa do portfólio enquanto converte a distância do stop-loss expressa em pips para um deslocamento de preço absoluto. A estratégia opera apenas posições compradas e foca em demonstrar a lógica de gestão do dinheiro em vez de um sinal de entrada preditivo.

Detalhes

  • Critérios de entrada:
    • Comprado: executa uma compra a mercado após cada contagem de velas concluída especificada por Check Interval (padrão a cada 980ª barra). A ordem usa o preço de fechamento da vela desencadeante como referência para cálculos de risco.
  • Comprado/Vendido: Somente comprado.
  • Critérios de saída:
    • O stop-loss protetor é anexado automaticamente via StartProtection a uma distância derivada do parâmetro Stop Loss (pips).
    • Nenhum alvo de lucro é usado; as posições fecham apenas pelo stop-loss ou intervenção manual.
  • Stops: Apenas Stop Loss.
  • Valores padrão:
    • Stop Loss (pips) = 25
    • Risk Percent = 10
    • Check Interval = 980
    • Candle Type = período de 1 minuto
  • Filtros:
    • Categoria: Gestão de risco
    • Direção: Comprado
    • Indicadores: Nenhum
    • Stops: Sim (stop-loss)
    • Complexidade: Básico
    • Período: Intradiário (configurável através de Candle Type)
    • Sazonalidade: Não
    • Redes neurais: Não
    • Divergência: Não
    • Nível de risco: Médio (escala com Risk Percent)

Lógica de Dimensionamento de Posição

  1. A estratégia lê Security.PriceStep e Security.Decimals para inferir o tamanho do pip. Pares com 3 ou 5 casas decimais usam um multiplicador décuplo para corresponder à definição de pip do MetaTrader.
  2. Stop Loss (pips) é multiplicado pelo tamanho do pip para obter uma distância de preço absoluta (ExtStopLoss) idêntica ao código MQL5.
  3. O valor atual do portfólio (preferindo Portfolio.CurrentValue e depois Portfolio.BeginValue) é multiplicado por Risk Percent / 100 para determinar o capital exposto por trade.
  4. O risco por lote único é calculado através do produto da distância do stop-loss, o número de passos de preço dentro dessa distância e Security.StepPrice quando disponível. Se StepPrice for desconhecido, a própria distância de preço é usada como fallback.
  5. A divisão do valor de risco pelo risco por lote produz o volume desejado. O resultado é normalizado para o VolumeStep do instrumento, limitado aos limites mínimo e máximo de volume, e registrado para transparência. Um valor de comparação com distância de stop-loss zero também é registrado para ilustrar por que o gestor de dinheiro recusa trades sem um stop protetor.

Fluxo de Trabalho

  1. Ao iniciar, a estratégia assina a série de velas configurada, calcula o tamanho do pip e habilita StartProtection com a distância de stop-loss absoluta calculada.
  2. Cada vela concluída incrementa um contador interno. Quando o contador atinge o Check Interval escolhido, a estratégia avalia o tamanho da posição, imprime informações de diagnóstico e redefine o contador.
  3. Se o volume calculado for positivo, uma ordem de compra a mercado é colocada. A proteção integrada anexa o stop-loss em Close - ExtStopLoss. Quaisquer erros (por exemplo, devido a dados insuficientes ou instrumentos com preço zero) impedem o envio da ordem.
  4. Nenhum trade adicional é realizado até que o contador complete outro intervalo, mantendo o foco na gestão do dinheiro em vez da frequência de sinais.

Notas de Uso

  • Defina Risk Percent para um valor conservador ao conectar a uma conta ao vivo; o risco padrão de 10% espelha o exemplo MQL, mas é agressivo para trading real.
  • Certifique-se de que o instrumento forneça metadados significativos de PriceStep e StepPrice. Quando indisponíveis, a estratégia ainda opera mas interpreta o risco em unidades de preço bruto.
  • A estratégia evita intencionalmente trades vendidos para manter fidelidade à demonstração original. Adapte as chamadas BuyMarket/SellMarket se o trading bidirecional for desejado.
  • Combine este módulo de gestão do dinheiro com outros geradores de sinais reutilizando o helper CalculateFixedMarginVolume do código da estratégia.
using System;
using System.Linq;
using System.Collections.Generic;

using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;

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

using StockSharp.Algo;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Recreates the MetaTrader Money Fixed Margin sample using StockSharp.
/// It demonstrates fixed percentage risk sizing for long trades.
/// </summary>
public class MoneyFixedMarginStrategy : Strategy
{
	private readonly StrategyParam<decimal> _stopLossPips;
	private readonly StrategyParam<decimal> _riskPercent;
	private readonly StrategyParam<int> _checkInterval;
	private readonly StrategyParam<DataType> _candleType;

	private int _barCount;
	private decimal _pipSize;

	/// <summary>
	/// Stop-loss distance expressed in pips.
	/// </summary>
	public decimal StopLossPips
	{
		get => _stopLossPips.Value;
		set => _stopLossPips.Value = value;
	}

	/// <summary>
	/// Portfolio percentage risked on each trade.
	/// </summary>
	public decimal RiskPercent
	{
		get => _riskPercent.Value;
		set => _riskPercent.Value = value;
	}

	/// <summary>
	/// Number of finished candles between trade attempts.
	/// </summary>
	public int CheckInterval
	{
		get => _checkInterval.Value;
		set => _checkInterval.Value = value;
	}

	/// <summary>
	/// Candle series used to time entries.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Initializes a new instance of <see cref="MoneyFixedMarginStrategy"/>.
	/// </summary>
	public MoneyFixedMarginStrategy()
	{
		_stopLossPips = Param(nameof(StopLossPips), 25m)
			.SetGreaterThanZero()
			.SetDisplay("Stop Loss (pips)", "Stop loss distance in pips", "Risk");

		_riskPercent = Param(nameof(RiskPercent), 10m)
			.SetGreaterThanZero()
			.SetDisplay("Risk Percent", "Percent of equity risked per trade", "Risk");

		_checkInterval = Param(nameof(CheckInterval), 150)
			.SetGreaterThanZero()
			.SetDisplay("Check Interval", "Completed candles between trades", "Execution");

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(15).TimeFrame())
			.SetDisplay("Candle Type", "Candle timeframe", "General");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_barCount = 0;
		_pipSize = 0m;
	}

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

		var priceStep = Security?.PriceStep ?? 1m;
		var decimals = Security?.Decimals ?? 0;
		var adjust = decimals == 3 || decimals == 5 ? 10m : 1m;

		_pipSize = priceStep * adjust;
		if (_pipSize <= 0m)
			_pipSize = priceStep > 0m ? priceStep : 1m;

		// Attach a protective stop using the pip-based distance converted to price units.
		StartProtection(
			new Unit(StopLossPips * _pipSize, UnitTypes.Absolute),
			new Unit(StopLossPips * _pipSize * 2, UnitTypes.Absolute));

		// Subscribe to the candle stream that emulates the tick counter from the MQL example.
		var subscription = SubscribeCandles(CandleType);
		subscription.Bind(ProcessCandle).Start();
	}

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

		// Count finished candles to mirror the tick counter from the original script.
		_barCount++;

		if (_barCount < CheckInterval)
			return;

		var entryPrice = candle.ClosePrice;

		if (entryPrice <= 0m)
		{
			LogWarning("Skip trade because entry price is not positive. Close={0}", entryPrice);
			return;
		}

		var riskAmount = CalculateRiskAmount();
		if (riskAmount <= 0m)
		{
			LogWarning("Skip trade because risk amount is not positive. Portfolio value={0}", riskAmount);
			return;
		}

		var stopDistance = StopLossPips * _pipSize;
		var stopPrice = entryPrice - stopDistance;

		var volumeWithoutStop = CalculateFixedMarginVolume(entryPrice, 0m, riskAmount);
		var volumeWithStop = CalculateFixedMarginVolume(entryPrice, stopPrice, riskAmount);

		this.LogInfo(
			"StopLoss=0 -> volume {0:0.####}; StopLoss={1:0.#####} -> volume {2:0.####}; Portfolio={3:0.##}",
			volumeWithoutStop,
			stopPrice,
			volumeWithStop,
			GetPortfolioValue());

		BuyMarket();

		// Reset the counter only after successfully sending an order.
		_barCount = 0;
	}

	private decimal CalculateRiskAmount()
	{
		var portfolioValue = GetPortfolioValue();
		return portfolioValue > 0m ? portfolioValue * RiskPercent / 100m : 0m;
	}

	private decimal GetPortfolioValue()
	{
		var current = Portfolio?.CurrentValue ?? 0m;
		if (current > 0m)
			return current;

		var begin = Portfolio?.BeginValue ?? 0m;
		return begin > 0m ? begin : current;
	}

	private decimal CalculateFixedMarginVolume(decimal entryPrice, decimal stopPrice, decimal riskAmount)
	{
		if (riskAmount <= 0m || entryPrice <= 0m || stopPrice <= 0m)
			return 0m;

		var stopDistance = entryPrice - stopPrice;
		if (stopDistance <= 0m)
			return 0m;

		var priceStep = Security?.PriceStep ?? 0m;
		if (priceStep <= 0m)
			priceStep = 1m;

		var stepPrice = 0m;
		if (stepPrice <= 0m)
			stepPrice = priceStep;

		var stepsCount = stopDistance / priceStep;
		if (stepsCount <= 0m)
			return 0m;

		var riskPerVolume = stepsCount * stepPrice;
		if (riskPerVolume <= 0m)
			return 0m;

		var rawVolume = riskAmount / riskPerVolume;
		return NormalizeVolume(rawVolume);
	}

	private decimal NormalizeVolume(decimal volume)
	{
		if (volume <= 0m)
			return 0m;

		if (Security?.VolumeStep is decimal step && step > 0m)
		{
			volume = Math.Ceiling(volume / step) * step;
		}

		return volume;
	}
}