┌─────────────────────────────────────────────────────────────────────────────┐
│                    THE INTEROPERABILITY PROBLEM                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  CURRENT STATE: SILOS                                                      │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                                                                     │   │
│  │   Ethereum  ← →  [No native comms]  ← →  Solana                    │   │
│  │      │                                │                             │   │
│  │      │                                │                             │   │
│  │      v                                v                             │   │
│  │   Polygon  ← →  [No native comms]  ← →  Avalanche                  │   │
│  │                                                                     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  DESIRED STATE: INTEROPERABLE ECOSYSTEM                                    │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                                                                     │   │
│  │   Ethereum  ←──────────────────→  Solana                           │   │
│  │      │                                │                             │   │
│  │      │                                │                             │   │
│  │      v                                v                             │   │
│  │   Polygon  ←──────────────────→  Avalanche                         │   │
│  │                                                                     │   │
│  │   All chains can communicate and transfer value/data                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    BRIDGE ARCHITECTURE                                      │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Source Chain (e.g., Ethereum)                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │  User locks 1 ETH in bridge contract                               │   │
│  │  │                                                                  │   │
│  │  v                                                                  │   │
│  │  Bridge contract emits lock event                                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BRIDGE VALIDATORS                                │   │
│  │  • Monitor lock events                                              │   │
│  │  • Validate transactions                                            │   │
│  │  • Sign messages                                                   │   │
│  │  • Relay to destination chain                                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  Destination Chain (e.g., Polygon)                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │  User receives 1 bridged ETH (wETH) on destination                 │   │
│  │  │                                                                  │   │
│  │  v                                                                  │   │
│  │  Bridge contract mints or unlocks wrapped token                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 9, LESSON 6: CROSS-CHAIN INTEROPERABILITY AND BRIDGES
# ===================================================================

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

print("="*70)
print("CROSS-CHAIN INTEROPERABILITY AND BRIDGES")
print("="*70)

# ----------------------------------------------------------------
# PART A: BRIDGE SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Cross-Chain Bridge Simulation")
print("-"*60)

class Blockchain:
    """
    Simulated blockchain for bridge testing.
    """
    def __init__(self, name: str):
        self.name = name
        self.balances: Dict[str, float] = {}
        self.transactions = []
    
    def add_account(self, address: str, balance: float):
        self.balances[address] = balance
    
    def get_balance(self, address: str) -> float:
        return self.balances.get(address, 0)
    
    def transfer(self, sender: str, recipient: str, amount: float) -> bool:
        if self.balances.get(sender, 0) < amount:
            print(f"  Insufficient balance on {self.name}")
            return False
        self.balances[sender] -= amount
        self.balances[recipient] = self.balances.get(recipient, 0) + amount
        tx_id = hashlib.sha256(f"{sender}{recipient}{amount}{time.time()}".encode()).hexdigest()[:8]
        self.transactions.append({
            'id': tx_id,
            'from': sender,
            'to': recipient,
            'amount': amount,
            'chain': self.name
        })
        return True
    
    def get_transaction(self, tx_id: str) -> Dict:
        for tx in self.transactions:
            if tx['id'] == tx_id:
                return tx
        return None

class Bridge:
    """
    Simulated cross-chain bridge.
    """
    def __init__(self, name: str, chain_a: Blockchain, chain_b: Blockchain):
        self.name = name
        self.chain_a = chain_a
        self.chain_b = chain_b
        self.locked_tokens: Dict[str, Dict] = {}
        self.validators = ['Validator1', 'Validator2', 'Validator3']
        self.validator_threshold = 2
    
    def bridge_transfer(self, user: str, from_chain: str, to_chain: str, amount: float) -> Dict:
        """Bridge assets from one chain to another."""
        if from_chain == self.chain_a.name:
            source_chain = self.chain_a
            dest_chain = self.chain_b
        elif from_chain == self.chain_b.name:
            source_chain = self.chain_b
            dest_chain = self.chain_a
        else:
            return {'error': 'Invalid chain'}
        
        # Lock tokens on source chain
        if not source_chain.transfer(user, 'bridge', amount):
            return {'error': 'Transfer failed'}
        
        # Record lock
        lock_id = hashlib.sha256(f"{user}{from_chain}{to_chain}{amount}{time.time()}".encode()).hexdigest()[:8]
        self.locked_tokens[lock_id] = {
            'user': user,
            'from_chain': from_chain,
            'to_chain': to_chain,
            'amount': amount,
            'status': 'locked'
        }
        print(f"Locked {amount} on {from_chain}")
        
        # Simulate validation
        validators_signed = random.randint(1, len(self.validators))
        if validators_signed < self.validator_threshold:
            self.locked_tokens[lock_id]['status'] = 'failed'
            return {'error': 'Insufficient validators'}
        
        # Mint on destination chain
        wrapped_symbol = f"w{source_chain.name[:3]}"
        dest_chain.add_account(user, dest_chain.get_balance(user) + amount)
        
        self.locked_tokens[lock_id]['status'] = 'completed'
        print(f"Minted {amount} on {to_chain}")
        
        return {
            'success': True,
            'lock_id': lock_id,
            'amount': amount,
            'from_chain': from_chain,
            'to_chain': to_chain
        }
    
    def get_bridge_metrics(self) -> Dict:
        total_locked = sum(data['amount'] for data in self.locked_tokens.values() if data['status'] == 'locked')
        total_completed = sum(data['amount'] for data in self.locked_tokens.values() if data['status'] == 'completed')
        return {
            'total_locked': total_locked,
            'total_completed': total_completed,
            'active_locks': len([d for d in self.locked_tokens.values() if d['status'] == 'locked'])
        }

# Create blockchains
eth = Blockchain("Ethereum")
polygon = Blockchain("Polygon")

# Add accounts
eth.add_account('Alice', 100)
eth.add_account('Bob', 50)
polygon.add_account('Alice', 0)
polygon.add_account('Bob', 0)

print("Bridge Simulation:")
print(f"Alice: ETH={eth.get_balance('Alice')}, Polygon={polygon.get_balance('Alice')}")

# Create bridge
bridge = Bridge("ETH-Polygon Bridge", eth, polygon)

# Transfer assets
print("\nTransferring assets across chains...")
result = bridge.bridge_transfer('Alice', 'Ethereum', 'Polygon', 30)
if result.get('success'):
    print(f"✅ Transfer successful: {result['amount']} from {result['from_chain']} to {result['to_chain']}")

print(f"\nAlice: ETH={eth.get_balance('Alice')}, Polygon={polygon.get_balance('Alice')}")

# Transfer back
print("\nTransferring back...")
result2 = bridge.bridge_transfer('Alice', 'Polygon', 'Ethereum', 20)
if result2.get('success'):
    print(f"✅ Transfer successful: {result2['amount']} from {result2['from_chain']} to {result2['to_chain']}")

print(f"\nAlice: ETH={eth.get_balance('Alice')}, Polygon={polygon.get_balance('Alice')}")

# Bridge metrics
metrics = bridge.get_bridge_metrics()
print(f"\nBridge Metrics:")
print(f"  Total Locked: {metrics['total_locked']}")
print(f"  Total Completed: {metrics['total_completed']}")
print(f"  Active Locks: {metrics['active_locks']}")

# ----------------------------------------------------------------
# PART B: BRIDGE TYPE COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Bridge Type Comparison")
print("-"*60)

bridge_types = {
    'Type': ['Trusted (Centralised)', 'Trustless (Decentralised)', 'Light Client', 'Oracle-Based', 'State Proof'],
    'Security': ['Low-Medium', 'Medium-High', 'High', 'Medium', 'High'],
    'Cost': ['Low', 'Medium', 'High', 'Medium', 'High'],
    'Speed': ['Fast', 'Medium', 'Slow', 'Fast', 'Medium'],
    'Trust Assumptions': ['High', 'Low', 'Low', 'Medium', 'Low'],
    'Examples': ['Binance Bridge', 'Across', 'Rainbow Bridge', 'Wormhole', 'IBC']
}

bridge_df = pd.DataFrame(bridge_types)
print(bridge_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: INTEROPERABILITY PROTOCOL COMPARISON
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Interoperability Protocol Comparison")
print("-"*60)

protocol_data = {
    'Protocol': ['IBC', 'XCMP', 'LayerZero', 'Wormhole', 'Axelar'],
    'Security Model': ['Light Client', 'Relay Chain', 'Oracle+Relayer', 'Guardian', 'Validator'],
    'Trust Assumptions': ['Low', 'Low', 'Medium', 'Medium', 'Medium'],
    'Latency': ['Low', 'Low', 'Medium', 'Medium', 'Medium'],
    'Messaging': ['Yes', 'Yes', 'Yes', 'Limited', 'Yes']
}

protocol_df = pd.DataFrame(protocol_data)
print(protocol_df.to_string(index=False))

# ----------------------------------------------------------------
# PART D: BRIDGE SECURITY CHECKLIST
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Bridge Security Checklist")
print("-"*60)

bridge_security = {
    "Smart Contract Security": [
        "Multiple independent audits",
        "Formal verification of critical functions",
        "Bug bounty program active",
        "Emergency stop/pause functionality"
    ],
    "Validator Security": [
        "Decentralised validator set",
        "Threshold signatures (m-of-n)",
        "Validator slashing mechanisms",
        "Regular validator rotation"
    ],
    "Operational Security": [
        "Real-time monitoring",
        "Incident response plan",
        "Regular security reviews",
        "Multi-sig for critical operations"
    ],
    "User Protection": [
        "Rate limits",
        "Transaction timeouts",
        "Clear documentation",
        "Insurance coverage"
    ]
}

for category, items in bridge_security.items():
    print(f"\n{category.upper()}:")
    for item in items:
        print(f"  □ {item}")

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

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

print("""
Cross-Chain Interoperability and Bridges – Key Takeaways:

1. Interoperability enables asset transfer, liquidity aggregation, and composability across chains.
2. Bridge types: trusted (centralised), trustless (decentralised), light client, oracle-based, state proof.
3. Key bridges: Wormhole, LayerZero, Axelar, Across, IBC, XCMP.
4. Security risks: validator collusion, smart contract bugs, oracle manipulation, replay attacks.
5. Major incidents: Wormhole ($320M), Ronin ($625M), Nomad ($190M).
6. Mitigation: multiple audits, formal verification, decentralised validators, multi-sig, monitoring.

Recommendations:
  - Use established bridges with proven security.
  - Diversify bridge usage to reduce risk.
  - Monitor bridge activity for anomalies.
  - Understand bridge security assumptions.
  - Consider insurance for large transfers.
  - Stay updated on bridge developments.
""")