Português PT
Ver no GitHub

Estratégia Cryptocurrency Fibonacci MAs (StockSharp)

Visão geral

Esta estratégia porta o expert advisor do MetaTrader "Cryptocurrency Fibonacci MAs" para a API de alto nível do StockSharp. O sistema acompanha uma pilha de médias móveis exponenciais baseadas em Fibonacci (8/13/21/55), valida momentum em um período mais alto e confirma a tendência macro com um filtro MACD mensal antes de enviar ordens a mercado. Apenas candles concluídos são processados e todas as atualizações de indicadores são realizadas pelo pipeline Bind/BindEx.

Em comparação com a versão MetaTrader, os seguintes ajustes intencionais foram feitos:

  • Take profit baseado em dinheiro, equity stop-out, trailing candle a candle e automação de break-even foram omitidos. A versão StockSharp usa stop-loss e take-profit clássicos baseados em pips via StartProtection.
  • Piramidagem de ordens é limitada a uma posição líquida por direção. Reversões fecham primeiro a exposição oposta, espelhando o modelo de posição líquida do StockSharp.
  • Dados multitemporais são fornecidos por assinaturas adicionais de candles em vez de solicitações ad hoc de indicadores sob demanda.

Lógica de negociação

Entrada comprada

  1. Alinhamento EMA: 8 > 13 > 21 > 55 no período principal.
  2. Momentum de período superior: o desvio absoluto do Momentum de 14 períodos a partir do nível neutro 100 está acima do limite de compra configurado em pelo menos um dos três últimos candles do período superior.
  3. Filtro MACD mensal: a linha principal MACD está acima da linha de sinal.
  4. Filtro de posição: a posição líquida atual deve estar zerada ou vendida e permanecer abaixo do volume máximo configurado.

Entrada vendida

  1. Alinhamento EMA: 8 < 13 < 21 < 55.
  2. Desvio de momentum acima do limite de venda em pelo menos um dos três últimos candles do período superior.
  3. Linha principal MACD abaixo de sua linha de sinal.
  4. Exposição líquida deve estar zerada ou comprada e dentro do limite MaxPositions.

Lógica de saída

  • StartProtection coloca ordens de stop-loss e take-profit de proteção expressas em distâncias de pip. Nenhuma lógica adicional de trailing ou break-even é aplicada nesta versão.
  • Sinais de reversão enviam o tamanho da ordem a mercado oposta, que primeiro compensa a posição existente antes de estabelecer a nova exposição.

Mapeamento multitemporal

O período superior usado para o indicador de momentum espelha a tabela de coeficientes original:

Período principal Período de momentum
1 minuto 15 minutos
5 minutos 30 minutos
15 minutos 1 hora
30 minutos 4 horas
1 hora 1 dia
4 horas 1 semana
1 dia 1 mês
1 semana 1 mês
1 mês 1 mês

A confirmação MACD sempre roda em uma aproximação mensal de 30 dias.

Parâmetros

Nome Descrição Padrão
TradeVolume Tamanho da ordem em lotes. 0.1
StopLossPips Distância de stop-loss em pips. 20
TakeProfitPips Distância de take-profit em pips. 50
MomentumBuyThreshold Desvio absoluto mínimo de momentum a partir de 100 exigido para operações compradas. 0.3
MomentumSellThreshold Desvio absoluto mínimo de momentum a partir de 100 exigido para operações vendidas. 0.3
MaxPositions Volume líquido máximo por direção expresso como múltiplos de TradeVolume. 1
CandleType Período primário para cálculos EMA. Candles de 1 hora

Notas de uso

  1. Anexe a estratégia a um símbolo e selecione um período apropriado por CandleType.
  2. Garanta que a fonte de dados possa fornecer tanto o período principal quanto os períodos superiores derivados (momentum e mensal).
  3. Ajuste parâmetros de risco baseados em pips para corresponder ao tamanho do tick do instrumento. O helper converte pips para passos do instrumento usando Security.PriceStep.
  4. Backtesting e otimização podem ajustar os limites de momentum e as distâncias de stop usando os intervalos de parâmetros fornecidos.
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;

public class CryptocurrencyFibonacciMAsStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<int> _stopLossPoints;
	private readonly StrategyParam<int> _takeProfitPoints;

	private ExponentialMovingAverage _fast;
	private ExponentialMovingAverage _slow;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _entryPrice;
	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 StopLossPoints { get => _stopLossPoints.Value; set => _stopLossPoints.Value = value; }
	public int TakeProfitPoints { get => _takeProfitPoints.Value; set => _takeProfitPoints.Value = value; }

	public CryptocurrencyFibonacciMAsStrategy()
	{
		_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");
		_stopLossPoints = Param(nameof(StopLossPoints), 200).SetNotNegative().SetDisplay("Stop Loss", "Stop-loss in price steps", "Risk");
		_takeProfitPoints = Param(nameof(TakeProfitPoints), 400).SetNotNegative().SetDisplay("Take Profit", "Take-profit in price steps", "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; _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;

		if (Position > 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close <= _entryPrice - StopLossPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close >= _entryPrice + TakeProfitPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}
		else if (Position < 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close >= _entryPrice + StopLossPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close <= _entryPrice - TakeProfitPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}

		if (_prevFast <= _prevSlow && fastValue > slowValue && Position <= 0)
		{ if (Position < 0) BuyMarket(); BuyMarket(); _entryPrice = close; _cooldown = 100; }
		else if (_prevFast >= _prevSlow && fastValue < slowValue && Position >= 0)
		{ if (Position > 0) SellMarket(); SellMarket(); _entryPrice = close; _cooldown = 100; }

		_prevFast = fastValue; _prevSlow = slowValue;
	}
}