How to Analyze Yield Farming Risk-Return Profiles: Sharpe Ratio Application

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

def collect_yield_data(protocol_name, pool_address, days=90):
    """
    Collect daily yield and TVL data for analysis
    """
    # Connect to DeFi data source (DefiPulse, DeFiLlama, etc.)
    end_date = datetime.now()
    start_date = end_date - timedelta(days=days)
    
    # Fetch daily APY, TVL, and token prices
    daily_data = {
        'date': [],
        'apy': [],           # Daily APY
        'tvl': [],           # Total Value Locked
        'token_price_a': [], # Token A price
        'token_price_b': [], # Token B price (for LP pairs)
        'volume': []         # Daily trading volume
    }
    
    return pd.DataFrame(daily_data)

# Example data collection
uniswap_eth_usdc = collect_yield_data('Uniswap', '0x88e6...', 90)
compound_dai = collect_yield_data('Compound', 'cDAI', 90)

def calculate_daily_returns(df):
    """
    Calculate daily returns including impermanent loss
    """
    df['daily_return'] = df['apy'] / 365  # Convert APY to daily
    
    # Calculate impermanent loss for LP positions
    if 'token_price_b' in df.columns:
        price_ratio = df['token_price_a'] / df['token_price_b']
        initial_ratio = price_ratio.iloc[0]
        
        # Impermanent loss formula
        df['il_factor'] = 2 * np.sqrt(price_ratio / initial_ratio) / (1 + price_ratio / initial_ratio) - 1
        df['net_return'] = df['daily_return'] + df['il_factor']
    else:
        df['net_return'] = df['daily_return']
    
    # Calculate rolling volatility
    df['volatility'] = df['net_return'].rolling(window=7).std() * np.sqrt(365)
    
    return df

# Process collected data
uniswap_processed = calculate_daily_returns(uniswap_eth_usdc)
compound_processed = calculate_daily_returns(compound_dai)

def calculate_defi_sharpe_ratio(df, risk_free_rate=0.05):
    """
    Calculate Sharpe ratio adjusted for DeFi-specific risks
    """
    # Annualized return
    annual_return = df['net_return'].mean() * 365
    
    # Annualized volatility
    annual_volatility = df['net_return'].std() * np.sqrt(365)
    
    # Smart contract risk adjustment (2-5% annual premium)
    sc_risk_premium = 0.03  # 3% for established protocols
    adjusted_return = annual_return - sc_risk_premium
    
    # Calculate Sharpe ratio
    excess_return = adjusted_return - risk_free_rate
    sharpe_ratio = excess_return / annual_volatility if annual_volatility > 0 else 0
    
    return {
        'annual_return': annual_return,
        'annual_volatility': annual_volatility,
        'sharpe_ratio': sharpe_ratio,
        'adjusted_return': adjusted_return
    }

# Calculate metrics for each strategy
uniswap_metrics = calculate_defi_sharpe_ratio(uniswap_processed)
compound_metrics = calculate_defi_sharpe_ratio(compound_processed)

print(f"Uniswap ETH/USDC Sharpe Ratio: {uniswap_metrics['sharpe_ratio']:.3f}")
print(f"Compound DAI Sharpe Ratio: {compound_metrics['sharpe_ratio']:.3f}")

def rank_yield_strategies(strategies_dict):
    """
    Rank yield farming strategies by risk-adjusted performance
    """
    comparison_df = pd.DataFrame(strategies_dict).T
    
    # Sort by Sharpe ratio (descending)
    comparison_df = comparison_df.sort_values('sharpe_ratio', ascending=False)
    
    # Add risk categories
    def risk_category(sharpe):
        if sharpe > 1.0:
            return "Excellent"
        elif sharpe > 0.5:
            return "Good"
        elif sharpe > 0.0:
            return "Fair"
        else:
            return "Poor"
    
    comparison_df['risk_category'] = comparison_df['sharpe_ratio'].apply(risk_category)
    
    return comparison_df

# Example comparison
strategies = {
    'Uniswap ETH/USDC': uniswap_metrics,
    'Compound DAI': compound_metrics,
    # Add more strategies...
}

ranking = rank_yield_strategies(strategies)
print(ranking)

def calculate_max_drawdown(returns_series):
    """
    Calculate maximum drawdown for risk assessment
    """
    cumulative_returns = (1 + returns_series).cumprod()
    running_max = cumulative_returns.expanding().max()
    drawdown = (cumulative_returns - running_max) / running_max
    max_drawdown = drawdown.min()
    
    return abs(max_drawdown)

# Calculate for each strategy
uniswap_dd = calculate_max_drawdown(uniswap_processed['net_return'])
print(f"Uniswap Max Drawdown: {uniswap_dd:.2%}")

def calculate_var(returns_series, confidence_level=0.05):
    """
    Calculate Value at Risk at specified confidence level
    """
    return np.percentile(returns_series, confidence_level * 100)

# 5% VaR (95% confidence level)
uniswap_var = calculate_var(uniswap_processed['net_return'])
print(f"Uniswap 5% Daily VaR: {uniswap_var:.2%}")

from scipy.optimize import minimize

def optimize_portfolio_weights(returns_matrix, target_return=None):
    """
    Optimize portfolio weights for maximum Sharpe ratio
    """
    n_assets = returns_matrix.shape[1]
    
    # Calculate expected returns and covariance matrix
    expected_returns = returns_matrix.mean() * 365
    cov_matrix = returns_matrix.cov() * 365
    
    # Objective function: minimize negative Sharpe ratio
    def negative_sharpe(weights):
        portfolio_return = np.sum(weights * expected_returns)
        portfolio_vol = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
        return -(portfolio_return - 0.05) / portfolio_vol  # 5% risk-free rate
    
    # Constraints: weights sum to 1
    constraints = {'type': 'eq', 'fun': lambda x: np.sum(x) - 1}
    
    # Bounds: 0 <= weight <= 1 for each asset
    bounds = tuple((0, 1) for _ in range(n_assets))
    
    # Initial guess: equal weights
    initial_weights = np.array([1/n_assets] * n_assets)
    
    # Optimize
    result = minimize(negative_sharpe, initial_weights, 
                     method='SLSQP', bounds=bounds, constraints=constraints)
    
    return result.x

# Example portfolio optimization
returns_matrix = pd.DataFrame({
    'Uniswap_ETH_USDC': uniswap_processed['net_return'],
    'Compound_DAI': compound_processed['net_return']
})

optimal_weights = optimize_portfolio_weights(returns_matrix)
print(f"Optimal allocation: {dict(zip(returns_matrix.columns, optimal_weights))}")

def rebalancing_trigger(current_sharpe, target_sharpe, tolerance=0.1):
    """
    Determine if portfolio rebalancing is needed
    """
    return abs(current_sharpe - target_sharpe) > tolerance

# Monitor and rebalance monthly
def monthly_rebalance_check(portfolio_data):
    """
    Check if monthly rebalancing is needed
    """
    monthly_returns = portfolio_data.resample('M')['net_return'].apply(list)
    
    for month, returns in monthly_returns.items():
        if len(returns) > 0:
            month_sharpe = calculate_defi_sharpe_ratio(
                pd.DataFrame({'net_return': returns})
            )['sharpe_ratio']
            
            # Trigger rebalancing if Sharpe ratio deviates significantly
            if rebalancing_trigger(month_sharpe, target_sharpe=0.8):
                print(f"Rebalancing recommended for {month}")

def risk_monitoring_system(current_data, thresholds):
    """
    Monitor portfolio risks and generate alerts
    """
    alerts = []
    
    # Check TVL decline (liquidation risk)
    if current_data['tvl_change'] < thresholds['tvl_decline']:
        alerts.append("WARNING: Significant TVL decline detected")
    
    # Check volatility spike
    if current_data['volatility'] > thresholds['max_volatility']:
        alerts.append("ALERT: Volatility exceeds safe threshold")
    
    # Check Sharpe ratio degradation
    if current_data['sharpe_ratio'] < thresholds['min_sharpe']:
        alerts.append("CAUTION: Sharpe ratio below acceptable level")
    
    return alerts

# Example monitoring thresholds
risk_thresholds = {
    'tvl_decline': -0.3,    # 30% TVL drop
    'max_volatility': 0.8,  # 80% annualized volatility
    'min_sharpe': 0.3       # Minimum acceptable Sharpe ratio
}