Português PT
Ver no GitHub

Estratégia HelloSmart

Esta estratégia implementa uma abordagem simples de grid trading que abre posições em apenas uma direção. Uma nova ordem é colocada cada vez que o mercado se move um número configurado de ticks contra a última entrada. Quando o volume acumulado da posição atinge um limite, o tamanho da próxima ordem é multiplicado. Todas as posições são fechadas quando o lucro ou perda total atinge os limites predefinidos.

Parâmetros

  • Trade Direction – escolher 1 para abrir apenas posições compradas ou 2 para abrir apenas posições vendidas.
  • Step – número de ticks de preço que o mercado deve mover antes de adicionar outra posição.
  • Initial Lot – volume base para a primeira ordem.
  • Threshold Volume – tamanho acumulado da posição que aciona a multiplicação do lote.
  • Maximum Lot – limite superior para o volume de qualquer ordem individual.
  • Profit Target – valor de lucro em moeda após o qual todas as posições são fechadas.
  • Loss Limit – valor de perda em moeda após o qual todas as posições são fechadas.
  • Lot Multiplier – fator aplicado à próxima ordem quando o volume limite é excedido.
  • Candle Type – série de velas usada para medir o movimento de preços.
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>
/// Grid strategy that opens sequential orders in a single direction.
/// Closes all positions on reaching profit or loss limits.
/// </summary>
public class HelloSmartStrategy : Strategy
{
	public enum TradeModes
	{
		Buy,
		Sell
	}

	private readonly StrategyParam<TradeModes> _tradeMode;
	private readonly StrategyParam<decimal> _stepTicks;
	private readonly StrategyParam<decimal> _profitTarget;
	private readonly StrategyParam<decimal> _lossLimit;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _lastPrice;

	public TradeModes Mode { get => _tradeMode.Value; set => _tradeMode.Value = value; }
	public decimal StepTicks { get => _stepTicks.Value; set => _stepTicks.Value = value; }
	public decimal ProfitTarget { get => _profitTarget.Value; set => _profitTarget.Value = value; }
	public decimal LossLimit { get => _lossLimit.Value; set => _lossLimit.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public HelloSmartStrategy()
	{
		_tradeMode = Param(nameof(Mode), TradeModes.Sell)
			.SetDisplay("Trade Direction", "Buy or Sell direction", "General");
		_stepTicks = Param(nameof(StepTicks), 300m)
			.SetGreaterThanZero()
			.SetDisplay("Step", "Price movement to add position", "Risk");
		_profitTarget = Param(nameof(ProfitTarget), 60m)
			.SetDisplay("Profit Target", "Close all positions on this profit", "Risk");
		_lossLimit = Param(nameof(LossLimit), 5100m)
			.SetDisplay("Loss Limit", "Close all positions on this loss", "Risk");
		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Type of candles", "General");
	}

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

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

		_lastPrice = 0m;
	}

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

		_lastPrice = 0m;

		var subscription = SubscribeCandles(CandleType);
		subscription.Bind(ProcessCandle).Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawOwnTrades(area);
		}
	}

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

		if (!IsFormedAndOnlineAndAllowTrading())
			return;

		var price = candle.ClosePrice;
		var stepPrice = StepTicks * 0.01m;

		// Check PnL limits first
		if (Position != 0 && (PnL > ProfitTarget || PnL < -LossLimit))
		{
			if (Position > 0)
				SellMarket();
			else
				BuyMarket();
			_lastPrice = price;
			return;
		}

		if (Mode == TradeModes.Buy)
		{
			var needOpen = Position <= 0 || (Position > 0 && (_lastPrice - price) >= stepPrice);
			if (needOpen)
			{
				BuyMarket();
				_lastPrice = price;
			}
		}
		else
		{
			var needOpen = Position >= 0 || (Position < 0 && (price - _lastPrice) >= stepPrice);
			if (needOpen)
			{
				SellMarket();
				_lastPrice = price;
			}
		}
	}
}