Overnight Effect High Volatility Crypto Strategy

using System;

using Ecng.Common;

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

namespace StockSharp.Samples.Strategies;

public class OvernightEffectHighVolatilityCryptoStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;

	private DateTime _currentDay;
	private bool _tradeTakenToday;

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

	public OvernightEffectHighVolatilityCryptoStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame());
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_currentDay = default;
		_tradeTakenToday = false;
	}

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

		_currentDay = default;
		_tradeTakenToday = false;

		var sma = new SimpleMovingAverage { Length = 20 };
		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(sma, (candle, smaVal) =>
			{
				if (candle.State != CandleStates.Finished)
					return;

				if (!sma.IsFormed)
					return;

				var day = candle.OpenTime.Date;
				if (_currentDay != day)
				{
					_currentDay = day;
					_tradeTakenToday = false;
				}

				if (_tradeTakenToday)
					return;

				var hour = candle.OpenTime.Hour;

				// Buy at 20:00, only once per day
				if (hour == 20 && Position <= 0 && candle.ClosePrice > smaVal)
				{
					BuyMarket();
					_tradeTakenToday = true;
				}
				// Sell at 8:00, only once per day
				else if (hour == 8 && Position >= 0 && candle.ClosePrice < smaVal)
				{
					SellMarket();
					_tradeTakenToday = true;
				}
			})
			.Start();

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

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 SimpleMovingAverage
from StockSharp.Algo.Strategies import Strategy


class overnight_effect_high_volatility_crypto_strategy(Strategy):
    def __init__(self):
        super(overnight_effect_high_volatility_crypto_strategy, self).__init__()
        self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromMinutes(5)))
        self._current_day = None
        self._trade_taken_today = False

    @property
    def candle_type(self):
        return self._candle_type.Value

    @candle_type.setter
    def candle_type(self, value):
        self._candle_type.Value = value

    def OnReseted(self):
        super(overnight_effect_high_volatility_crypto_strategy, self).OnReseted()
        self._current_day = None
        self._trade_taken_today = False

    def OnStarted2(self, time):
        super(overnight_effect_high_volatility_crypto_strategy, self).OnStarted2(time)
        self._current_day = None
        self._trade_taken_today = False
        self._sma = SimpleMovingAverage()
        self._sma.Length = 20
        subscription = self.SubscribeCandles(self.candle_type)
        subscription.Bind(self._sma, self.OnProcess).Start()

    def OnProcess(self, candle, sma_val):
        if candle.State != CandleStates.Finished:
            return
        if not self._sma.IsFormed:
            return
        sv = float(sma_val)
        close = float(candle.ClosePrice)
        day = candle.OpenTime.Date
        if self._current_day is None or self._current_day != day:
            self._current_day = day
            self._trade_taken_today = False
        if self._trade_taken_today:
            return
        hour = candle.OpenTime.Hour
        if hour == 20 and self.Position <= 0 and close > sv:
            self.BuyMarket()
            self._trade_taken_today = True
        elif hour == 8 and self.Position >= 0 and close < sv:
            self.SellMarket()
            self._trade_taken_today = True

    def CreateClone(self):
        return overnight_effect_high_volatility_crypto_strategy()