researching crypto altcoin momentum - expanding beyond btc/eth

import ccxt
import pandas as pd
from datetime import datetime, timedelta

def get_liquid_altcoins(min_volume_usd=50_000_000):
    """
    find altcoins with sufficient daily volume
    """
    exchange = ccxt.binance()
    markets = exchange.load_markets()

    # filter USDT pairs only
    usdt_pairs = [m for m in markets.keys() if '/USDT' in m]

    liquid_alts = []

    for pair in usdt_pairs:
        try:
            ticker = exchange.fetch_ticker(pair)

            # get 24h volume in USD
            volume_usd = ticker['quoteVolume']

            if volume_usd >= min_volume_usd:
                # exclude BTC and ETH (already trading these)
                symbol = pair.split('/')[0]
                if symbol not in ['BTC', 'ETH']:
                    liquid_alts.append({
                        'symbol': symbol,
                        'pair': pair,
                        'volume_24h': volume_usd,
                        'price': ticker['last']
                    })

        except Exception as e:
            continue

    # sort by volume descending
    liquid_alts.sort(key=lambda x: x['volume_24h'], reverse=True)

    return liquid_alts

def calculate_correlation_matrix(symbols, lookback_days=90):
    """
    calculate price correlation between assets
    """
    exchange = ccxt.binance()

    # fetch historical data
    dfs = {}
    for symbol in symbols:
        ohlcv = exchange.fetch_ohlcv(
            f"{symbol}/USDT",
            timeframe='1d',
            limit=lookback_days
        )
        df = pd.DataFrame(
            ohlcv,
            columns=['timestamp', 'open', 'high', 'low', 'close', 'volume']
        )
        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
        df.set_index('timestamp', inplace=True)
        dfs[symbol] = df['close']

    # create correlation matrix
    price_df = pd.DataFrame(dfs)
    correlation = price_df.corr()

    return correlation

def backtest_altcoin_momentum(symbol, start_date, end_date):
    """
    backtest momentum strategy on altcoin
    """
    exchange = ccxt.binance()

    # fetch 15min data
    ohlcv = exchange.fetch_ohlcv(
        f"{symbol}/USDT",
        timeframe='15m',
        since=int(start_date.timestamp() * 1000)
    )

    df = pd.DataFrame(
        ohlcv,
        columns=['timestamp', 'open', 'high', 'low', 'close', 'volume']
    )
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')

    # calculate indicators
    df['atr'] = calculate_atr(df, period=14)

    # detect consolidations
    df['consolidation'] = detect_consolidation(df, period=20)

    # identify breakouts
    df['breakout'] = detect_breakout(df)

    # volume filter
    df['avg_volume'] = df['volume'].rolling(50).mean()
    df['volume_ratio'] = df['volume'] / df['avg_volume']

    # simulate trades
    trades = []
    position = None

    for i in range(len(df)):
        row = df.iloc[i]

        # entry logic
        if position is None:
            if (row['breakout'] and
                row['volume_ratio'] > 1.5 and
                row['consolidation']):

                # calculate position size (0.5% risk)
                stop_distance = row['close'] - (row['low'] - row['atr'] * 0.5)
                position_size = (CAPITAL * 0.005) / stop_distance

                position = {
                    'entry_price': row['close'],
                    'entry_time': row['timestamp'],
                    'stop_loss': row['low'] - (row['atr'] * 0.5),
                    'size': position_size,
                    'stage1_exit': False
                }

        # exit logic
        elif position is not None:
            current_price = row['close']

            # calculate R-multiple
            risk = position['entry_price'] - position['stop_loss']
            profit = current_price - position['entry_price']
            r_multiple = profit / risk

            # stage 1: exit 50% at 2R
            if r_multiple >= 2.0 and not position['stage1_exit']:
                position['stage1_exit'] = True
                position['stop_loss'] = position['entry_price']  # breakeven

            # stage 2: trail stop with ATR
            if position['stage1_exit']:
                trailing_stop = current_price - (row['atr'] * 1.5)
                position['stop_loss'] = max(position['stop_loss'], trailing_stop)

            # check stop loss
            if current_price <= position['stop_loss']:
                pnl = (position['stop_loss'] - position['entry_price']) * position['size']
                trades.append({
                    'symbol': symbol,
                    'entry': position['entry_price'],
                    'exit': position['stop_loss'],
                    'pnl': pnl,
                    'r_multiple': r_multiple
                })
                position = None

    return trades