import ccxt
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import asyncio
import logging
logger = logging.getLogger('CryptoTrader')
class ExchangeManager:
    """Unified interface for multiple crypto exchanges."""
def __init__(self, exchange_id: str, api_key: str, secret: str,
                 sandbox: bool = True):
        exchange_class = getattr(ccxt, exchange_id)
        self.exchange = exchange_class({
            'apiKey': api_key,
            'secret': secret,
            'sandbox': sandbox,
            'enableRateLimit': True,
            'options': {'defaultType': 'spot'}
        })
        self.exchange.load_markets()
def fetch_ohlcv(self, symbol: str, timeframe: str = '1h',
                     limit: int = 500) -> pd.DataFrame:
        """Fetch OHLCV data as DataFrame."""
        raw = self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
        df = pd.DataFrame(raw, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
        df.set_index('timestamp', inplace=True)
        return df
def get_order_book(self, symbol: str, depth: int = 20) -> dict:
        """Fetch order book with spread analysis."""
        ob = self.exchange.fetch_order_book(symbol, limit=depth)
best_bid = ob['bids'][0][0] if ob['bids'] else 0
        best_ask = ob['asks'][0][0] if ob['asks'] else 0
        mid = (best_bid + best_ask) / 2
        spread_bps = (best_ask - best_bid) / mid * 10_000
# Depth analysis
        bid_depth = sum(b[0] * b[1] for b in ob['bids'][:depth])
        ask_depth = sum(a[0] * a[1] for a in ob['asks'][:depth])
        imbalance = (bid_depth - ask_depth) / (bid_depth + ask_depth)
return {
            'best_bid': best_bid,
            'best_ask': best_ask,
            'mid': mid,
            'spread_bps': spread_bps,
            'bid_depth_usd': bid_depth,
            'ask_depth_usd': ask_depth,
            'imbalance': imbalance
        }
def place_limit_order(self, symbol: str, side: str, amount: float,
                           price: float) -> dict:
        """Place a limit order with error handling."""
        try:
            order = self.exchange.create_limit_order(symbol, side, amount, price)
            logger.info(f"Order placed: {side} {amount} {symbol} @ {price}")
            return order
        except ccxt.InsufficientFunds as e:
            logger.error(f"Insufficient funds: {e}")
            return None
        except ccxt.InvalidOrder as e:
            logger.error(f"Invalid order: {e}")
            return None

class CrossExchangeArbitrage:
    """
    Monitor price differences across exchanges and execute
    when spread exceeds threshold after costs.
    """
def __init__(self, exchanges: dict, symbol: str = 'BTC/USDT',
                 min_spread_bps: float = 15.0, trade_size_usd: float = 10_000):
        self.exchanges = exchanges  # {name: ExchangeManager}
        self.symbol = symbol
        self.min_spread = min_spread_bps
        self.trade_size = trade_size_usd
def scan_opportunity(self) -> dict:
        """Scan all exchange pairs for arbitrage."""
        prices = {}
        for name, exchange in self.exchanges.items():
            try:
                ob = exchange.get_order_book(self.symbol)
                prices[name] = {
                    'bid': ob['best_bid'],
                    'ask': ob['best_ask'],
                    'spread_bps': ob['spread_bps']
                }
            except Exception as e:
                logger.warning(f"Failed to fetch {name}: {e}")
# Find best bid (sell venue) and best ask (buy venue)
        best_bid_exchange = max(prices, key=lambda x: prices[x]['bid'])
        best_ask_exchange = min(prices, key=lambda x: prices[x]['ask'])
best_bid = prices[best_bid_exchange]['bid']
        best_ask = prices[best_ask_exchange]['ask']
        mid = (best_bid + best_ask) / 2
        spread_bps = (best_bid - best_ask) / mid * 10_000
# Estimate costs (exchange fees + withdrawal + slippage)
        est_cost_bps = 10.0  # ~5bps maker fee each side
net_profit_bps = spread_bps - est_cost_bps
return {
            'buy_exchange': best_ask_exchange,
            'sell_exchange': best_bid_exchange,
            'buy_price': best_ask,
            'sell_price': best_bid,
            'gross_spread_bps': spread_bps,
            'est_cost_bps': est_cost_bps,
            'net_profit_bps': net_profit_bps,
            'actionable': net_profit_bps > self.min_spread
        }

class FundingRateArbitrage:
    """
    Capture perpetual futures funding rate:
When funding > threshold: short perp + long spot
When funding < -threshold: long perp + short spot
    """
def __init__(self, exchange: ExchangeManager,
                 funding_threshold: float = 0.0005,
                 position_size_usd: float = 50_000):
        self.exchange = exchange
        self.threshold = funding_threshold
        self.size = position_size_usd
def get_funding_rate(self, symbol: str) -> dict:
        """Fetch current and predicted funding rate."""
        # Most exchanges provide this via the futures API
        ticker = self.exchange.exchange.fetch_ticker(symbol)
        funding_info = self.exchange.exchange.fetch_funding_rate(symbol)
return {
            'current_rate': funding_info.get('fundingRate', 0),
            'next_funding_time': funding_info.get('fundingDatetime', ''),
            'annualized': funding_info.get('fundingRate', 0)  3  365 * 100
        }
def evaluate_trade(self, spot_symbol: str, perp_symbol: str) -> dict:
        """
        Evaluate funding arbitrage opportunity.
        """
        funding = self.get_funding_rate(perp_symbol)
        rate = funding['current_rate']
        annualized = funding['annualized']
spot_ob = self.exchange.get_order_book(spot_symbol)
        perp_ob = self.exchange.get_order_book(perp_symbol)
# Basis = perp price - spot price (as percentage)
        basis_pct = (perp_ob['mid'] - spot_ob['mid']) / spot_ob['mid'] * 100
signal = 'NONE'
        if rate > self.threshold:
            signal = 'SHORT_PERP_LONG_SPOT'
        elif rate < -self.threshold:
            signal = 'LONG_PERP_SHORT_SPOT'
# Expected return per 8-hour period
        funding_income = abs(rate) * self.size
        execution_cost = self.size * 0.001  # ~10bps round trip
return {
            'funding_rate': f"{rate:.4%}",
            'annualized_rate': f"{annualized:.1f}%",
            'basis_pct': f"{basis_pct:.3f}%",
            'signal': signal,
            'funding_income_per_8h': f"${funding_income:.2f}",
            'execution_cost': f"${execution_cost:.2f}",
            'net_profitable': funding_income > execution_cost
        }

class VolatilityBreakout:
    """
    Enter positions when price breaks out of a volatility channel.
    Optimized for high-vol altcoins.
    """
def __init__(self, atr_period: int = 14, atr_multiplier: float = 2.0,
                 risk_per_trade: float = 0.01, max_holding_hours: int = 48):
        self.atr_period = atr_period
        self.atr_mult = atr_multiplier
        self.risk = risk_per_trade
        self.max_hold = max_holding_hours
def compute_signal(self, df: pd.DataFrame) -> dict:
        """Generate breakout signal from hourly data."""
        # Average True Range
        high_low = df['high'] - df['low']
        high_close = abs(df['high'] - df['close'].shift())
        low_close = abs(df['low'] - df['close'].shift())
        true_range = pd.concat([high_low, high_close, low_close], axis=1).max(axis=1)
        atr = true_range.rolling(self.atr_period).mean()
# Channel
        upper = df['close'].rolling(self.atr_period).mean() + self.atr_mult * atr
        lower = df['close'].rolling(self.atr_period).mean() - self.atr_mult * atr
current_price = df['close'].iloc[-1]
        current_upper = upper.iloc[-1]
        current_lower = lower.iloc[-1]
        current_atr = atr.iloc[-1]
# Breakout detection
        if current_price > current_upper:
            signal = 'LONG'
            stop_loss = current_price - 2 * current_atr
            take_profit = current_price + 3 * current_atr
        elif current_price < current_lower:
            signal = 'SHORT'
            stop_loss = current_price + 2 * current_atr
            take_profit = current_price - 3 * current_atr
        else:
            signal = 'FLAT'
            stop_loss = take_profit = current_price
return {
            'signal': signal,
            'price': current_price,
            'stop_loss': stop_loss,
            'take_profit': take_profit,
            'atr': current_atr,
            'risk_reward': 1.5 if signal != 'FLAT' else 0
        }

class CryptoRiskManager:
    def __init__(self, max_portfolio_pct_per_coin: float = 0.15,
                 max_exchange_exposure_pct: float = 0.35,
                 max_daily_loss_pct: float = 0.03):
        self.max_coin = max_portfolio_pct_per_coin
        self.max_exchange = max_exchange_exposure_pct
        self.max_daily_loss = max_daily_loss_pct
def check_exchange_exposure(self, balances: dict, total_nav: float) -> dict:
        """Ensure no single exchange holds too much capital."""
        warnings = []
        for exchange, balance in balances.items():
            pct = balance / total_nav
            if pct > self.max_exchange:
                warnings.append(
                    f"{exchange}: {pct:.1%} exceeds {self.max_exchange:.1%} limit"
                )
        return {'warnings': warnings, 'safe': len(warnings) == 0}