# ===================================================================
# MODULE 7, LESSON 5: WEB3 AND DECENTRALISED IDENTITY
# ===================================================================

import hashlib
import json
import time
from dataclasses import dataclass
from typing import Dict, List, Optional
import random
import base64
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("WEB3, DECENTRALISED IDENTITY, AND THE METAVERSE ECONOMY")
print("="*70)

# ----------------------------------------------------------------
# PART A: SIMULATED DECENTRALISED IDENTITY (DID) SYSTEM
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Decentralised Identity (DID) Simulation")
print("-"*60)

class CryptoUtils:
    """Cryptographic utilities for DID operations."""
    
    @staticmethod
    def generate_key_pair():
        """Generate RSA key pair."""
        private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=2048
        )
        public_key = private_key.public_key()
        return private_key, public_key
    
    @staticmethod
    def sign_data(private_key, data):
        """Sign data with private key."""
        signature = private_key.sign(
            data.encode(),
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
        return base64.b64encode(signature).decode()
    
    @staticmethod
    def verify_signature(public_key, data, signature):
        """Verify signature with public key."""
        try:
            public_key.verify(
                base64.b64decode(signature),
                data.encode(),
                padding.PSS(
                    mgf=padding.MGF1(hashes.SHA256()),
                    salt_length=padding.PSS.MAX_LENGTH
                ),
                hashes.SHA256()
            )
            return True
        except Exception:
            return False
    
    @staticmethod
    def hash_data(data):
        """Hash data using SHA-256."""
        return hashlib.sha256(data.encode()).hexdigest()

class DIDRegistry:
    """Simulated DID registry on a blockchain."""
    
    def __init__(self):
        self.registry = {}  # DID -> public_key
        self.history = []  # Transaction history
    
    def register(self, did: str, public_key):
        """Register a DID with its public key."""
        self.registry[did] = public_key
        self.history.append({
            'type': 'register',
            'did': did,
            'timestamp': time.time()
        })
        return True
    
    def lookup(self, did: str):
        """Look up a DID's public key."""
        return self.registry.get(did)
    
    def verify_did(self, did: str, data: str, signature: str):
        """Verify a signature using the DID's registered public key."""
        public_key = self.lookup(did)
        if not public_key:
            return False
        return CryptoUtils.verify_signature(public_key, data, signature)

class Issuer:
    """An entity that issues verifiable credentials."""
    
    def __init__(self, name: str, did: str, private_key):
        self.name = name
        self.did = did
        self.private_key = private_key
    
    def issue_credential(self, subject_did: str, claims: Dict, expiry: int = 86400):
        """
        Issue a verifiable credential to a subject.
        """
        credential = {
            'issuer': self.did,
            'subject': subject_did,
            'claims': claims,
            'issued': time.time(),
            'expiry': time.time() + expiry,
            'id': f"cred_{hashlib.md5(str(claims).encode()).hexdigest()[:8]}"
        }
        
        # Sign the credential
        credential_json = json.dumps(credential, sort_keys=True)
        credential['signature'] = CryptoUtils.sign_data(
            self.private_key,
            credential_json
        )
        
        return credential

class DIDHolder:
    """A user who holds a decentralised identity."""
    
    def __init__(self, name: str):
        self.name = name
        self.private_key, self.public_key = CryptoUtils.generate_key_pair()
        self.did = f"did:example:{hashlib.sha256(str(self.public_key).encode()).hexdigest()[:16]}"
        self.credentials = []
    
    def register(self, registry: DIDRegistry):
        """Register DID with the registry."""
        registry.register(self.did, self.public_key)
        return self.did
    
    def receive_credential(self, credential: Dict):
        """Receive and store a verifiable credential."""
        self.credentials.append(credential)
    
    def create_presentation(self, registry: DIDRegistry, credential_id: str):
        """
        Create a verifiable presentation from a credential.
        """
        # Find the credential
        credential = None
        for cred in self.credentials:
            if cred.get('id') == credential_id:
                credential = cred
                break
        
        if not credential:
            return None
        
        # Create presentation
        presentation = {
            'credential': credential,
            'holder': self.did,
            'timestamp': time.time()
        }
        
        # Sign the presentation
        presentation_json = json.dumps(presentation, sort_keys=True)
        presentation['signature'] = CryptoUtils.sign_data(
            self.private_key,
            presentation_json
        )
        
        return presentation

class Verifier:
    """An entity that verifies credentials."""
    
    def __init__(self, name: str):
        self.name = name
    
    def verify_presentation(self, registry: DIDRegistry, presentation: Dict):
        """
        Verify a verifiable presentation.
        """
        # Check if presentation is properly formed
        if 'credential' not in presentation or 'holder' not in presentation:
            return False, "Invalid presentation format"
        
        credential = presentation['credential']
        holder_did = presentation['holder']
        signature = presentation.get('signature')
        
        # Verify the presentation signature
        if not signature:
            return False, "No signature"
        
        # Verify holder's signature
        presentation_json = json.dumps({
            'credential': credential,
            'holder': holder_did,
            'timestamp': presentation['timestamp']
        }, sort_keys=True)
        
        if not registry.verify_did(holder_did, presentation_json, signature):
            return False, "Invalid presentation signature"
        
        # Verify credential signature
        if 'signature' not in credential:
            return False, "Credential not signed"
        
        credential_sig = credential.pop('signature')
        credential_json = json.dumps(credential, sort_keys=True)
        credential['signature'] = credential_sig
        
        issuer_did = credential['issuer']
        if not registry.verify_did(issuer_did, credential_json, credential_sig):
            return False, "Invalid credential signature"
        
        # Check expiry
        if credential.get('expiry', 0) < time.time():
            return False, "Credential expired"
        
        # Verify claims
        claims = credential.get('claims', {})
        
        return True, claims

# Simulate the DID ecosystem
print("\nSimulating Decentralised Identity Ecosystem...")

# 1. Create DID registry
registry = DIDRegistry()
print(f"DID Registry created.")

# 2. Create issuer (bank)
bank_private, bank_public = CryptoUtils.generate_key_pair()
bank = Issuer("National Bank", "did:example:bank123", bank_private)
print(f"Bank DID: {bank.did}")

# 3. Create user (customer)
alice = DIDHolder("Alice")
alice_did = alice.register(registry)
print(f"Alice DID: {alice_did}")

# 4. Issue credential
credential = bank.issue_credential(
    subject_did=alice_did,
    claims={
        'name': 'Alice Smith',
        'income': 75000,
        'credit_score': 720,
        'verified': True,
        'kyc_status': 'approved'
    }
)
alice.receive_credential(credential)
print(f"Credential issued: {credential['id']}")

# 5. Create presentation
presentation = alice.create_presentation(registry, credential['id'])
print(f"Presentation created.")

# 6. Verify presentation
verifier = Verifier("Loan Provider")
is_valid, result = verifier.verify_presentation(registry, presentation)

print(f"\nVerification Result: {'✅ VALID' if is_valid else '❌ INVALID'}")
if is_valid:
    print(f"Verified Claims: {json.dumps(result, indent=2)}")

# ----------------------------------------------------------------
# PART B: ZERO-KNOWLEDGE PROOF SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Zero-Knowledge Proof Simulation")
print("-"*60)

class ZKProofSimulator:
    """
    Simulate zero-knowledge proofs for financial claims.
    """
    
    @staticmethod
    def prove_age_over_18(date_of_birth):
        """Prove age > 18 without revealing exact birthdate."""
        # In a real ZKP, this would use cryptographic protocols.
        # Here we simulate the concept.
        from datetime import datetime
        dob = datetime.strptime(date_of_birth, "%Y-%m-%d")
        age = (datetime.now() - dob).days / 365.25
        return age >= 18, age
    
    @staticmethod
    def prove_income_threshold(income, threshold=50000):
        """Prove income > threshold without revealing exact income."""
        return income >= threshold, income >= threshold
    
    @staticmethod
    def prove_credit_score_above(score, threshold=650):
        """Prove credit score above threshold without revealing exact score."""
        return score >= threshold, score >= threshold

# Simulate ZKP for loan application
print("\nLoan Application with Zero-Knowledge Proofs:")

# Alice's actual data
alice_age = 32
alice_income = 75000
alice_credit_score = 720

# Prove to the bank without revealing exact values
age_ok, _ = ZKProofSimulator.prove_age_over_18("1992-05-15")
income_ok, _ = ZKProofSimulator.prove_income_threshold(alice_income, 50000)
score_ok, _ = ZKProofSimulator.prove_credit_score_above(alice_credit_score, 680)

print(f"Alice's Proofs:")
print(f"  Age > 18: {age_ok} (without revealing exact age)")
print(f"  Income > $50,000: {income_ok} (without revealing exact income)")
print(f"  Credit Score > 680: {score_ok} (without revealing exact score)")
print("\n✅ Bank approved loan application based on zero-knowledge proofs.")
print("Alice's privacy is preserved – the bank only knows that she meets the criteria, not her exact personal data.")

# ----------------------------------------------------------------
# PART C: NFT AND DIGITAL ASSET SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: NFT and Digital Asset Simulation")
print("-"*60)

class NFT:
    """Simulated Non-Fungible Token."""
    
    def __init__(self, token_id, name, metadata, owner):
        self.token_id = token_id
        self.name = name
        self.metadata = metadata
        self.owner = owner
        self.created = time.time()
        self.transfer_history = []
    
    def transfer(self, new_owner):
        """Transfer NFT to a new owner."""
        self.transfer_history.append({
            'from': self.owner,
            'to': new_owner,
            'timestamp': time.time()
        })
        self.owner = new_owner
    
    def to_dict(self):
        return {
            'token_id': self.token_id,
            'name': self.name,
            'metadata': self.metadata,
            'owner': self.owner,
            'created': self.created
        }

# Create NFTs
nfts = [
    NFT(
        token_id=f"NFT_{i+1}",
        name=f"Financial Art #{i+1}",
        metadata={
            'artist': 'AI Financial',
            'description': 'A digital representation of financial markets',
            'attributes': {
                'risk_level': random.choice(['Low', 'Medium', 'High']),
                'sector': random.choice(['Tech', 'Finance', 'Energy', 'Healthcare']),
                'rarity': random.choice(['Common', 'Rare', 'Epic', 'Legendary'])
            }
        },
        owner='Alice'
    ) for i in range(5)
]

print("Created 5 NFTs:")
for nft in nfts:
    print(f"  {nft.token_id}: {nft.name} (Owner: {nft.owner})")

# Transfer an NFT
nfts[0].transfer('Bob')
print(f"\nNFT {nfts[0].token_id} transferred to Bob.")
print(f"  Transfer history: {len(nfts[0].transfer_history)} transactions")

# ----------------------------------------------------------------
# PART D: SIMULATED METAVERSE BANKING
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Simulated Metaverse Banking")
print("-"*60)

class MetaverseBank:
    """A virtual bank operating in the metaverse."""
    
    def __init__(self, name):
        self.name = name
        self.virtual_assets = {}
        self.customer_balances = {}
        self.nft_collections = {}
    
    def open_account(self, customer_id, initial_deposit=0):
        """Open a virtual bank account."""
        self.customer_balances[customer_id] = initial_deposit
        return f"Account opened for {customer_id}"
    
    def deposit(self, customer_id, amount):
        """Deposit virtual currency."""
        if customer_id in self.customer_balances:
            self.customer_balances[customer_id] += amount
            return True
        return False
    
    def withdraw(self, customer_id, amount):
        """Withdraw virtual currency."""
        if customer_id in self.customer_balances:
            if self.customer_balances[customer_id] >= amount:
                self.customer_balances[customer_id] -= amount
                return True
        return False
    
    def purchase_virtual_asset(self, customer_id, asset_name, price):
        """Purchase a virtual asset (e.g., virtual real estate)."""
        if customer_id in self.customer_balances:
            if self.customer_balances[customer_id] >= price:
                self.customer_balances[customer_id] -= price
                if customer_id not in self.virtual_assets:
                    self.virtual_assets[customer_id] = []
                self.virtual_assets[customer_id].append({
                    'asset': asset_name,
                    'purchase_price': price,
                    'timestamp': time.time()
                })
                return True
        return False
    
    def mint_nft(self, customer_id, nft_metadata):
        """Mint a new NFT for a customer."""
        nft_id = f"NFT_{len(self.nft_collections) + 1}"
        if customer_id not in self.nft_collections:
            self.nft_collections[customer_id] = []
        self.nft_collections[customer_id].append({
            'id': nft_id,
            'metadata': nft_metadata,
            'minted': time.time()
        })
        return nft_id

# Create metaverse bank
meta_bank = MetaverseBank("MetaBank")

# Simulate customers
customers = ['Alice', 'Bob', 'Charlie', 'Diana']

for customer in customers:
    meta_bank.open_account(customer, 1000)  # 1000 virtual currency

print("Metaverse Bank opened. Customers and initial balances:")
for customer in customers:
    print(f"  {customer}: ${meta_bank.customer_balances[customer]}")
print()

# Simulate activities
print("Simulating metaverse banking activities...")

# Alice buys virtual real estate
meta_bank.purchase_virtual_asset('Alice', 'Virtual Plot in Crypto Valley', 500)
print(f"Alice purchased virtual real estate.")

# Bob buys a virtual art piece
meta_bank.purchase_virtual_asset('Bob', 'Digital Mona Lisa', 300)

# Charlie mints an NFT
nft_metadata = {
    'name': 'CryptoPunk #42',
    'description': 'A rare digital punk avatar',
    'attributes': {
        'type': 'Alien',
        'accessories': 'Necklace, Hat',
        'rare': True
    }
}
meta_bank.mint_nft('Charlie', nft_metadata)
print(f"Charlie minted an NFT: CryptoPunk #42")

# Diana deposits more funds
meta_bank.deposit('Diana', 2000)

print("\nFinal Metaverse Bank Balances:")
for customer in customers:
    balance = meta_bank.customer_balances.get(customer, 0)
    assets = len(meta_bank.virtual_assets.get(customer, []))
    nfts = len(meta_bank.nft_collections.get(customer, []))
    print(f"  {customer}: ${balance:.2f} | Assets: {assets} | NFTs: {nfts}")

# ----------------------------------------------------------------
# PART E: WEB3 REGULATORY LANDSCAPE
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Web3 Regulatory Landscape")
print("-"*60)

print("""
Key Regulatory Frameworks for Web3:

1. MiCA (EU):
   - Markets in Crypto-Assets Regulation.
   - Comprehensive framework for crypto-assets.
   - Stablecoin requirements, issuer transparency, consumer protection.

2. SEC (US):
   - Cryptocurrencies may be securities (Howey Test).
   - Regulation of DeFi protocols and token offerings.
   - SEC vs. Ripple (XRP) case significant.

3. FATF:
   - Travel Rule: VASPs must share sender/receiver info.
   - AML/KYC requirements for exchanges.

4. Financial Action Task Force (FATF):
   - Recommendations for crypto-asset regulation.
   - Focus on AML/CFT for virtual assets.

5. National Regulations:
   - China: Ban on crypto trading and mining.
   - Singapore: Progressive regulation (licensing).
   - UK: FCA registration for crypto businesses.

6. DeFi Regulation:
   - Focus on KYC/AML for DeFi protocols.
   - Potential classification as securities or banking.
   - DAO legal status and liability.

Key Regulatory Challenges:
  - Cross-border nature of Web3.
  - Anonymous/Pseudonymous transactions.
  - Decentralised governance (DAOs) – who is responsible?
  - Consumer protection in DeFi.
  - Tax treatment of crypto transactions.
""")

# ----------------------------------------------------------------
# PART F: WEB3 OPPORTUNITIES AND RISKS FOR BANKS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Web3 Opportunities and Risks for Banks")
print("-"*60)

opportunities = {
    "Digital Asset Custody": {
        "Description": "Banks can provide custody for crypto assets and NFTs.",
        "Impact": "New revenue streams; attract crypto-native clients."
    },
    "Tokenisation": {
        "Description": "Tokenise real-world assets (real estate, bonds, commodities).",
        "Impact": "Increased liquidity; fractional ownership; new markets."
    },
    "Programmable Money": {
        "Description": "Smart contracts for automated payments, escrow, and lending.",
        "Impact": "Reduced costs; faster settlement; new products."
    },
    "DeFi Integration": {
        "Description": "Offer DeFi yields and products to retail customers.",
        "Impact": "Competitive advantage; customer retention."
    },
    "Metaverse Banking": {
        "Description": "Virtual branches and immersive customer experiences.",
        "Impact": "Enhanced engagement; new customer segments."
    }
}

risks = {
    "Regulatory Uncertainty": {
        "Description": "Evolving and fragmented regulation.",
        "Impact": "Compliance costs; potential fines."
    },
    "Security": {
        "Description": "Smart contract vulnerabilities, hacks, and scams.",
        "Impact": "Financial losses; reputational damage."
    },
    "Volatility": {
        "Description": "Crypto asset price volatility.",
        "Impact": "Portfolio risk; customer complaints."
    },
    "Operational Risk": {
        "Description": "Lack of established operational frameworks.",
        "Impact": "Process failures; integration challenges."
    },
    "Reputational Risk": {
        "Description": "Association with illicit activities or volatile markets.",
        "Impact": "Loss of trust; regulatory scrutiny."
    }
}

print("\nOpportunities:")
for opp, details in opportunities.items():
    print(f"  • {opp}: {details['Impact']}")

print("\nRisks:")
for risk, details in risks.items():
    print(f"  • {risk}: {details['Impact']}")

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

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

print("""
Web3 and the Future of Finance – Key Takeaways:

1. Web3 enables user ownership, decentralisation, and trustless interactions.
2. Decentralised Identity (DID) gives users control over their personal data.
3. Zero-Knowledge Proofs (ZKPs) preserve privacy while enabling verification.
4. NFTs enable ownership of digital assets and new economic models.
5. The Metaverse creates new opportunities for banking (virtual branches, events).
6. DAOs represent a new paradigm for organisational governance.
7. Key challenges: regulation, security, volatility, and operational risk.
8. Banks must balance innovation with risk management.

Recommendations:
  - Establish a Web3/Crypto Centre of Excellence.
  - Experiment with digital asset custody and tokenisation.
  - Develop a metaverse strategy (virtual presence, digital assets).
  - Invest in DID and ZKP capabilities for privacy-preserving KYC.
  - Monitor regulatory developments and engage with policymakers.
  - Build partnerships with Web3 companies and DeFi protocols.
  - Educate staff and customers on Web3 opportunities and risks.
""")

print("="*70)
print("END OF LESSON 5 – MODULE 7")
print("="*70)