Strategy browser

Backtest the "MACD Bidir" strategy (Momentum, AMD 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-12-09 to 2026-06-14, with this config and code:
config: {"exchange":{"name":"hyperliquid","key":"","secret":"","pair_whitelist":["XYZ-AMD/USDC:USDC"]},"stoploss":-0.05,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"isolated","minimal_roi":{"0":100},"order_types":{"entry":"limit","exit":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":500,"trading_mode":"futures","stake_currency":"USDC","max_open_trades":1,"dry_run_wallet":{"USDC":1000},"unfilledtimeout":{"entry":10,"exit":10,"unit":"minutes","exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# AMD 1h bidirectional MACD cross with EMA100 regime filter, trailing exit.
class StockMacdBidir(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = True
    process_only_new_candles = True
    startup_candle_count = 120

    minimal_roi = {"0": 100.0}
    stoploss = -0.05
    trailing_stop = True
    trailing_stop_positive = 0.03
    trailing_stop_positive_offset = 0.07
    trailing_only_offset_is_reached = True

    def populate_indicators(self, df, m):
        macd = ta.MACD(df)
        df["macd"] = macd["macd"]
        df["macdsignal"] = macd["macdsignal"]
        df["ema_100"] = ta.EMA(df, timeperiod=100)
        return df

    def populate_entry_trend(self, df, m):
        bull = (df["macd"] > df["macdsignal"]) & (df["macd"].shift(1) <= df["macdsignal"].shift(1))
        bear = (df["macd"] < df["macdsignal"]) & (df["macd"].shift(1) >= df["macdsignal"].shift(1))
        df.loc[bull & (df["macd"] > 0) & (df["close"] > df["ema_100"]), "enter_long"] = 1
        df.loc[bear & (df["macd"] < 0) & (df["close"] < df["ema_100"]), "enter_short"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[(df["macd"] < df["macdsignal"]), "exit_long"] = 1
        df.loc[(df["macd"] > df["macdsignal"]), "exit_short"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Donchian Breakout" strategy (Momentum, AMD 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-12-15 to 2026-06-14, with this config and code:
config: {"exchange":{"name":"hyperliquid","key":"","secret":"","pair_whitelist":["XYZ-AMD/USDC:USDC"]},"stoploss":-0.05,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"isolated","minimal_roi":{"0":100},"order_types":{"entry":"limit","exit":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":500,"trading_mode":"futures","stake_currency":"USDC","max_open_trades":1,"dry_run_wallet":{"USDC":1000},"unfilledtimeout":{"entry":10,"exit":10,"unit":"minutes","exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# AMD 1h 48-bar Donchian breakout above EMA200, volume-confirmed, trailing exit.
class StockDonchianBreakout(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 258

    minimal_roi = {"0": 100.0}
    stoploss = -0.05
    trailing_stop = True
    trailing_stop_positive = 0.035
    trailing_stop_positive_offset = 0.07
    trailing_only_offset_is_reached = True

    def populate_indicators(self, df, m):
        df["donch_hi"] = df["high"].rolling(48).max()
        df["donch_lo"] = df["low"].rolling(48).min()
        df["ema_200"] = ta.EMA(df, timeperiod=200)
        df["vol_ma"] = df["volume"].rolling(20).mean()
        return df

    def populate_entry_trend(self, df, m):
        brk = (df["close"] >= df["donch_hi"].shift(1)) & (df["close"] > df["ema_200"]) & (df["volume"] > df["vol_ma"])
        df.loc[brk, "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["close"] <= df["donch_lo"].shift(1), "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Donchian Breakout" strategy (Momentum, HIMS 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2026-04-05 to 2026-06-14, with this config and code:
config: {"exchange":{"name":"hyperliquid","key":"","secret":"","pair_whitelist":["XYZ-HIMS/USDC:USDC"]},"stoploss":-0.06,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"isolated","minimal_roi":{"0":100},"order_types":{"entry":"limit","exit":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":500,"trading_mode":"futures","stake_currency":"USDC","max_open_trades":1,"dry_run_wallet":{"USDC":1000},"unfilledtimeout":{"entry":10,"exit":10,"unit":"minutes","exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# HIMS 1h 48-bar Donchian breakout above EMA200, volume-confirmed, trailing exit.
class StockDonchianBreakout(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 258
    minimal_roi = {"0": 100.0}
    stoploss = -0.06
    trailing_stop = True
    trailing_stop_positive = 0.035
    trailing_stop_positive_offset = 0.07
    trailing_only_offset_is_reached = True

    def populate_indicators(self, df, m):
        df["donch_hi"] = df["high"].rolling(48).max()
        df["donch_lo"] = df["low"].rolling(48).min()
        df["ema_200"] = ta.EMA(df, timeperiod=200)
        df["vol_ma"] = df["volume"].rolling(20).mean()
        return df

    def populate_entry_trend(self, df, m):
        brk = (df["close"] >= df["donch_hi"].shift(1)) & (df["close"] > df["ema_200"]) & (df["volume"] > df["vol_ma"])
        df.loc[brk, "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["close"] <= df["donch_lo"].shift(1), "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Donchian Breakout" strategy (Momentum, MU 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-12-30 to 2026-06-14, with this config and code:
config: {"exchange":{"name":"hyperliquid","key":"","secret":"","pair_whitelist":["XYZ-MU/USDC:USDC"]},"stoploss":-0.05,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"isolated","minimal_roi":{"0":100},"order_types":{"entry":"limit","exit":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":500,"trading_mode":"futures","stake_currency":"USDC","max_open_trades":1,"dry_run_wallet":{"USDC":1000},"unfilledtimeout":{"entry":10,"exit":10,"unit":"minutes","exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# MU 1h 48-bar Donchian breakout above EMA200, volume-confirmed, trailing exit.
class StockDonchianBreakout(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 258
    minimal_roi = {"0": 100.0}
    stoploss = -0.05
    trailing_stop = True
    trailing_stop_positive = 0.035
    trailing_stop_positive_offset = 0.07
    trailing_only_offset_is_reached = True

    def populate_indicators(self, df, m):
        df["donch_hi"] = df["high"].rolling(48).max()
        df["donch_lo"] = df["low"].rolling(48).min()
        df["ema_200"] = ta.EMA(df, timeperiod=200)
        df["vol_ma"] = df["volume"].rolling(20).mean()
        return df

    def populate_entry_trend(self, df, m):
        brk = (df["close"] >= df["donch_hi"].shift(1)) & (df["close"] > df["ema_200"]) & (df["volume"] > df["vol_ma"])
        df.loc[brk, "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["close"] <= df["donch_lo"].shift(1), "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "EMA Trend" strategy (Momentum, MU 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-12-22 to 2026-06-14, with this config and code:
config: {"exchange":{"name":"hyperliquid","key":"","secret":"","pair_whitelist":["XYZ-MU/USDC:USDC"]},"stoploss":-0.05,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"isolated","minimal_roi":{"0":100},"order_types":{"entry":"limit","exit":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":500,"trading_mode":"futures","stake_currency":"USDC","max_open_trades":1,"dry_run_wallet":{"USDC":1000},"unfilledtimeout":{"entry":10,"exit":10,"unit":"minutes","exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# MU 1h EMA21/55 trend-follow, ADX filter, wide trailing exit.
class StockEmaTrend(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 60
    minimal_roi = {"0": 100.0}
    stoploss = -0.05
    trailing_stop = True
    trailing_stop_positive = 0.04
    trailing_stop_positive_offset = 0.08
    trailing_only_offset_is_reached = True

    def populate_indicators(self, df, m):
        df["ema_fast"] = ta.EMA(df, timeperiod=21)
        df["ema_slow"] = ta.EMA(df, timeperiod=55)
        df["adx"] = ta.ADX(df, timeperiod=14)
        return df

    def populate_entry_trend(self, df, m):
        df.loc[(df["ema_fast"] > df["ema_slow"]) & (df["close"] > df["ema_fast"]) & (df["adx"] > 20), "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["ema_fast"] < df["ema_slow"], "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "EMA Trend" strategy (Momentum, INTC 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-12-06 to 2026-06-14, with this config and code:
config: {"exchange":{"name":"hyperliquid","key":"","secret":"","pair_whitelist":["XYZ-INTC/USDC:USDC"]},"stoploss":-0.05,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"isolated","minimal_roi":{"0":100},"order_types":{"entry":"limit","exit":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":500,"trading_mode":"futures","stake_currency":"USDC","max_open_trades":1,"dry_run_wallet":{"USDC":1000},"unfilledtimeout":{"entry":10,"exit":10,"unit":"minutes","exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# INTC 1h EMA21/55 trend-follow, ADX filter, wide trailing exit.
class StockEmaTrend(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 60
    minimal_roi = {"0": 100.0}
    stoploss = -0.05
    trailing_stop = True
    trailing_stop_positive = 0.04
    trailing_stop_positive_offset = 0.08
    trailing_only_offset_is_reached = True

    def populate_indicators(self, df, m):
        df["ema_fast"] = ta.EMA(df, timeperiod=21)
        df["ema_slow"] = ta.EMA(df, timeperiod=55)
        df["adx"] = ta.ADX(df, timeperiod=14)
        return df

    def populate_entry_trend(self, df, m):
        df.loc[(df["ema_fast"] > df["ema_slow"]) & (df["close"] > df["ema_fast"]) & (df["adx"] > 20), "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["ema_fast"] < df["ema_slow"], "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "RSI Rip Short" strategy (Momentum, BABA 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2026-01-24 to 2026-06-14, with this config and code:
config: {"exchange":{"name":"hyperliquid","key":"","secret":"","pair_whitelist":["XYZ-BABA/USDC:USDC"]},"stoploss":-0.06,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"isolated","minimal_roi":{"0":0.06,"72":0.04,"168":0.02,"336":0},"order_types":{"entry":"limit","exit":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":500,"trading_mode":"futures","stake_currency":"USDC","max_open_trades":1,"dry_run_wallet":{"USDC":1000},"unfilledtimeout":{"entry":10,"exit":10,"unit":"minutes","exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# BABA 1h short the rip: RSI>68 below EMA200, cover RSI<42 / ROI ladder.
class StockRsiRipShort(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = True
    process_only_new_candles = True
    startup_candle_count = 210
    minimal_roi = {"0":0.06,"72":0.04,"168":0.02,"336":0}
    stoploss = -0.06
    trailing_stop = False

    def populate_indicators(self, df, m):
        df["rsi"] = ta.RSI(df, timeperiod=14)
        df["ema_200"] = ta.EMA(df, timeperiod=200)
        return df

    def populate_entry_trend(self, df, m):
        df.loc[(df["rsi"] > 68) & (df["close"] < df["ema_200"]), "enter_short"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["rsi"] < 42, "exit_short"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "RSI Rip Short" strategy (Momentum, COIN 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-12-04 to 2026-06-14, with this config and code:
config: {"exchange":{"name":"hyperliquid","key":"","secret":"","pair_whitelist":["XYZ-COIN/USDC:USDC"]},"stoploss":-0.06,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"isolated","minimal_roi":{"0":0.06,"72":0.04,"168":0.02,"336":0},"order_types":{"entry":"limit","exit":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":500,"trading_mode":"futures","stake_currency":"USDC","max_open_trades":1,"dry_run_wallet":{"USDC":1000},"unfilledtimeout":{"entry":10,"exit":10,"unit":"minutes","exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# COIN 1h short the rip: RSI>68 below EMA200, cover RSI<42 / ROI ladder.
class StockRsiRipShort(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = True
    process_only_new_candles = True
    startup_candle_count = 210

    minimal_roi = {"0":0.06,"72":0.04,"168":0.02,"336":0}
    stoploss = -0.06
    trailing_stop = False

    def populate_indicators(self, df, m):
        df["rsi"] = ta.RSI(df, timeperiod=14)
        df["ema_200"] = ta.EMA(df, timeperiod=200)
        return df

    def populate_entry_trend(self, df, m):
        df.loc[(df["rsi"] > 68) & (df["close"] < df["ema_200"]), "enter_short"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["rsi"] < 42, "exit_short"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Donchian Breakout" strategy (Momentum, INTC 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-12-14 to 2026-06-14, with this config and code:
config: {"exchange":{"name":"hyperliquid","key":"","secret":"","pair_whitelist":["XYZ-INTC/USDC:USDC"]},"stoploss":-0.05,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"isolated","minimal_roi":{"0":100},"order_types":{"entry":"limit","exit":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":500,"trading_mode":"futures","stake_currency":"USDC","max_open_trades":1,"dry_run_wallet":{"USDC":1000},"unfilledtimeout":{"entry":10,"exit":10,"unit":"minutes","exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# INTC 1h 48-bar Donchian breakout above EMA200, volume-confirmed, trailing exit.
class StockDonchianBreakout(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 258
    minimal_roi = {"0": 100.0}
    stoploss = -0.05
    trailing_stop = True
    trailing_stop_positive = 0.035
    trailing_stop_positive_offset = 0.07
    trailing_only_offset_is_reached = True

    def populate_indicators(self, df, m):
        df["donch_hi"] = df["high"].rolling(48).max()
        df["donch_lo"] = df["low"].rolling(48).min()
        df["ema_200"] = ta.EMA(df, timeperiod=200)
        df["vol_ma"] = df["volume"].rolling(20).mean()
        return df

    def populate_entry_trend(self, df, m):
        brk = (df["close"] >= df["donch_hi"].shift(1)) & (df["close"] > df["ema_200"]) & (df["volume"] > df["vol_ma"])
        df.loc[brk, "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["close"] <= df["donch_lo"].shift(1), "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "MM Bidir" strategy (Momentum, HYPE 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-16 to 2026-04-27, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["HYPE/USDC:USDC"]},"stoploss":-0.02,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":2,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# HYPE bi-directional pure-maker: 93% WR, 9.6h hold, 36/64 long/
# short, 2% taker (98% maker). Acts like a market maker collecting
# spread in chop. Both sides triggered by RSI extremes only during
# low-volatility regimes (calm = maker-friendly).
class CopyHypeMmBidir(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = True
    process_only_new_candles = True
    startup_candle_count = 80

    minimal_roi = {"0": 0.012, "240": 0.006, "720": 0.002, "1440": 0}
    stoploss = -0.02
    trailing_stop = False

    def populate_indicators(self, df, m):
        df["rsi"] = ta.RSI(df, timeperiod=14)
        df["ema_21"] = ta.EMA(df, timeperiod=21)
        df["atr"] = ta.ATR(df, timeperiod=14)
        df["atr_pct"] = df["atr"] / df["close"]
        df["calm"] = df["atr_pct"] < df["atr_pct"].rolling(60).quantile(0.5)
        return df

    def populate_entry_trend(self, df, m):
        long_setup = df["calm"] & (df["close"] < df["ema_21"]) & (df["rsi"] < 38)
        short_setup = df["calm"] & (df["close"] > df["ema_21"]) & (df["rsi"] > 62)
        df.loc[long_setup, "enter_long"] = 1
        df.loc[short_setup, "enter_short"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["close"] >= df["ema_21"], "exit_long"] = 1
        df.loc[df["close"] <= df["ema_21"], "exit_short"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Balanced Swing" strategy (Momentum, HYPE 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-16 to 2026-04-27, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["HYPE/USDC:USDC"]},"stoploss":-0.03,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":1,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta

class CopyHypeBalancedSwing(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = True
    process_only_new_candles = True
    startup_candle_count = 60

    minimal_roi = {"0": 0.025, "120": 0.015, "360": 0.008, "720": 0}
    stoploss = -0.03
    trailing_stop = False

    def populate_indicators(self, df, m):
        bb = ta.BBANDS(df, timeperiod=18, nbdevup=float(1.8), nbdevdn=float(1.8))
        df["bb_u"] = bb["upperband"]
        df["bb_l"] = bb["lowerband"]
        df["bb_mid"] = bb["middleband"]
        df["rsi"] = ta.RSI(df, timeperiod=14)
        df["adx"] = ta.ADX(df, timeperiod=14)
        df["bb_squeeze"] = (df["bb_u"] - df["bb_l"]) / df["bb_mid"] < 0.04
        df["squeeze_release"] = (~df["bb_squeeze"]) & df["bb_squeeze"].shift(1)
        return df

    def populate_entry_trend(self, df, m):
        release = df["squeeze_release"] & (df["adx"] > 18)
        long_setup = release & (df["close"] > df["bb_mid"]) & (df["rsi"] > 52)
        short_setup = release & (df["close"] < df["bb_mid"]) & (df["rsi"] < 48)
        df.loc[long_setup, "enter_long"] = 1
        df.loc[short_setup, "enter_short"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["close"] < df["bb_mid"], "exit_long"] = 1
        df.loc[df["close"] > df["bb_mid"], "exit_short"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Supertrend" strategy (Momentum, ZEC 4h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-29 to 2026-05-10, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["ZEC/USDC:USDC"]},"stoploss":-0.08,"pairlists":[{"method":"StaticPairList"}],"timeframe":"4h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":1,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta

class CopyZecSupertrend(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "4h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 120

    minimal_roi = {"0": 100.0}
    stoploss = -0.08
    trailing_stop = True
    trailing_stop_positive = 0.04
    trailing_stop_positive_offset = 0.08
    trailing_only_offset_is_reached = True

    def populate_indicators(self, df, m):
        atr = ta.ATR(df, timeperiod=10)
        hl2 = (df["high"] + df["low"]) / 2
        mult = 3.0
        upper = hl2 + mult * atr
        lower = hl2 - mult * atr
        st = [0.0] * len(df)
        dir_up = [True] * len(df)
        for i in range(1, len(df)):
            prev = st[i - 1]
            if df["close"].iloc[i] > prev:
                dir_up[i] = True
            elif df["close"].iloc[i] < prev:
                dir_up[i] = False
            else:
                dir_up[i] = dir_up[i - 1]
            if dir_up[i]:
                st[i] = max(lower.iloc[i], prev) if dir_up[i - 1] else lower.iloc[i]
            else:
                st[i] = min(upper.iloc[i], prev) if not dir_up[i - 1] else upper.iloc[i]
        df["st"] = st
        df["st_dir_up"] = dir_up
        df["ema_50"] = ta.EMA(df, timeperiod=50)
        return df

    def populate_entry_trend(self, df, m):
        flip_up = df["st_dir_up"] & (~df["st_dir_up"].shift(1).fillna(False))
        trend = df["close"] > df["ema_50"]
        df.loc[flip_up & trend, "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[~df["st_dir_up"], "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Hype Balanced Swing" strategy (Momentum, SOL 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-16 to 2026-04-27, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["SOL/USDC:USDC"]},"stoploss":-0.03,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":1,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta

class CopyHypeBalancedSwing(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = True
    process_only_new_candles = True
    startup_candle_count = 60

    minimal_roi = {"0": 0.025, "120": 0.015, "360": 0.008, "720": 0}
    stoploss = -0.03
    trailing_stop = False

    def populate_indicators(self, df, m):
        bb = ta.BBANDS(df, timeperiod=18, nbdevup=float(1.8), nbdevdn=float(1.8))
        df["bb_u"] = bb["upperband"]
        df["bb_l"] = bb["lowerband"]
        df["bb_mid"] = bb["middleband"]
        df["rsi"] = ta.RSI(df, timeperiod=14)
        df["adx"] = ta.ADX(df, timeperiod=14)
        df["bb_squeeze"] = (df["bb_u"] - df["bb_l"]) / df["bb_mid"] < 0.04
        df["squeeze_release"] = (~df["bb_squeeze"]) & df["bb_squeeze"].shift(1)
        return df

    def populate_entry_trend(self, df, m):
        release = df["squeeze_release"] & (df["adx"] > 18)
        long_setup = release & (df["close"] > df["bb_mid"]) & (df["rsi"] > 52)
        short_setup = release & (df["close"] < df["bb_mid"]) & (df["rsi"] < 48)
        df.loc[long_setup, "enter_long"] = 1
        df.loc[short_setup, "enter_short"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["close"] < df["bb_mid"], "exit_long"] = 1
        df.loc[df["close"] > df["bb_mid"], "exit_short"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Ichimoku Bidir" strategy (Momentum, ZEC 4h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-26 to 2026-05-07, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["ZEC/USDC:USDC"]},"stoploss":-0.05,"pairlists":[{"method":"StaticPairList"}],"timeframe":"4h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":1,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta

class CopyZecIchimokuBidir(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "4h"
    can_short = True
    process_only_new_candles = True
    startup_candle_count = 200

    minimal_roi = {"0": 100.0}
    stoploss = -0.05
    trailing_stop = True
    trailing_stop_positive = 0.025
    trailing_stop_positive_offset = 0.045
    trailing_only_offset_is_reached = True

    def populate_indicators(self, df, m):
        high9 = df["high"].rolling(9).max()
        low9 = df["low"].rolling(9).min()
        high26 = df["high"].rolling(26).max()
        low26 = df["low"].rolling(26).min()
        high52 = df["high"].rolling(52).max()
        low52 = df["low"].rolling(52).min()
        df["tenkan"] = (high9 + low9) / 2
        df["kijun"] = (high26 + low26) / 2
        df["senkou_a"] = ((df["tenkan"] + df["kijun"]) / 2).shift(26)
        df["senkou_b"] = ((high52 + low52) / 2).shift(26)
        df["cloud_top"] = df[["senkou_a", "senkou_b"]].max(axis=1)
        df["cloud_bot"] = df[["senkou_a", "senkou_b"]].min(axis=1)
        return df

    def populate_entry_trend(self, df, m):
        tk_bull = (df["tenkan"] > df["kijun"]) & (df["tenkan"].shift(1) <= df["kijun"].shift(1))
        tk_bear = (df["tenkan"] < df["kijun"]) & (df["tenkan"].shift(1) >= df["kijun"].shift(1))
        df.loc[tk_bull & (df["close"] > df["cloud_top"]), "enter_long"] = 1
        df.loc[tk_bear & (df["close"] < df["cloud_bot"]), "enter_short"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["close"] < df["kijun"], "exit_long"] = 1
        df.loc[df["close"] > df["kijun"], "exit_short"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Short Reversal" strategy (Momentum, DOGE 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-16 to 2026-04-27, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["DOGE/USDC:USDC"]},"stoploss":-0.022,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":2,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta

class CopyDogeShortReversal(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = True
    process_only_new_candles = True
    startup_candle_count = 60

    minimal_roi = {"0": 0.018, "60": 0.012, "180": 0.006, "360": 0}
    stoploss = -0.022
    trailing_stop = False

    def populate_indicators(self, df, m):
        df["rsi"] = ta.RSI(df, timeperiod=14)
        macd = ta.MACD(df, fastperiod=12, slowperiod=26, signalperiod=9)
        df["macd_hist"] = macd["macdhist"]
        df["macd_falling"] = df["macd_hist"] < df["macd_hist"].shift(1)
        df["macd_rising"] = df["macd_hist"] > df["macd_hist"].shift(1)
        df["ema_50"] = ta.EMA(df, timeperiod=50)
        return df

    def populate_entry_trend(self, df, m):
        short_setup = (df["rsi"] > 72) & df["macd_falling"] & (df["close"] > df["ema_50"])
        long_setup = (df["rsi"] < 28) & df["macd_rising"] & (df["close"] < df["ema_50"])
        df.loc[short_setup, "enter_short"] = 1
        df.loc[long_setup, "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["rsi"] < 50, "exit_short"] = 1
        df.loc[df["rsi"] > 50, "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Zec Ichimoku Bidir" strategy (Momentum, SUI 4h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-16 to 2026-04-27, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["SUI/USDC:USDC"]},"stoploss":-0.05,"pairlists":[{"method":"StaticPairList"}],"timeframe":"4h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":1,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta

class CopyZecIchimokuBidir(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "4h"
    can_short = True
    process_only_new_candles = True
    startup_candle_count = 200

    minimal_roi = {"0": 100.0}
    stoploss = -0.05
    trailing_stop = True
    trailing_stop_positive = 0.025
    trailing_stop_positive_offset = 0.045
    trailing_only_offset_is_reached = True

    def populate_indicators(self, df, m):
        high9 = df["high"].rolling(9).max()
        low9 = df["low"].rolling(9).min()
        high26 = df["high"].rolling(26).max()
        low26 = df["low"].rolling(26).min()
        high52 = df["high"].rolling(52).max()
        low52 = df["low"].rolling(52).min()
        df["tenkan"] = (high9 + low9) / 2
        df["kijun"] = (high26 + low26) / 2
        df["senkou_a"] = ((df["tenkan"] + df["kijun"]) / 2).shift(26)
        df["senkou_b"] = ((high52 + low52) / 2).shift(26)
        df["cloud_top"] = df[["senkou_a", "senkou_b"]].max(axis=1)
        df["cloud_bot"] = df[["senkou_a", "senkou_b"]].min(axis=1)
        return df

    def populate_entry_trend(self, df, m):
        tk_bull = (df["tenkan"] > df["kijun"]) & (df["tenkan"].shift(1) <= df["kijun"].shift(1))
        tk_bear = (df["tenkan"] < df["kijun"]) & (df["tenkan"].shift(1) >= df["kijun"].shift(1))
        df.loc[tk_bull & (df["close"] > df["cloud_top"]), "enter_long"] = 1
        df.loc[tk_bear & (df["close"] < df["cloud_bot"]), "enter_short"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["close"] < df["kijun"], "exit_long"] = 1
        df.loc[df["close"] > df["kijun"], "exit_short"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Hype Balanced Swing" strategy (Momentum, AVAX 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-16 to 2026-04-27, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["AVAX/USDC:USDC"]},"stoploss":-0.03,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":1,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta

class CopyHypeBalancedSwing(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = True
    process_only_new_candles = True
    startup_candle_count = 60

    minimal_roi = {"0": 0.025, "120": 0.015, "360": 0.008, "720": 0}
    stoploss = -0.03
    trailing_stop = False

    def populate_indicators(self, df, m):
        bb = ta.BBANDS(df, timeperiod=18, nbdevup=float(1.8), nbdevdn=float(1.8))
        df["bb_u"] = bb["upperband"]
        df["bb_l"] = bb["lowerband"]
        df["bb_mid"] = bb["middleband"]
        df["rsi"] = ta.RSI(df, timeperiod=14)
        df["adx"] = ta.ADX(df, timeperiod=14)
        df["bb_squeeze"] = (df["bb_u"] - df["bb_l"]) / df["bb_mid"] < 0.04
        df["squeeze_release"] = (~df["bb_squeeze"]) & df["bb_squeeze"].shift(1)
        return df

    def populate_entry_trend(self, df, m):
        release = df["squeeze_release"] & (df["adx"] > 18)
        long_setup = release & (df["close"] > df["bb_mid"]) & (df["rsi"] > 52)
        short_setup = release & (df["close"] < df["bb_mid"]) & (df["rsi"] < 48)
        df.loc[long_setup, "enter_long"] = 1
        df.loc[short_setup, "enter_short"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["close"] < df["bb_mid"], "exit_long"] = 1
        df.loc[df["close"] > df["bb_mid"], "exit_short"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "RSI Dip" strategy (Mean reversion, AMZN 1h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-27 to 2026-06-14, with this config and code:
config: {"exchange":{"name":"hyperliquid","key":"","secret":"","pair_whitelist":["XYZ-AMZN/USDC:USDC"]},"stoploss":-0.05,"pairlists":[{"method":"StaticPairList"}],"timeframe":"1h","margin_mode":"isolated","minimal_roi":{"0":0.05,"48":0.03,"120":0.015,"240":0},"order_types":{"entry":"limit","exit":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":500,"trading_mode":"futures","stake_currency":"USDC","max_open_trades":1,"dry_run_wallet":{"USDC":1000},"unfilledtimeout":{"entry":10,"exit":10,"unit":"minutes","exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# AMZN 1h RSI<30 dip-buy while above EMA200, exit on RSI>55 / ROI ladder.
class StockRsiDip(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "1h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 210

    minimal_roi = {"0":0.05,"48":0.03,"120":0.015,"240":0}
    stoploss = -0.05
    trailing_stop = False

    def populate_indicators(self, df, m):
        df["rsi"] = ta.RSI(df, timeperiod=14)
        df["ema_200"] = ta.EMA(df, timeperiod=200)
        df["ema_50"] = ta.EMA(df, timeperiod=50)
        return df

    def populate_entry_trend(self, df, m):
        dip = (df["rsi"] < 30) & (df["close"] > df["ema_200"])
        df.loc[dip, "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["rsi"] > 55, "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Maker Revert" strategy (Mean reversion, VVV 4h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-16 to 2026-04-27, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["VVV/USDC:USDC"]},"stoploss":-0.035,"pairlists":[{"method":"StaticPairList"}],"timeframe":"4h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":2,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta

class CopyVvvMakerRevert(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "4h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 60

    minimal_roi = {"0": 0.03, "240": 0.015, "1440": 0.005, "2880": 0}
    stoploss = -0.035
    trailing_stop = False

    def populate_indicators(self, df, m):
        df["dlow_14"] = df["low"].rolling(14).min()
        df["dhigh_14"] = df["high"].rolling(14).max()
        df["rsi"] = ta.RSI(df, timeperiod=14)
        df["ema_50"] = ta.EMA(df, timeperiod=50)
        return df

    def populate_entry_trend(self, df, m):
        uptrend = df["close"] > df["ema_50"]
        near_dlow = df["low"] <= df["dlow_14"].shift(1) * 1.01
        not_panic = df["rsi"] > 32
        df.loc[uptrend & near_dlow & not_panic, "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["high"] >= df["dhigh_14"].shift(1) * 0.99, "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Vvv Maker Revert" strategy (Mean reversion, SOL 4h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-16 to 2026-04-27, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["SOL/USDC:USDC"]},"stoploss":-0.035,"pairlists":[{"method":"StaticPairList"}],"timeframe":"4h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":2,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# VVV maker mean-revert: 75% WR, 26h hold, 19% taker (81% maker).
# Wallet posts limit bids at Donchian-low touches in established
# uptrend, takes quick small targets. 4h cadence matches hold time.
class CopyVvvMakerRevert(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "4h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 60

    minimal_roi = {"0": 0.03, "240": 0.015, "1440": 0.005, "2880": 0}
    stoploss = -0.035
    trailing_stop = False

    def populate_indicators(self, df, m):
        df["dlow_14"] = df["low"].rolling(14).min()
        df["dhigh_14"] = df["high"].rolling(14).max()
        df["rsi"] = ta.RSI(df, timeperiod=14)
        df["ema_50"] = ta.EMA(df, timeperiod=50)
        return df

    def populate_entry_trend(self, df, m):
        uptrend = df["close"] > df["ema_50"]
        near_dlow = df["low"] <= df["dlow_14"].shift(1) * 1.01
        not_panic = df["rsi"] > 32
        df.loc[uptrend & near_dlow & not_panic, "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["high"] >= df["dhigh_14"].shift(1) * 0.99, "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Vvv Maker Revert" strategy (Mean reversion, LINK 4h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-16 to 2026-04-27, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["LINK/USDC:USDC"]},"stoploss":-0.035,"pairlists":[{"method":"StaticPairList"}],"timeframe":"4h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":2,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# VVV maker mean-revert: 75% WR, 26h hold, 19% taker (81% maker).
# Wallet posts limit bids at Donchian-low touches in established
# uptrend, takes quick small targets. 4h cadence matches hold time.
class CopyVvvMakerRevert(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "4h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 60

    minimal_roi = {"0": 0.03, "240": 0.015, "1440": 0.005, "2880": 0}
    stoploss = -0.035
    trailing_stop = False

    def populate_indicators(self, df, m):
        df["dlow_14"] = df["low"].rolling(14).min()
        df["dhigh_14"] = df["high"].rolling(14).max()
        df["rsi"] = ta.RSI(df, timeperiod=14)
        df["ema_50"] = ta.EMA(df, timeperiod=50)
        return df

    def populate_entry_trend(self, df, m):
        uptrend = df["close"] > df["ema_50"]
        near_dlow = df["low"] <= df["dlow_14"].shift(1) * 1.01
        not_panic = df["rsi"] > 32
        df.loc[uptrend & near_dlow & not_panic, "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["high"] >= df["dhigh_14"].shift(1) * 0.99, "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Vvv Maker Revert" strategy (Mean reversion, BCH 4h) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2025-11-16 to 2026-04-27, with this config and code:
config: {"exchange":{"key":"","name":"hyperliquid","secret":"","pair_whitelist":["BCH/USDC:USDC"]},"stoploss":-0.035,"pairlists":[{"method":"StaticPairList"}],"timeframe":"4h","margin_mode":"cross","minimal_roi":{"0":100},"order_types":{"exit":"limit","entry":"limit","stoploss":"market","stoploss_on_exchange":false},"exit_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_amount":100,"trading_mode":"futures","entry_pricing":{"price_side":"same","order_book_top":1,"use_order_book":true},"stake_currency":"USDC","max_open_trades":2,"unfilledtimeout":{"exit":10,"unit":"minutes","entry":10,"exit_timeout_count":0}}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


# VVV maker mean-revert: 75% WR, 26h hold, 19% taker (81% maker).
# Wallet posts limit bids at Donchian-low touches in established
# uptrend, takes quick small targets. 4h cadence matches hold time.
class CopyVvvMakerRevert(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = "4h"
    can_short = False
    process_only_new_candles = True
    startup_candle_count = 60

    minimal_roi = {"0": 0.03, "240": 0.015, "1440": 0.005, "2880": 0}
    stoploss = -0.035
    trailing_stop = False

    def populate_indicators(self, df, m):
        df["dlow_14"] = df["low"].rolling(14).min()
        df["dhigh_14"] = df["high"].rolling(14).max()
        df["rsi"] = ta.RSI(df, timeperiod=14)
        df["ema_50"] = ta.EMA(df, timeperiod=50)
        return df

    def populate_entry_trend(self, df, m):
        uptrend = df["close"] > df["ema_50"]
        near_dlow = df["low"] <= df["dlow_14"].shift(1) * 1.01
        not_panic = df["rsi"] > 32
        df.loc[uptrend & near_dlow & not_panic, "enter_long"] = 1
        return df

    def populate_exit_trend(self, df, m):
        df.loc[df["high"] >= df["dhigh_14"].shift(1) * 0.99, "exit_long"] = 1
        return df


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).

Backtest the "Brent Scalp" strategy (Scalping, BRENTOIL 5m) on Superior Trade, then report the results.

Step 1 — install the Superior Trade skill:
  - OpenClaw: tell your agent "Install superior-skills"
  - or clone it: git clone https://github.com/Superior-Trade/superior-skills into your agent's skills folder
  - set your key: export SUPERIOR_TRADE_API_KEY=st_live_your_key_here

Step 2 — create the backtest (POST https://api.superior.trade/v1/backtesting, header "x-api-key: $SUPERIOR_TRADE_API_KEY", JSON body) over timerange 2026-03-04 to 2026-04-14, with this config and code:
config: {"exchange":{"name":"hyperliquid","pair_whitelist":["XYZ-BRENTOIL/USDC:USDC"]},"stoploss":-0.02,"pairlists":[{"method":"StaticPairList"}],"timeframe":"5m","margin_mode":"isolated","minimal_roi":{"0":0.015,"15":0.008,"30":0.004},"exit_pricing":{"price_side":"other"},"stake_amount":200,"trading_mode":"futures","entry_pricing":{"price_side":"other"},"stake_currency":"USDC","max_open_trades":1}
code:
from freqtrade.strategy import IStrategy
import pandas as pd
import talib.abstract as ta


class BrentScalpV7Strategy(IStrategy):
    minimal_roi = {"0": 0.015, "15": 0.008, "30": 0.004}
    stoploss = -0.02
    trailing_stop = True
    trailing_stop_positive = 0.004
    trailing_stop_positive_offset = 0.008
    trailing_only_offset_is_reached = True
    timeframe = "5m"
    process_only_new_candles = True
    startup_candle_count = 50

    def populate_indicators(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
        dataframe["ema_9"] = ta.EMA(dataframe, timeperiod=9)
        dataframe["ema_21"] = ta.EMA(dataframe, timeperiod=21)
        dataframe["ema_50"] = ta.EMA(dataframe, timeperiod=50)
        dataframe["rsi"] = ta.RSI(dataframe, timeperiod=14)
        dataframe["adx"] = ta.ADX(dataframe, timeperiod=14)

        macd = ta.MACD(dataframe, fastperiod=12, slowperiod=26, signalperiod=9)
        dataframe["macd_hist"] = macd["macdhist"]

        dataframe["vol_sma"] = dataframe["volume"].rolling(window=20).mean()
        return dataframe

    def populate_entry_trend(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
        dataframe.loc[
            # Macro trend filter
            (dataframe["close"] > dataframe["ema_50"]) &
            # EMA momentum cross
            (dataframe["ema_9"] > dataframe["ema_21"]) &
            (dataframe["close"] > dataframe["ema_9"]) &
            # RSI tighter band — avoid late entries
            (dataframe["rsi"] > 50) &
            (dataframe["rsi"] < 63) &
            # ADX > 20 = trending market (avoid choppy conditions)
            (dataframe["adx"] > 20) &
            # MACD positive AND increasing
            (dataframe["macd_hist"] > 0) &
            (dataframe["macd_hist"] > dataframe["macd_hist"].shift(1)) &
            # Volume conviction
            (dataframe["volume"] > dataframe["vol_sma"] * 1.2) &
            (dataframe["volume"] > 0),
            "enter_long"
        ] = 1
        return dataframe

    def populate_exit_trend(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
        dataframe.loc[
            (dataframe["ema_9"] < dataframe["ema_21"]) |
            (dataframe["rsi"] > 78),
            "exit_long"
        ] = 1
        return dataframe


Step 3 — start it: PUT https://api.superior.trade/v1/backtesting/{id}/status with body {"action":"start"}

Step 4 — poll GET https://api.superior.trade/v1/backtesting/{id} until status is "completed", fetch the resultUrl, and report profit_total, winrate, sharpe, and max_drawdown_account. These are top-level fields in the result JSON; profit_total, winrate, and max_drawdown_account are fractions (0.06 = 6%).