┌─────────────────────────────────────────────────────────────────────────────┐
│                    DEFI RISK CATEGORIES                                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    MARKET RISK                                      │   │
│  │  • Price volatility of underlying assets                          │   │
│  │  • Impermanent loss in AMMs                                        │   │
│  │  • Liquidity crises                                                │   │
│  │  • Slippage and market impact                                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    TECHNICAL RISK                                  │   │
│  │  • Smart contract vulnerabilities                                 │   │
│  │  • Oracle manipulation                                             │   │
│  │  • Front-running and MEV                                            │   │
│  │  • Protocol upgrades and bugs                                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    OPERATIONAL RISK                                │   │
│  │  • Governance attacks                                               │   │
│  │  • Key management failures                                         │   │
│  │  • Community disputes                                                │   │
│  │  • Human error                                                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    REGULATORY RISK                                  │   │
│  │  • Changing regulations                                             │   │
│  │  • Compliance failures                                              │   │
│  │  • Tax uncertainty                                                  │   │
│  │  • Jurisdictional issues                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    RISK MANAGEMENT PROCESS                                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. RISK IDENTIFICATION                                                     │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Identify all potential risks                                     │   │
│  │ • Document risk sources                                             │   │
│  │ • Categorise risks                                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  2. RISK ASSESSMENT                                                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Assess likelihood                                                │   │
│  │ • Assess impact                                                    │   │
│  │ • Prioritise risks                                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  3. RISK MITIGATION                                                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Implement controls                                                │   │
│  │ • Reduce likelihood and/or impact                                   │   │
│  │ • Transfer risk (insurance)                                        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  4. RISK MONITORING                                                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Continuous monitoring                                             │   │
│  │ • Regular reviews                                                   │   │
│  │ • Incident response                                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 9, LESSON 4: DEFI RISK AND SECURITY
# ===================================================================

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from typing import Dict, List, Tuple
import random
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("DEFI RISK AND SECURITY")
print("="*70)

# ----------------------------------------------------------------
# PART A: RISK ASSESSMENT FRAMEWORK
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: DeFi Risk Assessment Framework")
print("-"*60)

class DeFiRiskAssessment:
    """
    Comprehensive DeFi risk assessment tool.
    """
    def __init__(self, protocol_name: str):
        self.protocol_name = protocol_name
        self.risks = {}
        self.total_score = 0
    
    def add_risk(self, category: str, risk_name: str, likelihood: int, impact: int) -> None:
        """Add a risk with likelihood and impact scores (1-5)."""
        risk_score = likelihood * impact
        severity = self._get_severity(risk_score)
        self.risks[risk_name] = {
            'category': category,
            'likelihood': likelihood,
            'impact': impact,
            'risk_score': risk_score,
            'severity': severity
        }
        self.total_score += risk_score
    
    def _get_severity(self, score: int) -> str:
        if score >= 20:
            return 'Critical'
        elif score >= 12:
            return 'High'
        elif score >= 8:
            return 'Medium'
        else:
            return 'Low'
    
    def get_summary(self) -> pd.DataFrame:
        data = []
        for risk_name, details in self.risks.items():
            data.append({
                'Risk': risk_name,
                'Category': details['category'],
                'Likelihood': details['likelihood'],
                'Impact': details['impact'],
                'Score': details['risk_score'],
                'Severity': details['severity']
            })
        return pd.DataFrame(data)
    
    def get_severity_breakdown(self) -> Dict:
        breakdown = {'Critical': 0, 'High': 0, 'Medium': 0, 'Low': 0}
        for details in self.risks.values():
            breakdown[details['severity']] += 1
        return breakdown

# Create risk assessment
risk_assessment = DeFiRiskAssessment("DeFi Lending Protocol")

# Add risks
risks_data = [
    ('Market', 'Price Volatility', 4, 4),
    ('Market', 'Impermanent Loss', 3, 3),
    ('Market', 'Liquidity Crunch', 3, 5),
    ('Technical', 'Smart Contract Bug', 3, 5),
    ('Technical', 'Oracle Manipulation', 3, 4),
    ('Technical', 'Front-running/MEV', 5, 2),
    ('Operational', 'Governance Attack', 2, 5),
    ('Operational', 'Key Management Failure', 2, 5),
    ('Regulatory', 'Regulatory Enforcement', 3, 4),
    ('Regulatory', 'Tax Treatment Change', 3, 3)
]

for category, risk_name, likelihood, impact in risks_data:
    risk_assessment.add_risk(category, risk_name, likelihood, impact)

print(f"Risk Assessment: {risk_assessment.protocol_name}")
summary_df = risk_assessment.get_summary()
print(summary_df.to_string(index=False))

breakdown = risk_assessment.get_severity_breakdown()
print(f"\nSeverity Breakdown:")
for severity, count in breakdown.items():
    print(f"  {severity}: {count} risks")

# ----------------------------------------------------------------
# PART B: RISK HEATMAP VISUALISATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Risk Heatmap Visualisation")
print("-"*60)

fig, ax = plt.subplots(figsize=(10, 8))

# Create heatmap data
heatmap_data = np.zeros((5, 5))
risk_positions = {}

for risk_name, details in risk_assessment.risks.items():
    likelihood = details['likelihood']
    impact = details['impact']
    heatmap_data[likelihood-1][impact-1] = details['risk_score']
    risk_positions[risk_name] = (likelihood-1, impact-1)

# Plot heatmap
im = ax.imshow(heatmap_data, cmap='RdYlGn_r', interpolation='nearest', origin='lower')
ax.set_xticks(range(5))
ax.set_yticks(range(5))
ax.set_xticklabels(['1', '2', '3', '4', '5'])
ax.set_yticklabels(['1', '2', '3', '4', '5'])
ax.set_xlabel('Impact')
ax.set_ylabel('Likelihood')
ax.set_title('DeFi Risk Heatmap')

# Add annotations
for risk_name, (i, j) in risk_positions.items():
    score = heatmap_data[i][j]
    ax.text(j, i, f"{risk_name[:4]}\n{score:.0f}", 
            ha='center', va='center', fontsize=8, color='black' if score < 15 else 'white')

plt.colorbar(im, label='Risk Score')
plt.tight_layout()
plt.savefig('defi_risk_heatmap.png', dpi=300, bbox_inches='tight')
plt.show()
print("Risk heatmap saved as 'defi_risk_heatmap.png'")

# ----------------------------------------------------------------
# PART C: MITIGATION STRATEGIES
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Risk Mitigation Strategies")
print("-"*60)

mitigation_data = {
    'Risk': ['Smart Contract Bug', 'Oracle Manipulation', 'Price Volatility', 'Governance Attack', 'Front-running'],
    'Mitigation': [
        'Multiple audits, formal verification, bug bounties',
        'Multiple oracles, TWAP, circuit breakers',
        'Stablecoin pegs, diversification, position limits',
        'Time-locks, multi-sig, quorum requirements',
        'Private mempools, commit-reveal mechanisms'
    ],
    'Effectiveness': ['High', 'High', 'Medium', 'High', 'Medium']
}

mitigation_df = pd.DataFrame(mitigation_data)
print(mitigation_df.to_string(index=False))

# ----------------------------------------------------------------
# PART D: INSURANCE COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: DeFi Insurance Comparison")
print("-"*60)

insurance_data = {
    'Provider': ['Nexus Mutual', 'InsurAce', 'Unslashed', 'EulerInsure', 'Lloyd\'s'],
    'Coverage Type': ['Smart Contract', 'Multi-Protocol', 'Protocol-Specific', 'Parametric', 'Custody'],
    'Premium Model': ['Mutual', 'Premium', 'Premium', 'Parametric', 'Premium'],
    'Coverage Limit': ['$10M+', '$10M+', '$5M+', '$10M+', '$100M+'],
    'Trust Model': ['Community', 'Protocol', 'Protocol', 'Protocol', 'Institutional']
}

insurance_df = pd.DataFrame(insurance_data)
print(insurance_df.to_string(index=False))

# ----------------------------------------------------------------
# PART E: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

print("\n" + "="*70)
print("PART E: Summary and Recommendations")
print("="*70)

print("""
DeFi Risk and Security – Key Takeaways:

1. DeFi risks: market, technical, operational, regulatory.
2. Major incidents: smart contract bugs, oracle manipulation, key compromise, governance attacks.
3. Root causes: 45% smart contract bugs, 15% oracle manipulation.
4. Risk management: identification → assessment → mitigation → monitoring.
5. Mitigation: audits, formal verification, bug bounties, multi-sig, time-locks.
6. Insurance: Nexus Mutual, InsurAce, Unslashed, EulerInsure, Lloyd's.
7. Best practices: multiple audits, decentralised oracles, emergency stop, continuous monitoring.

Recommendations:
  - Conduct comprehensive risk assessments.
  - Implement multiple layers of security.
  - Use decentralised oracles with multiple sources.
  - Consider formal verification for critical logic.
  - Obtain insurance coverage.
  - Monitor contracts continuously.
  - Have an incident response plan.
  - Engage the community in risk management.
""")