Creating Stablecoin Insurance Fund: My Nexus Mutual Coverage Protocol Journey

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@nexusmutual/contracts/interfaces/INexusMutual.sol";
import "@nexusmutual/contracts/interfaces/ICover.sol";

contract StablecoinInsuranceFund is ReentrancyGuard, Ownable {
    
    // Core insurance contracts
    INexusMutual public nexusMutual;
    ICover public nexusCover;
    
    // Supported stablecoins
    mapping(address => bool) public supportedStablecoins;
    mapping(address => string) public stablecoinSymbols;
    
    // Coverage tracking
    struct Coverage {
        uint256 coverId;
        address protocol;
        address asset;
        uint256 amount;
        uint256 premium;
        uint256 startTime;
        uint256 endTime;
        bool active;
        uint256 riskScore; // 1-100 scale
    }
    
    mapping(uint256 => Coverage) public coverages;
    mapping(address => uint256[]) public protocolCoverages; // protocol => coverage IDs
    mapping(address => uint256) public totalCoverage; // asset => total covered amount
    
    // Risk assessment data
    struct ProtocolRisk {
        uint256 tvlScore;           // TVL stability score
        uint256 auditScore;         // Audit quality score  
        uint256 timeScore;          // Time since deployment
        uint256 exploitHistory;     // Historical exploit score
        uint256 teamScore;          // Team reputation score
        uint256 lastUpdated;
    }
    
    mapping(address => ProtocolRisk) public protocolRisks;
    
    // Insurance pool management
    uint256 public totalPoolBalance;
    uint256 public reserveRatio = 2000; // 20% reserve ratio
    uint256 public maxCoveragePerProtocol = 500000 * 1e6; // $500K max per protocol
    
    // Events
    event CoveragePurchased(
        uint256 indexed coverId,
        address indexed protocol,
        address indexed asset,
        uint256 amount,
        uint256 premium
    );
    
    event ClaimSubmitted(
        uint256 indexed coverId,
        address indexed submitter,
        uint256 amount,
        string reason
    );
    
    event CoverageExpired(uint256 indexed coverId);
    event RiskScoreUpdated(address indexed protocol, uint256 newScore);
    
    constructor(
        address _nexusMutual,
        address _nexusCover
    ) {
        nexusMutual = INexusMutual(_nexusMutual);
        nexusCover = ICover(_nexusCover);
        
        // Initialize supported stablecoins
        _addSupportedStablecoin(0xA0b86a33E6411Ff6b12A4e4c0d03Ff2e34Dd7Ae6, "USDC");
        _addSupportedStablecoin(0xdAC17F958D2ee523a2206206994597C13D831ec7, "USDT");
        _addSupportedStablecoin(0x6B175474E89094C44Da98b954EedeAC495271d0F, "DAI");
    }
    
    function purchaseProtocolCoverage(
        address protocol,
        address asset,
        uint256 amount,
        uint256 duration,
        bytes calldata coverData
    ) external nonReentrant returns (uint256 coverId) {
        
        require(supportedStablecoins[asset], "Unsupported stablecoin");
        require(amount > 0, "Coverage amount must be positive");
        require(duration >= 30 days && duration <= 365 days, "Invalid duration");
        
        // Check coverage limits
        require(
            totalCoverage[asset] + amount <= maxCoveragePerProtocol,
            "Exceeds maximum coverage"
        );
        
        // Calculate risk-adjusted premium
        uint256 riskScore = calculateProtocolRisk(protocol);
        uint256 premium = calculatePremium(amount, duration, riskScore);
        
        // Transfer premium payment
        IERC20(asset).transferFrom(msg.sender, address(this), premium);
        
        // Purchase coverage through Nexus Mutual
        // This is a simplified interface - actual implementation would use proper Nexus API
        coverId = _purchaseNexusCoverage(protocol, asset, amount, duration, coverData);
        
        // Record coverage
        Coverage memory newCoverage = Coverage({
            coverId: coverId,
            protocol: protocol,
            asset: asset,
            amount: amount,
            premium: premium,
            startTime: block.timestamp,
            endTime: block.timestamp + duration,
            active: true,
            riskScore: riskScore
        });
        
        coverages[coverId] = newCoverage;
        protocolCoverages[protocol].push(coverId);
        totalCoverage[asset] += amount;
        totalPoolBalance += premium;
        
        emit CoveragePurchased(coverId, protocol, asset, amount, premium);
        
        return coverId;
    }
    
    function calculateProtocolRisk(address protocol) public view returns (uint256) {
        ProtocolRisk memory risk = protocolRisks[protocol];
        
        // If no risk data, return maximum risk score
        if (risk.lastUpdated == 0) {
            return 90; // High risk for unknown protocols
        }
        
        // Weighted risk calculation
        uint256 totalScore = (
            risk.tvlScore * 25 +        // 25% weight on TVL stability
            risk.auditScore * 20 +      // 20% weight on audit quality
            risk.timeScore * 15 +       // 15% weight on time since deployment
            risk.exploitHistory * 25 +  // 25% weight on exploit history
            risk.teamScore * 15         // 15% weight on team reputation
        ) / 100;
        
        // Data freshness penalty
        uint256 dataAge = block.timestamp - risk.lastUpdated;
        if (dataAge > 7 days) {
            totalScore += 10; // Increase risk for stale data
        }
        
        return totalScore > 100 ? 100 : totalScore;
    }
    
    function calculatePremium(
        uint256 amount,
        uint256 duration,
        uint256 riskScore
    ) public pure returns (uint256) {
        
        // Base premium rate: 2% annually
        uint256 basePremium = (amount * 200) / 10000;
        
        // Adjust for duration (pro-rated)
        uint256 durationAdjusted = (basePremium * duration) / 365 days;
        
        // Risk adjustment (multiply by risk factor)
        uint256 riskMultiplier = 50 + riskScore; // 50-150% based on risk
        uint256 riskAdjusted = (durationAdjusted * riskMultiplier) / 100;
        
        return riskAdjusted;
    }
    
    function submitClaim(
        uint256 coverId,
        uint256 claimAmount,
        string calldata reason,
        bytes calldata evidence
    ) external nonReentrant {
        
        Coverage storage coverage = coverages[coverId];
        require(coverage.active, "Coverage not active");
        require(block.timestamp <= coverage.endTime, "Coverage expired");
        require(claimAmount <= coverage.amount, "Claim exceeds coverage");
        
        // Submit claim to Nexus Mutual
        _submitNexusClaim(coverId, claimAmount, reason, evidence);
        
        emit ClaimSubmitted(coverId, msg.sender, claimAmount, reason);
    }
    
    function updateProtocolRisk(
        address protocol,
        uint256 tvlScore,
        uint256 auditScore,
        uint256 timeScore,
        uint256 exploitHistory,
        uint256 teamScore
    ) external onlyOwner {
        
        protocolRisks[protocol] = ProtocolRisk({
            tvlScore: tvlScore,
            auditScore: auditScore,
            timeScore: timeScore,
            exploitHistory: exploitHistory,
            teamScore: teamScore,
            lastUpdated: block.timestamp
        });
        
        uint256 newRiskScore = calculateProtocolRisk(protocol);
        emit RiskScoreUpdated(protocol, newRiskScore);
    }
    
    function expireCoverage(uint256 coverId) external {
        Coverage storage coverage = coverages[coverId];
        require(coverage.active, "Coverage already inactive");
        require(block.timestamp > coverage.endTime, "Coverage not yet expired");
        
        coverage.active = false;
        totalCoverage[coverage.asset] -= coverage.amount;
        
        emit CoverageExpired(coverId);
    }
    
    // Internal functions for Nexus Mutual integration
    function _purchaseNexusCoverage(
        address protocol,
        address asset,
        uint256 amount,
        uint256 duration,
        bytes calldata coverData
    ) internal returns (uint256) {
        // Simplified - actual implementation would integrate with Nexus Mutual API
        return block.timestamp; // Return timestamp as mock cover ID
    }
    
    function _submitNexusClaim(
        uint256 coverId,
        uint256 amount,
        string calldata reason,
        bytes calldata evidence
    ) internal {
        // Integration with Nexus Mutual claim submission
        // This would interact with their governance system
    }
    
    function _addSupportedStablecoin(address token, string memory symbol) internal {
        supportedStablecoins[token] = true;
        stablecoinSymbols[token] = symbol;
    }
    
    // View functions
    function getProtocolCoverages(address protocol) external view returns (uint256[] memory) {
        return protocolCoverages[protocol];
    }
    
    function getCoverageDetails(uint256 coverId) external view returns (Coverage memory) {
        return coverages[coverId];
    }
    
    function getTotalCoverage(address asset) external view returns (uint256) {
        return totalCoverage[asset];
    }
}

# risk_assessment.py
import asyncio
import requests
import numpy as np
from dataclasses import dataclass
from typing import Dict, List, Optional
import logging
from web3 import Web3
import json
import time

@dataclass
class ProtocolMetrics:
    protocol_address: str
    protocol_name: str
    tvl: float
    tvl_change_7d: float
    tvl_change_30d: float
    audit_score: float
    deployment_date: int
    exploit_count: int
    last_exploit_date: Optional[int]
    team_reputation: float
    github_activity: float
    token_price_stability: float

class AutomatedRiskAssessment:
    def __init__(self, w3: Web3):
        self.w3 = w3
        self.protocols = {}
        self.risk_scores = {}
        
        # Risk scoring weights (learned from historical data)
        self.scoring_weights = {
            'tvl_stability': 0.25,
            'audit_quality': 0.20,
            'time_factor': 0.15,
            'exploit_history': 0.25,
            'team_reputation': 0.15
        }
        
        # Data sources
        self.defi_llama_api = "https://api.llama.fi"
        self.defisafety_api = "https://api.defisafety.com"
        
    async def assess_protocol_risk(self, protocol_address: str) -> Dict:
        """Comprehensive risk assessment for a DeFi protocol"""
        
        try:
            # Gather all protocol metrics
            metrics = await self.gather_protocol_metrics(protocol_address)
            
            # Calculate individual risk components
            tvl_risk = self.calculate_tvl_risk(metrics)
            audit_risk = self.calculate_audit_risk(metrics)
            time_risk = self.calculate_time_risk(metrics)
            exploit_risk = self.calculate_exploit_risk(metrics)
            team_risk = self.calculate_team_risk(metrics)
            
            # Calculate composite risk score
            composite_score = (
                tvl_risk * self.scoring_weights['tvl_stability'] +
                audit_risk * self.scoring_weights['audit_quality'] +
                time_risk * self.scoring_weights['time_factor'] +
                exploit_risk * self.scoring_weights['exploit_history'] +
                team_risk * self.scoring_weights['team_reputation']
            )
            
            # Risk categorization
            if composite_score <= 30:
                risk_category = "LOW"
            elif composite_score <= 60:
                risk_category = "MEDIUM"
            elif composite_score <= 80:
                risk_category = "HIGH"
            else:
                risk_category = "CRITICAL"
            
            risk_assessment = {
                'protocol_address': protocol_address,
                'protocol_name': metrics.protocol_name,
                'composite_score': composite_score,
                'risk_category': risk_category,
                'components': {
                    'tvl_risk': tvl_risk,
                    'audit_risk': audit_risk,
                    'time_risk': time_risk,
                    'exploit_risk': exploit_risk,
                    'team_risk': team_risk
                },
                'metrics': metrics,
                'assessment_time': time.time(),
                'confidence': self.calculate_confidence_score(metrics)
            }
            
            # Store assessment
            self.risk_scores[protocol_address] = risk_assessment
            
            return risk_assessment
            
        except Exception as e:
            logging.error(f"Risk assessment failed for {protocol_address}: {e}")
            return self.get_default_high_risk_assessment(protocol_address)
    
    async def gather_protocol_metrics(self, protocol_address: str) -> ProtocolMetrics:
        """Gather comprehensive metrics for protocol analysis"""
        
        # Fetch TVL data from DeFi Llama
        tvl_data = await self.fetch_tvl_data(protocol_address)
        
        # Fetch audit information
        audit_data = await self.fetch_audit_data(protocol_address)
        
        # Fetch on-chain deployment data
        deployment_data = await self.fetch_deployment_data(protocol_address)
        
        # Fetch exploit history
        exploit_data = await self.fetch_exploit_history(protocol_address)
        
        # Fetch team and governance data
        team_data = await self.fetch_team_data(protocol_address)
        
        return ProtocolMetrics(
            protocol_address=protocol_address,
            protocol_name=tvl_data.get('name', 'Unknown'),
            tvl=tvl_data.get('tvl', 0),
            tvl_change_7d=tvl_data.get('change_7d', 0),
            tvl_change_30d=tvl_data.get('change_1m', 0),
            audit_score=audit_data.get('score', 0),
            deployment_date=deployment_data.get('deployment_date', 0),
            exploit_count=exploit_data.get('count', 0),
            last_exploit_date=exploit_data.get('last_date'),
            team_reputation=team_data.get('reputation_score', 50),
            github_activity=team_data.get('github_activity', 0),
            token_price_stability=await self.calculate_token_stability(protocol_address)
        )
    
    def calculate_tvl_risk(self, metrics: ProtocolMetrics) -> float:
        """Calculate risk based on TVL stability and size"""
        
        # TVL size risk (larger TVL = lower risk up to a point)
        if metrics.tvl > 1_000_000_000:  # $1B+
            size_risk = 10
        elif metrics.tvl > 500_000_000:  # $500M+
            size_risk = 20
        elif metrics.tvl > 100_000_000:  # $100M+
            size_risk = 35
        elif metrics.tvl > 10_000_000:   # $10M+
            size_risk = 50
        else:
            size_risk = 80  # High risk for small TVL
        
        # TVL volatility risk
        volatility_7d = abs(metrics.tvl_change_7d)
        volatility_30d = abs(metrics.tvl_change_30d)
        
        if volatility_30d > 50:  # 50%+ change in 30 days
            volatility_risk = 80
        elif volatility_30d > 30:
            volatility_risk = 60
        elif volatility_30d > 15:
            volatility_risk = 40
        else:
            volatility_risk = 20
        
        # Combined TVL risk
        tvl_risk = (size_risk * 0.6 + volatility_risk * 0.4)
        
        return min(100, tvl_risk)
    
    def calculate_audit_risk(self, metrics: ProtocolMetrics) -> float:
        """Calculate risk based on audit quality and coverage"""
        
        # Audit score is typically 0-100, where 100 is best
        # Convert to risk score (inverse relationship)
        if metrics.audit_score >= 90:
            return 10  # Very low risk
        elif metrics.audit_score >= 80:
            return 25
        elif metrics.audit_score >= 70:
            return 40
        elif metrics.audit_score >= 60:
            return 60
        elif metrics.audit_score > 0:
            return 80
        else:
            return 95  # Very high risk for unaudited protocols
    
    def calculate_time_risk(self, metrics: ProtocolMetrics) -> float:
        """Calculate risk based on protocol maturity"""
        
        if metrics.deployment_date == 0:
            return 90  # High risk for unknown deployment date
        
        protocol_age = time.time() - metrics.deployment_date
        age_days = protocol_age / (24 * 3600)
        
        if age_days > 730:  # 2+ years
            return 15
        elif age_days > 365:  # 1+ year
            return 30
        elif age_days > 180:  # 6+ months
            return 50
        elif age_days > 90:   # 3+ months
            return 70
        else:
            return 85  # High risk for very new protocols
    
    def calculate_exploit_risk(self, metrics: ProtocolMetrics) -> float:
        """Calculate risk based on exploit history"""
        
        if metrics.exploit_count == 0:
            return 20  # Low risk for no exploits
        
        # Recent exploit penalty
        if metrics.last_exploit_date:
            days_since_exploit = (time.time() - metrics.last_exploit_date) / (24 * 3600)
            
            if days_since_exploit < 30:
                recency_penalty = 50
            elif days_since_exploit < 90:
                recency_penalty = 30
            elif days_since_exploit < 365:
                recency_penalty = 15
            else:
                recency_penalty = 5
        else:
            recency_penalty = 0
        
        # Exploit frequency penalty
        frequency_penalty = min(50, metrics.exploit_count * 20)
        
        exploit_risk = 20 + recency_penalty + frequency_penalty
        
        return min(100, exploit_risk)
    
    def calculate_team_risk(self, metrics: ProtocolMetrics) -> float:
        """Calculate risk based on team reputation and activity"""
        
        # Team reputation (0-100 scale)
        reputation_risk = 100 - metrics.team_reputation
        
        # GitHub activity factor
        if metrics.github_activity > 100:  # High activity
            activity_risk = 10
        elif metrics.github_activity > 50:
            activity_risk = 25
        elif metrics.github_activity > 10:
            activity_risk = 40
        else:
            activity_risk = 70  # Low activity = higher risk
        
        team_risk = (reputation_risk * 0.7 + activity_risk * 0.3)
        
        return min(100, team_risk)
    
    async def fetch_tvl_data(self, protocol_address: str) -> Dict:
        """Fetch TVL data from DeFi Llama"""
        
        try:
            # This is a simplified example - actual implementation would
            # require proper DeFi Llama API integration
            response = requests.get(f"{self.defi_llama_api}/protocol/{protocol_address}")
            
            if response.status_code == 200:
                return response.json()
            else:
                return {'tvl': 0, 'change_7d': 0, 'change_1m': 0, 'name': 'Unknown'}
                
        except Exception as e:
            logging.warning(f"Failed to fetch TVL data: {e}")
            return {'tvl': 0, 'change_7d': 0, 'change_1m': 0, 'name': 'Unknown'}
    
    async def fetch_audit_data(self, protocol_address: str) -> Dict:
        """Fetch audit data from various sources"""
        
        try:
            # Integration with audit databases like DeFi Safety
            # This is a placeholder - actual implementation would aggregate
            # data from multiple audit sources
            
            audit_sources = [
                'consensys',
                'openzeppelin',
                'trailofbits',
                'certik',
                'quantstamp'
            ]
            
            # Mock audit score calculation
            # In practice, this would parse actual audit reports
            base_score = 60  # Default score for unknown audits
            
            return {'score': base_score, 'auditors': audit_sources[:2]}
            
        except Exception as e:
            logging.warning(f"Failed to fetch audit data: {e}")
            return {'score': 0, 'auditors': []}
    
    async def monitor_risk_changes(self):
        """Continuously monitor risk score changes"""
        
        while True:
            try:
                for protocol_address in self.protocols.keys():
                    # Get current risk score
                    current_assessment = await self.assess_protocol_risk(protocol_address)
                    
                    # Check for significant changes
                    if protocol_address in self.risk_scores:
                        previous_score = self.risk_scores[protocol_address]['composite_score']
                        current_score = current_assessment['composite_score']
                        
                        change = abs(current_score - previous_score)
                        
                        if change > 10:  # 10+ point change triggers alert
                            await self.send_risk_alert(protocol_address, current_assessment, change)
                
            except Exception as e:
                logging.error(f"Risk monitoring error: {e}")
            
            await asyncio.sleep(3600)  # Check every hour
    
    def calculate_confidence_score(self, metrics: ProtocolMetrics) -> float:
        """Calculate confidence in the risk assessment"""
        
        confidence_factors = []
        
        # TVL data availability
        if metrics.tvl > 0:
            confidence_factors.append(25)
        
        # Audit data availability
        if metrics.audit_score > 0:
            confidence_factors.append(20)
        
        # Deployment date availability
        if metrics.deployment_date > 0:
            confidence_factors.append(15)
        
        # Team data availability
        if metrics.team_reputation > 0:
            confidence_factors.append(20)
        
        # GitHub activity data
        if metrics.github_activity > 0:
            confidence_factors.append(10)
        
        # Token stability data
        if metrics.token_price_stability > 0:
            confidence_factors.append(10)
        
        return sum(confidence_factors)
    
    async def send_risk_alert(self, protocol_address: str, assessment: Dict, change: float):
        """Send alert for significant risk changes"""
        
        alert_message = f"""
        RISK ALERT: {assessment['protocol_name']}
        
        Risk Score Changed: {change:+.1f} points
        Current Risk: {assessment['composite_score']:.1f} ({assessment['risk_category']})
        
        Components:
        - TVL Risk: {assessment['components']['tvl_risk']:.1f}
        - Audit Risk: {assessment['components']['audit_risk']:.1f}  
        - Time Risk: {assessment['components']['time_risk']:.1f}
        - Exploit Risk: {assessment['components']['exploit_risk']:.1f}
        - Team Risk: {assessment['components']['team_risk']:.1f}
        
        Consider adjusting insurance coverage.
        """
        
        logging.warning(alert_message)
        # Implement your preferred notification method (email, Slack, etc.)

# coverage_manager.py
import asyncio
import logging
from typing import Dict, List
from web3 import Web3
import time

class AutomatedCoverageManager:
    def __init__(self, w3: Web3, insurance_contract_address: str):
        self.w3 = w3
        self.insurance_contract = self.w3.eth.contract(
            address=insurance_contract_address,
            abi=INSURANCE_CONTRACT_ABI
        )
        
        self.coverage_targets = {}  # protocol -> target coverage amount
        self.current_coverages = {}  # protocol -> current coverage details
        self.risk_assessor = AutomatedRiskAssessment(w3)
        
        # Coverage management parameters
        self.min_coverage_ratio = 0.8    # 80% minimum coverage
        self.max_coverage_ratio = 1.2    # 120% maximum coverage
        self.rebalance_threshold = 0.1   # 10% deviation triggers rebalance
        
    async def manage_coverage_portfolio(self):
        """Main loop for automated coverage management"""
        
        while True:
            try:
                # Update risk assessments
                await self.update_all_risk_assessments()
                
                # Check coverage adequacy
                coverage_actions = await self.assess_coverage_needs()
                
                # Execute coverage adjustments
                for action in coverage_actions:
                    await self.execute_coverage_action(action)
                
                # Monitor active claims
                await self.monitor_active_claims()
                
                # Generate coverage report
                await self.generate_coverage_report()
                
            except Exception as e:
                logging.error(f"Coverage management error: {e}")
            
            await asyncio.sleep(1800)  # Run every 30 minutes
    
    async def assess_coverage_needs(self) -> List[Dict]:
        """Assess current coverage needs and recommend actions"""
        
        actions = []
        
        for protocol, target_amount in self.coverage_targets.items():
            try:
                # Get current coverage
                current_coverage = await self.get_current_coverage(protocol)
                
                # Get current risk assessment
                risk_assessment = await self.risk_assessor.assess_protocol_risk(protocol)
                
                # Calculate optimal coverage amount
                optimal_amount = self.calculate_optimal_coverage(
                    target_amount, 
                    risk_assessment
                )
                
                # Check if adjustment is needed
                if current_coverage == 0:
                    # No coverage exists, need to purchase
                    actions.append({
                        'type': 'purchase',
                        'protocol': protocol,
                        'amount': optimal_amount,
                        'reason': 'no_existing_coverage',
                        'priority': 'high'
                    })
                    
                else:
                    # Check if coverage needs adjustment
                    coverage_ratio = current_coverage / optimal_amount
                    
                    if coverage_ratio < self.min_coverage_ratio:
                        # Increase coverage
                        additional_amount = optimal_amount - current_coverage
                        actions.append({
                            'type': 'increase',
                            'protocol': protocol,
                            'amount': additional_amount,
                            'current_coverage': current_coverage,
                            'target_coverage': optimal_amount,
                            'reason': 'insufficient_coverage',
                            'priority': 'medium'
                        })
                        
                    elif coverage_ratio > self.max_coverage_ratio:
                        # Reduce coverage (over-insured)
                        excess_amount = current_coverage - optimal_amount
                        actions.append({
                            'type': 'reduce',
                            'protocol': protocol,
                            'amount': excess_amount,
                            'current_coverage': current_coverage,
                            'target_coverage': optimal_amount,
                            'reason': 'excessive_coverage',
                            'priority': 'low'
                        })
                
                # Check for expiring coverage
                expiring_coverage = await self.check_expiring_coverage(protocol)
                if expiring_coverage:
                    actions.append({
                        'type': 'renew',
                        'protocol': protocol,
                        'amount': optimal_amount,
                        'expiring_coverage_id': expiring_coverage['cover_id'],
                        'expiry_date': expiring_coverage['expiry_date'],
                        'reason': 'coverage_expiring',
                        'priority': 'high'
                    })
                
            except Exception as e:
                logging.error(f"Error assessing coverage for {protocol}: {e}")
        
        # Sort actions by priority
        priority_order = {'high': 0, 'medium': 1, 'low': 2}
        actions.sort(key=lambda x: priority_order.get(x['priority'], 3))
        
        return actions
    
    def calculate_optimal_coverage(self, target_amount: float, risk_assessment: Dict) -> float:
        """Calculate optimal coverage amount based on risk"""
        
        risk_score = risk_assessment['composite_score']
        
        # Higher risk protocols need more coverage buffer
        if risk_score > 80:
            coverage_multiplier = 1.3  # 30% buffer for high risk
        elif risk_score > 60:
            coverage_multiplier = 1.2  # 20% buffer for medium risk
        elif risk_score > 40:
            coverage_multiplier = 1.1  # 10% buffer for low risk
        else:
            coverage_multiplier = 1.0  # No buffer for very low risk
        
        optimal_amount = target_amount * coverage_multiplier
        
        # Apply protocol-specific limits
        max_coverage_per_protocol = 500_000  # $500K max
        optimal_amount = min(optimal_amount, max_coverage_per_protocol)
        
        return optimal_amount
    
    async def execute_coverage_action(self, action: Dict):
        """Execute a coverage management action"""
        
        try:
            if action['type'] == 'purchase':
                await self.purchase_new_coverage(action)
                
            elif action['type'] == 'increase':
                await self.increase_coverage(action)
                
            elif action['type'] == 'reduce':
                await self.reduce_coverage(action)
                
            elif action['type'] == 'renew':
                await self.renew_coverage(action)
            
            logging.info(f"Coverage action executed: {action['type']} for {action['protocol']}")
            
        except Exception as e:
            logging.error(f"Failed to execute coverage action: {e}")
    
    async def purchase_new_coverage(self, action: Dict):
        """Purchase new insurance coverage"""
        
        protocol = action['protocol']
        amount = action['amount']
        
        # Get the stablecoin to use for this protocol
        asset = await self.get_protocol_primary_asset(protocol)
        
        # Calculate coverage duration (default 365 days)
        duration = 365 * 24 * 3600
        
        # Prepare coverage data
        cover_data = self.prepare_coverage_data(protocol, asset, amount)
        
        # Execute purchase transaction
        tx = self.insurance_contract.functions.purchaseProtocolCoverage(
            protocol,
            asset,
            int(amount * 1e6),  # Convert to token units
            duration,
            cover_data
        ).build_transaction({
            'from': self.w3.eth.default_account,
            'gas': 500000,
            'gasPrice': self.w3.eth.gas_price
        })
        
        # Sign and send transaction
        signed_tx = self.w3.eth.account.sign_transaction(tx, private_key=PRIVATE_KEY)
        tx_hash = self.w3.eth.send_raw_transaction(signed_tx.rawTransaction)
        
        # Wait for confirmation
        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
        
        if receipt['status'] == 1:
            logging.info(f"Coverage purchased: {amount} for {protocol}")
        else:
            raise Exception(f"Coverage purchase failed: {receipt}")
    
    async def monitor_active_claims(self):
        """Monitor active insurance claims"""
        
        # Get all active claims
        active_claims = await self.get_active_claims()
        
        for claim in active_claims:
            try:
                # Check claim status
                status = await self.check_claim_status(claim['claim_id'])
                
                if status == 'approved':
                    logging.info(f"Claim approved: {claim['claim_id']} for {claim['amount']}")
                    await self.process_approved_claim(claim)
                    
                elif status == 'rejected':
                    logging.warning(f"Claim rejected: {claim['claim_id']}")
                    await self.handle_rejected_claim(claim)
                    
                elif status == 'needs_evidence':
                    logging.info(f"Additional evidence needed for claim: {claim['claim_id']}")
                    await self.provide_additional_evidence(claim)
                
            except Exception as e:
                logging.error(f"Error monitoring claim {claim['claim_id']}: {e}")
    
    async def auto_submit_claim(self, protocol: str, exploit_details: Dict):
        """Automatically submit insurance claim for detected exploits"""
        
        try:
            # Get affected coverage
            coverage = await self.get_protocol_coverage(protocol)
            
            if not coverage:
                logging.warning(f"No coverage found for exploited protocol: {protocol}")
                return
            
            # Calculate claim amount
            claim_amount = min(
                exploit_details['loss_amount'],
                coverage['amount']
            )
            
            # Prepare evidence
            evidence = {
                'exploit_tx_hash': exploit_details['tx_hash'],
                'exploit_timestamp': exploit_details['timestamp'],
                'loss_amount': exploit_details['loss_amount'],
                'affected_users': exploit_details.get('affected_users', []),
                'security_report': exploit_details.get('security_report', ''),
                'media_coverage': exploit_details.get('media_links', [])
            }
            
            # Submit claim
            await self.submit_claim(
                coverage['cover_id'],
                claim_amount,
                f"Smart contract exploit on {protocol}",
                json.dumps(evidence).encode()
            )
            
            logging.info(f"Auto-submitted claim for {protocol}: ${claim_amount:,.2f}")
            
        except Exception as e:
            logging.error(f"Failed to auto-submit claim for {protocol}: {e}")
    
    async def generate_coverage_report(self):
        """Generate comprehensive coverage status report"""
        
        report = {
            'timestamp': time.time(),
            'total_protocols': len(self.coverage_targets),
            'total_coverage_amount': 0,
            'total_premium_paid': 0,
            'coverage_by_risk_level': {'low': 0, 'medium': 0, 'high': 0, 'critical': 0},
            'expiring_soon': [],
            'uncovered_protocols': [],
            'over_insured_protocols': []
        }
        
        for protocol, target_amount in self.coverage_targets.items():
            try:
                # Get current coverage and risk
                current_coverage = await self.get_current_coverage(protocol)
                risk_assessment = await self.risk_assessor.assess_protocol_risk(protocol)
                
                report['total_coverage_amount'] += current_coverage
                
                # Track by risk level
                risk_level = risk_assessment['risk_category'].lower()
                if risk_level in report['coverage_by_risk_level']:
                    report['coverage_by_risk_level'][risk_level] += current_coverage
                
                # Check coverage adequacy
                if current_coverage == 0:
                    report['uncovered_protocols'].append(protocol)
                elif current_coverage > target_amount * 1.2:
                    report['over_insured_protocols'].append({
                        'protocol': protocol,
                        'current': current_coverage,
                        'target': target_amount,
                        'excess': current_coverage - target_amount
                    })
                
                # Check for expiring coverage
                expiring = await self.check_expiring_coverage(protocol, days_ahead=30)
                if expiring:
                    report['expiring_soon'].append(expiring)
                
            except Exception as e:
                logging.error(f"Error generating report for {protocol}: {e}")
        
        # Log summary
        logging.info(f"Coverage Report: {report['total_protocols']} protocols, "
                    f"${report['total_coverage_amount']:,.2f} total coverage")
        
        # Store report for historical analysis
        await self.store_coverage_report(report)
        
        return report