DeFi Protocol Analysis with Ollama: TVL and Yield Farming Evaluation Guide

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Download the llama2 model optimized for financial analysis
ollama pull llama2:13b

# Verify installation
ollama list

# requirements.txt for DeFi analysis
import requests
import pandas as pd
import numpy as np
from web3 import Web3
import json
from datetime import datetime, timedelta
import matplotlib.pyplot as plt
import seaborn as sns

# Ollama integration
import ollama

# Initialize Ollama client
client = ollama.Client()

class DeFiAnalyzer:
    def __init__(self, rpc_url, ollama_model="llama2:13b"):
        """Initialize DeFi analyzer with blockchain connection and Ollama"""
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.ollama_model = ollama_model
        self.client = ollama.Client()
        
    def verify_connection(self):
        """Verify blockchain and Ollama connections"""
        return self.w3.is_connected() and self.client.list()

# Example usage
analyzer = DeFiAnalyzer("https://mainnet.infura.io/v3/YOUR_PROJECT_ID")
print(f"Connections ready: {analyzer.verify_connection()}")

class TVLAnalyzer:
    def __init__(self, analyzer):
        self.analyzer = analyzer
        
    def fetch_protocol_tvl(self, protocol_address):
        """Fetch current TVL for a specific protocol"""
        # Example: Uniswap V3 factory contract
        contract_abi = [
            {
                "inputs": [],
                "name": "totalValueLocked",
                "outputs": [{"type": "uint256"}],
                "stateMutability": "view",
                "type": "function"
            }
        ]
        
        contract = self.analyzer.w3.eth.contract(
            address=protocol_address, 
            abi=contract_abi
        )
        
        tvl_wei = contract.functions.totalValueLocked().call()
        tvl_eth = self.analyzer.w3.from_wei(tvl_wei, 'ether')
        
        return float(tvl_eth)
    
    def analyze_tvl_trends(self, protocol_data, timeframe_days=30):
        """Analyze TVL trends using Ollama"""
        tvl_history = protocol_data['tvl_history']
        
        prompt = f"""
        Analyze this DeFi protocol's TVL data for the past {timeframe_days} days:
        
        TVL History: {tvl_history}
        
        Provide analysis on:
        1. TVL growth rate and sustainability
        2. Volatility patterns and risk indicators
        3. Correlation with market events
        4. Investment recommendation (bullish/bearish/neutral)
        
        Format response as structured data.
        """
        
        response = self.analyzer.client.generate(
            model=self.analyzer.ollama_model,
            prompt=prompt
        )
        
        return response['response']

# Usage example
tvl_analyzer = TVLAnalyzer(analyzer)
protocol_tvl = tvl_analyzer.fetch_protocol_tvl("0x1F98431c8aD98523631AE4a59f267346ea31F984")
print(f"Current Protocol TVL: {protocol_tvl:.2f} ETH")

def assess_tvl_quality(self, protocol_address, tvl_data):
    """Assess TVL quality using multiple metrics"""
    
    quality_metrics = {
        'liquidity_depth': self.calculate_liquidity_depth(protocol_address),
        'asset_diversity': self.calculate_asset_diversity(tvl_data),
        'stickiness_ratio': self.calculate_stickiness_ratio(tvl_data),
        'whale_concentration': self.calculate_whale_concentration(protocol_address)
    }
    
    # Use Ollama to interpret quality metrics
    prompt = f"""
    Evaluate this DeFi protocol's TVL quality:
    
    Metrics:
    - Liquidity Depth: {quality_metrics['liquidity_depth']}
    - Asset Diversity: {quality_metrics['asset_diversity']}
    - Stickiness Ratio: {quality_metrics['stickiness_ratio']}
    - Whale Concentration: {quality_metrics['whale_concentration']}
    
    Provide:
    1. Overall TVL quality score (1-10)
    2. Key strengths and weaknesses
    3. Risk level assessment
    """
    
    response = self.analyzer.client.generate(
        model=self.analyzer.ollama_model,
        prompt=prompt
    )
    
    return response['response']

class YieldFarmingAnalyzer:
    def __init__(self, analyzer):
        self.analyzer = analyzer
        
    def calculate_real_yield(self, pool_data):
        """Calculate real yield accounting for all factors"""
        
        # Extract key metrics
        base_apr = pool_data['base_apr']
        reward_apr = pool_data['reward_apr']
        impermanent_loss_risk = pool_data['il_risk']
        gas_costs = pool_data['gas_costs']
        
        # Calculate real yield
        gross_yield = base_apr + reward_apr
        net_yield = gross_yield - impermanent_loss_risk - gas_costs
        
        return {
            'gross_yield': gross_yield,
            'net_yield': net_yield,
            'risk_adjusted_yield': net_yield * (1 - pool_data['risk_score'])
        }
    
    def evaluate_farming_opportunity(self, pool_address, investment_amount):
        """Comprehensive yield farming evaluation"""
        
        pool_data = self.fetch_pool_data(pool_address)
        yield_metrics = self.calculate_real_yield(pool_data)
        
        # Use Ollama for advanced analysis
        prompt = f"""
        Evaluate this yield farming opportunity:
        
        Pool: {pool_address}
        Investment: ${investment_amount:,.2f}
        
        Metrics:
        - Gross APR: {yield_metrics['gross_yield']:.2f}%
        - Net APR: {yield_metrics['net_yield']:.2f}%
        - Risk-Adjusted APR: {yield_metrics['risk_adjusted_yield']:.2f}%
        
        Pool Details:
        - TVL: ${pool_data['tvl']:,.2f}
        - Volume (24h): ${pool_data['volume_24h']:,.2f}
        - Fees: {pool_data['fee_tier']}%
        - Token Pair: {pool_data['token0']}/{pool_data['token1']}
        
        Provide:
        1. Investment recommendation (strong buy/buy/hold/sell/strong sell)
        2. Optimal position size
        3. Risk factors to monitor
        4. Exit strategy suggestions
        """
        
        response = self.analyzer.client.generate(
            model=self.analyzer.ollama_model,
            prompt=prompt
        )
        
        return {
            'analysis': response['response'],
            'metrics': yield_metrics,
            'pool_data': pool_data
        }

# Example usage
yield_analyzer = YieldFarmingAnalyzer(analyzer)
opportunity = yield_analyzer.evaluate_farming_opportunity(
    "0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640",  # USDC/ETH pool
    50000  # $50,000 investment
)
print(opportunity['analysis'])

def calculate_impermanent_loss(self, initial_prices, current_prices, pool_weights=[0.5, 0.5]):
    """Calculate impermanent loss for liquidity positions"""
    
    # Price ratios
    price_ratio = current_prices[1] / current_prices[0]
    initial_ratio = initial_prices[1] / initial_prices[0]
    
    # Calculate impermanent loss
    if pool_weights == [0.5, 0.5]:  # 50/50 pool
        ratio_change = price_ratio / initial_ratio
        il_multiplier = 2 * (ratio_change ** 0.5) / (1 + ratio_change)
        impermanent_loss = (il_multiplier - 1) * 100
    else:
        # Custom weights calculation
        w0, w1 = pool_weights
        term1 = (price_ratio ** w1) * ((1/price_ratio) ** w0)
        term2 = w0 * (1/price_ratio) + w1 * price_ratio
        il_multiplier = term1 / term2
        impermanent_loss = (il_multiplier - 1) * 100
    
    return {
        'impermanent_loss_percent': impermanent_loss,
        'price_ratio_change': (ratio_change - 1) * 100,
        'recommendation': self.get_il_recommendation(impermanent_loss)
    }

def get_il_recommendation(self, il_percent):
    """Get recommendation based on impermanent loss"""
    if il_percent < -2:
        return "Low risk - suitable for most strategies"
    elif il_percent < -5:
        return "Moderate risk - monitor closely"
    elif il_percent < -10:
        return "High risk - consider reducing position"
    else:
        return "Very high risk - exit recommended"

class ContractSecurityAnalyzer:
    def __init__(self, analyzer):
        self.analyzer = analyzer
        
    def analyze_contract_security(self, contract_address):
        """Analyze smart contract security using Ollama"""
        
        # Fetch contract source code
        contract_source = self.fetch_contract_source(contract_address)
        
        # Get contract metadata
        contract_info = self.get_contract_info(contract_address)
        
        prompt = f"""
        Analyze this smart contract for security risks:
        
        Contract Address: {contract_address}
        Contract Age: {contract_info['age_days']} days
        Transaction Count: {contract_info['tx_count']:,}
        
        Source Code Preview:
        {contract_source[:2000]}...
        
        Identify:
        1. Known vulnerability patterns
        2. Admin privileges and risks
        3. Upgrade mechanisms
        4. Access control issues
        5. Overall security score (1-10)
        
        Provide practical security assessment.
        """
        
        response = self.analyzer.client.generate(
            model=self.analyzer.ollama_model,
            prompt=prompt
        )
        
        return response['response']
    
    def check_audit_status(self, protocol_name):
        """Check if protocol has been audited"""
        
        # Common audit firms and their findings
        audit_sources = [
            "Trail of Bits", "ConsenSys Diligence", "OpenZeppelin",
            "Quantstamp", "CertiK", "PeckShield"
        ]
        
        # This would typically query audit databases
        # For demo purposes, we'll use Ollama to analyze known information
        
        prompt = f"""
        Research audit status for {protocol_name}:
        
        Check for:
        1. Completed audits by major firms
        2. Critical vulnerabilities found
        3. Fix implementation status
        4. Ongoing security monitoring
        
        Provide audit summary and security recommendation.
        """
        
        response = self.analyzer.client.generate(
            model=self.analyzer.ollama_model,
            prompt=prompt
        )
        
        return response['response']

class TokenomicsAnalyzer:
    def __init__(self, analyzer):
        self.analyzer = analyzer
        
    def analyze_tokenomics(self, token_address, protocol_data):
        """Comprehensive tokenomics analysis"""
        
        token_info = self.fetch_token_info(token_address)
        
        # Calculate key metrics
        metrics = {
            'total_supply': token_info['total_supply'],
            'circulating_supply': token_info['circulating_supply'],
            'inflation_rate': self.calculate_inflation_rate(token_address),
            'emission_schedule': protocol_data['emission_schedule'],
            'utility_functions': protocol_data['utility_functions'],
            'governance_power': protocol_data['governance_power']
        }
        
        prompt = f"""
        Analyze this DeFi protocol's tokenomics:
        
        Token Metrics:
        - Total Supply: {metrics['total_supply']:,.0f}
        - Circulating Supply: {metrics['circulating_supply']:,.0f}
        - Annual Inflation: {metrics['inflation_rate']:.2f}%
        
        Token Utility:
        {metrics['utility_functions']}
        
        Governance:
        {metrics['governance_power']}
        
        Emission Schedule:
        {metrics['emission_schedule']}
        
        Evaluate:
        1. Token value accrual mechanisms
        2. Inflation sustainability
        3. Governance centralization risks
        4. Long-term tokenomics viability
        5. Investment attractiveness (1-10)
        """
        
        response = self.analyzer.client.generate(
            model=self.analyzer.ollama_model,
            prompt=prompt
        )
        
        return {
            'analysis': response['response'],
            'metrics': metrics
        }

class ProtocolMonitor:
    def __init__(self, analyzer):
        self.analyzer = analyzer
        self.monitored_protocols = {}
        
    def add_protocol(self, name, address, thresholds):
        """Add protocol to monitoring list"""
        self.monitored_protocols[name] = {
            'address': address,
            'thresholds': thresholds,
            'last_check': datetime.now()
        }
    
    def check_all_protocols(self):
        """Check all monitored protocols for alerts"""
        alerts = []
        
        for name, config in self.monitored_protocols.items():
            protocol_alerts = self.check_protocol_alerts(name, config)
            if protocol_alerts:
                alerts.extend(protocol_alerts)
        
        if alerts:
            self.send_alerts(alerts)
        
        return alerts
    
    def check_protocol_alerts(self, name, config):
        """Check specific protocol for alert conditions"""
        alerts = []
        
        # Fetch current data
        current_data = self.fetch_protocol_data(config['address'])
        
        # Check TVL threshold
        if current_data['tvl_change_24h'] < config['thresholds']['tvl_drop']:
            alerts.append({
                'protocol': name,
                'type': 'TVL_DROP',
                'value': current_data['tvl_change_24h'],
                'threshold': config['thresholds']['tvl_drop']
            })
        
        # Check yield changes
        if current_data['yield_change'] < config['thresholds']['yield_drop']:
            alerts.append({
                'protocol': name,
                'type': 'YIELD_DROP',
                'value': current_data['yield_change'],
                'threshold': config['thresholds']['yield_drop']
            })
        
        return alerts
    
    def generate_alert_summary(self, alerts):
        """Generate human-readable alert summary using Ollama"""
        
        prompt = f"""
        Generate alert summary for DeFi protocol monitoring:
        
        Alerts: {alerts}
        
        Create:
        1. Priority ranking (critical/high/medium/low)
        2. Action recommendations
        3. Market context analysis
        4. Brief explanation for each alert
        
        Format as actionable summary.
        """
        
        response = self.analyzer.client.generate(
            model=self.analyzer.ollama_model,
            prompt=prompt
        )
        
        return response['response']

# Example monitoring setup
monitor = ProtocolMonitor(analyzer)
monitor.add_protocol("Uniswap V3", "0x1F98431c8aD98523631AE4a59f267346ea31F984", {
    'tvl_drop': -10,  # Alert if TVL drops more than 10%
    'yield_drop': -20,  # Alert if yield drops more than 20%
    'volume_drop': -30  # Alert if volume drops more than 30%
})

def compare_protocols(self, protocol_list, comparison_metrics):
    """Compare multiple DeFi protocols using Ollama"""
    
    protocol_data = {}
    for protocol in protocol_list:
        protocol_data[protocol['name']] = self.fetch_comprehensive_data(protocol['address'])
    
    prompt = f"""
    Compare these DeFi protocols across key metrics:
    
    Protocols: {list(protocol_data.keys())}
    
    Comparison Data:
    {json.dumps(protocol_data, indent=2)}
    
    Metrics to Compare:
    {comparison_metrics}
    
    Provide:
    1. Ranking by overall attractiveness
    2. Strengths and weaknesses of each
    3. Best use cases for different investor profiles
    4. Risk-adjusted recommendations
    """
    
    response = self.analyzer.client.generate(
        model=self.analyzer.ollama_model,
        prompt=prompt
    )
    
    return response['response']

def analyze_market_cycle_impact(self, protocol_address, market_data):
    """Analyze how market cycles affect protocol performance"""
    
    historical_performance = self.fetch_historical_data(protocol_address, days=365)
    
    prompt = f"""
    Analyze this DeFi protocol's performance across market cycles:
    
    Protocol: {protocol_address}
    
    Historical Data:
    - Bull Market Performance: {historical_performance['bull_market']}
    - Bear Market Performance: {historical_performance['bear_market']}
    - Sideways Market Performance: {historical_performance['sideways_market']}
    
    Current Market State: {market_data['current_cycle']}
    
    Provide:
    1. Protocol resilience assessment
    2. Optimal allocation timing
    3. Risk management strategies
    4. Expected performance in current cycle
    """
    
    response = self.analyzer.client.generate(
        model=self.analyzer.ollama_model,
        prompt=prompt
    )
    
    return response['response']

def complete_protocol_analysis(protocol_address, investment_amount):
    """Complete DeFi protocol analysis workflow"""
    
    # Initialize analyzers
    analyzer = DeFiAnalyzer("https://mainnet.infura.io/v3/YOUR_PROJECT_ID")
    tvl_analyzer = TVLAnalyzer(analyzer)
    yield_analyzer = YieldFarmingAnalyzer(analyzer)
    security_analyzer = ContractSecurityAnalyzer(analyzer)
    tokenomics_analyzer = TokenomicsAnalyzer(analyzer)
    
    # Perform comprehensive analysis
    results = {
        'tvl_analysis': tvl_analyzer.analyze_tvl_trends(
            {'tvl_history': fetch_tvl_history(protocol_address)}
        ),
        'yield_analysis': yield_analyzer.evaluate_farming_opportunity(
            protocol_address, investment_amount
        ),
        'security_analysis': security_analyzer.analyze_contract_security(
            protocol_address
        ),
        'tokenomics_analysis': tokenomics_analyzer.analyze_tokenomics(
            protocol_address, fetch_protocol_data(protocol_address)
        )
    }
    
    # Generate final recommendation
    final_prompt = f"""
    Synthesize this comprehensive DeFi protocol analysis:
    
    TVL Analysis: {results['tvl_analysis']}
    Yield Analysis: {results['yield_analysis']['analysis']}
    Security Analysis: {results['security_analysis']}
    Tokenomics Analysis: {results['tokenomics_analysis']['analysis']}
    
    Investment Amount: ${investment_amount:,.2f}
    
    Provide:
    1. Final investment recommendation
    2. Optimal position sizing
    3. Risk management strategy
    4. Monitoring plan
    5. Exit criteria
    """
    
    final_recommendation = analyzer.client.generate(
        model=analyzer.ollama_model,
        prompt=final_prompt
    )
    
    return {
        'detailed_analysis': results,
        'final_recommendation': final_recommendation['response']
    }

# Execute complete analysis
analysis_result = complete_protocol_analysis(
    "0x1F98431c8aD98523631AE4a59f267346ea31F984",  # Uniswap V3
    100000  # $100,000 investment
)

print("=== FINAL RECOMMENDATION ===")
print(analysis_result['final_recommendation'])

class RiskManager:
    def __init__(self, analyzer):
        self.analyzer = analyzer
        self.risk_weights = {
            'smart_contract': 0.30,
            'liquidity': 0.25,
            'market': 0.20,
            'regulatory': 0.15,
            'operational': 0.10
        }
    
    def calculate_composite_risk(self, protocol_address):
        """Calculate composite risk score"""
        
        risk_scores = {
            'smart_contract': self.assess_smart_contract_risk(protocol_address),
            'liquidity': self.assess_liquidity_risk(protocol_address),
            'market': self.assess_market_risk(protocol_address),
            'regulatory': self.assess_regulatory_risk(protocol_address),
            'operational': self.assess_operational_risk(protocol_address)
        }
        
        # Calculate weighted composite score
        composite_score = sum(
            score * self.risk_weights[category] 
            for category, score in risk_scores.items()
        )
        
        # Use Ollama for risk interpretation
        prompt = f"""
        Interpret this DeFi protocol risk assessment:
        
        Risk Scores (1-10, higher = more risk):
        - Smart Contract Risk: {risk_scores['smart_contract']:.1f}
        - Liquidity Risk: {risk_scores['liquidity']:.1f}
        - Market Risk: {risk_scores['market']:.1f}
        - Regulatory Risk: {risk_scores['regulatory']:.1f}
        - Operational Risk: {risk_scores['operational']:.1f}
        
        Composite Risk Score: {composite_score:.1f}
        
        Provide:
        1. Risk level classification (low/medium/high/critical)
        2. Key risk factors to monitor
        3. Risk mitigation strategies
        4. Position sizing recommendations
        """
        
        response = self.analyzer.client.generate(
            model=self.analyzer.ollama_model,
            prompt=prompt
        )
        
        return {
            'individual_scores': risk_scores,
            'composite_score': composite_score,
            'interpretation': response['response']
        }

class PerformanceTracker:
    def __init__(self, analyzer):
        self.analyzer = analyzer
        self.positions = {}
    
    def track_position_performance(self, position_id, protocol_address):
        """Track individual position performance"""
        
        current_data = self.fetch_current_position_data(position_id)
        historical_data = self.fetch_position_history(position_id)
        
        performance_metrics = {
            'total_return': current_data['value'] / current_data['initial_investment'] - 1,
            'annualized_return': self.calculate_annualized_return(historical_data),
            'max_drawdown': self.calculate_max_drawdown(historical_data),
            'sharpe_ratio': self.calculate_sharpe_ratio(historical_data),
            'impermanent_loss': current_data['impermanent_loss']
        }
        
        # Generate performance analysis
        prompt = f"""
        Analyze this DeFi position performance:
        
        Position ID: {position_id}
        Protocol: {protocol_address}
        
        Performance Metrics:
        - Total Return: {performance_metrics['total_return']:.2%}
        - Annualized Return: {performance_metrics['annualized_return']:.2%}
        - Max Drawdown: {performance_metrics['max_drawdown']:.2%}
        - Sharpe Ratio: {performance_metrics['sharpe_ratio']:.2f}
        - Impermanent Loss: {performance_metrics['impermanent_loss']:.2%}
        
        Provide:
        1. Performance assessment (excellent/good/average/poor)
        2. Comparison to benchmarks
        3. Optimization recommendations
        4. Hold/adjust/exit recommendation
        """
        
        response = self.analyzer.client.generate(
            model=self.analyzer.ollama_model,
            prompt=prompt
        )
        
        return {
            'metrics': performance_metrics,
            'analysis': response['response']
        }

def identify_analysis_mistakes(analysis_data):
    """Identify common DeFi analysis mistakes using Ollama"""
    
    prompt = f"""
    Review this DeFi analysis for common mistakes:
    
    Analysis Data: {analysis_data}
    
    Check for these common errors:
    1. Ignoring impermanent loss in yield calculations
    2. Not accounting for gas costs
    3. Overlooking smart contract upgrade risks
    4. Focusing only on APY without risk assessment
    5. Not considering token emission inflation
    6. Ignoring liquidity depth for large positions
    7. Not tracking governance token voting power concentration
    
    Identify any mistakes and suggest corrections.
    """
    
    response = client.generate(
        model="llama2:13b",
        prompt=prompt
    )
    
    return response['response']