import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import ccxt
class CryptoMomentumAnalyzer:
    def __init__(self, exchange='binance'):
        self.exchange = getattr(ccxt, exchange)()
        self.exchange.enable_rateimit = True
def calculate_volume_weighted_momentum(self, symbol, timeframe='1h', periods=24):
        """
        Volume-weighted momentum identifies truly strong moves vs. low-volume noise
        Formula: (Price Change × Volume) / Average Volume
        """
# Fetch OHLCV data
        ohlcv = self.exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=periods)
        df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
        df['date'] = pd.to_datetime(df['timestamp'], unit='ms')
# Calculate metrics
        df['price_change'] = df['close'].pct_change()
        df['avg_volume'] = df['volume'].rolling(window=20).mean()
        df['volume_ratio'] = df['volume'] / df['avg_volume']
# Volume-weighted momentum
        df['vw_momentum'] = df['price_change'] * df['volume_ratio']
return df
def identify_momentum_breakouts(self, symbol, lookback=20, volume_threshold=1.5):
        """
        Identify upside/downside breakouts with volume confirmation
        """
df = self.calculate_volume_weighted_momentum(symbol)
# High-volume moves
        high_volume_up = (df['price_change'] > 0.02) & (df['volume_ratio'] > volume_threshold)
        high_volume_down = (df['price_change'] < -0.02) & (df['volume_ratio'] > volume_threshold)
# Breakout detection: new 20-period high/low on volume
        df['high_20'] = df['high'].rolling(window=lookback).max()
        df['low_20'] = df['low'].rolling(window=lookback).min()
upside_breakout = (df['close'] > df['high_20'].shift(1)) & high_volume_up
        downside_breakout = (df['close'] < df['low_20'].shift(1)) & high_volume_down
return {
            'df': df,
            'upside_breakout': upside_breakout.iloc[-1],
            'downside_breakout': downside_breakout.iloc[-1],
            'current_volume_ratio': df['volume_ratio'].iloc[-1]
        }
Usage
analyzer = CryptoMomentumAnalyzer()
result = analyzer.identify_momentum_breakouts('BTC/USDT')
if result['upside_breakout']:
    print("Bitcoin upside breakout detected with strong volume")

def analyze_on_chain_momentum(symbol, lookback_hours=24):
    """
    On-chain metrics reveal institutional behavior
Large transaction volume
Exchange inflow/outflow
Active addresses
    """
api = GlassNode()  # Requires API key
# Active addresses: count of unique addresses active
    active_addresses = api.get_metric('active_addresses', symbol, lookback_hours)
# Exchange flow: net inflow to exchanges (selling pressure)
    exchange_inflow = api.get_metric('exchange_inflow', symbol, lookback_hours)
# Mean transaction value
    mean_tx_value = api.get_metric('mean_transaction_value', symbol, lookback_hours)
# Momentum = more active addresses + fewer exchange inflows = accumulation
    momentum_score = active_addresses - exchange_inflow
return {
        'active_addresses': active_addresses[-1],
        'exchange_inflow': exchange_inflow[-1],
        'momentum_score': momentum_score[-1],
        'sentiment': 'BULLISH' if momentum_score[-1] > 0 else 'BEARISH'
    }

class CryptoMomentumTradingBot:
    def __init__(self, exchange='binance', api_key='', api_secret='',
                 initial_balance=10000, leverage=5, risk_per_trade=0.02):
        self.exchange = ccxt.binance({
            'apiKey': api_key,
            'secret': api_secret,
            'enableRateLimit': True
        })
        self.balance = initial_balance
        self.leverage = leverage  # 5x leverage typical for crypto
        self.risk_per_trade = risk_per_trade
        self.positions = {}
        self.margin_level = 2.0  # Liquidation typically at 1.25x
def run_momentum_scanner(self, symbols_to_scan, timeframe='1h'):
        """
        Scan 100+ crypto pairs for momentum breakouts
        Execute orders on high-confidence signals
        """
opportunities = []
for symbol in symbols_to_scan:
            try:
                # Fetch data
                ohlcv = self.exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=48)
                df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
# Calculate indicators
                df['rsi'] = self.calculate_rsi(df['close'])
                df['macd'], df['signal'], df['histogram'] = self.calculate_macd(df['close'])
                df['atr'] = self.calculate_atr(df['high'], df['low'], df['close'])
# Signal generation
                rsi = df['rsi'].iloc[-1]
                macd_hist = df['histogram'].iloc[-1]
                atr = df['atr'].iloc[-1]
# Momentum entry conditions
                if rsi < 30 and macd_hist < 0:
                    # Strong oversold + negative histogram = reversal setup
                    opportunities.append({
                        'symbol': symbol,
                        'signal': 'LONG',
                        'confidence': 0.7,
                        'entry_price': df['close'].iloc[-1],
                        'atr': atr
                    })
elif rsi > 70 and macd_hist > 0:
                    # Strong overbought + positive histogram = reversal setup
                    opportunities.append({
                        'symbol': symbol,
                        'signal': 'SHORT',
                        'confidence': 0.7,
                        'entry_price': df['close'].iloc[-1],
                        'atr': atr
                    })
except Exception as e:
                print(f"Error scanning {symbol}: {e}")
# Execute high-confidence signals
        for opp in sorted(opportunities, key=lambda x: x['confidence'], reverse=True)[:3]:
            self.execute_momentum_trade(opp)
def execute_momentum_trade(self, opportunity):
        """Execute crypto momentum trade with proper risk management"""
symbol = opportunity['symbol']
        signal = opportunity['signal']
        entry_price = opportunity['entry_price']
        atr = opportunity['atr']
# Position size based on leverage and risk
        risk_amount = self.balance  self.risk_per_trade  self.leverage
        position_size = risk_amount / (2.0 * atr)
# Stop loss and take profit
        if signal == 'LONG':
            stop_loss = entry_price - (2.0 * atr)
            take_profit = entry_price + (3.0 * atr)
            order = self.exchange.create_market_buy_order(
                symbol, position_size / entry_price
            )
        else:  # SHORT
            stop_loss = entry_price + (2.0 * atr)
            take_profit = entry_price - (3.0 * atr)
            order = self.exchange.create_market_sell_order(
                symbol, position_size / entry_price
            )
self.positions[symbol] = {
            'entry_price': entry_price,
            'entry_time': datetime.now(),
            'position_size': position_size,
            'signal': signal,
            'stop_loss': stop_loss,
            'take_profit': take_profit,
            'order_id': order['id']
        }
print(f"Executed {signal} on {symbol} at {entry_price:.2f}")
def monitor_positions(self):
        """
        Continuous monitoring with automatic stop-loss execution
        Critical for crypto: prices move 5% in minutes
        """
for symbol in list(self.positions.keys()):
            try:
                ticker = self.exchange.fetch_ticker(symbol)
                current_price = ticker['last']
pos = self.positions[symbol]
# Check stop loss
                if pos['signal'] == 'LONG' and current_price <= pos['stop_loss']:
                    self.exchange.create_market_sell_order(
                        symbol, pos['position_size']
                    )
                    del self.positions[symbol]
                    print(f"Stop loss executed on {symbol}")
# Check take profit
                if pos['signal'] == 'LONG' and current_price >= pos['take_profit']:
                    self.exchange.create_market_sell_order(
                        symbol, pos['position_size']
                    )
                    del self.positions[symbol]
                    print(f"Profit target hit on {symbol}")
# Check liquidation margin
                margin_level = self.calculate_margin_level()
                if margin_level < 1.5:
                    # Reduce positions to bring margin above 2.0
                    print("WARNING: Margin below 1.5x, reducing leverage")
                    self.reduce_leverage()
except Exception as e:
                print(f"Error monitoring {symbol}: {e}")
def calculate_rsi(self, prices, period=14):
        """RSI calculation"""
        deltas = prices.diff()
        seed = deltas[:period+1]
        up = seed[seed >= 0].sum() / period
        down = -seed[seed < 0].sum() / period
        rs = up / down
        rsi = 100 - 100 / (1 + rs)
        return rsi
def calculate_macd(self, prices, fast=12, slow=26, signal=9):
        """MACD calculation"""
        ema_fast = prices.ewm(span=fast).mean()
        ema_slow = prices.ewm(span=slow).mean()
        macd_line = ema_fast - ema_slow
        signal_line = macd_line.ewm(span=signal).mean()
        histogram = macd_line - signal_line
        return macd_line, signal_line, histogram
def calculate_atr(self, high, low, close, period=14):
        """ATR calculation"""
        tr1 = high - low
        tr2 = abs(high - close.shift(1))
        tr3 = abs(low - close.shift(1))
        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
        return tr.rolling(period).mean()

class CryptoRiskManager:
    def __init__(self, max_leverage=5.0, margin_safety=2.0):
        self.max_leverage = max_leverage
        self.margin_safety = margin_safety
def validate_trade_crypto(self, position_size, entry_price, stop_loss, balance, leverage):
        """
        Crypto-specific validation considering leverage and liquidation risk
        """
# Calculate notional exposure
        notional = position_size * entry_price
        risk_amount = abs(entry_price - stop_loss) * position_size
# Actual leverage applied
        actual_leverage = notional / balance
if actual_leverage > self.max_leverage:
            return False, "Leverage exceeds maximum"
# Margin requirement
        margin_used = notional / leverage
        margin_available = balance - margin_used
# Safety check: margin available > 50% of balance
        if margin_available < balance * 0.5:
            return False, "Insufficient margin safety"
return True, "Trade validated"
def adjust_for_volatility_regime(self, vix_equivalent, position_size):
        """
        Crypto volatility (using realized volatility as proxy)
        Reduce position size in high volatility
        """
if vix_equivalent > 50:  # Extreme volatility
            return position_size * 0.5
        elif vix_equivalent > 40:  # High volatility
            return position_size * 0.7
        elif vix_equivalent > 30:  # Moderate volatility
            return position_size * 0.85
        else:  # Normal volatility
            return position_size