DeFi Insurance for AI Agents: Protecting Against Smart Contract Failures

#!/usr/bin/env python3
"""
DeFi Insurance Cost Calculator for AI Agents
Evaluates coverage value and recommends optimal insurance strategy.
Purple Flea Research — purpleflea.com
"""

from dataclasses import dataclass, field
from typing import List, Dict, Optional
import math
import json


@dataclass
class ProtocolPosition:
    name: str
    value_usd: float
    # Annual exploit probability (0.0 - 1.0)
    exploit_probability: float
    # Expected loss as fraction of position if exploit occurs
    loss_severity: float = 0.8
    # Available insurance annual premium rate
    premium_rate: float = 0.03
    # Protocol audit count
    audit_count: int = 1
    # Protocol TVL in millions USD
    tvl_millions: float = 100.0


@dataclass
class InsuranceAnalysis:
    protocol: str
    position_usd: float
    annual_premium_usd: float
    expected_annual_loss: float
    risk_adjusted_value: float
    insurance_net_value: float
    recommendation: str
    confidence: str


class InsuranceCostCalculator:
    """
    Calculates the financial value of DeFi insurance for agent positions.
    Uses expected utility theory with log-utility (Kelly criterion) for
    risk-aversion calibration.
    """

    PROTOCOL_RISK_PROFILES: Dict[str, float] = {
        "aave": 0.005,       # 0.5% annual exploit probability
        "uniswap": 0.003,    # 0.3% - one of the most battle-tested
        "compound": 0.007,   # 0.7% - older, larger attack surface
        "curve": 0.012,       # 1.2% - had the July 2023 exploit
        "new_protocol": 0.08, # 8% - first 6 months are high risk
    }

    def estimate_exploit_probability(self, position: ProtocolPosition) -> float:
        """
        Estimate annual exploit probability using heuristics when
        explicit probability is not provided.
        """
        base_rate = 0.04  # 4% base rate for DeFi protocols

        # Audit discount: each audit reduces risk by ~35%
        audit_factor = (1 - 0.35) ** position.audit_count

        # TVL factor: larger protocols attract more scrutiny but also more attackers
        # Diminishing returns modeled as log
        tvl_factor = max(0.3, 1.0 - math.log10(max(1, position.tvl_millions)) * 0.15)

        return base_rate * audit_factor * tvl_factor

    def calculate_expected_loss(self, position: ProtocolPosition) -> float:
        """Annual expected loss in USD."""
        prob = position.exploit_probability
        if prob == 0:
            prob = self.estimate_exploit_probability(position)
        return position.value_usd * prob * position.loss_severity

    def log_utility(self, wealth: float, risk_aversion: float = 2.0) -> float:
        """Log utility function for risk-aversion modeling (CRRA)."""
        if wealth <= 0:
            return -float('inf')
        if risk_aversion == 1:
            return math.log(wealth)
        return (wealth ** (1 - risk_aversion)) / (1 - risk_aversion)

    def risk_adjusted_value(
        self,
        position: ProtocolPosition,
        total_wealth: float,
        risk_aversion: float = 2.0
    ) -> float:
        """
        Certainty equivalent of holding the uninsured position.
        Uses CRRA utility to account for risk aversion.
        """
        prob_exploit = position.exploit_probability
        if prob_exploit == 0:
            prob_exploit = self.estimate_exploit_probability(position)

        loss_amount = position.value_usd * position.loss_severity

        # Expected utility: p(no exploit) * U(W) + p(exploit) * U(W - loss)
        u_no_loss = self.log_utility(total_wealth, risk_aversion)
        u_with_loss = self.log_utility(
            max(1, total_wealth - loss_amount), risk_aversion
        )
        expected_utility = (
            (1 - prob_exploit) * u_no_loss +
            prob_exploit * u_with_loss
        )

        # Certainty equivalent (inverse of utility function)
        if risk_aversion == 1:
            certainty_equiv_wealth = math.exp(expected_utility)
        else:
            certainty_equiv_wealth = (
                expected_utility * (1 - risk_aversion)
            ) ** (1 / (1 - risk_aversion))

        return total_wealth - certainty_equiv_wealth

    def analyze_position(
        self,
        position: ProtocolPosition,
        total_agent_wealth: float,
        risk_aversion: float = 2.0
    ) -> InsuranceAnalysis:
        """Full insurance analysis for a single position."""
        annual_premium = position.value_usd * position.premium_rate
        expected_loss = self.calculate_expected_loss(position)
        risk_premium = self.risk_adjusted_value(
            position, total_agent_wealth, risk_aversion
        )

        # Net value of insurance = risk premium reduction - premium cost
        net_value = risk_premium - annual_premium

        if net_value > annual_premium * 0.5:
            recommendation = "STRONGLY RECOMMEND"
            confidence = "HIGH"
        elif net_value > 0:
            recommendation = "RECOMMEND"
            confidence = "MEDIUM"
        elif net_value > -annual_premium * 0.3:
            recommendation = "BORDERLINE — consider self-insurance"
            confidence = "LOW"
        else:
            recommendation = "NOT RECOMMENDED — self-insure via escrow reserve"
            confidence = "HIGH"

        return InsuranceAnalysis(
            protocol=position.name,
            position_usd=position.value_usd,
            annual_premium_usd=annual_premium,
            expected_annual_loss=expected_loss,
            risk_adjusted_value=risk_premium,
            insurance_net_value=net_value,
            recommendation=recommendation,
            confidence=confidence
        )

    def portfolio_analysis(
        self,
        positions: List[ProtocolPosition],
        total_wealth: float,
        portfolio_discount: float = 0.15
    ) -> Dict:
        """Analyze insurance for full portfolio with bundling discount."""
        analyses = [
            self.analyze_position(p, total_wealth)
            for p in positions
        ]

        total_premium_individual = sum(a.annual_premium_usd for a in analyses)
        total_premium_bundle = total_premium_individual * (1 - portfolio_discount)
        total_expected_loss = sum(a.expected_annual_loss for a in analyses)

        return {
            "positions": [
                {
                    "protocol": a.protocol,
                    "position_usd": a.position_usd,
                    "annual_premium": a.annual_premium_usd,
                    "expected_loss": a.expected_annual_loss,
                    "recommendation": a.recommendation,
                }
                for a in analyses
            ],
            "summary": {
                "total_position_value": sum(p.value_usd for p in positions),
                "total_premium_individual": total_premium_individual,
                "total_premium_bundle": total_premium_bundle,
                "bundle_savings": total_premium_individual - total_premium_bundle,
                "total_expected_annual_loss": total_expected_loss,
                "insurance_recommended": total_premium_bundle < total_expected_loss,
            }
        }


if __name__ == "__main__":
    calculator = InsuranceCostCalculator()

    # Example: Agent with $50,000 total wealth, positions across protocols
    positions = [
        ProtocolPosition(
            name="Aave v3",
            value_usd=20000,
            exploit_probability=0.005,
            loss_severity=0.9,
            premium_rate=0.018,
            audit_count=8,
            tvl_millions=8000
        ),
        ProtocolPosition(
            name="New DeFi Protocol",
            value_usd=5000,
            exploit_probability=0.08,
            loss_severity=1.0,
            premium_rate=0.07,
            audit_count=1,
            tvl_millions=12
        ),
        ProtocolPosition(
            name="Curve Finance",
            value_usd=15000,
            exploit_probability=0.015,
            loss_severity=0.75,
            premium_rate=0.028,
            audit_count=5,
            tvl_millions=2200
        ),
    ]

    result = calculator.portfolio_analysis(positions, total_wealth=50000)
    print(json.dumps(result, indent=2))

"""
Escrow Self-Insurance Reserve Manager
Manages a Purple Flea Escrow reserve for agent self-insurance.
API: escrow.purpleflea.com
"""
import requests
import os
from typing import Optional

ESCROW_API = "https://escrow.purpleflea.com/api"
AGENT_WALLET = os.environ.get("AGENT_WALLET_ADDRESS")
AGENT_SECRET = os.environ.get("AGENT_SECRET")

# Target reserve = 4% of AUM
RESERVE_RATIO = 0.04

def get_reserve_status() -> dict:
    r = requests.get(
        f"{ESCROW_API}/reserves/{AGENT_WALLET}",
        headers={"Authorization": f"Bearer {AGENT_SECRET}"}
    )
    return r.json()

def top_up_reserve(current_aum: float, current_reserve: float) -> Optional[dict]:
    target = current_aum * RESERVE_RATIO
    deficit = target - current_reserve
    if deficit <= 0:
        return None  # Reserve is healthy
    r = requests.post(
        f"{ESCROW_API}/reserve/deposit",
        json={
            "agent": AGENT_WALLET,
            "amount_usdc": deficit,
            "purpose": "self_insurance",
            "release_conditions": {
                "type": "oracle_trigger",
                "oracle": "chainlink_exploit_feed",
                "min_loss_threshold_usd": 500
            }
        },
        headers={"Authorization": f"Bearer {AGENT_SECRET}"}
    )
    return r.json()

def claim_reserve(loss_amount: float, proof_tx_hash: str) -> dict:
    """Emergency claim on self-insurance reserve after verified exploit."""
    r = requests.post(
        f"{ESCROW_API}/reserve/claim",
        json={
            "agent": AGENT_WALLET,
            "claim_amount_usdc": loss_amount,
            "proof": {
                "type": "exploit_loss",
                "transaction_hash": proof_tx_hash,
                "block_number": None  # Auto-resolved
            }
        },
        headers={"Authorization": f"Bearer {AGENT_SECRET}"}
    )
    return r.json()