┌─────────────────────────────────────────────────────────────────────────────┐
│                    CURRENT STATE: SILOS                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌───────────────┐   ┌───────────────┐   ┌───────────────┐               │
│  │   Ethereum    │   │   Solana      │   │   Avalanche   │               │
│  │               │   │               │   │               │               │
│  │  DeFi, DApps  │   │  High-speed   │   │  Subnets     │               │
│  └───────────────┘   └───────────────┘   └───────────────┘               │
│        │                     │                     │                       │
│        └──────────┬──────────┘                     │                       │
│                   │                                │                       │
│                   v                                v                       │
│           ┌───────────────┐               ┌───────────────┐              │
│           │   No native   │               │   No native   │              │
│           │communication  │               │communication  │              │
│           └───────────────┘               └───────────────┘              │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    TOKEN BRIDGE FLOW                                        │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Source Chain (e.g., Ethereum)                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │  User locks 1 ETH in bridge contract                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │  Bridge validators confirm lock                                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  Destination Chain (e.g., Polygon)                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │  Bridge mints 1 bridged ETH (wETH) on destination                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │  User receives wETH, can use in destination ecosystem             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 1, LESSON 7: INTEROPERABILITY AND CROSS-CHAIN TECHNOLOGY
# ===================================================================

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

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

# ----------------------------------------------------------------
# PART A: SIMPLE TOKEN BRIDGE SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Simple Token Bridge Simulation")
print("-"*60)

class Chain:
    def __init__(self, name: str):
        self.name = name
        self.balances: Dict[str, int] = {}
        self.tokens: Dict[str, int] = {}  # token symbol -> total supply
    
    def add_token(self, symbol: str, total_supply: int, initial_holder: str):
        self.tokens[symbol] = total_supply
        self.balances[initial_holder] = self.balances.get(initial_holder, 0) + total_supply
        print(f"{self.name}: Added {total_supply} {symbol} to {initial_holder}")
    
    def transfer(self, sender: str, recipient: str, amount: int, token: str = "ETH") -> bool:
        if token not in self.tokens:
            print(f"Token {token} not on {self.name}")
            return False
        if self.balances.get(sender, 0) < amount:
            print(f"Insufficient balance for {sender}")
            return False
        self.balances[sender] -= amount
        self.balances[recipient] = self.balances.get(recipient, 0) + amount
        return True
    
    def get_balance(self, address: str, token: str = "ETH") -> int:
        if token not in self.tokens:
            return 0
        return self.balances.get(address, 0)

class Bridge:
    def __init__(self, chain_a: Chain, chain_b: Chain):
        self.chain_a = chain_a
        self.chain_b = chain_b
        self.locked_tokens: Dict[str, int] = {}  # address -> amount locked on chain A
        self.minted_tokens: Dict[str, int] = {}  # address -> amount minted on chain B
        self.events = []
    
    def deposit(self, user: str, amount: int, token: str = "ETH") -> bool:
        # Lock on chain A, mint on chain B
        if self.chain_a.balances.get(user, 0) < amount:
            print("Insufficient balance on chain A")
            return False
        # Lock tokens on chain A
        self.chain_a.balances[user] -= amount
        self.locked_tokens[user] = self.locked_tokens.get(user, 0) + amount
        
        # Mint wrapped tokens on chain B
        wrapped_symbol = f"w{token}"  # e.g., wETH
        if wrapped_symbol not in self.chain_b.tokens:
            self.chain_b.tokens[wrapped_symbol] = 0
        self.chain_b.balances[user] = self.chain_b.balances.get(user, 0) + amount
        self.chain_b.tokens[wrapped_symbol] += amount
        
        self.events.append({
            'type': 'deposit',
            'user': user,
            'amount': amount,
            'chain_a': self.chain_a.name,
            'chain_b': self.chain_b.name
        })
        print(f"Deposited {amount} {token} on {self.chain_a.name}, minted {amount} {wrapped_symbol} on {self.chain_b.name}")
        return True
    
    def withdraw(self, user: str, amount: int, token: str = "ETH"):
        wrapped_symbol = f"w{token}"
        if self.chain_b.balances.get(user, 0) < amount:
            print("Insufficient wrapped balance on chain B")
            return False
        # Burn wrapped tokens on chain B
        self.chain_b.balances[user] -= amount
        self.chain_b.tokens[wrapped_symbol] -= amount
        
        # Unlock tokens on chain A
        if self.locked_tokens.get(user, 0) < amount:
            print("Bridge doesn't have enough locked tokens")
            return False
        self.locked_tokens[user] -= amount
        self.chain_a.balances[user] = self.chain_a.balances.get(user, 0) + amount
        
        self.events.append({
            'type': 'withdraw',
            'user': user,
            'amount': amount,
            'chain_a': self.chain_a.name,
            'chain_b': self.chain_b.name
        })
        print(f"Withdrew {amount} {token} from {self.chain_b.name}, unlocked on {self.chain_a.name}")
        return True

# Create chains
eth = Chain("Ethereum")
polygon = Chain("Polygon")

# Add native tokens
eth.add_token("ETH", 1000, "Alice")
polygon.add_token("MATIC", 2000, "Bob")

# Create bridge
bridge = Bridge(eth, polygon)

# Initial balances
print("\nInitial balances:")
print(f"Alice on Ethereum: {eth.balances.get('Alice', 0)} ETH")
print(f"Bob on Polygon: {polygon.balances.get('Bob', 0)} MATIC")

# Bridge deposit
bridge.deposit("Alice", 100, "ETH")
print(f"After deposit: Alice on Polygon has {polygon.balances.get('Alice', 0)} wETH")
print(f"Locked in bridge: {bridge.locked_tokens.get('Alice', 0)}")

# Withdraw
bridge.withdraw("Alice", 50, "ETH")
print(f"After withdrawal: Alice on Ethereum has {eth.balances.get('Alice', 0)} ETH")

# ----------------------------------------------------------------
# PART B: ATOMIC SWAP SIMULATION (HTLC)
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Atomic Swap (HTLC) Simulation")
print("-"*60)

class HTLC:
    def __init__(self, owner: str, counterparty: str, amount: int, hashlock: str, timelock: int):
        self.owner = owner
        self.counterparty = counterparty
        self.amount = amount
        self.hashlock = hashlock
        self.timelock = timelock
        self.secret = None
        self.refunded = False
        self.claimed = False
    
    def claim(self, secret: str, from_addr: str) -> bool:
        if self.claimed or self.refunded:
            print("Already claimed or refunded.")
            return False
        if from_addr != self.counterparty:
            print("Only counterparty can claim.")
            return False
        if hashlib.sha256(secret.encode()).hexdigest() != self.hashlock:
            print("Invalid secret.")
            return False
        self.secret = secret
        self.claimed = True
        print(f"Claim successful! Secret: {secret}")
        return True
    
    def refund(self, from_addr: str) -> bool:
        if self.claimed:
            print("Already claimed, cannot refund.")
            return False
        if from_addr != self.owner:
            print("Only owner can refund.")
            return False
        # Check timelock
        if time.time() < self.timelock:
            print("Timelock not expired yet.")
            return False
        self.refunded = True
        print("Refund successful.")
        return True

# Simulate atomic swap
alice_secret = "secret123"
hashlock = hashlib.sha256(alice_secret.encode()).hexdigest()
timelock = int(time.time()) + 10  # 10 seconds from now

alice_contract = HTLC("Alice", "Bob", 10, hashlock, timelock)

print("Alice creates HTLC: lock 10 BTC, Bob must provide secret to claim.")

# Simulate Bob claims
print("\nBob tries to claim with wrong secret:")
alice_contract.claim("wrong_secret", "Bob")

print("\nBob tries to claim with correct secret:")
alice_contract.claim(alice_secret, "Bob")

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

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

interop_compare = pd.DataFrame({
    'Protocol': ['Cosmos (IBC)', 'Polkadot (XCMP)', 'LayerZero', 'Chainlink CCIP', 'Wormhole'],
    'Trust Model': ['Trustless (light clients)', 'Trustless (Relay Chain)', 'Trustless (oracles)', 'Decentralised Oracles', 'Validator set'],
    'Message Type': ['Token + Data', 'Arbitrary', 'Arbitrary', 'Token + Data', 'Token + Data'],
    'Supported Chains': ['Cosmos SDK', 'Polkadot parachains', 'Many', 'EVM + others', 'Many'],
    'Security': ['High', 'High', 'Medium', 'High', 'Medium (hacks)'],
    'Complexity': ['High', 'High', 'Medium', 'Medium', 'Medium']
})

print(interop_compare.to_string(index=False))

# ----------------------------------------------------------------
# PART D: ORACLE SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Oracle Data Feed Simulation")
print("-"*60)

class Oracle:
    def __init__(self, sources: List[str]):
        self.sources = sources
        self.price_data = {}
    
    def fetch_price(self, pair: str) -> float:
        # Simulate fetching from multiple sources
        prices = [random.uniform(1800, 2000) for _ in self.sources]  # ETH/USD
        # Average with some noise
        avg = sum(prices) / len(prices)
        self.price_data[pair] = avg
        print(f"Oracle fetched {pair} price: {avg:.2f} from {len(self.sources)} sources")
        return avg
    
    def get_aggregated_price(self, pair: str) -> float:
        if pair not in self.price_data:
            return self.fetch_price(pair)
        return self.price_data[pair]

oracle = Oracle(["Chainlink", "CoinGecko", "Binance"])
price = oracle.get_aggregated_price("ETH/USD")
print(f"Aggregated ETH/USD price: {price:.2f}")

# ----------------------------------------------------------------
# PART E: CROSS-CHAIN ATTACK ANALYSIS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Cross-Chain Attack Surface Analysis")
print("-"*60)

attacks = {
    "Bridge Exploit": {
        "Description": "Attacker finds vulnerability in bridge smart contract.",
        "Examples": ["Wormhole ($320M)", "Ronin ($625M)"],
        "Mitigation": "Audits, multi-sig, time locks, validator diversity."
    },
    "Validator Collusion": {
        "Description": "Validators of a bridge collude to steal locked funds.",
        "Examples": ["Any multisig bridge with too few validators"],
        "Mitigation": "Threshold signatures, decentralised set, economic slashing."
    },
    "Oracle Manipulation": {
        "Description": "Attacker manipulates oracle price to get arbitrage.",
        "Examples": ["Lending liquidations"],
        "Mitigation": "Use multiple oracles, TWAP, circuit breakers."
    },
    "Replay Attack": {
        "Description": "Transaction replayed on another chain.",
        "Examples": ["Ethereum Classic replay after hard fork"],
        "Mitigation": "Chain-specific transaction signing (e.g., chain ID)."
    }
}

for attack, details in attacks.items():
    print(f"\n{attack.upper()}:")
    print(f"  {details['Description']}")
    print(f"  Examples: {', '.join(details['Examples'])}")
    print(f"  Mitigation: {details['Mitigation']}")

# ----------------------------------------------------------------
# PART F: INTEROPERABILITY METRICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Interoperability Metrics Dashboard")
print("-"*60)

metrics = pd.DataFrame({
    'Metric': [
        'Number of Bridges',
        'Total Value Locked (TVL) in Bridges',
        'Cross-chain Transaction Volume (daily)',
        'Bridge Hacks (cumulative losses)',
        'Interoperability Protocol Adoption',
        'Average Bridge Fee'
    ],
    'Value (Estimate)': [
        '50+',
        '$20B+',
        '$2B+',
        '$2.5B+',
        'Growing rapidly',
        '0.05-0.5%'
    ]
})

print(metrics.to_string(index=False))

# Visualise cross-chain activity
fig, ax = plt.subplots(figsize=(10, 4))
chains = ['Ethereum', 'Polygon', 'Arbitrum', 'Optimism', 'Avalanche']
volume = [500, 200, 150, 100, 80]  # in millions
ax.bar(chains, volume, color='purple', alpha=0.7)
ax.set_ylabel('Daily Volume ($M)')
ax.set_title('Cross-chain Bridge Volume by Chain')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('cross_chain_volume.png', dpi=300, bbox_inches='tight')
plt.show()
print("Cross-chain volume chart saved as 'cross_chain_volume.png'")

# ----------------------------------------------------------------
# PART G: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

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

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

1. Interoperability allows blockchains to communicate and share value.
2. Bridges enable token transfer between chains; types: centralised, decentralised, trustless.
3. Atomic swaps use HTLCs for trustless exchange.
4. Major protocols: Cosmos IBC, Polkadot XCMP, LayerZero, Chainlink CCIP.
5. Oracles provide off-chain data essential for cross-chain operations.
6. Security risks: bridge hacks, validator collusion, oracle manipulation.
7. Interoperability is critical for the multi-chain future.

Recommendations:
  - Evaluate bridge security before using (audits, reputation).
  - Use well-known, battle-tested bridges.
  - Understand the trust model of each cross-chain protocol.
  - Consider layer-0 protocols for long-term interoperability.
  - Stay updated on evolving standards (e.g., xERC20).
""")