Deutsch DE
Auf GitHub ansehen

VR Setka 3-Strategie

Die VR Setka 3-Strategie implementiert einen gitterbasierten Handelsansatz. Die Strategie platziert symmetrische Buy- und Sell-Limit-Orders rund um den aktuellen Marktpreis. Nachdem eine Order ausgeführt wurde, wird das Take-Profit-Niveau anhand des durchschnittlichen Einstiegspreises aller Positionen in der aktiven Richtung neu berechnet. Neue Grid-Orders werden mit zunehmendem Abstand und optional mit zunehmendem Volumen (Martingal) platziert.

Parameter

  • Start Offset – anfänglicher Abstand vom aktuellen Kurs für das erste Paar von Limit-Orders.
  • Take Profit – Abstand vom durchschnittlichen Einstiegspreis, bei dem alle Positionen mit Gewinn geschlossen werden.
  • Grid Distance – Basisschritt zwischen Grid-Niveaus.
  • Step Distance – zusätzlicher Abstand für jedes weitere Grid-Niveau.
  • Use Martingale – wenn aktiviert, erhöht jede neue Grid-Order ihr Volumen mit dem Multiplikator.
  • Martingale Multiplier – Faktor für die Volumenserhöhung bei aktivem Martingal.
  • Volume – Basisordervolumen für das erste Niveau.
  • Candle Type – Zeitrahmen zur Synchronisierung der Strategieoperationen.

Algorithmus

  1. Zu Beginn platziert die Strategie ein Buy Limit unterhalb und ein Sell Limit oberhalb des aktuellen Kurses.
  2. Wenn eine Seite ausgeführt wird, wird die entgegengesetzte Order storniert.
  3. Die Strategie berechnet ein gemeinsames Take-Profit-Niveau beim Durchschnittspreis ± Take Profit.
  4. Wenn sich der Kurs gegen die Position bewegt, wird eine neue Limit-Order bei Grid Distance + Step Distance × Niveau vom Durchschnittspreis platziert. Das Volumen erhöht sich, wenn Martingal aktiviert ist.
  5. Wenn der Kurs das Take-Profit-Niveau erreicht, werden alle Positionen in dieser Richtung geschlossen und das Grid wird zurückgesetzt.

Hinweise

  • Die Strategie öffnet keine Positionen in beiden Richtungen gleichzeitig.
  • Angemessenes Risikomanagement ist erforderlich, da Martingal die Positionsgröße schnell erhöhen kann.
  • Funktioniert mit jedem von StockSharp unterstützten Instrument, solange der gewählte Kerzentyp verfügbar ist.
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;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Grid strategy inspired by VR SETKA 3.
/// Places limit orders at grid levels. When filled, places next level.
/// Closes position on take profit.
/// </summary>
public class VRSetka3Strategy : Strategy
{
	private readonly StrategyParam<decimal> _startOffset;
	private readonly StrategyParam<decimal> _takeProfit;
	private readonly StrategyParam<decimal> _gridDistance;
	private readonly StrategyParam<decimal> _stepDistance;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _buyAvgPrice;
	private decimal _buyVolume;
	private decimal _sellAvgPrice;
	private decimal _sellVolume;
	private int _buyCount;
	private int _sellCount;
	private bool _hasBuyPending;
	private bool _hasSellPending;

	public decimal StartOffset
	{
		get => _startOffset.Value;
		set => _startOffset.Value = value;
	}

	public decimal TakeProfit
	{
		get => _takeProfit.Value;
		set => _takeProfit.Value = value;
	}

	public decimal GridDistance
	{
		get => _gridDistance.Value;
		set => _gridDistance.Value = value;
	}

	public decimal StepDistance
	{
		get => _stepDistance.Value;
		set => _stepDistance.Value = value;
	}

	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	public VRSetka3Strategy()
	{
		_startOffset = Param(nameof(StartOffset), 100m)
			.SetGreaterThanZero()
			.SetDisplay("Start Offset", "Offset for first limit orders", "Parameters");

		_takeProfit = Param(nameof(TakeProfit), 300m)
			.SetGreaterThanZero()
			.SetDisplay("Take Profit", "Distance for profit taking", "Parameters");

		_gridDistance = Param(nameof(GridDistance), 300m)
			.SetGreaterThanZero()
			.SetDisplay("Grid Distance", "Base distance between grid levels", "Parameters");

		_stepDistance = Param(nameof(StepDistance), 50m)
			.SetGreaterThanZero()
			.SetDisplay("Step Distance", "Additional distance for next levels", "Parameters");

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).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();
		ResetState();
	}

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

		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;

		var price = candle.ClosePrice;

		// Check take profit for long grid
		if (_buyVolume > 0 && price >= _buyAvgPrice + TakeProfit)
		{
			SellMarket();
			ResetState();
			return;
		}

		// Check take profit for short grid
		if (_sellVolume > 0 && price <= _sellAvgPrice - TakeProfit)
		{
			BuyMarket();
			ResetState();
			return;
		}

		// Place grid orders
		if (_buyVolume > 0 && !_hasBuyPending)
		{
			var level = _buyAvgPrice - (GridDistance + StepDistance * _buyCount);
			if (level > 0)
			{
				BuyLimit(level);
				_hasBuyPending = true;
			}
		}
		else if (_sellVolume > 0 && !_hasSellPending)
		{
			var level = _sellAvgPrice + (GridDistance + StepDistance * _sellCount);
			SellLimit(level);
			_hasSellPending = true;
		}
		else if (_buyVolume == 0 && _sellVolume == 0)
		{
			if (!_hasBuyPending)
			{
				var buyPrice = price - StartOffset;
				if (buyPrice > 0)
				{
					BuyLimit(buyPrice);
					_hasBuyPending = true;
				}
			}

			if (!_hasSellPending)
			{
				var sellPrice = price + StartOffset;
				SellLimit(sellPrice);
				_hasSellPending = true;
			}
		}
	}

	/// <inheritdoc />
	protected override void OnOwnTradeReceived(MyTrade trade)
	{
		base.OnOwnTradeReceived(trade);

		if (trade.Order.Side == Sides.Buy)
		{
			_buyAvgPrice = (_buyAvgPrice * _buyVolume + trade.Trade.Price * trade.Trade.Volume) / (_buyVolume + trade.Trade.Volume);
			_buyVolume += trade.Trade.Volume;
			_buyCount++;
			_hasBuyPending = false;
		}
		else if (trade.Order.Side == Sides.Sell)
		{
			_sellAvgPrice = (_sellAvgPrice * _sellVolume + trade.Trade.Price * trade.Trade.Volume) / (_sellVolume + trade.Trade.Volume);
			_sellVolume += trade.Trade.Volume;
			_sellCount++;
			_hasSellPending = false;
		}
	}

	private void ResetState()
	{
		_buyAvgPrice = _sellAvgPrice = 0;
		_buyVolume = _sellVolume = 0;
		_buyCount = _sellCount = 0;
		_hasBuyPending = _hasSellPending = false;
	}
}