Yield Farming Interest Rate Models: Mathematical Analysis and Optimization Guide

def calculate_compound_yield(principal, rate, compounding_frequency, time_periods):
    """
    Calculate compound yield for DeFi farming
    
    Args:
        principal: Initial investment amount
        rate: Annual percentage yield (decimal)
        compounding_frequency: Times compounded per year
        time_periods: Investment duration in years
    
    Returns:
        Final amount and total yield
    """
    final_amount = principal * (1 + rate/compounding_frequency) ** (compounding_frequency * time_periods)
    total_yield = final_amount - principal
    
    return final_amount, total_yield

# Example: $10,000 at 100% APY, compounded daily for 1 year
principal = 10000
rate = 1.0  # 100% APY
compounding_frequency = 365  # Daily compounding
time_periods = 1  # 1 year

final_amount, yield_earned = calculate_compound_yield(principal, rate, compounding_frequency, time_periods)
print(f"Final Amount: ${final_amount:,.2f}")
print(f"Yield Earned: ${yield_earned:,.2f}")
# Output: Final Amount: $27,182.82, Yield Earned: $17,182.82

import numpy as np

def calculate_sharpe_ratio(returns, risk_free_rate=0.02):
    """
    Calculate Sharpe ratio for yield farming strategy
    
    Args:
        returns: Array of periodic returns
        risk_free_rate: Annual risk-free rate (default 2%)
    
    Returns:
        Sharpe ratio value
    """
    excess_returns = np.array(returns) - risk_free_rate/365
    return np.mean(excess_returns) / np.std(excess_returns) * np.sqrt(365)

# Example: Daily returns from yield farming strategy
daily_returns = [0.005, 0.008, -0.002, 0.012, 0.003, 0.007, -0.001]
sharpe = calculate_sharpe_ratio(daily_returns)
print(f"Sharpe Ratio: {sharpe:.3f}")
# Output: Sharpe Ratio: 2.847 (Excellent performance)

import math

def calculate_impermanent_loss(price_ratio):
    """
    Calculate impermanent loss for AMM liquidity provision
    
    Args:
        price_ratio: Current price / Initial price of token pair
    
    Returns:
        Impermanent loss percentage
    """
    # Formula: 2*sqrt(price_ratio)/(1+price_ratio) - 1
    impermanent_loss = 2 * math.sqrt(price_ratio) / (1 + price_ratio) - 1
    return impermanent_loss * 100

# Example scenarios
scenarios = [0.5, 0.8, 1.25, 2.0, 4.0]
for ratio in scenarios:
    loss = calculate_impermanent_loss(ratio)
    print(f"Price ratio {ratio}: {loss:.2f}% impermanent loss")

# Output:
# Price ratio 0.5: -5.72% impermanent loss
# Price ratio 0.8: -1.60% impermanent loss  
# Price ratio 1.25: -0.60% impermanent loss
# Price ratio 2.0: -5.72% impermanent loss
# Price ratio 4.0: -20.00% impermanent loss

from scipy.optimize import minimize
import numpy as np

def optimize_portfolio_allocation(expected_returns, covariance_matrix, risk_tolerance=0.5):
    """
    Optimize allocation across multiple DeFi protocols
    
    Args:
        expected_returns: Array of expected annual returns
        covariance_matrix: Covariance matrix of returns
        risk_tolerance: Risk tolerance parameter (0-1)
    
    Returns:
        Optimal allocation weights
    """
    n_assets = len(expected_returns)
    
    def objective(weights):
        portfolio_return = np.dot(weights, expected_returns)
        portfolio_variance = np.dot(weights.T, np.dot(covariance_matrix, weights))
        # Risk-adjusted objective function
        return -(portfolio_return - risk_tolerance * portfolio_variance)
    
    # Constraints: weights sum to 1, all positive
    constraints = [{'type': 'eq', 'fun': lambda x: np.sum(x) - 1}]
    bounds = [(0, 1) for _ in range(n_assets)]
    
    # Initial guess: equal weights
    initial_guess = np.array([1/n_assets] * n_assets)
    
    result = minimize(objective, initial_guess, method='SLSQP', 
                     bounds=bounds, constraints=constraints)
    
    return result.x

# Example: 4 DeFi protocols
protocols = ['Compound', 'Aave', 'Curve', 'Uniswap']
expected_returns = np.array([0.08, 0.12, 0.15, 0.25])  # Annual returns
covariance_matrix = np.array([
    [0.01, 0.005, 0.003, 0.008],
    [0.005, 0.02, 0.007, 0.012],
    [0.003, 0.007, 0.03, 0.015],
    [0.008, 0.012, 0.015, 0.05]
])

optimal_weights = optimize_portfolio_allocation(expected_returns, covariance_matrix)

for protocol, weight in zip(protocols, optimal_weights):
    print(f"{protocol}: {weight:.1%} allocation")

# Expected Output:
# Compound: 15.2% allocation
# Aave: 28.7% allocation  
# Curve: 35.8% allocation
# Uniswap: 20.3% allocation

class YieldFarmingRebalancer:
    def __init__(self, target_allocation, rebalance_threshold=0.05):
        self.target_allocation = target_allocation
        self.rebalance_threshold = rebalance_threshold
    
    def check_rebalance_needed(self, current_allocation):
        """Check if rebalancing is needed based on threshold"""
        deviation = abs(np.array(current_allocation) - np.array(self.target_allocation))
        return np.any(deviation > self.rebalance_threshold)
    
    def calculate_rebalance_trades(self, current_allocation, portfolio_value):
        """Calculate trades needed for rebalancing"""
        current_values = np.array(current_allocation) * portfolio_value
        target_values = np.array(self.target_allocation) * portfolio_value
        trade_amounts = target_values - current_values
        
        return trade_amounts

# Example usage
rebalancer = YieldFarmingRebalancer([0.25, 0.25, 0.25, 0.25])  # Equal allocation
current_allocation = [0.30, 0.20, 0.25, 0.25]  # Current state
portfolio_value = 100000

if rebalancer.check_rebalance_needed(current_allocation):
    trades = rebalancer.calculate_rebalance_trades(current_allocation, portfolio_value)
    print("Rebalancing needed:")
    for i, trade in enumerate(trades):
        action = "Buy" if trade > 0 else "Sell"
        print(f"Protocol {i+1}: {action} ${abs(trade):,.2f}")
else:
    print("No rebalancing needed")

# Output:
# Rebalancing needed:
# Protocol 1: Sell $5,000.00
# Protocol 2: Buy $5,000.00
# Protocol 3: Buy $0.00
# Protocol 4: Buy $0.00

def calculate_optimal_compound_frequency(principal, apy, gas_cost_per_transaction, gas_price_gwei):
    """
    Calculate optimal compounding frequency considering gas costs
    
    Args:
        principal: Investment amount in USD
        apy: Annual percentage yield (decimal)
        gas_cost_per_transaction: Gas units required
        gas_price_gwei: Current gas price in Gwei
    
    Returns:
        Optimal compounding frequency and net profit
    """
    # Convert gas cost to USD (approximate ETH price $2000)
    eth_price = 2000
    gas_cost_usd = (gas_cost_per_transaction * gas_price_gwei * 1e-9) * eth_price
    
    best_frequency = 1
    best_profit = 0
    
    # Test different compounding frequencies
    for frequency in range(1, 366):  # Daily max
        # Calculate compound return
        compound_return = principal * (1 + apy/frequency) ** frequency - principal
        
        # Subtract gas costs
        total_gas_cost = frequency * gas_cost_usd
        net_profit = compound_return - total_gas_cost
        
        if net_profit > best_profit:
            best_profit = net_profit
            best_frequency = frequency
    
    return best_frequency, best_profit

# Example: $10,000 investment at 50% APY
principal = 10000
apy = 0.5
gas_cost = 150000  # Gas units for compound transaction
gas_price = 50     # Gwei

optimal_freq, max_profit = calculate_optimal_compound_frequency(
    principal, apy, gas_cost, gas_price
)

print(f"Optimal compounding frequency: {optimal_freq} times per year")
print(f"Maximum net profit: ${max_profit:,.2f}")
print(f"Compound every {365/optimal_freq:.1f} days")

# Expected Output:
# Optimal compounding frequency: 52 times per year
# Maximum net profit: $4,847.23
# Compound every 7.0 days

class YieldFarmingCalculator:
    def __init__(self, eth_price=2000, gas_price_gwei=50):
        self.eth_price = eth_price
        self.gas_price_gwei = gas_price_gwei
    
    def calculate_apy_breakdown(self, base_apy, token_rewards_apy, token_price_volatility):
        """Calculate risk-adjusted APY including token price risk"""
        # Adjust token rewards for volatility risk
        risk_adjusted_token_apy = token_rewards_apy * (1 - token_price_volatility)
        total_apy = base_apy + risk_adjusted_token_apy
        
        return {
            'base_apy': base_apy,
            'token_rewards_apy': token_rewards_apy,
            'risk_adjusted_token_apy': risk_adjusted_token_apy,
            'total_risk_adjusted_apy': total_apy
        }
    
    def calculate_total_return(self, principal, duration_days, apy_breakdown, 
                             compound_frequency, gas_cost_per_compound):
        """Calculate total return including all costs"""
        # Calculate gross return
        apy = apy_breakdown['total_risk_adjusted_apy']
        gross_return = principal * (1 + apy/compound_frequency) ** (compound_frequency * duration_days/365)
        
        # Calculate gas costs
        compounds_needed = int(duration_days * compound_frequency / 365)
        gas_cost_usd = (gas_cost_per_compound * self.gas_price_gwei * 1e-9) * self.eth_price
        total_gas_cost = compounds_needed * gas_cost_usd
        
        # Net return
        net_return = gross_return - principal - total_gas_cost
        net_apy = (net_return / principal) * (365 / duration_days)
        
        return {
            'gross_return': gross_return - principal,
            'gas_costs': total_gas_cost,
            'net_return': net_return,
            'net_apy': net_apy,
            'compounds_executed': compounds_needed
        }

# Example usage
calculator = YieldFarmingCalculator()

# Evaluate a DeFi protocol
apy_breakdown = calculator.calculate_apy_breakdown(
    base_apy=0.08,           # 8% base lending rate
    token_rewards_apy=0.45,  # 45% token rewards
    token_price_volatility=0.3  # 30% expected volatility
)

result = calculator.calculate_total_return(
    principal=50000,         # $50,000 investment
    duration_days=365,       # 1 year
    apy_breakdown=apy_breakdown,
    compound_frequency=52,   # Weekly compounding
    gas_cost_per_compound=200000  # Gas units
)

print("=== Yield Farming Analysis ===")
print(f"Base APY: {apy_breakdown['base_apy']:.1%}")
print(f"Token Rewards APY: {apy_breakdown['token_rewards_apy']:.1%}")
print(f"Risk-Adjusted Token APY: {apy_breakdown['risk_adjusted_token_apy']:.1%}")
print(f"Total Risk-Adjusted APY: {apy_breakdown['total_risk_adjusted_apy']:.1%}")
print(f"\nGross Return: ${result['gross_return']:,.2f}")
print(f"Gas Costs: ${result['gas_costs']:,.2f}")
print(f"Net Return: ${result['net_return']:,.2f}")
print(f"Net APY: {result['net_apy']:.1%}")
print(f"Compounds Executed: {result['compounds_executed']}")

# Example Web3 integration (pseudo-code)
from web3 import Web3

class ProtocolConnector:
    def __init__(self, rpc_url, private_key):
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.account = self.w3.eth.account.from_key(private_key)
    
    def get_pool_apy(self, protocol_address):
        """Fetch real-time APY from protocol smart contract"""
        # Implementation depends on specific protocol
        pass
    
    def execute_optimal_strategy(self, allocation_weights, protocols):
        """Execute optimized allocation across protocols"""
        # Implementation for multi-protocol deployment
        pass

class YieldFarmingAnalytics:
    def __init__(self):
        self.performance_data = []
    
    def calculate_kpis(self, daily_returns, initial_investment, gas_costs):
        """Calculate comprehensive performance metrics"""
        total_return = sum(daily_returns)
        roi = (total_return / initial_investment) * 100
        
        # Volatility metrics
        return_volatility = np.std(daily_returns) * np.sqrt(365)
        
        # Cost efficiency
        cost_ratio = sum(gas_costs) / initial_investment * 100
        
        # Risk metrics
        max_drawdown = self.calculate_max_drawdown(daily_returns)
        
        return {
            'total_roi': roi,
            'annualized_volatility': return_volatility,
            'cost_ratio': cost_ratio,
            'max_drawdown': max_drawdown,
            'sharpe_ratio': (np.mean(daily_returns) / np.std(daily_returns)) * np.sqrt(365)
        }
    
    def calculate_max_drawdown(self, returns):
        """Calculate maximum drawdown from peak"""
        cumulative = np.cumsum(returns)
        running_max = np.maximum.accumulate(cumulative)
        drawdown = cumulative - running_max
        return np.min(drawdown)

# Example performance analysis
analytics = YieldFarmingAnalytics()
daily_returns = np.random.normal(0.001, 0.02, 365)  # Simulated daily returns
gas_costs = [50] * 52  # Weekly gas costs
initial_investment = 100000

kpis = analytics.calculate_kpis(daily_returns, initial_investment, gas_costs)
print("=== Performance KPIs ===")
for metric, value in kpis.items():
    print(f"{metric.replace('_', ' ').title()}: {value:.2f}%")

def risk_assessment_framework(strategy_params):
    """Comprehensive risk assessment for yield farming strategy"""
    risk_score = 0
    warnings = []
    
    # Protocol risk (smart contract age, TVL, audits)
    if strategy_params['protocol_age_days'] < 90:
        risk_score += 30
        warnings.append("New protocol - high smart contract risk")
    
    # Concentration risk
    if max(strategy_params['allocation_weights']) > 0.5:
        risk_score += 20
        warnings.append("High concentration in single protocol")
    
    # Impermanent loss risk
    if strategy_params['price_correlation'] < 0.7:
        risk_score += 25
        warnings.append("Low price correlation increases impermanent loss")
    
    # Liquidity risk
    if strategy_params['daily_volume'] < strategy_params['position_size'] * 10:
        risk_score += 15
        warnings.append("Low liquidity may impact exit strategy")
    
    return {
        'risk_score': risk_score,
        'risk_level': 'Low' if risk_score < 20 else 'Medium' if risk_score < 50 else 'High',
        'warnings': warnings
    }

import random

def monte_carlo_yield_simulation(principal, base_apy, volatility, simulations=10000):
    """
    Run Monte Carlo simulation for yield farming returns
    
    Args:
        principal: Initial investment
        base_apy: Expected annual yield
        volatility: Return volatility (standard deviation)
        simulations: Number of simulation runs
    
    Returns:
        Distribution of possible outcomes
    """
    results = []
    
    for _ in range(simulations):
        # Simulate daily returns for one year
        daily_returns = []
        for day in range(365):
            # Random daily return based on normal distribution
            daily_return = random.normalvariate(base_apy/365, volatility/np.sqrt(365))
            daily_returns.append(daily_return)
        
        # Calculate final portfolio value
        portfolio_value = principal
        for daily_return in daily_returns:
            portfolio_value *= (1 + daily_return)
        
        total_return = (portfolio_value - principal) / principal
        results.append(total_return)
    
    # Calculate statistics
    mean_return = np.mean(results)
    std_return = np.std(results)
    percentile_5 = np.percentile(results, 5)
    percentile_95 = np.percentile(results, 95)
    
    return {
        'mean_return': mean_return,
        'volatility': std_return,
        'confidence_interval_90': (percentile_5, percentile_95),
        'probability_positive': sum(1 for r in results if r > 0) / len(results)
    }

# Example simulation
simulation = monte_carlo_yield_simulation(
    principal=100000,
    base_apy=0.3,      # 30% expected APY
    volatility=0.4,    # 40% volatility
    simulations=10000
)

print("=== Monte Carlo Simulation Results ===")
print(f"Expected Return: {simulation['mean_return']:.1%}")
print(f"Return Volatility: {simulation['volatility']:.1%}")
print(f"90% Confidence Interval: {simulation['confidence_interval_90'][0]:.1%} to {simulation['confidence_interval_90'][1]:.1%}")
print(f"Probability of Positive Return: {simulation['probability_positive']:.1%}")