import ccxt
import pandas as pd
import numpy as np
from statsmodels.tsa.stattools import coint
class CryptoPairsAnalyzer:
    def __init__(self, exchange='binance'):
        self.exchange = getattr(ccxt, exchange)()
        self.exchange.enableRateLimit = True
def fetch_crypto_ohlcv(self, pair, timeframe='4h', limit=500):
        """
        Fetch OHLCV data for crypto pair
        """
ohlcv = self.exchange.fetch_ohlcv(pair, timeframe=timeframe, limit=limit)
        df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
        df['date'] = pd.to_datetime(df['timestamp'], unit='ms')
        df.set_index('date', inplace=True)
return df
def analyze_btc_eth_pair(self):
        """
        Bitcoin-Ethereum pairs trading analysis
        """
btc_data = self.fetch_crypto_ohlcv('BTC/USDT', timeframe='4h')
        eth_data = self.fetch_crypto_ohlcv('ETH/USDT', timeframe='4h')
btc_prices = btc_data['close'].values
        eth_prices = eth_data['close'].values
# Cointegration test
        score, pvalue, _ = coint(btc_prices, eth_prices)
# Correlation
        correlation = np.corrcoef(btc_prices, eth_prices)[0, 1]
# Ratio analysis
        ratio = eth_prices / (btc_prices / 100)  # ETH to BTC ratio
        ratio_mean = np.mean(ratio)
        ratio_std = np.std(ratio)
return {
            'correlation': correlation,
            'cointegration_pvalue': pvalue,
            'ratio_mean': ratio_mean,
            'ratio_std': ratio_std,
            'ratio_current': ratio[-1],
            'zscore': (ratio[-1] - ratio_mean) / ratio_std
        }
Usage
analyzer = CryptoPairsAnalyzer()
btc_eth_analysis = analyzer.analyze_btc_eth_pair()
print(f"BTC-ETH Correlation: {btc_eth_analysis['correlation']:.4f}")
print(f"Cointegration p-value: {btc_eth_analysis['cointegration_pvalue']:.4f}")
print(f"Current ratio Z-score: {btc_eth_analysis['zscore']:.2f}")

def find_crypto_pairs_candidates():
    """
    Screen crypto pairs for trading potential
    Focus on: stablecoins, exchange tokens, protocol tokens, L1 tokens
    """
pairs_to_test = [
        ('BTC/USDT', 'ETH/USDT'),        # Major assets
        ('SOL/USDT', 'AVAX/USDT'),       # L1 competition
        ('LINK/USDT', 'BAND/USDT'),      # Oracle tokens
        ('AAVE/USDT', 'COMP/USDT'),      # Lending protocols
        ('UNI/USDT', 'SUSHI/USDT'),      # DEX tokens
        ('ARB/USDT', 'OP/USDT'),         # L2 tokens
        ('MATIC/USDT', 'AVAX/USDT'),     # Scaling solutions
    ]
cointegrated_pairs = []
analyzer = CryptoPairsAnalyzer()
for pair1, pair2 in pairs_to_test:
        try:
            data1 = analyzer.fetch_crypto_ohlcv(pair1, timeframe='4h', limit=200)
            data2 = analyzer.fetch_crypto_ohlcv(pair2, timeframe='4h', limit=200)
prices1 = data1['close'].values
            prices2 = data2['close'].values
# Cointegration test
            _, pvalue, _ = coint(prices1, prices2)
# Correlation
            correlation = np.corrcoef(prices1, prices2)[0, 1]
if pvalue < 0.05 and correlation > 0.7:
                cointegrated_pairs.append({
                    'pair1': pair1,
                    'pair2': pair2,
                    'pvalue': pvalue,
                    'correlation': correlation,
                    'strength': -np.log10(pvalue)
                })
except Exception as e:
            print(f"Error testing {pair1}/{pair2}: {e}")
return sorted(cointegrated_pairs, key=lambda x: x['strength'], reverse=True)
candidates = find_crypto_pairs_candidates()
for pair in candidates[:5]:
    print(f"{pair['pair1']} + {pair['pair2']}: p={pair['pvalue']:.4f}")

class CryptoPairsTrader:
    def __init__(self, exchange='binance', api_key='', api_secret='',
                 testnet=True, initial_capital=1000):
        self.exchange = ccxt.binance({
            'apiKey': api_key,
            'secret': api_secret,
            'enableRateLimit': True,
            'test': testnet  # Use testnet first
        })
        self.balance = initial_capital
        self.positions = {}
def calculate_crypto_spread(self, pair1, pair2, lookback_hours=24):
        """
        Calculate spread between two crypto assets
        Crypto spreads revert faster than equities (hours vs. days)
        """
# Fetch hourly data (crypto moves fast)
        data1 = self.exchange.fetch_ohlcv(pair1, timeframe='1h', limit=lookback_hours)
        data2 = self.exchange.fetch_ohlcv(pair2, timeframe='1h', limit=lookback_hours)
df1 = pd.DataFrame(data1, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
        df2 = pd.DataFrame(data2, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
prices1 = df1['close'].values
        prices2 = df2['close'].values
# Normalize to same scale
        ratio = prices2 / prices1
# Spread statistics
        ratio_mean = np.mean(ratio[-20:])  # Recent 20-hour mean
        ratio_std = np.std(ratio[-20:])
zscore = (ratio[-1] - ratio_mean) / ratio_std
return {
            'ratio': ratio[-1],
            'zscore': zscore,
            'mean': ratio_mean,
            'std': ratio_std,
            'price1': prices1[-1],
            'price2': prices2[-1]
        }
def execute_crypto_pairs_trade(self, pair1, pair2, signal):
        """
        Execute hedged crypto trade on exchange
        """
spread_data = self.calculate_crypto_spread(pair1, pair2)
# Position sizing: normalize to equal notional exposure
        notional = 500  # $500 per leg
        size1 = notional / spread_data['price1']
        size2 = notional / spread_data['price2']
# Convert to exchange format (e.g., "0.01 BTC")
        size1_formatted = self.exchange.amount_to_precision(pair1, size1)
        size2_formatted = self.exchange.amount_to_precision(pair2, size2)
try:
            if signal == 'LONG_P2_SHORT_P1':  # ratio too low
                # Buy pair2, short pair1
                order1 = self.exchange.create_market_sell_order(pair1, size1_formatted)
                order2 = self.exchange.create_market_buy_order(pair2, size2_formatted)
elif signal == 'SHORT_P2_LONG_P1':  # ratio too high
                # Short pair2, buy pair1
                order1 = self.exchange.create_market_buy_order(pair1, size1_formatted)
                order2 = self.exchange.create_market_sell_order(pair2, size2_formatted)
print(f"Executed {signal}: {pair1}/{pair2}")
self.positions[f"{pair1}/{pair2}"] = {
                'entry_zscore': spread_data['zscore'],
                'order1': order1,
                'order2': order2,
                'entry_time': pd.Timestamp.now()
            }
except Exception as e:
            print(f"Trade execution error: {e}")
def monitor_and_rebalance(self, pair1, pair2, exit_zscore=0.5):
        """
        Monitor pairs and exit when spread reverts to mean
        Crypto pairs revert faster, so check every hour
        """
pair_key = f"{pair1}/{pair2}"
if pair_key not in self.positions:
            return
spread_data = self.calculate_crypto_spread(pair1, pair2)
        zscore = spread_data['zscore']
# Exit when spread reverts
        if abs(zscore) < exit_zscore:
            # Close both legs
            self.exchange.cancel_order(self.positions[pair_key]['order1']['id'], pair1)
            self.exchange.cancel_order(self.positions[pair_key]['order2']['id'], pair2)
del self.positions[pair_key]
            print(f"Closed {pair_key}: Z-score={zscore:.2f}")

def diversify_across_exchanges(pair1, pair2):
    """
    Trade on different exchanges to reduce counterparty risk
    """
# Get prices from multiple exchanges
    binance = ccxt.binance()
    kraken = ccxt.kraken()
    coinbase = ccxt.coinbase()
btc_binance = binance.fetch_ticker('BTC/USDT')['last']
    btc_kraken = kraken.fetch_ticker('BTC/USD')['last']
# If price divergence > 1%, execute arbitrage
    divergence = abs(btc_binance - btc_kraken) / btc_binance
if divergence > 0.01:
        print(f"Exchange arbitrage opportunity: {divergence:.2%}")
        # Buy cheaper, sell more expensive

# Use reputable custodians for live trading
Kraken, Coinbase Pro, Gemini offer institutional custody
For testing: use testnet
testnet_exchange = ccxt.binance({'test': True})
For small amounts: self-custody with hardware wallet
For large amounts: institutional custodian

def safe_leverage_position_sizing(balance, pair1_notional, pair2_notional, max_leverage=3.0):
    """
    Crypto margin trading is dangerous; size carefully
    """
total_notional = pair1_notional + pair2_notional
    leverage = total_notional / balance
if leverage > max_leverage:
        return False, f"Leverage {leverage:.1f}x exceeds maximum {max_leverage}x"
# Safety: ensure 2x liquidation cushion
    liquidation_price_ratio = 1.0 / (1 - 1/leverage/2)
return True, f"Safe. Leverage: {leverage:.1f}x"