large changes

_backtest_breakout.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import os
-
-# Force local imports
-sys.path.insert(0, os.getcwd())
-
-import strategy_breakout
-import backtest as bt_mod
-from hbot import HyperliquidAPI
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-
-api = HyperliquidAPI(verify_ssl=False)
-
-def run_backtest(coin, timeframe, days):
-    print(f"--- Backtesting {coin} ({timeframe}) for last {days} days ---")
-    start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
-    raw = api.get_candles(coin, timeframe, start_ms)
-    if not raw:
-        print(f"No data for {coin}")
-        return None
-        
-    rows = [{'timestamp': pd.to_datetime(int(x['t']), unit='ms', utc=True),
-             'open': float(x['o']), 'high': float(x['h']), 'low': float(x['l']),
-             'close': float(x['c']), 'volume': float(x['v'])} for x in raw]
-    df = pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-    
-    strategy = strategy_breakout.StrategyEngine({})
-    bt = bt_mod.StrategyBacktester(
-        strategy=strategy, 
-        starting_capital=1000.0,
-        fee_bps=4.32, 
-        slippage_bps=1.0, 
-        position_risk_fraction=0.01, # 1% risk per trade
-        strategy_name="strategy_breakout"
-    )
-    
-    result = bt.backtest(df, coin, timeframe)
-    return result
-
-COINS = ['BTC', 'ETH', 'SOL', 'TIA', 'ARB', 'WIF', 'DOGE']
-TIMEFRAMES = ['1h']
-DAYS = 180
-
-results = []
-for coin in COINS:
-    for tf in TIMEFRAMES:
-        res = run_backtest(coin, tf, DAYS)
-        if res:
-            results.append(res)
-
-print("\n" + "="*80)
-print(f"{'COIN':<8} | {'TF':<4} | {'TRADES':<6} | {'WIN%':<6} | {'RETURN%':<10} | {'PF':<5} | {'DD%':<6}")
-print("-" * 80)
-for r in results:
-    print(f"{r.coin:<8} | {r.timeframe:<4} | {r.trades:<6} | {r.win_rate*100:<6.1f} | {r.total_return_pct:<10.2f} | {r.profit_factor:<5.2f} | {r.max_drawdown_pct:<6.2f}")
-print("="*80)

_backtest_hma.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import os
-
-# Force local imports
-sys.path.insert(0, os.getcwd())
-
-import strategy_hma_cross
-import backtest as bt_mod
-from hbot import HyperliquidAPI
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-
-api = HyperliquidAPI(verify_ssl=False)
-
-def run_backtest(coin, timeframe, days):
-    print(f"--- Backtesting {coin} ({timeframe}) for last {days} days ---")
-    start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
-    raw = api.get_candles(coin, timeframe, start_ms)
-    if not raw:
-        print(f"No data for {coin}")
-        return None
-        
-    rows = [{'timestamp': pd.to_datetime(int(x['t']), unit='ms', utc=True),
-             'open': float(x['o']), 'high': float(x['h']), 'low': float(x['l']),
-             'close': float(x['c']), 'volume': float(x['v'])} for x in raw]
-    df = pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-    
-    strategy = strategy_hma_cross.StrategyEngine({})
-    bt = bt_mod.StrategyBacktester(
-        strategy=strategy, 
-        starting_capital=1000.0,
-        fee_bps=4.32, 
-        slippage_bps=1.0, 
-        position_risk_fraction=0.01,
-        strategy_name="strategy_hma_cross"
-    )
-    
-    result = bt.backtest(df, coin, timeframe)
-    return result
-
-COINS = ['BTC', 'ETH', 'SOL', 'TIA', 'ARB', 'WIF', 'DOGE']
-TIMEFRAMES = ['1h']
-DAYS = 90
-
-results = []
-for coin in COINS:
-    for tf in TIMEFRAMES:
-        res = run_backtest(coin, tf, DAYS)
-        if res:
-            results.append(res)
-
-print("\n" + "="*80)
-print(f"{'COIN':<8} | {'TF':<4} | {'TRADES':<6} | {'WIN%':<6} | {'RETURN%':<10} | {'PF':<5} | {'DD%':<6}")
-print("-" * 80)
-for r in results:
-    print(f"{r.coin:<8} | {r.timeframe:<4} | {r.trades:<6} | {r.win_rate*100:<6.1f} | {r.total_return_pct:<10.2f} | {r.profit_factor:<5.2f} | {r.max_drawdown_pct:<6.2f}")
-print("="*80)

_backtest_rsi_extreme.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import os
-
-# Force local imports
-sys.path.insert(0, os.getcwd())
-
-import strategy_rsi_extreme
-import backtest as bt_mod
-from hbot import HyperliquidAPI
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-
-api = HyperliquidAPI(verify_ssl=False)
-
-def run_backtest(coin, timeframe, days):
-    print(f"--- Backtesting {coin} ({timeframe}) for last {days} days ---")
-    start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
-    raw = api.get_candles(coin, timeframe, start_ms)
-    if not raw:
-        print(f"No data for {coin}")
-        return None
-        
-    rows = [{'timestamp': pd.to_datetime(int(x['t']), unit='ms', utc=True),
-             'open': float(x['o']), 'high': float(x['h']), 'low': float(x['l']),
-             'close': float(x['c']), 'volume': float(x['v'])} for x in raw]
-    df = pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-    
-    strategy = strategy_rsi_extreme.StrategyEngine({})
-    bt = bt_mod.StrategyBacktester(
-        strategy=strategy, 
-        starting_capital=1000.0,
-        fee_bps=4.32, 
-        slippage_bps=1.0, 
-        position_risk_fraction=0.015, # Slightly higher risk for high-confidence setups
-        strategy_name="strategy_rsi_extreme"
-    )
-    
-    result = bt.backtest(df, coin, timeframe)
-    return result
-
-COINS = ['BTC', 'ETH', 'SOL', 'TIA', 'ARB', 'WIF', 'DOGE']
-TIMEFRAMES = ['1h']
-DAYS = 180
-
-results = []
-for coin in COINS:
-    for tf in TIMEFRAMES:
-        res = run_backtest(coin, tf, DAYS)
-        if res:
-            results.append(res)
-
-print("\n" + "="*80)
-print(f"{'COIN':<8} | {'TF':<4} | {'TRADES':<6} | {'WIN%':<6} | {'RETURN%':<10} | {'PF':<5} | {'DD%':<6}")
-print("-" * 80)
-for r in results:
-    print(f"{r.coin:<8} | {r.timeframe:<4} | {r.trades:<6} | {r.win_rate*100:<6.1f} | {r.total_return_pct:<10.2f} | {r.profit_factor:<5.2f} | {r.max_drawdown_pct:<6.2f}")
-print("="*80)

_backtest_st_pullback.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import os
-
-# Force local imports
-sys.path.insert(0, os.getcwd())
-
-import strategy_st_pullback
-import backtest as bt_mod
-from hbot import HyperliquidAPI
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-
-api = HyperliquidAPI(verify_ssl=False)
-
-def run_backtest(coin, timeframe, days):
-    print(f"--- Backtesting {coin} ({timeframe}) for last {days} days ---")
-    start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
-    raw = api.get_candles(coin, timeframe, start_ms)
-    if not raw:
-        print(f"No data for {coin}")
-        return None
-        
-    rows = [{'timestamp': pd.to_datetime(int(x['t']), unit='ms', utc=True),
-             'open': float(x['o']), 'high': float(x['h']), 'low': float(x['l']),
-             'close': float(x['c']), 'volume': float(x['v'])} for x in raw]
-    df = pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-    
-    strategy = strategy_st_pullback.StrategyEngine({})
-    bt = bt_mod.StrategyBacktester(
-        strategy=strategy, 
-        starting_capital=1000.0,
-        fee_bps=4.32, 
-        slippage_bps=1.0, 
-        position_risk_fraction=0.01, # 1% risk per trade
-        strategy_name="strategy_st_pullback"
-    )
-    
-    result = bt.backtest(df, coin, timeframe)
-    return result
-
-COINS = ['BTC', 'ETH', 'SOL', 'TIA', 'ARB', 'WIF', 'DOGE']
-TIMEFRAMES = ['1h']
-DAYS = 180
-
-results = []
-for coin in COINS:
-    for tf in TIMEFRAMES:
-        res = run_backtest(coin, tf, DAYS)
-        if res:
-            results.append(res)
-
-print("\n" + "="*80)
-print(f"{'COIN':<8} | {'TF':<4} | {'TRADES':<6} | {'WIN%':<6} | {'RETURN%':<10} | {'PF':<5} | {'DD%':<6}")
-print("-" * 80)
-for r in results:
-    print(f"{r.coin:<8} | {r.timeframe:<4} | {r.trades:<6} | {r.win_rate*100:<6.1f} | {r.total_return_pct:<10.2f} | {r.profit_factor:<5.2f} | {r.max_drawdown_pct:<6.2f}")
-print("="*80)

_backtest_vw_reversion.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import os
-
-# Force local imports
-sys.path.insert(0, os.getcwd())
-
-import strategy_vw_reversion
-import backtest as bt_mod
-from hbot import HyperliquidAPI
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-
-api = HyperliquidAPI(verify_ssl=False)
-
-def run_backtest(coin, timeframe, days):
-    print(f"--- Backtesting {coin} ({timeframe}) for last {days} days ---")
-    start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
-    raw = api.get_candles(coin, timeframe, start_ms)
-    if not raw:
-        print(f"No data for {coin}")
-        return None
-        
-    rows = [{'timestamp': pd.to_datetime(int(x['t']), unit='ms', utc=True),
-             'open': float(x['o']), 'high': float(x['h']), 'low': float(x['l']),
-             'close': float(x['c']), 'volume': float(x['v'])} for x in raw]
-    df = pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-    
-    strategy = strategy_vw_reversion.StrategyEngine({})
-    bt = bt_mod.StrategyBacktester(
-        strategy=strategy, 
-        starting_capital=1000.0,
-        fee_bps=1.44, 
-        slippage_bps=0.5, 
-        position_risk_fraction=0.015,
-        strategy_name="strategy_vw_reversion"
-    )
-    
-    result = bt.backtest(df, coin, timeframe)
-    return result
-
-COINS = ['kPEPE', 'NEAR', 'RNDR', 'INJ', 'SUI', 'FET']
-TIMEFRAMES = ['1h']
-DAYS = 180
-
-results = []
-for coin in COINS:
-    for tf in TIMEFRAMES:
-        res = run_backtest(coin, tf, DAYS)
-        if res:
-            results.append(res)
-
-print("\n" + "="*80)
-print(f"{'COIN':<8} | {'TF':<4} | {'TRADES':<6} | {'WIN%':<6} | {'RETURN%':<10} | {'PF':<5} | {'DD%':<6}")
-print("-" * 80)
-for r in results:
-    print(f"{r.coin:<8} | {r.timeframe:<4} | {r.trades:<6} | {r.win_rate*100:<6.1f} | {r.total_return_pct:<10.2f} | {r.profit_factor:<5.2f} | {r.max_drawdown_pct:<6.2f}")
-print("="*80)

_backtest_zscore.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import os
-
-# Force local imports
-sys.path.insert(0, os.getcwd())
-
-import strategy_mean_reversion_zscore
-import backtest as bt_mod
-from hbot import HyperliquidAPI
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-
-api = HyperliquidAPI(verify_ssl=False)
-
-def run_backtest(coin, timeframe, days):
-    print(f"--- Backtesting {coin} ({timeframe}) for last {days} days ---")
-    start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
-    raw = api.get_candles(coin, timeframe, start_ms)
-    if not raw:
-        print(f"No data for {coin}")
-        return None
-        
-    rows = [{'timestamp': pd.to_datetime(int(x['t']), unit='ms', utc=True),
-             'open': float(x['o']), 'high': float(x['h']), 'low': float(x['l']),
-             'close': float(x['c']), 'volume': float(x['v'])} for x in raw]
-    df = pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-    
-    strategy = strategy_mean_reversion_zscore.StrategyEngine({})
-    bt = bt_mod.StrategyBacktester(
-        strategy=strategy, 
-        starting_capital=1000.0,
-        fee_bps=1.44, 
-        slippage_bps=0.5, 
-        position_risk_fraction=0.01,
-        strategy_name="strategy_mean_reversion_zscore"
-    )
-    
-    result = bt.backtest(df, coin, timeframe)
-    return result
-
-COINS = ['kPEPE', 'NEAR', 'RNDR', 'INJ', 'SUI', 'FET']
-TIMEFRAMES = ['1h']
-DAYS = 180
-
-results = []
-for coin in COINS:
-    for tf in TIMEFRAMES:
-        res = run_backtest(coin, tf, DAYS)
-        if res:
-            results.append(res)
-
-print("\n" + "="*80)
-print(f"{'COIN':<8} | {'TF':<4} | {'TRADES':<6} | {'WIN%':<6} | {'RETURN%':<10} | {'PF':<5} | {'DD%':<6}")
-print("-" * 80)
-for r in results:
-    print(f"{r.coin:<8} | {r.timeframe:<4} | {r.trades:<6} | {r.win_rate*100:<6.1f} | {r.total_return_pct:<10.2f} | {r.profit_factor:<5.2f} | {r.max_drawdown_pct:<6.2f}")
-print("="*80)

_debug_ml.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python3
-import sys, importlib
-import strategy_ml_auto as m
-sys.modules['strategy'] = m
-import backtest as bt
-importlib.reload(bt)
-from hbot import HyperliquidAPI
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-
-api = HyperliquidAPI(verify_ssl=False)
-start_ms = int((datetime.now(timezone.utc)-timedelta(days=180)).timestamp()*1000)
-raw = api.get_candles('WIF','1h',start_ms)
-rows=[{'timestamp':pd.to_datetime(int(x['t']),unit='ms',utc=True),
-       'open':float(x['o']),'high':float(x['h']),'low':float(x['l']),
-       'close':float(x['c']),'volume':float(x['v'])} for x in raw]
-df=pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-print('raw candles:', len(df))
-
-engine = m.StrategyEngine({'coin':'WIF'})
-data = engine.add_indicators(df)
-print('after add_indicators:', len(data))
-print('LGB_AVAILABLE:', m.LGB_AVAILABLE)
-print('TRAIN_WINDOW:', m.TRAIN_WINDOW)
-
-# Check MIN_TRAIN_ROWS exists in strategy_ml_auto
-print('MIN_TRAIN_ROWS in m:', hasattr(m, 'MIN_TRAIN_ROWS'), getattr(m,'MIN_TRAIN_ROWS','MISSING'))
-
-# Check features after _build_features
-from strategy_ml_auto import _build_features, FEATURE_COLS
-d2 = _build_features(data)
-print('after _build_features:', len(d2))
-nans = d2[FEATURE_COLS].isna().sum()
-bad = nans[nans>0]
-print('cols still NaN:', bad.to_dict() if len(bad) else 'none - all clean')
-print('feature cols count:', len(FEATURE_COLS))
-clean = d2.dropna(subset=FEATURE_COLS)
-print('rows after dropna(FEATURE_COLS):', len(clean))
-

_diversification_analysis.py

@@ -1,131 +0,0 @@
-#!/usr/bin/env python3
-"""
-Diversification analysis — answers: how many coins per strategy is optimal?
-
-For each strategy, backtests all candidate coins independently at equal
-$1000 capital, then simulates portfolios of 1 to N coins (best-first) to
-show the return/drawdown tradeoff of adding more slots.
-"""
-import sys, importlib
-from hbot import HyperliquidAPI
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-
-api = HyperliquidAPI(verify_ssl=False)
-
-def get_df(coin, tf, days):
-    start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
-    raw = api.get_candles(coin, tf, start_ms)
-    if not raw:
-        return pd.DataFrame()
-    rows = [{'timestamp': pd.to_datetime(int(x['t']), unit='ms', utc=True),
-             'open': float(x['o']), 'high': float(x['h']), 'low': float(x['l']),
-             'close': float(x['c']), 'volume': float(x['v'])} for x in raw]
-    return pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-
-def run_bt(strat_name, coin, tf, days=180, capital=1000.0):
-    for k in ['strategy', 'backtest']:
-        sys.modules.pop(k, None)
-    m = importlib.import_module(strat_name)
-    sys.modules['strategy'] = m
-    import backtest as bt
-    importlib.reload(bt)
-    df = get_df(coin, tf, days)
-    if df.empty or len(df) < 100:
-        return None
-    s = m.StrategyEngine({'use_regime_filter': False, 'coin': coin})
-    b = bt.StrategyBacktester(s, capital, 0, 1.0, 0.01, strategy_name=strat_name)
-    return b.backtest(df, coin, tf)
-
-CANDIDATES = {
-    ('strategy_conservative', '1h'):  ['WIF','TIA','NEAR','OP','SOL','INJ','DOT','LINK'],
-    ('strategy_hype',         '1h'):  ['TIA','APT','DOT','NEAR','DOGE','WIF','ETH','ARB'],
-    ('strategy_scalp',        '30m'): ['ARB','TIA','NEAR','BTC','DOT','APT','SOL','OP'],
-    ('strategy_scalp',        '15m'): ['OP','DOGE','INJ','ARB','SUI','DOT','TIA','ETH'],
-}
-
-print("=" * 75)
-print("PER-COIN PERFORMANCE  (180d, $1000 each, realistic fees, 1% risk/trade)")
-print("=" * 75)
-
-all_results = {}
-for (strat, tf), coins in CANDIDATES.items():
-    key = f"{strat}_{tf}"
-    print(f"\n── {strat} {tf} ──")
-    print(f"  {'coin':>5} | {'trades':>6} | {'win%':>5} | {'ret%':>7} | {'pf':>4} | {'dd%':>5} | {'sharpe':>6} | {'ret$':>7}")
-    results = []
-    for coin in coins:
-        r = run_bt(strat, coin, tf)
-        if r and r.trades > 3:
-            ret_dollar = r.final_equity - 1000.0
-            results.append((coin, r))
-            flag = ' ✓' if r.total_return_pct > 0 and r.profit_factor > 1.1 else ''
-            print(f"  {coin:>5} | {r.trades:>6} | {r.win_rate*100:>5.1f} | "
-                  f"{r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | "
-                  f"{r.max_drawdown_pct:>5.2f} | {r.sharpe_ratio:>6.2f} | {ret_dollar:>+7.2f}{flag}")
-    all_results[key] = results
-
-print()
-print("=" * 75)
-print("PORTFOLIO SIMULATION — returns by number of slots (best-first, equal weight)")
-print("=" * 75)
-print("  ◀ marks the last profitable coin (adding more coins beyond this hurts returns)")
-
-for key, results in all_results.items():
-    if not results:
-        continue
-    strat, tf = key.rsplit('_', 1)
-    sorted_r = sorted(results, key=lambda x: x[1].total_return_pct, reverse=True)
-    profitable = [x for x in sorted_r if x[1].total_return_pct > 0 and x[1].profit_factor > 1.0]
-
-    print(f"\n── {key} ──")
-    print(f"  {'n':>2} | {'coins':<28} | {'port ret%':>9} | {'avg dd%':>7} | {'worst dd%':>9} | note")
-
-    for n in range(1, min(len(sorted_r) + 1, 7)):
-        top_n = sorted_r[:n]
-        cap = 1000.0 / n
-        port_final = sum(cap * (1 + r.total_return_pct / 100) for _, r in top_n)
-        port_ret   = (port_final - 1000.0) / 1000.0 * 100
-        avg_dd     = sum(r.max_drawdown_pct for _, r in top_n) / n
-        worst_dd   = max(r.max_drawdown_pct for _, r in top_n)
-        coin_list  = '+'.join(c for c, _ in top_n)
-        note = ''
-        if n == 1:
-            note = 'best only'
-        elif n == len(profitable):
-            note = '◀ all profitable'
-        elif n > len(profitable):
-            note = 'adding losers'
-        print(f"  {n:>2} | {coin_list:<28} | {port_ret:>+9.2f} | {avg_dd:>7.2f} | {worst_dd:>9.2f} | {note}")
-
-print()
-print("=" * 75)
-print("VERDICT")
-print("=" * 75)
-
-# Cross-strategy summary
-for key, results in all_results.items():
-    if not results:
-        continue
-    sorted_r   = sorted(results, key=lambda x: x[1].total_return_pct, reverse=True)
-    profitable = [x for x in sorted_r if x[1].total_return_pct > 0 and x[1].profit_factor > 1.0]
-    n_opt      = len(profitable)
-
-    if n_opt == 0:
-        best_ret = sorted_r[0][1].total_return_pct if sorted_r else 0
-        print(f"  {key}: 0 profitable coins — consider skipping this strategy right now")
-    elif n_opt == 1:
-        c, r = profitable[0]
-        print(f"  {key}: 1 strong coin ({c} {r.total_return_pct:+.1f}%) — concentrate, don't dilute")
-    else:
-        one_ret = sorted_r[0][1].total_return_pct
-        n_cap   = 1000.0 / n_opt
-        n_final = sum(n_cap * (1 + r.total_return_pct / 100) for _, r in profitable)
-        n_ret   = (n_final - 1000.0) / 1000.0 * 100
-        avg_dd_1 = sorted_r[0][1].max_drawdown_pct
-        avg_dd_n = sum(r.max_drawdown_pct for _, r in profitable) / n_opt
-        print(f"  {key}: {n_opt} profitable coins | "
-              f"1-coin ret={one_ret:+.1f}% dd={avg_dd_1:.1f}% vs "
-              f"{n_opt}-coin ret={n_ret:+.1f}% dd={avg_dd_n:.1f}% "
-              f"→ {'diversify ✓' if n_ret > one_ret * 0.8 and avg_dd_n < avg_dd_1 else 'concentrate ✓' if one_ret > n_ret else 'diversify ✓'}")
-

_find_coins.py

@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-import sys, importlib
-
-def run_bt(strat_name, coin, tf, days, fee_bps, slip_bps, risk_frac):
-    sys.modules.pop('strategy', None)
-    sys.modules.pop('backtest', None)
-    m = importlib.import_module(strat_name)
-    sys.modules['strategy'] = m
-    import backtest as bt
-    importlib.reload(bt)
-    from hbot import HyperliquidAPI
-    from datetime import datetime, timedelta, timezone
-    import pandas as pd
-    api = HyperliquidAPI(verify_ssl=False)
-    start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
-    raw = api.get_candles(coin, tf, start_ms)
-    if not raw: return None
-    rows = [{'timestamp': pd.to_datetime(int(x['t']), unit='ms', utc=True),
-             'open': float(x['o']), 'high': float(x['h']), 'low': float(x['l']),
-             'close': float(x['c']), 'volume': float(x['v'])} for x in raw]
-    df = pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-    if len(df) < 150: return None
-    s = m.StrategyEngine({'use_regime_filter': False})
-    b = bt.StrategyBacktester(s, 100.0, fee_bps, slip_bps, risk_frac,
-                               strategy_name=strat_name)
-    return b.backtest(df, coin, tf)
-
-print('Tier 1 candidates (strategy_conservative, 1h, 180d, maker fees) — NOT TIA/SOL:')
-print(f'  {"coin":>5} | {"trades":>6} | {"win%":>5} | {"ret%":>7} | {"pf":>4} | {"dd%":>5} | {"fees$":>6}')
-for coin in ['BTC','ETH','LINK','AVAX','BNB','INJ','ATOM','NEAR','FIL','OP','ARB','SUI']:
-    r = run_bt('strategy_conservative', coin, '1h', 180, 1.44, 0.5, 0.003)
-    if r and r.trades > 0:
-        m = ' ✓' if r.total_return_pct > 3 and r.profit_factor > 1.3 and r.max_drawdown_pct < 5 else ''
-        print(f'  {coin:>5} | {r.trades:>6} | {r.win_rate*100:>5.1f} | {r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | {r.max_drawdown_pct:>5.2f} | {r.total_fees_paid:>6.2f}{m}')
-
-print()
-print('Tier 3 candidates (strategy_scalp, 15m, 90d, hybrid fees) — NOT TIA/SOL:')
-print(f'  {"coin":>5} | {"trades":>6} | {"win%":>5} | {"ret%":>7} | {"pf":>4} | {"dd%":>5} | {"fees$":>6}')
-for coin in ['BTC','ETH','LINK','AVAX','BNB','INJ','ARB','WIF','DOGE','OP','NEAR','SUI','APT']:
-    r = run_bt('strategy_scalp', coin, '15m', 90, 4.32, 1.5, 0.005)
-    if r and r.trades > 5:
-        m = ' ✓' if r.total_return_pct > 0 and r.profit_factor > 1.1 else ''
-        print(f'  {coin:>5} | {r.trades:>6} | {r.win_rate*100:>5.1f} | {r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | {r.max_drawdown_pct:>5.2f} | {r.total_fees_paid:>6.2f}{m}')
-

_scan_30m.py

@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-import sys, importlib
-from hbot import HyperliquidAPI
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-
-api = HyperliquidAPI(verify_ssl=False)
-
-def run_bt(strat_name, coin, tf, days, fee_bps=4.32, slip_bps=1.0, risk_frac=0.005):
-    sys.modules.pop('strategy', None)
-    sys.modules.pop('backtest', None)
-    m = importlib.import_module(strat_name)
-    sys.modules['strategy'] = m
-    import backtest as bt
-    importlib.reload(bt)
-    start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
-    raw = api.get_candles(coin, tf, start_ms)
-    if not raw: return None
-    rows = [{'timestamp': pd.to_datetime(int(x['t']), unit='ms', utc=True),
-             'open': float(x['o']), 'high': float(x['h']), 'low': float(x['l']),
-             'close': float(x['c']), 'volume': float(x['v'])} for x in raw]
-    df = pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-    if len(df) < 150: return None
-    s = m.StrategyEngine({'use_regime_filter': False})
-    b = bt.StrategyBacktester(s, 100.0, fee_bps, slip_bps, risk_frac,
-                               strategy_name=strat_name)
-    return b.backtest(df, coin, tf)
-
-print('=== strategy_hype on SOL 1h (current aggressive bot) ===')
-print(f'  {"days":>4} | {"trades":>6} | {"win%":>5} | {"ret%":>7} | {"pf":>4} | {"dd%":>5} | {"sharpe":>6}')
-for days in [30, 60, 90, 120, 180]:
-    r = run_bt('strategy_hype', 'SOL', '1h', days)
-    if r:
-        m = ' ✓' if r.total_return_pct > 0 and r.profit_factor > 1.1 else ' ✗'
-        print(f'  {days:>4} | {r.trades:>6} | {r.win_rate*100:>5.1f} | {r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | {r.max_drawdown_pct:>5.2f} | {r.sharpe_ratio:>6.2f}{m}')
-
-print()
-print('=== strategy_hype: SOL vs TIA vs other coins (180d, 1h) ===')
-print(f'  {"coin":>5} | {"trades":>6} | {"win%":>5} | {"ret%":>7} | {"pf":>4} | {"dd%":>5}')
-for coin in ['SOL', 'TIA', 'LINK', 'NEAR', 'AVAX', 'BNB', 'INJ', 'ARB']:
-    r = run_bt('strategy_hype', coin, '1h', 180)
-    if r:
-        m = ' ✓' if r.total_return_pct > 3 and r.profit_factor > 1.2 else ''
-        print(f'  {coin:>5} | {r.trades:>6} | {r.win_rate*100:>5.1f} | {r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | {r.max_drawdown_pct:>5.2f}{m}')

_scan_all.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-"""Scans coins across timeframes to find the best fit for each bot tier."""
-import sys, importlib
-from hbot import HyperliquidAPI
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-
-api = HyperliquidAPI(verify_ssl=False)
-
-def get_df(coin, tf, days):
-    start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
-    raw = api.get_candles(coin, tf, start_ms)
-    if not raw: return pd.DataFrame()
-    rows = [{'timestamp': pd.to_datetime(int(x['t']), unit='ms', utc=True),
-             'open': float(x['o']), 'high': float(x['h']), 'low': float(x['l']),
-             'close': float(x['c']), 'volume': float(x['v'])} for x in raw]
-    df = pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-    return df
-
-def run_bt(strategy_mod, df, coin, tf, fee_bps, slip_bps, risk_frac, strat_name=""):
-    sys.modules.pop('strategy', None)
-    sys.modules.pop('backtest', None)
-    sys.modules['strategy'] = strategy_mod
-    import backtest as bt_mod
-    importlib.reload(bt_mod)
-    s = strategy_mod.StrategyEngine({'use_regime_filter': False})
-    bt = bt_mod.StrategyBacktester(s, 100.0, fee_bps, slip_bps, risk_frac,
-                                    strategy_name=strat_name)
-    return bt.backtest(df, coin, tf)
-
-COINS = ['BTC','ETH','SOL','TIA','AVAX','LINK','ARB','DOGE','BNB','WIF','SUI','INJ','OP','MATIC','APT','NEAR','FIL','SEI','ATOM']
-
-# ── TIER 1: Long-term (4h) — conservative mean reversion ──────────────────
-print('\n══ TIER 1: Long-term bot (4h, 180d, conservative) ══')
-import strategy as t1_mod
-print(f'{"coin":>5} | {"trades":>6} | {"win%":>5} | {"ret%":>7} | {"pf":>4} | {"dd%":>5} | {"sharpe":>6}')
-t1_results = []
-for coin in COINS:
-    try:
-        df = get_df(coin, '4h', 180)
-        if len(df) < 150: continue
-        r = run_bt(t1_mod, df, coin, '4h', 1.44, 0.5, 0.003, strat_name='strategy_conservative')
-        t1_results.append(r)
-    except Exception as e:
-        pass
-t1_results.sort(key=lambda r: (r.total_return_pct if r.profit_factor > 1.1 and r.trades >= 8 else -999), reverse=True)
-for r in t1_results[:10]:
-    m = ' ✓' if r.total_return_pct > 5 and r.profit_factor > 1.2 and r.trades >= 8 and r.max_drawdown_pct < 8 else ''
-    print(f'{r.coin:>5} | {r.trades:>6} | {r.win_rate*100:>5.1f} | {r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | {r.max_drawdown_pct:>5.2f} | {r.sharpe_ratio:>6.2f}{m}')
-
-# ── TIER 3: Scalp (15m) — use strategy_hype (RSI pullback) ────────────────
-print('\n══ TIER 3: Scalp bot (15m, 90d, hybrid fees) ══')
-import strategy_hype as t3_mod
-print(f'{"coin":>5} | {"trades":>6} | {"win%":>5} | {"ret%":>7} | {"pf":>4} | {"dd%":>5} | {"sharpe":>6}')
-t3_results = []
-for coin in COINS:
-    try:
-        df = get_df(coin, '15m', 90)
-        if len(df) < 300: continue
-        r = run_bt(t3_mod, df, coin, '15m', 4.32, 1.5, 0.005, strat_name='strategy_hype')
-        t3_results.append(r)
-    except Exception as e:
-        pass
-t3_results.sort(key=lambda r: (r.total_return_pct if r.profit_factor > 1.1 and r.trades >= 15 else -999), reverse=True)
-for r in t3_results[:10]:
-    m = ' ✓' if r.total_return_pct > 0 and r.profit_factor > 1.1 and r.trades >= 15 and r.max_drawdown_pct < 10 else ''
-    print(f'{r.coin:>5} | {r.trades:>6} | {r.win_rate*100:>5.1f} | {r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | {r.max_drawdown_pct:>5.2f} | {r.sharpe_ratio:>6.2f}{m}')
-
-# Also try 5m
-print('\n══ TIER 3: Scalp bot (5m, 60d, hybrid fees) ══')
-for coin in COINS:
-    try:
-        df = get_df(coin, '5m', 60)
-        if len(df) < 500: continue
-        r = run_bt(t3_mod, df, coin, '5m', 4.32, 1.5, 0.005, strat_name='strategy_hype')
-        t3_results.append(r)
-    except Exception as e:
-        pass
-t3_5m = [r for r in t3_results if r.timeframe == '5m']
-t3_5m.sort(key=lambda r: (r.total_return_pct if r.profit_factor > 1.1 and r.trades >= 20 else -999), reverse=True)
-for r in t3_5m[:10]:
-    m = ' ✓' if r.total_return_pct > 0 and r.profit_factor > 1.1 and r.trades >= 20 and r.max_drawdown_pct < 10 else ''
-    print(f'{r.coin:>5} | {r.trades:>6} | {r.win_rate*100:>5.1f} | {r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | {r.max_drawdown_pct:>5.2f} | {r.sharpe_ratio:>6.2f}{m}')
-

_scan_coins.py

@@ -38,8 +38,6 @@ STRATEGY_FEES = {
     'strategy_hype':         dict(fee_bps=4.32, slip_bps=1.0),
     'strategy_scalp':        dict(fee_bps=4.32, slip_bps=1.5),
     'strategy_ml_auto':      dict(fee_bps=4.32, slip_bps=1.0),
-    'strategy_vw_reversion': dict(fee_bps=1.44, slip_bps=0.5),
-    'strategy_mean_reversion_zscore': dict(fee_bps=1.44, slip_bps=0.5),
 }
 
 COINS = ['TIA', 'LINK', 'NEAR', 'INJ', 'ARB', 'AVAX', 'SOL', 'BTC', 'ETH',
@@ -51,18 +49,14 @@ Q = {
     'strategy_hype':         dict(min_ret=3.0,  min_pf=1.15, max_dd=99.0),
     'strategy_scalp':        dict(min_ret=1.0,  min_pf=1.05, max_dd=15.0),
     'strategy_ml_auto':      dict(min_ret=-5.0, min_pf=0.90, max_dd=25.0),
-    'strategy_vw_reversion': dict(min_ret=2.0,  min_pf=1.10, max_dd=15.0),
-    'strategy_mean_reversion_zscore': dict(min_ret=2.0, min_pf=1.10, max_dd=15.0),
 }
 
 # ── Capital allocation per strategy (must sum to 1.0) ────────────────────────
 CAPITAL = {
-    'strategy_hype':         0.15,
-    'strategy_conservative': 0.15,
-    'strategy_scalp':        0.15,
-    'strategy_vw_reversion': 0.15,
-    'strategy_mean_reversion_zscore': 0.15,
-    'strategy_ml_auto':      0.125,   # per ML slot; 2 slots = 0.25 total
+    'strategy_hype':         0.33,
+    'strategy_conservative': 0.33,
+    'strategy_scalp':        0.34,
+    'strategy_ml_auto':      0.50,   # 2 slots = 1.0 total
 }
 
 
@@ -153,25 +147,10 @@ scalp_qualified = print_table('strategy_scalp 30m 180d', r3_30[:8], Q['strategy_
 scalp_combined = [(r, '30m') for r in scalp_qualified]
 
 # ─────────────────────────────────────────────────────────────────────────────
-# 4. VW Reversion
-# ─────────────────────────────────────────────────────────────────────────────
-rvw = sorted(
-    filter(None, [run_bt('strategy_vw_reversion', c, '1h') for c in COINS]),
-    key=lambda x: x.total_return_pct, reverse=True)
-vw_qualified = print_table(
-    'strategy_vw_reversion 1h 180d', rvw[:8], Q['strategy_vw_reversion'])
 
-# ─────────────────────────────────────────────────────────────────────────────
-# 5. Z-Score Mean Reversion
-# ─────────────────────────────────────────────────────────────────────────────
-rzs = sorted(
-    filter(None, [run_bt('strategy_mean_reversion_zscore', c, '1h') for c in COINS]),
-    key=lambda x: x.total_return_pct, reverse=True)
-zscore_qualified = print_table(
-    'strategy_mean_reversion_zscore 1h 180d', rzs[:8], Q['strategy_mean_reversion_zscore'])
 
 # ─────────────────────────────────────────────────────────────────────────────
-# 6. ML Auto — ranked from seed file
+# ML Auto — ranked from seed file
 # ─────────────────────────────────────────────────────────────────────────────
 print(f'\n=== strategy_ml_auto 1h 180d (ranked from backtest seed) ===')
 print(f'  {"coin":>5} | {"trades":>6} | {"win%":>5} | {"ret%":>7} | {"pf":>4} | '
@@ -244,10 +223,6 @@ def _pick_best(qualified, strategy, timeframe_or_pairs, max_slots=1):
 slots += _pick_best(hype_qualified,         'strategy_hype',         '1h',  max_slots=1)
 # Conservative (lowest drawdown)
 slots += _pick_best(conservative_qualified, 'strategy_conservative', '1h',  max_slots=1)
-# VW Reversion
-slots += _pick_best(vw_qualified,           'strategy_vw_reversion', '1h',  max_slots=1)
-# Z-Score
-slots += _pick_best(zscore_qualified,       'strategy_mean_reversion_zscore', '1h',  max_slots=1)
 # Scalp best coin+tf combo
 slots += _pick_best(scalp_combined,         'strategy_scalp',        scalp_combined,  max_slots=1)
 
@@ -266,8 +241,6 @@ if not slots:
     for strat, results, tf in [
         ('strategy_hype',         r2,   '1h'),
         ('strategy_conservative', r1,   '1h'),
-        ('strategy_vw_reversion', rvw,  '1h'),
-        ('strategy_mean_reversion_zscore', rzs, '1h'),
         ('strategy_scalp',        r3_30,'30m'),
     ]:
         for r in results:

_validate_bots.py

@@ -1,63 +0,0 @@
-#!/usr/bin/env python3
-"""Validate all three strategy tiers."""
-import sys, importlib
-from hbot import HyperliquidAPI
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-
-api = HyperliquidAPI(verify_ssl=False)
-
-def get_df(coin, tf, days):
-    start_ms = int((datetime.now(timezone.utc) - timedelta(days=days)).timestamp() * 1000)
-    raw = api.get_candles(coin, tf, start_ms)
-    if not raw: return pd.DataFrame()
-    rows = [{'timestamp': pd.to_datetime(int(x['t']), unit='ms', utc=True),
-             'open': float(x['o']), 'high': float(x['h']), 'low': float(x['l']),
-             'close': float(x['c']), 'volume': float(x['v'])} for x in raw]
-    return pd.DataFrame(rows).drop_duplicates('timestamp').sort_values('timestamp').set_index('timestamp')
-
-def run_bt(strat_name, coin, tf, days, fee_bps, slip_bps, risk_frac):
-    sys.modules.pop('strategy', None)
-    sys.modules.pop('backtest', None)
-    m = importlib.import_module(strat_name)
-    sys.modules['strategy'] = m
-    import backtest as bt
-    importlib.reload(bt)
-    df = get_df(coin, tf, days)
-    if len(df) < 100: return None
-    s = m.StrategyEngine({'use_regime_filter': False})
-    b = bt.StrategyBacktester(s, 100.0, fee_bps, slip_bps, risk_frac,
-                               strategy_name=strat_name)
-    return b.backtest(df, coin, tf)
-
-print("╔══════════════════════════════════════════════════════════════════╗")
-print("║           3-BOT SYSTEM VALIDATION                               ║")
-print("╠══════════════════════════════════════════════════════════════════╣")
-
-# TIER 1 — Conservative TIA 1h (wider stops, patience)
-print("║ TIER 1 — Conservative (strategy_conservative) TIA 1h            ║")
-print("╠══════════════════════════════════════════════════════════════════╣")
-print(f"  {'days':>4} | {'trades':>6} | {'win%':>5} | {'ret%':>7} | {'pf':>4} | {'dd%':>5} | {'sharpe':>6} | {'fees$':>6}")
-for days in [60, 90, 120, 180]:
-    r = run_bt('strategy_conservative', 'TIA', '1h', days, 1.44, 0.5, 0.003)
-    if r: print(f"  {days:>4} | {r.trades:>6} | {r.win_rate*100:>5.1f} | {r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | {r.max_drawdown_pct:>5.2f} | {r.sharpe_ratio:>6.2f} | {r.total_fees_paid:>6.2f}")
-
-# TIER 2 — Aggressive SOL 1h
-print("╠══════════════════════════════════════════════════════════════════╣")
-print("║ TIER 2 — Aggressive (strategy_hype) SOL 1h                      ║")
-print("╠══════════════════════════════════════════════════════════════════╣")
-for days in [60, 90, 120, 180]:
-    r = run_bt('strategy_hype', 'SOL', '1h', days, 4.32, 3.0, 0.005)
-    if r: print(f"  {days:>4} | {r.trades:>6} | {r.win_rate*100:>5.1f} | {r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | {r.max_drawdown_pct:>5.2f} | {r.sharpe_ratio:>6.2f} | {r.total_fees_paid:>6.2f}")
-
-# TIER 3 — Scalp TIA 15m
-print("╠══════════════════════════════════════════════════════════════════╣")
-print("║ TIER 3 — Scalp (strategy_scalp) TIA 15m                         ║")
-print("╠══════════════════════════════════════════════════════════════════╣")
-for days in [60, 90, 120, 180]:
-    r = run_bt('strategy_scalp', 'TIA', '15m', days, 4.32, 1.5, 0.005)
-    if r: print(f"  {days:>4} | {r.trades:>6} | {r.win_rate*100:>5.1f} | {r.total_return_pct:>7.2f} | {r.profit_factor:>4.2f} | {r.max_drawdown_pct:>5.2f} | {r.sharpe_ratio:>6.2f} | {r.total_fees_paid:>6.2f}")
-
-print("╚══════════════════════════════════════════════════════════════════╝")
-
-

autonomous_bot.py

@@ -237,14 +237,12 @@ SLOT_PRESETS = {
         ("strategy_ml_auto",  "SOL",  "1h",  0.15),
     ],
     "new_mix": [
-        ("strategy_vw_reversion",         "INJ",  "1h", 0.50),
-        ("strategy_mean_reversion_zscore", "NEAR", "1h", 0.50),
+        ("strategy_hype", "TIA", "1h", 0.50),
+        ("strategy_scalp", "NEAR", "30m", 0.50),
     ],
     "extended": [
-        ("strategy_hype",                 "TIA",  "1h",  0.25),
-        ("strategy_scalp",                "NEAR", "30m", 0.25),
-        ("strategy_vw_reversion",         "INJ",  "1h",  0.25),
-        ("strategy_mean_reversion_zscore", "NEAR", "1h",  0.25),
+        ("strategy_hype",  "TIA",  "1h",  0.50),
+        ("strategy_scalp", "NEAR", "30m", 0.50),
     ],
 }
 
@@ -963,8 +961,8 @@ def main():
             "all   = conservative/LINK + hype/TIA + scalp/NEAR\n"
             "ml    = ml_auto/BTC + ml_auto/ETH\n"
             "all3  = hype + scalp + ml_auto (5 slots, all 3 strategies)\n"
-            "new_mix = vw_reversion/INJ + zscore/NEAR (newly optimized)\n"
-            "extended = hype/TIA + scalp/NEAR + vw_reversion/INJ + zscore/NEAR\n"
+            "new_mix = hype/TIA + scalp/NEAR\n"
+            "extended = hype/TIA + scalp/NEAR\n"
             "Ignored when --config (or auto-detected bot_config.json) is provided.\n"
             ),
             )

backtest.py

@@ -9,8 +9,6 @@ from typing import List, Optional
 import numpy as np
 import pandas as pd
 
-from strategy import StrategyEngine
-
 # ── Realistic per-strategy fee profiles (your account rates) ─────────────────
 # Taker: 0.0432%  (4.32 bps)  Maker: 0.0144%  (1.44 bps)
 #
@@ -33,12 +31,6 @@ STRATEGY_FEE_PROFILES = {
     "strategy_hype":         dict(entry_fee_bps=4.32, exit_fee_bps=2.88),
     "strategy_scalp":        dict(entry_fee_bps=4.32, exit_fee_bps=2.88),
     "strategy_ml_auto":      dict(entry_fee_bps=4.32, exit_fee_bps=2.88),
-    "strategy_breakout":     dict(entry_fee_bps=4.32, exit_fee_bps=2.88),
-    "strategy_mean_reversion_zscore": dict(entry_fee_bps=1.44, exit_fee_bps=1.44),
-    "strategy_hma_cross": dict(entry_fee_bps=4.32, exit_fee_bps=2.88),
-    "strategy_rsi_extreme": dict(entry_fee_bps=4.32, exit_fee_bps=2.88),
-    "strategy_st_pullback": dict(entry_fee_bps=4.32, exit_fee_bps=2.88),
-    "strategy_vw_reversion": dict(entry_fee_bps=1.44, exit_fee_bps=1.44),
 }
 
 

bot_config.json

@@ -1,43 +1,37 @@
 {
-  "generated_at": "2026-05-26T17:02:05.363830+00:00",
+  "generated_at": "2026-05-27T01:44:42.822174+00:00",
   "scan_days": 180,
-  "ml_backtest_seed_path": "/home/chiggin/hyperliquid-bot/reports/ml_auto_backtest_seed.json",
+  "ml_backtest_seed_path": "/Users/daniel.a/hyperliquid-bot/reports/ml_auto_backtest_seed.json",
   "slots": [
     {
       "strategy": "strategy_hype",
       "coin": "TIA",
       "timeframe": "1h",
-      "capital_frac": 0.15
+      "capital_frac": 0.33
     },
     {
       "strategy": "strategy_conservative",
       "coin": "WIF",
       "timeframe": "1h",
-      "capital_frac": 0.15
+      "capital_frac": 0.33
     },
     {
-      "strategy": "strategy_vw_reversion",
+      "strategy": "strategy_scalp",
       "coin": "ARB",
-      "timeframe": "1h",
-      "capital_frac": 0.15
-    },
-    {
-      "strategy": "strategy_mean_reversion_zscore",
-      "coin": "NEAR",
-      "timeframe": "1h",
-      "capital_frac": 0.15
+      "timeframe": "30m",
+      "capital_frac": 0.17
     },
     {
       "strategy": "strategy_ml_auto",
       "coin": "SUI",
       "timeframe": "1h",
-      "capital_frac": 0.125
+      "capital_frac": 0.085
     },
     {
       "strategy": "strategy_ml_auto",
-      "coin": "INJ",
+      "coin": "NEAR",
       "timeframe": "1h",
-      "capital_frac": 0.125
+      "capital_frac": 0.085
     }
   ]
 }

reports/funding_arb.log

@@ -0,0 +1,4 @@
+2026-05-26 11:21:01,628 - INFO - Health-check server on port 7860
+2026-05-26 11:21:14,671 - WARNING - SSL error — disabling verification.
+2026-05-26 11:21:25,451 - WARNING - SSL error — disabling verification.
+2026-05-26 11:24:56,770 - WARNING - SSL error — disabling verification.

reports/funding_monitor.log

@@ -0,0 +1,6 @@
+2026-05-26 11:16:19,059 - INFO - Single-poll mode.
+2026-05-26 11:16:19,172 - WARNING - SSL error — retrying without verification.
+2026-05-26 11:16:19,648 - WARNING - SSL error — retrying without verification.
+2026-05-26 11:18:06,707 - INFO - Single-poll mode.
+2026-05-26 11:18:06,828 - WARNING - SSL error — retrying without verification.
+2026-05-26 11:18:07,324 - WARNING - SSL error — retrying without verification.

strategy.py

@@ -1,194 +0,0 @@
-#!/usr/bin/env python3
-"""Strategy: Mean Reversion Bollinger Bounce for SOL (15m/1h)
-With optional ML regime filter (regime.py).
-
-Capitalizes on sideways chop by fading extremes, and now uses a Hidden Markov
-Model-based regime classifier to ONLY trade when the market is in 'ranging' mode.
-In trending regimes, signals are suppressed to avoid getting run over.
-
-Core Logic:
-- Uses Bollinger Bands (2.25 Standard Deviations) to find extremes.
-- ADX Filter: Only takes trades when ADX < 25 (market is ranging).
-- RSI Filter: Adds confluence for oversold/overbought conditions.
-- HMM Regime Gate: Skips signal if ML says market is trending (not ranging).
-- Target: The mean (20 SMA).
-
-To disable ML regime filter: set use_regime_filter=False in config.
-"""
-
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple
-import numpy as np
-import pandas as pd
-
-try:
-    from regime import RegimeDetector
-    REGIME_AVAILABLE = True
-except ImportError:
-    REGIME_AVAILABLE = False
-
-
-@dataclass
-class TradeIntent:
-    coin: str
-    timeframe: str
-    side: str
-    entry_price: float
-    stop_loss: float
-    take_profit: float
-    confidence: float
-
-
-class StrategyEngine:
-    def __init__(self, config: Dict):
-        self.config = config
-        self._use_regime = config.get("use_regime_filter", True) and REGIME_AVAILABLE
-        self._regime_detector: Optional[object] = None   # RegimeDetector instance
-
-    # ------------------------------------------------------------------
-    # Fit ML regime model on a full DataFrame (call once before backtesting)
-    # ------------------------------------------------------------------
-    def fit_regime(self, df: pd.DataFrame) -> None:
-        """Train the HMM regime detector on the provided OHLCV+indicator DataFrame."""
-        if not self._use_regime:
-            return
-        det = RegimeDetector(n_states=3)
-        det.fit(df)
-        self._regime_detector = det
-        dist = det.regime_distribution()
-        print(f"[Regime] Distribution: {dist}")
-
-    def regime_for_row(self, row: pd.Series) -> str:
-        """Return regime label for a single row. 'unknown' if not fitted."""
-        if not self._use_regime or self._regime_detector is None:
-            return "ranging"   # pass-through: assume ranging (strategy works)
-        return self._regime_detector.predict(row)
-
-    # ------------------------------------------------------------------
-    # Indicators (unchanged)
-    # ------------------------------------------------------------------
-    def add_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
-        d = df.copy()
-
-        # Bollinger Bands (20, 2.25 SD)
-        d["sma_20"] = d["close"].rolling(window=20).mean()
-        d["std_20"] = d["close"].rolling(window=20).std()
-        d["bb_upper"] = d["sma_20"] + (2.25 * d["std_20"])
-        d["bb_lower"] = d["sma_20"] - (2.25 * d["std_20"])
-
-        # RSI-14
-        delta = d["close"].diff()
-        up = delta.clip(lower=0); dn = -delta.clip(upper=0)
-        rs = up.rolling(14).mean() / dn.rolling(14).mean().replace(0, np.nan)
-        d["rsi"] = 100 - (100 / (1 + rs))
-
-        # ATR-14
-        tr = pd.concat([
-            d["high"] - d["low"],
-            (d["high"] - d["close"].shift()).abs(),
-            (d["low"]  - d["close"].shift()).abs(),
-            ], axis=1).max(axis=1)
-        d["atr"]     = tr.rolling(14).mean()
-        d["atr_pct"] = d["atr"] / d["close"] * 100
-        d["atr_pct_sma"] = d["atr_pct"].rolling(100).mean()
-
-        # ADX-14 (Trend strength filter)
-        pdm = d["high"].diff().clip(lower=0)
-        mdm = (-d["low"].diff()).clip(lower=0)
-        pdm = pdm.where(pdm > mdm, 0.0)
-        mdm = mdm.where(mdm > pdm, 0.0)
-        pdi = 100 * pdm.rolling(14).mean() / d["atr"].replace(0, np.nan)
-        mdi = 100 * mdm.rolling(14).mean() / d["atr"].replace(0, np.nan)
-        dx  = 100 * (pdi - mdi).abs() / (pdi + mdi).replace(0, np.nan)
-        d["adx"] = dx.rolling(14).mean()
-
-        # Professional Indicators
-        d["ema_9"] = d["close"].ewm(span=9, adjust=False).mean()
-        d["ema_21"] = d["close"].ewm(span=21, adjust=False).mean()
-        
-        # Donchian Channels (20)
-        d["donchian_upper"] = d["high"].rolling(20).max()
-        d["donchian_lower"] = d["low"].rolling(20).min()
-        
-        # Volume Filter
-        d["volume_sma"] = d["volume"].rolling(20).mean()
-
-        # Structural extremes
-        d["swing_low5"]  = d["low"].rolling(5).min()
-        d["swing_high5"] = d["high"].rolling(5).max()
-
-        return d.dropna()
-
-    def signal_for_row(self, row: pd.Series) -> int:
-        regime = self.regime_for_row(row)
-        
-        close = float(row["close"])
-        open_price = float(row["open"])
-        rsi = float(row["rsi"])
-        vol = float(row["volume"])
-        vol_sma = float(row["volume_sma"])
-        
-        # Volume Confirmation
-        vol_filter = vol > (vol_sma * 0.9)
-
-        # --- INSTITUTIONAL TREND-FOLLOWING ---
-        if regime == "uptrend":
-            # 1. Breakout Confirmation
-            if close > (row["donchian_upper"] * 1.002) and vol_filter:
-                return 1
-            # 2. Momentum Confluence
-            if close > row["ema_9"] and close > row["ema_21"] and rsi > 60:
-                return 1
-                
-        elif regime == "downtrend":
-            # 1. Breakout Confirmation
-            if close < (row["donchian_lower"] * 0.998) and vol_filter:
-                return -1
-            # 2. Momentum Confluence
-            if close < row["ema_9"] and close < row["ema_21"] and rsi < 40:
-                return -1
-        
-        # In Ranging regimes, we wait for a transition to trend
-        return 0
-
-    def risk_levels(
-            self, entry: float, atr: float, side: int, atr_pct: float = 0.0, row: Optional[pd.Series] = None
-    ) -> Tuple[float, float]:
-        # Institutional Standard: 3.0 ATR Stop to survive noise, dynamic target
-        if side == 1:
-            sl = entry - (3.0 * atr)
-            tp = entry + (7.0 * atr) # Wide TP, reliance on trail_stop
-        else:
-            sl = entry + (3.0 * atr)
-            tp = entry - (7.0 * atr)
-
-        return sl, tp
-
-    def trail_stop(self, side: int, entry: float, current_sl: float, close: float, atr: float) -> float:
-        """Professional Trailing Stop: Moves SL as trade progresses in profit."""
-        if side == 1: # Long
-            # Move SL up to (close - 3.5*ATR) but NEVER move it down
-            new_sl = max(current_sl, close - (3.5 * atr))
-            return new_sl
-        else: # Short
-            # Move SL down to (close + 3.5*ATR) but NEVER move it up
-            new_sl = min(current_sl, close + (3.5 * atr))
-            return new_sl
-
-    # ------------------------------------------------------------------
-    # Build intent (live scanning)
-    # ------------------------------------------------------------------
-    def build_intent(self, coin: str, timeframe: str, row: pd.Series) -> Optional[TradeIntent]:
-        signal = self.signal_for_row(row)
-        if signal == 0:
-            return None
-        side  = "long" if signal == 1 else "short"
-        entry = float(row["close"])
-        stop, tp = self.risk_levels(entry, float(row["atr"]), signal, float(row["atr_pct"]), row)
-        conf  = round(min(0.95, max(0.5, 1.0 - (row["adx"] / 50.0))), 2)
-        return TradeIntent(coin, timeframe, side, entry, stop, tp, conf)
-
-
-
-

strategy_breakout.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python3
-"""
-Strategy: Volatility & Volume Breakout (1h/4h)
-==============================================
-This strategy targets high-momentum breakouts from consolidation zones.
-
-Core Logic:
-- Donchian Channels: Defines the consolidation range. Breakout above/below triggers interest.
-- SuperTrend: Confirms the prevailing trend direction to avoid counter-trend fakeouts.
-- Volume Surge: Requires volume to be at least 50% higher than its 20-period SMA.
-- ADX Filter: Ensures the market is actually starting to trend (ADX > 25).
-
-Risk Management:
-- Stop Loss: 2.0 * ATR for breathing room.
-- Take Profit: 4.0 * ATR (2:1 Reward-to-Risk).
-- Trailing Stop: Moves with price once in profit.
-"""
-
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple
-import numpy as np
-import pandas as pd
-import ta
-
-@dataclass
-class TradeIntent:
-    coin: str
-    timeframe: str
-    side: str
-    entry_price: float
-    stop_loss: float
-    take_profit: float
-    confidence: float
-
-class StrategyEngine:
-    def __init__(self, config: Dict):
-        self.config = config
-        self.use_maker_orders = False # Breakouts often need market entries
-        
-    def add_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
-        d = df.copy()
-        
-        # Donchian Channels (20) - Shifted to avoid lookahead (breakout of PREVIOUS 20 highs)
-        d["donchian_high"] = d["high"].shift(1).rolling(20).max()
-        d["donchian_low"]  = d["low"].shift(1).rolling(20).min()
-        
-        # ATR (14)
-        d["atr"] = ta.volatility.AverageTrueRange(d["high"], d["low"], d["close"], window=14).average_true_range()
-        d["atr_pct"] = d["atr"] / d["close"] * 100
-        
-        # ADX (14)
-        adx_ind = ta.trend.ADXIndicator(d["high"], d["low"], d["close"], window=14)
-        d["adx"] = adx_ind.adx()
-        
-        # Volume SMA (20)
-        d["volume_sma"] = d["volume"].rolling(20).mean()
-        
-        # SuperTrend (10, 3.0)
-        multiplier = 3.0
-        period = 10
-        hl2 = (d["high"] + d["low"]) / 2
-        
-        # Basic Upper/Lower bands
-        d["st_upper_basic"] = hl2 + (multiplier * d["atr"])
-        d["st_lower_basic"] = hl2 - (multiplier * d["atr"])
-        
-        # Final Bands
-        upper_band = d["st_upper_basic"].values
-        lower_band = d["st_lower_basic"].values
-        close = d["close"].values
-        
-        final_upper = np.zeros(len(d))
-        final_lower = np.zeros(len(d))
-        st = np.zeros(len(d))
-        direction = np.zeros(len(d))
-        
-        for i in range(1, len(d)):
-            # Final Upper Band
-            if upper_band[i] < final_upper[i-1] or close[i-1] > final_upper[i-1]:
-                final_upper[i] = upper_band[i]
-            else:
-                final_upper[i] = final_upper[i-1]
-                
-            # Final Lower Band
-            if lower_band[i] > final_lower[i-1] or close[i-1] < final_lower[i-1]:
-                final_lower[i] = lower_band[i]
-            else:
-                final_lower[i] = final_lower[i-1]
-            
-            # SuperTrend
-            if i == 1:
-                direction[i] = 1
-            elif st[i-1] == final_upper[i-1]:
-                direction[i] = -1 if close[i] <= final_upper[i] else 1
-            else:
-                direction[i] = 1 if close[i] >= final_lower[i] else -1
-                
-            st[i] = final_upper[i] if direction[i] == -1 else final_lower[i]
-            
-        d["supertrend"] = st
-        d["st_direction"] = direction
-
-        return d.dropna()
-
-    def signal_for_row(self, row: pd.Series) -> int:
-        close = float(row["close"])
-        vol = float(row["volume"])
-        vol_sma = float(row["volume_sma"])
-        adx = float(row["adx"])
-        st_dir = int(row["st_direction"])
-        
-        # Volume Surge: 1.5x average
-        vol_surge = vol > (vol_sma * 1.5)
-        # Trending: ADX > 25
-        trending = adx > 25
-        
-        # LONG: Breakout High + SuperTrend Up + Volume Surge + Trending
-        if close > row["donchian_high"] and st_dir == 1 and vol_surge and trending:
-            return 1
-            
-        # SHORT: Breakout Low + SuperTrend Down + Volume Surge + Trending
-        if close < row["donchian_low"] and st_dir == -1 and vol_surge and trending:
-            return -1
-            
-        return 0
-
-    def risk_levels(self, entry: float, atr: float, side: int, atr_pct: float = 0.0, row: Optional[pd.Series] = None) -> Tuple[float, float]:
-        if side == 1:
-            sl = entry - (2.0 * atr)
-            tp = entry + (4.0 * atr)
-        else:
-            sl = entry + (2.0 * atr)
-            tp = entry - (4.0 * atr)
-        return sl, tp
-
-    def trail_stop(self, side: int, entry: float, current_sl: float, close: float, atr: float) -> float:
-        # Tighten stop as price moves in our favor
-        if side == 1:
-            return max(current_sl, close - (2.5 * atr))
-        else:
-            return min(current_sl, close + (2.5 * atr))
-
-    def build_intent(self, coin: str, timeframe: str, row: pd.Series) -> Optional[TradeIntent]:
-        signal = self.signal_for_row(row)
-        if signal == 0:
-            return None
-        side = "long" if signal == 1 else "short"
-        entry = float(row["close"])
-        stop, tp = self.risk_levels(entry, float(row["atr"]), signal, float(row["atr_pct"]), row)
-        conf = 0.8
-        return TradeIntent(coin, timeframe, side, entry, stop, tp, conf)

strategy_hma_cross.py

@@ -1,110 +0,0 @@
-#!/usr/bin/env python3
-"""
-Strategy: Hull Moving Average (HMA) Cross (1h)
-==============================================
-Uses the Hull Moving Average to reduce lag while maintaining smoothness.
-
-Core Logic:
-- Fast HMA (9) and Slow HMA (21).
-- Entry (Long): HMA(9) crosses above HMA(21) AND RSI > 55.
-- Entry (Short): HMA(9) crosses below HMA(21) AND RSI < 45.
-- Exit: Opposite HMA cross or Stop Loss / Take Profit.
-- ATR-based risk management.
-"""
-
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple
-import numpy as np
-import pandas as pd
-import ta
-
-@dataclass
-class TradeIntent:
-    coin: str
-    timeframe: str
-    side: str
-    entry_price: float
-    stop_loss: float
-    take_profit: float
-    confidence: float
-
-def hma(series, window):
-    """Hull Moving Average implementation."""
-    w_half = int(window / 2)
-    w_sqrt = int(np.sqrt(window))
-    
-    wma_half = series.rolling(w_half).apply(lambda x: np.dot(x, np.arange(1, w_half + 1)) / np.sum(np.arange(1, w_half + 1)), raw=True)
-    wma_full = series.rolling(window).apply(lambda x: np.dot(x, np.arange(1, window + 1)) / np.sum(np.arange(1, window + 1)), raw=True)
-    
-    diff = 2 * wma_half - wma_full
-    hma = diff.rolling(w_sqrt).apply(lambda x: np.dot(x, np.arange(1, w_sqrt + 1)) / np.sum(np.arange(1, w_sqrt + 1)), raw=True)
-    return hma
-
-class StrategyEngine:
-    def __init__(self, config: Dict):
-        self.config = config
-        self.use_maker_orders = False # Trend crosses usually need market orders
-        
-    def add_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
-        d = df.copy()
-        
-        # HMA 9 and 21
-        d["hma_fast"] = hma(d["close"], 9)
-        d["hma_slow"] = hma(d["close"], 21)
-        
-        # RSI (14)
-        d["rsi"] = ta.momentum.RSIIndicator(d["close"], window=14).rsi()
-        
-        # ATR (14)
-        d["atr"] = ta.volatility.AverageTrueRange(d["high"], d["low"], d["close"], window=14).average_true_range()
-        d["atr_pct"] = d["atr"] / d["close"] * 100
-        
-        # Previous values for crossover detection
-        d["hma_fast_prev"] = d["hma_fast"].shift(1)
-        d["hma_slow_prev"] = d["hma_slow"].shift(1)
-        
-        return d.dropna()
-
-    def signal_for_row(self, row: pd.Series) -> int:
-        f = float(row["hma_fast"])
-        s = float(row["hma_slow"])
-        f_prev = float(row["hma_fast_prev"])
-        s_prev = float(row["hma_slow_prev"])
-        rsi = float(row["rsi"])
-        
-        # LONG: HMA Fast crosses ABOVE HMA Slow + RSI > 55
-        if f_prev <= s_prev and f > s and rsi > 55:
-            return 1
-            
-        # SHORT: HMA Fast crosses BELOW HMA Slow + RSI < 45
-        if f_prev >= s_prev and f < s and rsi < 45:
-            return -1
-            
-        return 0
-
-    def risk_levels(self, entry: float, atr: float, side: int, atr_pct: float = 0.0, row: Optional[pd.Series] = None) -> Tuple[float, float]:
-        # 1.5 ATR Stop, 3.0 ATR Target (2:1 RR)
-        if side == 1:
-            sl = entry - (1.5 * atr)
-            tp = entry + (3.0 * atr)
-        else:
-            sl = entry + (1.5 * atr)
-            tp = entry - (3.0 * atr)
-        return sl, tp
-
-    def trail_stop(self, side: int, entry: float, current_sl: float, close: float, atr: float) -> float:
-        if side == 1:
-            return max(current_sl, close - (2.0 * atr))
-        else:
-            return min(current_sl, close + (2.0 * atr))
-
-    def build_intent(self, coin: str, timeframe: str, row: pd.Series) -> Optional[TradeIntent]:
-        signal = self.signal_for_row(row)
-        if signal == 0:
-            return None
-        side = "long" if signal == 1 else "short"
-        entry = float(row["close"])
-        stop, tp = self.risk_levels(entry, float(row["atr"]), signal, float(row["atr_pct"]), row)
-        conf = 0.75
-        return TradeIntent(coin, timeframe, side, entry, stop, tp, conf)

strategy_mean_reversion_zscore.py

@@ -1,116 +0,0 @@
-#!/usr/bin/env python3
-"""
-Strategy: Z-Score Mean Reversion (1h)
-=====================================
-This strategy identifies extreme price deviations from the mean (20-period SMA)
-and trades the reversion back to that mean, with 200 EMA directional filter.
-
-Core Logic:
-- Z-Score: (Close - SMA) / StdDev. Measures how many standard deviations price is from the mean.
-- Entry (Long): Z-Score < -1.5 (Oversold) AND Price > 200 EMA (reversion in uptrend).
-- Entry (Short): Z-Score > 1.5 (Overbought) AND Price < 200 EMA (reversion in downtrend).
-- Exit: Price hits the SMA (Z-Score returns to 0) or Stop Loss is hit.
-- Filter: ADX < 30 (avoid strong trends), 200 EMA for trend direction.
-- Philosophy: Trade extreme reversals only in the direction of the longer-term trend.
-"""
-
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple
-import numpy as np
-import pandas as pd
-import ta
-
-@dataclass
-class TradeIntent:
-    coin: str
-    timeframe: str
-    side: str
-    entry_price: float
-    stop_loss: float
-    take_profit: float
-    confidence: float
-
-class StrategyEngine:
-    def __init__(self, config: Dict):
-        self.config = config
-        self.use_maker_orders = True # Mean reversion can often use limit orders at extremes
-        
-    def add_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
-        d = df.copy()
-        
-        # SMA (20) and StdDev (20)
-        d["sma"] = d["close"].rolling(20).mean()
-        d["std"] = d["close"].rolling(20).std()
-        
-        # Z-Score
-        d["zscore"] = (d["close"] - d["sma"]) / d["std"]
-        
-        # EMA (200) for trend filter
-        d["ema200"] = d["close"].ewm(span=200, adjust=False).mean()
-        
-        # ATR (14) for stop loss
-        d["atr"] = ta.volatility.AverageTrueRange(d["high"], d["low"], d["close"], window=14).average_true_range()
-        d["atr_pct"] = d["atr"] / d["close"] * 100
-        
-        # ADX (14) to filter out strong trends (lowering threshold slightly)
-        adx_ind = ta.trend.ADXIndicator(d["high"], d["low"], d["close"], window=14)
-        d["adx"] = adx_ind.adx()
-        
-        return d.dropna()
-
-    def signal_for_row(self, row: pd.Series) -> int:
-         z = float(row["zscore"])
-         adx = float(row["adx"])
-         close = float(row["close"])
-         ema200 = float(row["ema200"])
-
-         # Only trade in moderately trending or ranging markets
-         if adx > 30:
-             return 0
-
-         # ── 200 EMA directional filter (only trade extreme reversion in direction of trend) ──
-         # LONG only if z-score is BELOW -1.5 AND price is ABOVE 200 EMA (reversion in uptrend)
-         # This avoids catching falling knives in downtrends
-         if z < -1.5 and close > ema200:
-             return 1
-
-         # SHORT only if z-score is ABOVE 1.5 AND price is BELOW 200 EMA (reversion in downtrend)
-         # This avoids catching rallies in uptrends
-         if z > 1.5 and close < ema200:
-             return -1
-
-         return 0
-
-    def risk_levels(self, entry: float, atr: float, side: int, atr_pct: float = 0.0, row: Optional[pd.Series] = None) -> Tuple[float, float]:
-        # TP is the mean (SMA), which we can approximate as the current entry minus/plus some distance
-        # but the backtest engine expects a fixed TP. 
-        # Since we want to exit at mean, let's set TP to 1.5 * ATR and SL to 1.5 * ATR for a 1:1 ratio.
-        # Actually, if we are at Z=2.0, reverting to 0 is roughly 2.0 * StdDev.
-        
-        # Let's use a dynamic TP based on the SMA if available in row
-        if row is not None and "sma" in row:
-            tp = float(row["sma"])
-        else:
-            tp = entry + (2.0 * atr) if side == 1 else entry - (2.0 * atr)
-
-        if side == 1:
-            sl = entry - (2.0 * atr)
-        else:
-            sl = entry + (2.0 * atr)
-            
-        return sl, tp
-
-    def trail_stop(self, side: int, entry: float, current_sl: float, close: float, atr: float) -> float:
-        # Mean reversion usually doesn't trail stop, or trails very loosely
-        return current_sl
-
-    def build_intent(self, coin: str, timeframe: str, row: pd.Series) -> Optional[TradeIntent]:
-        signal = self.signal_for_row(row)
-        if signal == 0:
-            return None
-        side = "long" if signal == 1 else "short"
-        entry = float(row["close"])
-        stop, tp = self.risk_levels(entry, float(row["atr"]), signal, float(row["atr_pct"]), row)
-        conf = 0.7
-        return TradeIntent(coin, timeframe, side, entry, stop, tp, conf)

strategy_vw_reversion.py

@@ -1,116 +0,0 @@
-#!/usr/bin/env python3
-"""
-Strategy: Volatility-Weighted Mean Reversion (1h)
-==================================================
-Combines trend-alignment with high-conviction mean reversion entries.
-Inspired by the 'hype' strategy's use of multi-indicator filters.
-
-Core Logic:
-- Trend: 200-EMA for long-term direction.
-- Momentum: RSI(14) with tight entry windows (Long: 30-45, Short: 55-70).
-- Volatility: Entry ONLY when price touches/crosses Bollinger Band extremes.
-- Filters: ADX < 35 (not parabolic) and Volume > 0.9x SMA20.
-- Target: The SMA(20) "Mean".
-- Risk: 2.0 ATR Stop, SMA(20) Take Profit (min 1.5:1 RR).
-"""
-
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple
-import numpy as np
-import pandas as pd
-import ta
-
-@dataclass
-class TradeIntent:
-    coin: str
-    timeframe: str
-    side: str
-    entry_price: float
-    stop_loss: float
-    take_profit: float
-    confidence: float
-
-class StrategyEngine:
-    def __init__(self, config: Dict):
-        self.config = config
-        self.use_maker_orders = True
-        
-    def add_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
-        d = df.copy()
-        
-        # Trend
-        d["ema200"] = d["close"].ewm(span=200, adjust=False).mean()
-        
-        # Volatility (Bollinger Bands 20, 2.0)
-        bb = ta.volatility.BollingerBands(d["close"], window=20, window_dev=2.0)
-        d["bb_high"] = bb.bollinger_hband()
-        d["bb_low"] = bb.bollinger_lband()
-        d["sma20"] = bb.bollinger_mavg()
-        
-        # Momentum
-        d["rsi"] = ta.momentum.RSIIndicator(d["close"], window=14).rsi()
-        d["adx"] = ta.trend.ADXIndicator(d["high"], d["low"], d["close"], window=14).adx()
-        
-        # Volume
-        d["volume_sma"] = d["volume"].rolling(20).mean()
-        
-        # ATR for risk
-        d["atr"] = ta.volatility.AverageTrueRange(d["high"], d["low"], d["close"], window=14).average_true_range()
-        d["atr_pct"] = d["atr"] / d["close"] * 100
-        
-        return d.dropna()
-
-    def signal_for_row(self, row: pd.Series) -> int:
-        close = float(row["close"])
-        ema200 = float(row["ema200"])
-        bb_high = float(row["bb_high"])
-        bb_low = float(row["bb_low"])
-        rsi = float(row["rsi"])
-        adx = float(row["adx"])
-        vol = float(row["volume"])
-        vol_sma = float(row["volume_sma"])
-        
-        # Global Filters
-        if adx > 35 or vol < vol_sma * 0.9:
-            return 0
-            
-        # LONG: Above EMA200 (uptrend) AND price touches/below BB_LOW AND RSI in 30-45 zone
-        if close > ema200 and close <= bb_low * 1.002 and 30 <= rsi <= 45:
-            return 1
-            
-        # SHORT: Below EMA200 (downtrend) AND price touches/above BB_HIGH AND RSI in 55-70 zone
-        if close < ema200 and close >= bb_high * 0.998 and 55 <= rsi <= 70:
-            return -1
-            
-        return 0
-
-    def risk_levels(self, entry: float, atr: float, side: int, atr_pct: float = 0.0, row: Optional[pd.Series] = None) -> Tuple[float, float]:
-        # TP is the mean (SMA20)
-        if row is not None and "sma20" in row.index:
-            tp = float(row["sma20"])
-        else:
-            tp = entry + (2.0 * atr) if side == 1 else entry - (2.0 * atr)
-            
-        # SL is 2.0 ATR
-        if side == 1:
-            sl = entry - (2.0 * atr)
-            # Ensure TP is at least slightly above entry, else use ATR
-            if tp <= entry + (0.5 * atr): tp = entry + (2.5 * atr)
-        else:
-            sl = entry + (2.0 * atr)
-            if tp >= entry - (0.5 * atr): tp = entry - (2.5 * atr)
-            
-        return sl, tp
-
-    def trail_stop(self, side: int, entry: float, current_sl: float, close: float, atr: float) -> float:
-        return current_sl
-
-    def build_intent(self, coin: str, timeframe: str, row: pd.Series) -> Optional[TradeIntent]:
-        signal = self.signal_for_row(row)
-        if signal == 0:
-            return None
-        side = "long" if signal == 1 else "short"
-        entry = float(row["close"])
-        sl, tp = self.risk_levels(entry, float(row["atr"]), signal, 0, row)
-        return TradeIntent(coin, timeframe, side, entry, sl, tp, 0.8)