La estrategia Crypto Scalper Momentum replica el asesor experto original de MetaTrader "Crypto Scalper" combinando Money Flow Index, Momentum y filtros MACD multimarco. Opera en un marco intradía principal, confirma el momentum de corto plazo en un marco superior y respeta un filtro de macrotendencia derivado de un MACD lento. Se preservan varias funciones de gestión de riesgo de la implementación MQL, incluidos objetivos de cesta basados en divisa, trailing monetario, stops de break-even y protección contra drawdown de patrimonio.
Lógica de negociación
Indicadores principales
Money Flow Index (MFI) en el marco principal con valor predeterminado de 14 periodos.
MACD en el marco principal (configuración EMA 12/26/9).
Momentum de marco superior
Indicador Momentum calculado en una serie de velas separada. La distancia absoluta frente a la línea base de MetaTrader (100) debe superar un umbral configurable.
Filtro de macrotendencia
Un MACD lento evaluado en un marco macro (diario por defecto) evita operar contra la tendencia superior y fuerza la liquidación cuando se invierte.
Reglas de entrada
Largos: al menos uno de los tres últimos valores MFI está por debajo del umbral de sobreventa, la desviación de momentum supera el umbral, la línea MACD principal está por encima de la señal y el MACD macro es alcista.
Cortos: condiciones espejo usando umbrales de sobrecompra y confirmaciones MACD bajistas.
Reglas de salida
Stop-loss y take-profit fijos expresados en pips.
Trailing stop opcional mediante extremos de velas o trailing clásico basado en distancia.
Movimiento a break-even tras una excursión favorable configurable.
La reversión del MACD macro cierra la exposición existente.
Objetivos monetarios, objetivos porcentuales y trailing de beneficio en dinero replican las funciones de MQL.
Un vigilante de drawdown de patrimonio cierra todas las operaciones cuando la cuenta retrocede un porcentaje dado desde el máximo.
Gestión de riesgo
Stops/objetivos: distancias configurables en pips con activación opcional.
Trailing: basado en velas (mínimo más bajo/máximo más alto de velas recientes) o trailing clásico en pips.
Break-even: mueve los stops para asegurar beneficios una vez alcanzada la distancia de activación.
Gestión monetaria: take-profit de cesta en divisa, porcentaje del patrimonio inicial y trailing de beneficio en dinero.
Stop de patrimonio: monitoriza el patrimonio máximo observado y cierra operaciones cuando el drawdown supera el porcentaje permitido.
Parámetros
Nombre
Descripción
CandleType
Serie principal de velas usada para entradas.
MomentumCandleType
Velas de marco superior que alimentan el indicador Momentum.
MacroCandleType
Velas de marco lento usadas para el filtro MACD macro.
MfiPeriod
Longitud del Money Flow Index.
MfiOversold / MfiOverbought
Umbrales del oscilador (30 / 70 por defecto).
MomentumPeriod
Longitud del Momentum en el marco superior.
MomentumThreshold
Desviación mínima desde la línea 100 requerida por el filtro de momentum.
MomentumReference
Valor base (el predeterminado de MetaTrader es 100).
Guardia de drawdown de patrimonio relativa al máximo observado.
ForceExit
Aplana inmediatamente las posiciones en el siguiente cierre de vela.
Notas
Las distancias en pips se convierten con PriceStep del instrumento. Si el broker no proporciona un paso de precio, se usa un valor alternativo de 0.0001, igual que el manejo de puntos en MetaTrader.
La suscripción MACD macro puede apuntarse a velas mensuales para imitar el EA original. Las velas diarias son el valor predeterminado porque las barras mensuales pueden no estar disponibles en todos los feeds de datos.
Todos los comentarios dentro del código están escritos en inglés para cumplir las reglas del repositorio.
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 CryptoScalperMomentumStrategy : 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 CryptoScalperMomentumStrategy()
{
_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;
}
}
import clr
clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")
from System import TimeSpan
from StockSharp.Messages import DataType, CandleStates
from StockSharp.Algo.Indicators import ExponentialMovingAverage
from StockSharp.Algo.Strategies import Strategy
class crypto_scalper_momentum_strategy(Strategy):
def __init__(self):
super(crypto_scalper_momentum_strategy, self).__init__()
self._fast_period = self.Param("FastPeriod", 14) \
.SetDisplay("Fast Period", "Fast MA period", "Indicator")
self._slow_period = self.Param("SlowPeriod", 50) \
.SetDisplay("Slow Period", "Slow MA period", "Indicator")
self._stop_loss_points = self.Param("StopLossPoints", 200) \
.SetDisplay("Stop Loss", "Stop-loss in price steps", "Risk")
self._take_profit_points = self.Param("TakeProfitPoints", 400) \
.SetDisplay("Take Profit", "Take-profit in price steps", "Risk")
self._fast = None
self._slow = None
self._prev_fast = 0.0
self._prev_slow = 0.0
self._entry_price = 0.0
self._cooldown = 0
@property
def fast_period(self):
return self._fast_period.Value
@property
def slow_period(self):
return self._slow_period.Value
@property
def stop_loss_points(self):
return self._stop_loss_points.Value
@property
def take_profit_points(self):
return self._take_profit_points.Value
def OnReseted(self):
super(crypto_scalper_momentum_strategy, self).OnReseted()
self._fast = None
self._slow = None
self._prev_fast = 0.0
self._prev_slow = 0.0
self._entry_price = 0.0
self._cooldown = 0
def OnStarted2(self, time):
super(crypto_scalper_momentum_strategy, self).OnStarted2(time)
self._fast = ExponentialMovingAverage()
self._fast.Length = self.fast_period
self._slow = ExponentialMovingAverage()
self._slow.Length = self.slow_period
subscription = self.SubscribeCandles(DataType.TimeFrame(TimeSpan.FromMinutes(5)))
subscription.Bind(self._fast, self._slow, self._process_candle)
subscription.Start()
def _process_candle(self, candle, fast_value, slow_value):
if candle.State != CandleStates.Finished:
return
fast_val = float(fast_value)
slow_val = float(slow_value)
if not self._fast.IsFormed or not self._slow.IsFormed:
self._prev_fast = fast_val
self._prev_slow = slow_val
return
if self._cooldown > 0:
self._cooldown -= 1
self._prev_fast = fast_val
self._prev_slow = slow_val
return
close = float(candle.ClosePrice)
step = float(self.Security.PriceStep) if self.Security is not None and self.Security.PriceStep is not None else 1.0
if self.Position > 0 and self._entry_price > 0:
if self.stop_loss_points > 0 and close <= self._entry_price - self.stop_loss_points * step:
self.SellMarket()
self._entry_price = 0.0
self._cooldown = 100
self._prev_fast = fast_val
self._prev_slow = slow_val
return
if self.take_profit_points > 0 and close >= self._entry_price + self.take_profit_points * step:
self.SellMarket()
self._entry_price = 0.0
self._cooldown = 100
self._prev_fast = fast_val
self._prev_slow = slow_val
return
elif self.Position < 0 and self._entry_price > 0:
if self.stop_loss_points > 0 and close >= self._entry_price + self.stop_loss_points * step:
self.BuyMarket()
self._entry_price = 0.0
self._cooldown = 100
self._prev_fast = fast_val
self._prev_slow = slow_val
return
if self.take_profit_points > 0 and close <= self._entry_price - self.take_profit_points * step:
self.BuyMarket()
self._entry_price = 0.0
self._cooldown = 100
self._prev_fast = fast_val
self._prev_slow = slow_val
return
if self._prev_fast <= self._prev_slow and fast_val > slow_val and self.Position <= 0:
if self.Position < 0:
self.BuyMarket()
self.BuyMarket()
self._entry_price = close
self._cooldown = 100
elif self._prev_fast >= self._prev_slow and fast_val < slow_val and self.Position >= 0:
if self.Position > 0:
self.SellMarket()
self.SellMarket()
self._entry_price = close
self._cooldown = 100
self._prev_fast = fast_val
self._prev_slow = slow_val
def CreateClone(self):
return crypto_scalper_momentum_strategy()