Hypotheses

Reproduce the supplied executable grid strategy, credited to 51bitquant, using LTCUSDT.BINANCE_SPOT, a CASH account, leverage 1.0 and $100,000 starting capital. Source defaults are exactly grid_step=2.0 quote-currency units, profit_step=2.0 quote-currency units, trading_size=1.0 base unit, max_pos=100, profit_orders_counts=10, trailing_stop_multiplier=2.0 and stop_minutes=360.0. Timer constants are NORMAL_TIMER_INTERVAL=5, PROFIT_TIMER_INTERVAL=5 and STOP_TIMER_INTERVAL=60 event callbacks, not bar counts. get_step() always returns 1. on_tick only stores the latest bid/ask; on_bar and on_stop_order do nothing. Initialize the source position calculator from current position and avg_price, initially 0.0; register the timer on start and unregister it on stop. Preserve the actual code, including its defective cooldown and ineffective hard inventory cap; do not silently repair either. This is a reproduction experiment with unverified performance, not a recommendation for deployment.

Concrete trading idea: reproduce the supplied DualThrustStrategy, credited to 用Python的交易员, using AVAXUSDT.BYBIT one-minute bars. Source: https://github.com/51bitquant/howtrader/blob/fcad8e2d86825506b9d33441ab78be853c2c3bdd/examples/strategies/dual_thrust_strategy.py . Preserve the exact source defaults fixed_size=1, k1=0.4, k2=0.6 and exit_time=14:55. This implementation uses the previous calendar day's high-minus-low, not the conventional multi-day Dual Thrust range formula. Preserve literal fixed-size quantity: one AVAX per entry or opposing stop order. This is an explicit exception to capital-relative sizing for faithful reproduction; replacing it with an equity fraction would change the submitted strategy. Use a MARGIN account with configured leverage=1.0. Platform fees are 0.020% maker and 0.055% taker per fill; all-taker round-trip cost is 0.110% of notional. The source has no performance evidence. Use UTC as the explicitly chosen platform calendar timezone because the source supplies no timezone. Preserve one-minute bar opening timestamps for its date/time comparisons by deriving them from platform close timestamps; orders are submitted only after the bar becomes available.

Translate the supplied TurtleRules implementation by FengkieJ, published in Jesse's example-strategies repository under MIT, preserving executable behavior rather than correcting it to textbook Turtle rules. Trade AVAXUSD.HYPERLIQUID long and short on 1-DAY bars with $100,000 starting capital. The source does not prescribe a symbol or bar interval; these are platform research choices. Exact source defaults are unit_risk_percent=1, entry_dc_period=20, exit_dc_period=10, atr_period=20, atr_multiplier=2, maximum_pyramiding_levels=4, pyramiding_threshold=0.5, system_type='S1', and dollars_per_point=1. Initialize current_pyramiding_levels=0, last_opened_price=0, last_was_profitable=false. The before() hook assigns these defaults each evaluation. No performance claim is accepted without our own fee-inclusive backtest.

Translate the supplied IFR2 strategy without changing its trading rules. Credit: Jesse community; the source identifies gabrielweich/jesse-strategies. Use ADAUSDT.BINANCE_SPOT on 4-HOUR bars, CASH account, long-only, leverage 1.0. Instrument and interval are platform research choices: neither is specified by the source. Preserve RSI period 2, entry threshold 10, Ichimoku periods 20/30/120 and displacement 60, Hilbert Transform trend-mode filtering, entire-balance fee-adjusted sizing, unconditional cancellation of pending entries, and the two-prior-high exit. There is no source stop-loss, profit target, maximum holding period, pyramiding rule, or signal-dependent sizing. Performance remains unverified. [Pinned IFR2 source](https://github.com/jesse-ai/example-strategies/blob/7c91e0a37bf62165790120d730442e4f6eb00364/IFR2/__init__.py).

The supplied code is a tradeable, long-only NASDAQ-100 allocation strategy, not merely an LSTM utility. Credit: Quantiacs; licence reported as MIT in the brief. It trains separate neural networks for 12 low-volatility eligible stocks and converts their raw outputs into daily portfolio weights smoothed against previous weights. A faithful executable port is currently infeasible: the documented equity feed does not establish availability of Quantiacs' historical NASDAQ-100 eligibility/is_liquid series, and the strategy sandbox forbids imports of torch, qnt, xarray and pandas. Do not substitute today's constituents, a hand-picked basket, a crypto universe or another model. This specification describes the supplied source; its performance is unverified.

Translate limin's Apache-2.0 TqSdk Turtle demonstration at the supplied commit, preserving its actual rules rather than substituting textbook Turtle rules. Replace the original expired SHFE.au2006 gold contract with LTCUSD.HYPERLIQUID, a linear perpetual permitting both directions. Defaults are donchian_channel_open_position=20, donchian_channel_stop_profit=10, atr_day_length=20 and max_risk_ratio=0.5. Maintain a 100-slot daily candle buffer, including the developing current candle. Execution responds to changed last-trade prices, not daily closes. Start with target position=0 and last_price=NaN. Run parameter recalculation initially and subsequently only when a new daily candle starts WHILE FLAT. While invested, N and unit remain frozen, but the rolling 10-completed-day exit channel continues changing. Historical trade ticks are required to reconstruct the developing candle and execution sequence; daily OHLCV alone cannot faithfully reproduce this example. Missing adequate tick history makes the faithful experiment infeasible, rather than authorizing a close-only substitute.

Reproduce the executable rules of Chaos's Apache-2.0 TqSdk hull example, preserving all signal and exit defaults, including apparent mistakes and unused settings. Original market: SHFE.au2306 gold futures; original target position: +/-30 contracts; original backtest dates: 2022-11-01 through 2023-04-01; original bar interval: 86400 seconds. Platform adaptation: LTCUSD.HYPERLIQUID perpetual, long and short, 1x configured leverage, capital-relative sizing. This tests transfer of the rules to crypto, not reproduction of the original gold results. Important timing detail: the source evaluates when the latest daily bar's datetime changes, using that newly forming bar, not when its daily close becomes final. A faithful implementation therefore needs the first observed trade of each new UTC daily bar plus preceding completed daily OHLCV. Do not use that day's eventual high, low or close at its opening timestamp. A completed-daily-close implementation would be a separately identified adaptation, not a faithful timing port.

Faithful research port of the supplied MIT-licensed KingKeltnerStrategy, credited to 用Python的交易员. Preserve source defaults exactly: kk_length=11, kk_dev=1.6, trailing_percent=0.8 and fixed_size=1. Trade AVAXUSDT.BYBIT perpetuals, long or short, with 5-minute signal updates and 1-minute execution bars. The source aggregates minute bars into clock-aligned 5-minute bars, requests 10 days of initialization history, and uses a default 100-element ArrayManager. Preserve its rolling-array indicator calculations and initialization gate. The only deliberate strategy adaptation is capital-relative sizing: fixed_size=1 represents one platform allocation unit rather than one AVAX. No extra trend filter, profit target, funding filter, cooldown or holding-time exit is authorized. This is an unverified reproduction experiment, not an assertion that the source is profitable.

Reproduce the supplied TurtleSignalStrategy trading rules, credited to 用Python的交易员, with original defaults entry_window=20, exit_window=10, atr_window=20 and fixed_size=1. This is an executable long-short strategy, not a utility. Use AVAXUSD.HYPERLIQUID-4-HOUR-LAST-EXTERNAL with a MARGIN account and leverage=1.0. Two platform adaptations are explicit: feed completed 4-hour bars instead of the source's default tick-generated 1-minute bars, and interpret fixed_size=1 as one capital-relative allocation unit rather than one literal coin/contract. These adaptations preserve channel, order, fill-callback and pyramiding rules, but do not constitute an identical minute-frequency or fixed-contract experiment. Keep all parameters fixed; do not add trend filters, funding gates, profit targets or conventional Turtle last-fill ladders. Performance is unverified.

StatArb by Myquant is trading code, not a utility. However, a faithful executable hypothesis cannot be instantiated on this platform: its signal handler hardcodes IF1703 and IF1704, historical CFFEX contracts, while CFFEX instruments, data and fees are absent from the supplied platform infrastructure. Replacing them with crypto perpetuals would change the economic mechanism. Preserve the specification below as a source audit; do not send it to coding as a viable strategy. Source: https://github.com/myquant/strategy/blob/17595e6bf4a118e1fa87c90bfb0fd78afa69a60b/Arbitrage/python/strategy_sa.py. Licence reported in the brief: Apache-2.0.

Translate the supplied MIT-licensed DualThrustStrategy into FactoryStrategy, preserving its trading branches and defaults: k1=0.4, k2=0.6, fixed_size=1, exit_time=14:55, and load_bar(10). Trade AVAXUSDT.BINANCE using 1-MINUTE bars, a MARGIN netting account, and leverage=1.0. The original instrument, timezone, and contract multiplier are unspecified; this experiment explicitly chooses AVAX and UTC. Source attribution: [vn.py DualThrustStrategy by 用Python的交易员](https://github.com/vnpy/vnpy_ctastrategy/blob/6ef76981624bf55b2ea978f8587f74d633aafc72/vnpy_ctastrategy/strategies/dual_thrust_strategy.py). This implementation uses the previous accumulated calendar day's high minus low, not the textbook multi-day Dual Thrust range formula. Preserve the signal and order rules; the only sizing adaptation is mapping one source size unit to a capital-relative platform quantity. Performance is unverified.

This is executable trading strategy code, not a display utility. Preserve its numerical defaults and ordered branches. Original settings are SYMBOL=SHFE.au2106, POSITION_SIZE=50 contracts, START_DATE=2020-11-01, END_DATE=2020-12-15, daily bars of 86400 seconds, WINDOW_SIZE=14, ENTRY_THRESHOLD=1.8, EXIT_THRESHOLD=0.4, STOP_LOSS_THRESHOLD=2.5 and TIME_STOP_DAYS=8. The comment mentioning 20 days is inaccurate: the executable slice uses 14. A proposed platform-market adaptation is LTCUSD.HYPERLIQUID, long-short, with daily observations and fixed 20% equity notional at entry, leverage 1.0. This changes the instrument and sizing, so it is not a reproduction of the original gold-contract results. Exact signal timing also needs support: the source evaluates when the newest daily bar's datetime changes, using that developing bar's current close, rather than waiting for its completed daily close. A completed-daily-close implementation must be recorded as a separate adaptation.

Reproduce the supplied RSI2 trading strategy, originally implemented by FengkieJ on 2020-06-27 from Larry Connors' RSI2 concept. Preserve every strategy rule and all five defaults: fast_sma_period=5, slow_sma_period=200, rsi_period=2, rsi_ob_threshold=90, rsi_os_threshold=10. Test DOTUSD.HYPERLIQUID on 1-DAY bars with a margin account, fixed 1.0 leverage and the source's entire-balance, fee-adjusted sizing. The source specifies neither instrument nor timeframe; these are platform research choices, not original defaults. No stop-loss, profit target, maximum holding time, funding filter or signal-strength sizing is present. Performance is unverified. Source: [pinned RSI2 implementation](https://github.com/jesse-ai/example-strategies/blob/7c91e0a37bf62165790120d730442e4f6eb00364/RSI2/__init__.py).

Faithful line-for-line translation of the GPL-3.0 Freqtrade strategy 'Low_BB' by berlinguyinca (author Thorsten), https://github.com/freqtrade/freqtrade-strategies/blob/f3340ce11f5bdf62f598522e64d1f5638eaa13f5/user_data/strategies/berlinguyinca/Low_BB.py. The author gets the credit. Any performance the original claims is unverified; our backtest with real fees decides. The source is a real, tradeable strategy, not a utility. INDICATORS: populate_indicators first computes Bollinger(20, 2) on the typical price and MACD(12,26,9). Both are then OVERWRITTEN or never used: the 'required for graphing' block recomputes bb_lowerband/bb_middleband/bb_upperband from Bollinger(window=20, stds=2) on CLOSE, and MACD is never referenced by entry or exit. The developer must therefore use the CLOSE-based band, defined as qtpylib does it: mid = rolling mean(close, 20), std = pandas rolling std(close, 20) with ddof=1 (sample std), lower = mid - 2*std. MACD and the typical-price band are dead code and must not be implemented as signals. ENTRY: enter_long = 1 when close <= 0.98 * bb_lowerband on a closed 1m bar; there are no other conditions. Freqtrade fills at the NEXT candle's open, so the port submits a market buy on that signal bar's close (equivalent within one bar). EXIT SIGNAL: populate_exit_trend runs dataframe.loc[(), 'exit_long'] = 1. Verified on pandas 2.3.3, that statement creates the exit_long column but leaves it all-NaN, so the strategy has NO signal exit. That matches the docstring's 'sell if (trailing) stop loss is hit'. trailing_stop is not set, so the stop is a FIXED stop, not a trailing one. Positions close only through: (1) minimal_roi = {"0": 0.9, "1": 0.05, "10": 0.04, "15": 0.5}, keyed by minutes since entry. The rule in force is the one with the largest key <= the trade's age: ages 0 to <1 min take +90%, 1 to <10 min take +5%, 10 to <15 min take +4%, and 15+ min take +50%, which in practice is unbounded. (2) stoploss = -0.015, a fixed -1.5% from the entry price that is always active. No time stop, no other exit. VENUE/INSTRUMENTS: the rules are long-only with no leverage, so they belong on BINANCE_SPOT (CASH), which is also under its >=15% venue quota at 10.7%. Freqtrade runs a strategy over a pairlist, one trade per pair, so the faithful platform equivalent runs the identical rules independently on 6 liquid, volatile Binance Spot alts. Each has 1m history from 2018-2020 in the catalog (checked): DOGE, SOL, AVAX, ADA, XRP, LINK. BTC is deliberately excluded. A 1m close 2% below its lower band is rare enough on BTC to give almost no trades, and BTC is the over-mined series. SIZING: this replaces Freqtrade's stake_amount/max_open_trades. Each pair gets a fixed 1/6 of account equity per trade (≈16.7% notional, the max exposure per position), at most one open position per pair, leverage 1.0. The -1.5% stop therefore risks ≈0.25% of equity per trade. FEES: Binance Spot 0.10% taker each side, 0.20% round trip.

Faithful translation of Hummingbot's open-source controller controllers/directional_trading/bollingrid.py (author: hummingbot, commit 9af100d6, Apache-2.0; credit to the authors). The controller computes pandas_ta Bollinger Bands (length 100, std 2.0) on 3-minute candles of the traded pair. BBP = %B = (close - lower)/(upper - lower); BBB = bandwidth = (upper - lower)/middle * 100. Signal = +1 when BBP < bb_long_threshold (0.0, i.e. close below the lower band), -1 when BBP > bb_short_threshold (1.0, close above the upper band), else 0. On a nonzero signal it spawns a GridExecutor on the signal side whose price range is scaled by the current band width w = BBB/100: LONG (BUY grid): start_price = close*(1 - 0.25w), end_price = close*(1 + 0.75w), limit_price = close*(1 - 0.35w). SHORT (SELL grid): start_price = close*(1 - 0.75w), end_price = close*(1 + 0.25w), limit_price = close*(1 + 0.35w). Grid params passed unchanged: min_spread_between_orders 0.005, order_frequency 2s, max_orders_per_batch 1, min_order_amount_quote 6, max_open_orders 5. Everything else comes from DirectionalTradingControllerConfigBase defaults (the source sets none of them): connector binance_perpetual, trading_pair WLD-USDT, total_amount_quote 100, max_executors_per_side 2, cooldown_time 300s, leverage 20, position_mode HEDGE, stop_loss 0.03, take_profit 0.02, time_limit 2700s (45 min), take_profit_order_type LIMIT, trailing_stop activation 0.015 / trailing_delta 0.003. Executor amount = total_amount_quote / max_executors_per_side = 50 USDT notional each. The controller has no signal-based stop actions; executors end only through their own barriers. PLATFORM MAPPING: venue BINANCE USD-M (the source's default connector is binance_perpetual and its default pair is WLD-USDT, so WLDUSDT.BINANCE is the faithful instrument; it is also not BTC, and WLD has almost no corpus history). The catalog has WLDUSDT.BINANCE-3-MINUTE-LAST-EXTERNAL from 2023-07-24 to 2026-10-01 (~3.2 years, ~560k bars), so the source's 3m interval is kept exactly. Sizing is scaled from 100 USDT to our $100k account by keeping the same proportions: total_amount_quote = 100% of equity, each executor gets 50% of equity in notional, and at most 2 executors per side. min_order_amount_quote keeps its ratio to executor budget (6/50 = 12% of executor notional), which caps the grid at 8 levels just as the 100-USDT original does. Leverage is 2.0, fixed. The source uses 20x but that is only margin; notional exposure is set by total_amount_quote, and 2x is enough margin headroom for 2 same-side executors (100% equity notional) plus an opposite-side pair. Hummingbot runs HEDGE mode, but our account nets positions; the developer must track each executor's levels and inventory in strategy-side bookkeeping and submit net orders. Fees: Binance USD-M maker 0.02%, taker 0.05%. Grid opens and per-level take-profits are LIMIT (maker); stop-loss, limit-price, time-limit and trailing exits are MARKET (taker). This is the BB-fade-on-a-fast-timeframe class that is mostly dead here. It is proposed as a faithful port whose maker-only grid legs and 2% per-level TP are the one feature that might clear costs. Our own backtest decides; no claimed performance is assumed.

Faithful translation of the open-source Hummingbot V2 directional controller 'MACDBBV1Controller' (controllers/directional_trading/macd_bb_v1.py, commit 9af100d, Apache-2.0, author: hummingbot — full credit to them). Any performance it claims is unverified; our fee-inclusive backtest decides. The controller is a two-sided reversal signal: go LONG when price closes below the lower Bollinger band (BBP < 0) while MACD is still negative but its histogram has turned positive (downside momentum fading); go SHORT when price closes above the upper band (BBP > 1) while MACD is still positive but its histogram has turned negative. It has NO signal-based exit: every position is a Hummingbot PositionExecutor closed only by the triple barrier inherited from DirectionalTradingControllerConfigBase defaults (take_profit 0.02, stop_loss 0.03, time_limit 2700 s, trailing_stop activation 0.015 / delta 0.003), with max_executors_per_side=2 and cooldown_time=300 s. INSTRUMENT/VENUE: the base config's default market is connector 'binance_perpetual', trading_pair 'WLD-USDT', so the port runs on WLDUSDT.BINANCE (Binance USD-M perp, catalog bar dir WLDUSDT.BINANCE-3-MINUTE-LAST-EXTERNAL, history 2023-07-24 to now, ~3.2 years) at the source's default interval '3m' — no timeframe substitution needed. That also keeps it off BTC (the concentrated series) and fills the under-represented long-short and short-horizon (1m-15m) buckets. Bar type: WLDUSDT.BINANCE-3-MINUTE-LAST-EXTERNAL. SIZING: Hummingbot's per-executor amount is total_amount_quote / max_executors_per_side as fixed quote notional, and its leverage=20 only sets margin, not notional. On our $100k account this maps to per-executor notional = executor_notional_pct x equity with executor_notional_pct = 0.5 (total_amount_quote = 100% of equity split over 2 executors per side), so max same-side exposure = 1.0x equity. config.leverage = 1.0 and the `leverage` parameter mirrors config.leverage.

Faithful line-for-line translation of the Freqtrade open-source strategy 'Supertrend' (https://github.com/freqtrade/freqtrade-strategies/blob/f3340ce11f5bdf62f598522e64d1f5638eaa13f5/user_data/strategies/Supertrend.py, GPL-3.0, author @juankysoriano / Juan Carlos Soriano, who gets the credit). The original runs on 1h candles and goes long only. It enters when three 'buy' Supertrend indicators all read 'up' and leaves when three separate 'sell' Supertrend indicators all read 'down'. Exits also come from a stepped minimal-ROI table, a -26.5% stoploss and the trailing-stop settings. The parameter values are the hyperopted defaults in buy_params/sell_params. These override the IntParameter defaults (4/14): buy (multiplier, period) = (4,8), (7,9), (1,8); sell (multiplier, period) = (1,16), (3,18), (6,18). VENUE CHOICE: the original is a long-only, unlevered Freqtrade strategy, i.e. spot. Platform routing therefore puts it on BINANCE_SPOT (CASH, 0.10% taker per side, ~0.20% RT). The instrument is LINKUSDT.BINANCE_SPOT 1-HOUR (catalog has bars from 2019-01-16 to 2026-10-01, ~67k bars). We chose LINK instead of BTC because BTC is ~44-62% of the corpus and LINK spot has no recorded use. LINK is also volatile enough that the 8.7% / 5.8% / 2.9% ROI targets are reachable within the ROI time windows. SUPERTREND DEFINITION (technical.indicators.supertrend, per freqtrade-strategies issue #30 comment 853042401), computed per (multiplier m, period p): TR = TA-Lib TRANGE (max(high-low, |high-prev_close|, |low-prev_close|)); ATR = simple moving average of TR over p bars (SMA, NOT Wilder smoothing); basic_ub = (high+low)/2 + m*ATR; basic_lb = (high+low)/2 - m*ATR. final_ub and final_lb start at 0.0. For i >= p: final_ub[i] = basic_ub[i] if (basic_ub[i] < final_ub[i-1] or close[i-1] > final_ub[i-1]) else final_ub[i-1]; final_lb[i] = basic_lb[i] if (basic_lb[i] > final_lb[i-1] or close[i-1] < final_lb[i-1]) else final_lb[i-1]. ST starts at 0.0. For i >= p: if ST[i-1]==final_ub[i-1] and close[i] <= final_ub[i] then ST=final_ub[i]; elif ST[i-1]==final_ub[i-1] and close[i] > final_ub[i] then ST=final_lb[i]; elif ST[i-1]==final_lb[i-1] and close[i] >= final_lb[i] then ST=final_lb[i]; elif ST[i-1]==final_lb[i-1] and close[i] < final_lb[i] then ST=final_ub[i]; else 0.0. Direction STX = 'down' if ST>0 and close<ST; 'up' if ST>0 and close>=ST; empty/undefined (neither up nor down) if ST<=0 or not yet warmed up. IMPLEMENTATION NOTE: the original computes all 630 hyperopt-range combinations in populate_indicators. That is only for the hyperopt search. The developer must compute ONLY the 6 used Supertrends, each as an O(1) incremental state machine (rolling TR deque for the SMA plus prev final_ub/final_lb/ST/close). Do NOT recompute over history each bar: recent sandbox_timeout deaths came from exactly that. Equality tests ST[i-1]==final_ub[i-1] should compare against the stored previous value (same float object semantics, i.e. track which band ST is on with a state flag equivalent to the equality). CAVEAT: the source does `_, stx = ftt.supertrend(...)` and its docstring says the call returns a (value, direction) tuple. If the installed `technical` version returns a DataFrame instead, the unpacking would yield column names. We translate the documented intent (the direction series), not that possible library mismatch. Performance claims of the original (hyperopted with ShortTradeDurHyperOptLoss on 2021+ data) are treated as unverified; our fee-inclusive backtest decides.

Faithful line-for-line translation of the open-source Freqtrade strategy FSupertrendStrategy (https://github.com/freqtrade/freqtrade-strategies/blob/f3340ce11f5bdf62f598522e64d1f5638eaa13f5/user_data/strategies/futures/FSupertrendStrategy.py, GPL-3.0). Credit goes to the author, @juankysoriano (Juan Carlos Soriano). Any performance the source claims is unverified; our fee-inclusive backtest decides. IMPORTANT FIDELITY NOTE (verified against the source at that commit): the class does NOT set `can_short = True`, and IStrategy defaults to `can_short = False`. Freqtrade's backtester zeroes the `enter_short`/`exit_short` columns when can_short is False, so the strategy as written trades LONG ONLY, at leverage 1 (there is no leverage() callback), even though it sits in the futures folder and computes short signals. A faithful port is therefore long-only and unlevered. Our routing rule puts long-only, no-leverage strategies on BINANCE_SPOT, so the port runs there. The source's short-entry rule is documented below for completeness but must NOT trade. Instrument choice: the source names no pair. Its hyperopt ran on 1h bars from 2021-01-01. BTC is over-concentrated in the corpus (and BtcAtrChannelSuperTrendRegimeFilteredLS is already in the pipeline), so this port runs on LINKUSDT.BINANCE_SPOT 1-HOUR. The catalog holds continuous LINK spot 1h bars from 2019-01-16 to 2026-10-01, about 7.7 years. BINANCE_SPOT has a 10.7% share against its ≥15% target. SUPERTREND INDICATOR (technical.indicators.supertrend, freqtrade/technical; port exactly; the developer must NOT substitute a Wilder/EMA ATR). Inputs are period p and multiplier m, over arrays high, low and close of length N. 1. tr = talib TRANGE(high, low, close): tr[0] = NaN; tr[i] = max(high[i]-low[i], |high[i]-close[i-1]|, |low[i]-close[i-1]|). 2. atr = SIMPLE rolling mean of tr over p bars (pandas rolling(p).mean()). It is NaN until index p, because index p-1 still includes tr[0] = NaN. 3. basic_ub = (high+low)/2 + m*atr; basic_lb = (high+low)/2 - m*atr. 4. final_ub and final_lb start as zeros. For i in range(p, N): final_ub[i] = basic_ub[i] if (basic_ub[i] < final_ub[i-1] or close[i-1] > final_ub[i-1]) else final_ub[i-1]. final_lb[i] = basic_lb[i] if (basic_lb[i] > final_lb[i-1] or close[i-1] < final_lb[i-1]) else final_lb[i-1]. 5. st starts as zeros. For i in range(p, N): if st[i-1] == final_ub[i-1], then st[i] = final_ub[i] if close[i] <= final_ub[i] else final_lb[i]. Elif st[i-1] == final_lb[i-1], then st[i] = final_lb[i] if close[i] >= final_lb[i] else final_ub[i]. Otherwise st[i] stays 0. Bootstrap: at i = p, st[p-1] = 0 == final_ub[p-1] = 0, so the first branch fires. 6. Direction stx[i] = 'down' if st[i] > 0 and close[i] < st[i]; 'up' if st[i] > 0 and close[i] >= st[i]; otherwise none (the strategy fills it with '' = neither up nor down). This is a recursive state machine. Implement it INCREMENTALLY: keep a deque of the last p TR values plus the previous final_ub, final_lb, st and close for each of the 6 distinct (p, m) instances, updated O(1) per bar. Do not recompute over history on every bar; the recent sandbox timeouts were caused by exactly that. Exact equality comparisons are safe because st is always assigned from final_ub or final_lb. ACTIVE PARAMETERS. The hyperopted buy_params and sell_params override the IntParameter defaults; these are the values the code trades. - Buy set: ST1 = (p=8, m=4), ST2 = (p=9, m=7), ST3 = (p=8, m=1). - Sell set: ST1 = (p=16, m=1), ST2 = (p=18, m=3), ST3 = (p=18, m=6). The IntParameter defaults (14/1, 10/3, 10/4) are NOT used. RISK, ROI AND EXIT SETTINGS AS WRITTEN: timeframe 1h; startup_candle_count 18; minimal_roi = {0: 0.10, 30: 0.75, 60: 0.05, 120: 0.025} (minutes since entry); stoploss -0.265; trailing_stop True; trailing_stop_positive 0.05; trailing_stop_positive_offset 0.10; trailing_only_offset_is_reached False; use_exit_signal True (default); exit_profit_only False (default). There is one position at a time.

Faithful translation of ianzeng123's FMZ open-source strategy '交割合约现货套利策略测试版' (credit to the author). The source pairs a SPOT market (exchanges[0], BTC_USDT) with USDT-margined DELIVERY futures (exchanges[1], BTC_USDT.quarter and BTC_USDT.next_quarter; allowedCoins=['BTC']). For each delivery contract it keeps a 1-minute history of spreadRate = (deliveryClose - spotClose)/spotClose (max 5000 points), runs an hourly ADF stationarity test on the last 1000 points, and when the spread is 'stationary enough' and |z| >= 1.0 it opens a hedged pair: z>0 ('positive' / 正套) = BUY spot + SELL the delivery future; z<0 ('negative' / 反套) = SELL spot + BUY the delivery future. It exits when the dollar spread returns into a target band, on a 1.5% combined stop-loss, 1 day before delivery, or after 10 days if profitable. There is no take-profit. PLATFORM MAPPING. Spot leg: BTCUSDT.BINANCE_SPOT (CASH, 0.10%/side taker). Futures leg: Binance USD-M BTCUSDT dated quarterlies (BINANCE venue, MARGIN, 0.05% taker / 0.02% maker), catalog ids BTCUSDT_YYMMDD.BINANCE, 1-MINUTE bars verified present in the catalog for every quarterly from BTCUSDT_210326 to BTCUSDT_261225 (each with ~3-6 months of 1m history before its expiry; BTCUSDT_270326 has only started). Primary instrument = BTCUSDT.BINANCE_SPOT-1-MINUTE-LAST-EXTERNAL; every quarterly is an extra_instrument with its 1-MINUTE bar type. The source discovers pairs once at startup; in a multi-year backtest the port must re-run the discovery whenever a contract expires: at any bar the 'quarter' contract is the listed contract with the nearest delivery date that still has bars, 'next_quarter' the following one; each is paired with spot independently (own price history, ADF cache, fail counter, cooldowns and position record), and a contract is skipped for NEW entries when daysToDelivery < minDaysToDelivery (7). Delivery time is parsed exactly as the source does: the YYMMDD in the symbol at 16:00 UTC (parseDeliveryDateFromString). Bars of a contract after that time are ignored. Futures leg leverage = marginLevel 10 (config leverage 10.0; spot leg is CASH, unlevered). SIZING (source default, kept): orderAmount = 0.05 BTC spot per pair; futures quantity = the same 0.05 BTC (the source's calculateContractAmount floor(spotAmount/ctVal) is a coin-to-contract conversion so the futures notional matches the spot leg; Binance USD-M quarterlies are quoted in base units with 0.001 step, so the hedge is exactly 0.05 BTC). Spot buys require USDT balance >= 0.05*price + minUSDTReserve (10 USDT). With the $100k account this uses ~2-6% of equity per pair — that is the author's sizing and is kept on purpose; per-trade results are judged in % of notional. SPOT SHORTING. The account starts with USDT only, so the source's own checkSpotBalance('sell') fails for a reverse (z<0) entry ('BTC不足', canRetry=false: skip, no cooldown, keep waiting for a positive opportunity). The port keeps that check; coins already committed to the OTHER pair's open positive-arb record are treated as unavailable (otherwise the reverse arb on one contract would sell the hedge of the other — a corruption the source would also suffer, documented as the one deliberate deviation). In practice the strategy therefore runs only the positive (long spot / short quarterly) side unless spot BTC is free. Direction overall: market-neutral (long spot + short future).

Translation of QuantRocket's open-source Moonshot strategy 'ValueMomentumTrendCombined' (vmot_combined.py, Apache-2.0, credit: QuantRocket LLC; modeled on Alpha Architect's VMOT ETF). LONG-ONLY, multi-instrument US equity strategy on venue USEQ, 1-DAY bars. CODE values are used where they differ from the docstring: VALUE_TOP_N_PCT=20 and MOMENTUM_TOP_N_PCT=20 (the docstring says 10). PORTABILITY, stated plainly: steps 2 (value screen: cheapest 20% by EV/EBIT, EBIT>0, Sharadar ART) and 3 (top 50% by Piotroski F-score from 9 Sharadar fundamental components) CANNOT be translated. The factory has no point-in-time fundamentals history; Yahoo supplies prices, splits and dividends only, and src/data/yahoo_quotes.py fetches current-snapshot fundamentals for display, which would be look-ahead. Step 1b (exclude financials/ADRs/REITs) is done by construction of the fixed universe below. In the port, the momentum screen therefore ranks within the whole liquidity-screened universe, where the original ranks only within quality-value stocks. That is a material change: what is left is the momentum + trend half of VMOT, and the analyst should judge it as that. Every other rule is ported exactly. UNIVERSE (fixed, all verified present in the catalog as <SYM>.USEQ-1-DAY-LAST-EXTERNAL; non-financial, non-REIT, US-listed S&P 500 large caps, no ADRs): AAPL MSFT AMZN GOOGL META NVDA AVGO ORCL CSCO ADBE CRM INTC TXN QCOM AMD IBM ACN JNJ PFE MRK ABBV LLY UNH AMGN TMO ABT MDT BMY GILD PG KO PEP WMT COST MCD NKE HD LOW SBUX DIS CMCSA VZ T XOM CVX COP CAT DE HON GE MMM UNP UPS LMT RTX BA LIN (59 stocks), plus SPY.USEQ as the trend instrument. The original TREND_SID FIBBG000BDTBL9 is SPY; SPY is a signal only and is never traded. Primary instrument = SPY.USEQ (its bar drives the daily decision clock); the 59 stocks go in extra_instruments/extra_bar_types. RULES (per daily close t, computed on synchronized closes): (1c) avg_dollar_volume = rolling 90-bar mean of close*volume; rank descending pct across names with data (pandas rank pct, average ties); liquid = rank <= 0.60. (4) momentum = (close[t-22] - close[t-252]) / close[t-252] (NaN if close[t-252]==0 or missing); rank descending pct ONLY among liquid names; have_momentum = rank <= 0.20. (5) positive_days = count of days with close.pct_change() > 0 over the last 252 bars; rank descending pct ONLY among have_momentum names; selected = rank <= 0.50. (6) Equal weight: w_i = 1/N_selected for selected names, 0 otherwise. (7) Quarterly rebalance 'Q-NOV': the stock weights are recomputed only from the signal of the last trading day of February, May, August and November, i.e. the last value inside each Q-NOV period. They are held constant until the next such date; there is no drift rebalancing in between, because Moonshot charges turnover only on weight changes. (8-9) Trend overlay on SPY: below_zero = SPY close / SPY close[t-252] - 1 < 0; below_mavg = SPY close < SPY 252-bar SMA; n = below_zero + below_mavg. This is sampled WEEKLY ('W' = weeks ending Sunday), taking the last trading day of each week (normally Friday's close), and held through the following week. Final weight = w_i if n==0, w_i/2 if n==1, 0 if n==2; the remainder stays in cash. EXECUTION LAG (target_weights_to_positions = weights.shift()): a weight change decided at close t is executed on the next session's bar t+1 with market orders. Positions are resized only when a name's FINAL target weight changes, either at a quarterly reselection or at a weekly trend-count change. Sizing: target notional_i = final_weight_i * account equity at leverage 1.0 (USEQ margin is not used); whole shares, floor; skip orders below min notional. Fees: platform USEQ (zero commission, spread+impact modeled) replaces the original $0.005/share PerShareCommission. PERFORMANCE ENGINEERING (two recent USEQ multi-name ports died on the 300 s sandbox limit): keep per-name fixed-length deques (253 closes, 90 dollar-volumes, 252 positive-day flags with a running sum, 252 SPY closes with a running sum for the SMA). Update O(1) per bar, and do the cross-sectional ranking only once per day after all 60 bars for date t have arrived (key on the bar ts, process when the date's bar set is complete or on the SPY bar), and ONLY on rebalance/trend-sample days. Never rescan history.

Port of QuantRocket's open-source Moonshot strategy 'TrendDayStrategy' (code 'trend-day', https://github.com/quantrocket-codeload/trend-day, Apache-2.0, author QuantRocket LLC, who gets the credit). ORIGINAL RULES, exactly as written: universe 'leveraged-etf' on US-stock 1-minute data; DB_TIMES 14:00 and 15:59; MIN_PCT_CHANGE = 0.06. Each day: return = (OPEN of the 14:00 bar - CLOSE of the prior session's 15:59 bar) / prior session close. Signal +1 (long) if return > +0.06, -1 (short) if return < -0.06, otherwise 0. Weights: allocate_fixed_weights_capped(signals, 0.20, cap=1.0), so each active position gets 20% of capital, and all weights are scaled down proportionally if gross exposure would exceed 100%. Positions are entered the same day as the signal with a MARKET order at 14:01 (the close of the 14:00 bar is the entry price) and exited with a market-on-close (MOC) order at the 16:00 session close. There are no stops, no take-profit and no overnight holding. The original's costs were $0.005/share commission and 3 bps slippage; ours use the USEQ model, which charges zero commission and models spread and impact. PLATFORM ADAPTATION, stated honestly: (1) The universe is the 3 leveraged/volatility ETFs that exist in our USEQ universe and catalog: TQQQ.USEQ, SQQQ.USEQ and UVXY.USEQ. Other leveraged ETFs such as SOXL, SPXL and TNA are not collected. (2) Timeframe is 1-HOUR, not 1-minute. USEQ 1-minute bars start 2026-08-06, about 38 sessions, which would give fewer than 10 signals at a 6% threshold. USEQ 1-HOUR bars cover 2024-08-14 to now, about 530 sessions. Yahoo hourly bars are close-stamped at 10:30, 11:30, 12:30, 13:30, 14:30, 15:30 and 16:00 ET, so no bar closes at 14:00. The checkpoint is therefore the CLOSE of the bar stamped 14:30 ET, 30 minutes later than the original's 14:00, and the hold is 14:30 to 16:00, not 14:01 to 16:00. On half-day sessions (13:00 close) there is no 14:30 bar, so no trade, which matches the original because its 14:00 bar is missing on half-days. (3) The prior session close is the close of the previous session's final bar (stamped 16:00 ET, or 13:00 on half-days), equivalent to the original's 15:59 bar close. Sizing: 20% of current equity notional per active instrument, as in the original. With 3 instruments, gross exposure is at most 60%, so the 1.0 cap never binds but is still implemented. Long and short are allowed; USEQ is a Reg-T margin account, run at leverage 1.0. Note that TQQQ and SQQQ are mirror images, so a strong Nasdaq day usually signals both, long one and short the other. That is effectively the same bet on two instruments, net about 40% of equity on the Nasdaq direction. The original does this too and it is kept faithfully. Pre-study on our 1h catalog (gross, close-to-close, no costs), 6% threshold, return from 14:30 to 16:00 in the signal direction: TQQQ n=45, mean +0.31%, hit rate 64%; SQQQ n=44, mean +0.41%, hit rate 66%; UVXY n=94, mean +0.98%, hit rate 70%. That totals about 183 position-days in about 2 years. Treat these numbers as unverified until our backtest runs.

Translate QuantRocket's executable GDX_GLD_Pair subclass, preserving its daily rolling Johansen weights, one-standard-deviation bands, independent persistent long/short signal states, daily target-weight recalculation and next-session-open execution. Use GDX.USEQ as primary and GLD.USEQ as the secondary trading leg, both with 1-DAY-LAST-EXTERNAL bars. Original defaults are LOOKBACK_WINDOW=20, BBAND_STD=1, DB_FIELDS=['Close','Open']; the subclass selects GDX and GLD from usstock-1d. Original USStockCommission charges $0.005/share; replace that commission with platform USEQ zero commissions and modeled spread/impact, explicitly reporting the difference. Do not claim source profitability or add filters, stop-losses, cointegration significance tests or parameter optimization.

Test the submitted moving-average ordering mechanism independently on LTC and LINK perpetuals using 4-HOUR bars. Preserve the five SMA periods, five-bar confirmation, rising ADX filter and ordering-break exit. Replace the source's fixed forex lot size with capital-relative volatility sizing. This is a source-derived replication hypothesis, not an established crypto edge. Maintain incremental indicators and bounded buffers rather than rescanning historical data.

Translate ianzeng123's executable multi-asset allocation strategy, preserving the supplied code rather than correcting it to match the prose. Trade BTC, gold, SPY and crude-oil USDT perpetuals on Bybit. The code uses PERIOD_H1, not the description's 15-minute covariance bars. Preserve signed risk-parity weights, volatility-dependent exposure, initial/timed/weight-change/direction-change rebalancing and emergency partial reductions. Source defaults are TRADE_MODE=paper, INIT_CAPITAL=10000 USDT, LOOKBACK=60, EWMA_LAMBDA=0.94, TARGET_VOL=0.15, MAX_LEVERAGE=3, REBALANCE_HOURS=24, DRIFT_THRESHOLD=0.15, POSITION_RATIO=0.95 and MIN_REBAL_USDT=5. The platform adaptation uses its actual $100000 account equity and engine accounting, with real commissions and execution costs; do not reproduce the source's fee-free simulated PnL as backtest results. Preserve the source paper branch's allocation decisions separately from engine accounting. No parameter optimization is authorized.