GridStrategyMinimal

"""
GridStrategyMinimal — DCA-on-dips approximation of a grid bot.

True grid bots place a static ladder of buy/sell limit orders across a price
range; freqtrade can't express that directly (one order per side per pair).
This strategy tests the same mean-reversion thesis with freqtrade's native
position_adjustment_enable mechanism:

  - Enter when price drops below 20-bar SMA by >= GRID_STEP_PCT.
  - Each subsequent tranche is added when price drops a further GRID_STEP_PCT
    below the previous entry, up to MAX_LEVELS.
  - Each open position exits at GRID_STEP_PCT profit (ROI ladder).
  - Stop-loss is intentionally wide — grid bots accept being underwater.

Drafted as the kill-gate test for the "is grid bot a viable diversifier"
question.
"""
from datetime import datetime
from typing import Optional

import talib.abstract as ta
from pandas import DataFrame
from freqtrade.persistence import Trade
from freqtrade.strategy import IStrategy

GRID_STEP_PCT = 0.015
MAX_LEVELS = 5
SMA_PERIOD = 20


class GridStrategyMinimal(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"

    minimal_roi = {"0": GRID_STEP_PCT}
    stoploss = -0.30

    trailing_stop = False
    process_only_new_candles = True
    use_exit_signal = False
    exit_profit_only = False

    position_adjustment_enable = True
    max_entry_position_adjustment = MAX_LEVELS - 1

    startup_candle_count = SMA_PERIOD + 5

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe["sma"] = ta.SMA(dataframe["close"], timeperiod=SMA_PERIOD)
        dataframe["pct_from_sma"] = (dataframe["close"] - dataframe["sma"]) / dataframe["sma"]
        return dataframe

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[dataframe["pct_from_sma"] < -GRID_STEP_PCT, "enter_long"] = 1
        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe["exit_long"] = 0
        return dataframe

    def adjust_trade_position(
        self,
        trade: Trade,
        current_time: datetime,
        current_rate: float,
        current_profit: float,
        min_stake: Optional[float],
        max_stake: float,
        current_entry_rate: float,
        current_exit_rate: float,
        current_entry_profit: float,
        current_exit_profit: float,
        **kwargs,
    ) -> Optional[float]:
        if trade.nr_of_successful_entries >= MAX_LEVELS:
            return None
        filled_entries = trade.select_filled_orders(trade.entry_side)
        if not filled_entries:
            return None
        last_entry_price = filled_entries[-1].price
        if current_rate < last_entry_price * (1 - GRID_STEP_PCT):
            return trade.stake_amount
        return None