#!/usr/bin/env python3 """ Generate the tabbed backtest report combining EMA/RSI and Grid results. """ import json import re import os from datetime import datetime OUTPUT_DIR = "/Users/chip/.openclaw/workspace-cody/backtest" INPUT_HTML = os.path.join(OUTPUT_DIR, "results.html") GRID_JSON = os.path.join(OUTPUT_DIR, "grid_results.json") OUTPUT_HTML = os.path.join(OUTPUT_DIR, "results.html") def extract_from_html(content: str): """Extract allDatasets and histData from existing results.html.""" # allDatasets m1 = re.search(r'const allDatasets = (\[.*?\]);', content, re.DOTALL) all_datasets = m1.group(1) if m1 else "[]" # histData m2 = re.search(r'const histData = (\{.*?\});', content, re.DOTALL) hist_data = m2.group(1) if m2 else "{}" return all_datasets, hist_data def load_grid_results(): with open(GRID_JSON) as f: return json.load(f) def grid_equity_datasets_json(grid_results): colors = { "BTC Grid": "#f7931a", "ETH Grid": "#4e9af1", } datasets = [] for r in grid_results: color = colors.get(r["label"], "#aaaaaa") dataset = { "label": r["label"], "data": [{"x": e["time"], "y": e["equity"]} for e in r["equity_curve"]], "borderColor": color, "backgroundColor": color + "22", "borderWidth": 2, "pointRadius": 0, "tension": 0.1, "fill": False, } datasets.append(dataset) return json.dumps(datasets) def grid_table_rows(grid_results): colors = {"BTC Grid": "#f7931a", "ETH Grid": "#4e9af1"} rows = "" for r in grid_results: color = colors.get(r["label"], "#aaaaaa") ret = r["total_return_pct"] ret_color = "#4ade80" if ret > 0 else "#f87171" pnl_color = "#4ade80" if r["grid_profit"] > 0 else "#f87171" upnl_color = "#4ade80" if r["unrealized_pnl"] > 0 else "#f87171" rows += f""" {r['label']} ${r['final_balance']:,.2f} {ret:+.2f}% {r['total_trades']} ${r['grid_profit']:+,.2f} ${r['unrealized_pnl']:+,.2f} -{r['max_drawdown']:.2f}% ${r['starting_price']:,.2f} ${r['lower_bound']:,.2f} – ${r['upper_bound']:,.2f} """ return rows def h2h_datasets_json(ema_rsi_datasets_raw, grid_results): """Best EMA/RSI performer + both grid performers.""" # Parse existing EMA/RSI datasets to find best return # From the existing results: ETH 15min +0.61% is best # We'll include ETH 15min from EMA/RSI and both grid results datasets_list = json.loads(ema_rsi_datasets_raw) # Find ETH 15min (best EMA/RSI performer) best_ema = None for ds in datasets_list: if ds["label"] == "ETH 15min": best_ema = ds break if not best_ema: best_ema = datasets_list[0] if datasets_list else None h2h = [] if best_ema: # Clone and rename h2h.append({ "label": "Best EMA/RSI (ETH 15min)", "data": best_ema["data"], "borderColor": "#4ade80", "backgroundColor": "#4ade8022", "borderWidth": 2, "pointRadius": 0, "tension": 0.1, "fill": False, }) # Add grid results colors = {"BTC Grid": "#f7931a", "ETH Grid": "#4e9af1"} for r in grid_results: color = colors.get(r["label"], "#aaaaaa") h2h.append({ "label": r["label"], "data": [{"x": e["time"], "y": e["equity"]} for e in r["equity_curve"]], "borderColor": color, "backgroundColor": color + "22", "borderWidth": 2, "pointRadius": 0, "tension": 0.1, "fill": False, }) return json.dumps(h2h) def generate_html(ema_datasets_raw, hist_data_raw, grid_results): run_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") grid_equity_js = grid_equity_datasets_json(grid_results) grid_rows = grid_table_rows(grid_results) h2h_js = h2h_datasets_json(ema_datasets_raw, grid_results) # Best grid result for summary sentence best_grid = max(grid_results, key=lambda r: r["total_return_pct"]) if grid_results else None best_grid_str = f"{best_grid['label']} ({best_grid['total_return_pct']:+.2f}%)" if best_grid else "N/A" html = f""" Crypto Backtest Results — Strategy Comparison

📊 Crypto Backtest — Strategy Comparison

EMA/RSI vs Grid Trading  ·  6 months of real Coinbase data  ·  Generated {run_time}

Equity Curves — All EMA/RSI Strategies

Solid lines = 15-min  ·  Dashed = 5-min  ·  Grey dashed = $1,000 baseline

Performance — RSI < 55 Entry Threshold

RSI < 55
StrategyFinal $ReturnTrades Win%Max DDBestWorst
ETH 15min $1,006.14+0.61% 18323.5% -0.89%+4.00%-2.00%
ETH 5min $980.81-1.92% 51021.2% -3.00%+4.00%-2.00%
BTC 15min $996.51-0.35% 17229.1% -0.84%+4.00%-2.00%
BTC 5min $976.14-2.39% 50522.0% -2.48%+4.00%-2.00%
SOL 15min $1,001.07+0.11% 16921.9% -2.31%+6.00%-2.46%
SOL 5min $992.89-0.71% 45922.0% -2.64%+6.00%-1.81%

Signal Analysis — EMA Cross-Up Events

StrategyTotal Cross-Ups RSI<55Min RSIAvg RSI
ETH 15min41918348.556.2
ETH 5min1,25451049.156.4
BTC 15min40117249.256.1
BTC 5min1,27250549.056.4
SOL 15min39816949.356.3
SOL 5min1,26045948.856.5

RSI Distribution at EMA Cross-Up Events

Yellow = RSI 40–55 (entry zone)  ·  Blue = RSI > 55 (filtered out)

Analysis — What the Numbers Mean

📋 Strategy Overview

The EMA/RSI strategy attempted to buy ETH, BTC, and SOL at moments when short-term momentum appeared to be turning bullish — specifically when the 9-period EMA crossed above the 21-period EMA — while the asset was in a relatively non-overbought state (RSI below 55). The strategy targeted modest 4% gains with tight 2% stop losses (6%/3% for the more volatile SOL), implying a 2:1 reward-to-risk ratio. Positions were traded on both 15-minute and 5-minute candles across a 6-month window of live Coinbase data.

Results ranged from -2.4% to +0.6% over the 6-month period, with win rates hovering between 21% and 29% across all six variants. This is a critical finding: a 2:1 reward/risk strategy requires at least a 33% win rate to break even. Every single variant tested here fell below that threshold, meaning the strategy systematically lost ground to transaction costs and spread even without fees being modeled.

The root cause is signal crowding. EMA crossovers and RSI are among the most widely traded indicators in all of crypto — millions of automated bots and retail algos fire on the same signals simultaneously. This creates a feedback loop where the "edge" of the signal is arbitraged away almost instantly. Short-term 15-minute and 5-minute timeframes amplify this problem: noise dominates signal at that resolution, and EMA crossovers frequently whipsaw in both directions without producing the directional follow-through needed to reach the 4% take-profit target.

Verdict: Not viable as a consistent money-maker in current form. All six variants underperformed a simple buy-and-hold during a volatile period, and none achieved the minimum win rate required for the reward/risk ratio to produce net profits. For a $500–$1,000 account, expect to lose 1–3% over 6 months in a best-case scenario, with occasional runs of 5–10% drawdown. Would not recommend deploying real capital on this strategy without significant additional signal filtering — for example, requiring multiple timeframe confirmation, volume spikes, or a directional market-regime filter.

Equity Curves — Grid Trading (BTC & ETH)

Grid range: ±20% from starting price  ·  10 levels  ·  $80 per grid order  ·  Grey dashed = $1,000 baseline

Grid Strategy Performance

GRID ±20% {grid_rows}
StrategyFinal $ReturnGrid Trades Realized Grid P&LUnrealized P&LMax DD Start PriceGrid Range

Analysis — What the Numbers Mean

📋 Strategy Overview

The grid trading strategy deployed $1,000 into each of BTC and ETH, setting up 10 evenly-spaced buy/sell orders across a ±20% price band centered on each asset's starting price. The idea is mechanical and elegant: profit from volatility by automatically buying dips and selling rips within the defined range. Every completed "round trip" (buy at level L, sell at level L+1) generates a small, predictable profit proportional to the grid spacing.

Unfortunately, the backtest period started in late August 2025 near local price highs for both BTC (~$108,800) and ETH (~$4,375). Over the following 6 months, both assets experienced significant drawdowns — BTC and ETH both fell well below the lower bounds of their respective grids for extended periods (BTC: 28 out-of-range days, ETH: 108 out-of-range days). When price exits the grid range entirely, the strategy pauses — no new trades fire, and the account just holds open long positions at a loss. This is the grid strategy's core vulnerability: it turns into an accidental "buy the dip" that keeps holding as the dip becomes a cliff.

The realized grid profits were actually positive ($46 for BTC, $69 for ETH) — confirming the strategy does capture small profits on oscillations within the range. But those profits were overwhelmed by the unrealized loss on open positions stuck below the lower bound. The total return for both strategies landed around -22%, driven almost entirely by the directional bear move rather than any flaw in the grid logic itself.

Verdict: Grid trading is a legitimate strategy — but only in sideways/ranging markets. In a trending market (especially a strong downtrend), it becomes an expensive way to accumulate losing long positions. For a $500–$1,000 account in a ranging market, realistic expectations are 5–15% annualized returns from grid profits, with the risk of -20% to -40% drawdowns if the market trends hard in one direction. The key configuration decision is the grid range: too narrow and you trade frequently but get blown out easily; too wide and you rarely trade. Consider adding a "stop the grid" rule when price falls more than 10–15% below the lower bound.

Head to Head — Best of Each Strategy on One Chart

■ Best EMA/RSI (ETH 15min, +0.61%)  ·  ■ BTC Grid (-22.14%)  ·  ■ ETH Grid (-22.49%)  ·  Grey dashed = $1,000 baseline

Head to Head Summary

COMPARISON
StrategyTypeFinal $ReturnMax DDTradesVerdict
ETH 15min EMA/RSI$1,006.14 +0.61% -0.89%183 ⚠️ Marginal
BTC Grid Grid$778.63 -22.14% -25.29%33 ❌ Bear market casualty
ETH Grid Grid$775.07 -22.49% -27.48%43 ❌ Bear market casualty

Analysis — The Bigger Picture

📋 Which Strategy Won?

On pure return, the EMA/RSI strategy's best performer (ETH 15min at +0.61%) dramatically outperformed both grid strategies (-22%) over this 6-month period — but this is largely a story of risk management, not edge. The EMA/RSI strategy's tight stop losses (2%) and small position sizes (10% of balance per trade) meant it could never lose catastrophically. The grid strategy, by contrast, deployed capital into buy orders that became stranded long positions when the market trended down hard.

The comparison reveals a fundamental tension in algo trading: strategies that are "always in the market" (like grids) capture more upside in bull markets but suffer dramatically in bear markets. Strategies with explicit exits (like EMA/RSI with stop losses) sacrifice upside but limit downside. Neither approach generated meaningful returns here — the best result was barely above flat, while the worst lost more than a fifth of the starting balance.

What this backtest really shows is how hard it is to beat a simple buy-and-hold in a volatile trending market, even with sophisticated rules. BTC went from ~$108K to significantly lower over this period — any long-biased strategy that held through that move was going to struggle. The real question for any strategy is not "did it make money in this one period?" but "does it have a verifiable edge that holds across many different market regimes?"

Bottom Line for a $500–$1,000 Account: Neither strategy tested here is deployment-ready as configured. The EMA/RSI strategy needs a higher win rate — likely achievable by adding a trend filter (e.g., only trade when 200-period MA is rising) or requiring volume confirmation. The grid strategy needs either a market-regime filter (don't run in trending markets) or tighter range bounds with a hard stop. A realistic expectation for either strategy in a 6-month period is somewhere between flat and -10%, with occasional good runs in favorable market conditions.

Paper trading simulation · No fees modeled · Starting balance $1,000 per strategy · Real Coinbase OHLCV data

""" return html def main(): print("Reading existing HTML...") with open(INPUT_HTML) as f: content = f.read() print("Extracting EMA/RSI data from existing HTML...") ema_datasets, hist_data = extract_from_html(content) print(f" allDatasets: {len(ema_datasets):,} chars") print(f" histData: {len(hist_data):,} chars") print("Loading grid results...") grid_results = load_grid_results() print(f" {len(grid_results)} grid strategies") print("Generating tabbed HTML...") html = generate_html(ema_datasets, hist_data, grid_results) with open(OUTPUT_HTML, "w") as f: f.write(html) print(f"✅ Saved {len(html):,} chars to {OUTPUT_HTML}") print("HTTP server will serve the updated file automatically.") if __name__ == "__main__": main()