┌─────────────────────────────────────────────────────────────────────────────┐
│                    EVOLUTION OF BLOCKCHAIN TECHNOLOGY                      │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1991 ──── 2008 ──── 2009 ──── 2013 ──── 2015 ──── 2017 ──── 2020 ──── 2024│
│    │         │         │         │         │         │         │           │
│    v         v         v         v         v         v         v           │
│  ┌─────┐  ┌─────┐  ┌─────┐  ┌─────┐  ┌─────┐  ┌─────┐  ┌─────────────┐  │
│  │Time-│  │Bit- │  │Bit- │  │Ethe-│  │Hy- │  │DeFi│  │  Enterprise  │  │
│  │stamp│  │coin │  │coin │  │reum │  │per-│  │ &  │  │  Adoption &  │  │
│  │Chain│  │Whit-│  │Launch│  │Launch│  │led-│  │NFTs│  │  Regulation  │  │
│  │     │  │epaper│  │     │  │     │  │ger │  │    │  │              │  │
│  └─────┘  └─────┘  └─────┘  └─────┘  └─────┘  └─────┘  └─────────────┘  │
│                                                                             │
│  Key Milestones:                                                            │
│  • 1991: Stuart Haber and Scott Stornetta propose timestamping of documents │
│  • 2008: Satoshi Nakamoto publishes Bitcoin whitepaper                     │
│  • 2009: Bitcoin network launches with genesis block                       │
│  • 2013: Vitalik Buterin proposes Ethereum                                 │
│  • 2015: Ethereum launches with smart contract functionality               │
│  • 2017: ICO boom and enterprise blockchain interest                       │
│  • 2020: DeFi explosion and institutional adoption                         │
│  • 2024: Regulatory frameworks mature, CBDCs emerge                       │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    KEY CHARACTERISTICS OF BLOCKCHAIN                        │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DECENTRALISATION                                  │   │
│  │  No central authority controls the network.                         │   │
│  │  Consensus among participants validates transactions.              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    IMMUTABILITY                                      │   │
│  │  Once recorded, data cannot be altered retroactively.               │   │
│  │  Cryptographic hash functions ensure integrity.                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    TRANSPARENCY                                      │   │
│  │  All transactions are visible to network participants.              │   │
│  │  Public blockchains offer full transparency.                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    SECURITY                                          │   │
│  │  Cryptographic algorithms protect data.                             │   │
│  │  Consensus mechanisms prevent double-spending.                     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PROGRAMMABILITY                                   │   │
│  │  Smart contracts enable programmable transactions.                  │   │
│  │  DApps run on blockchain networks.                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    EFFICIENCY                                        │   │
│  │  Removes intermediaries, reducing friction.                         │   │
│  │  Automates settlement and clearing processes.                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

                    ┌─────────────────┐
                    │   DECENTRALISATION  │
                    │      (Security)     │
                    │                     │
                    └─────────┬──────────┘
                              │
          ┌───────────────────┼───────────────────┐
          │                   │                   │
          v                   v                   v
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│    SCALABILITY  │ │                 │ │    SECURITY     │
│    (Speed)      │ │    TRILEMMA     │ │  (Immutability) │
│                 │ │                 │ │                 │
└─────────────────┘ └─────────────────┘ └─────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    TYPES OF BLOCKCHAIN NETWORKS                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PUBLIC BLOCKCHAIN                                 │   │
│  │  • Permissionless - anyone can participate                          │   │
│  │  • Fully decentralised                                              │   │
│  │  • Examples: Bitcoin, Ethereum, Solana                              │   │
│  │  • Use cases: Cryptocurrency, DeFi, NFTs                           │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PRIVATE BLOCKCHAIN                                │   │
│  │  • Permissioned - only authorised participants                      │   │
│  │  • Centralised control                                              │   │
│  │  • Examples: Hyperledger Fabric, Corda                             │   │
│  │  • Use cases: Enterprise applications, supply chain, banking       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CONSORTIUM BLOCKCHAIN                             │   │
│  │  • Semi-permissioned - controlled by multiple organisations         │   │
│  │  • Shared governance                                                │   │
│  │  • Examples: R3 Corda, Energy Web Foundation                       │   │
│  │  • Use cases: Industry consortia, trade finance, insurance         │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    BLOCKCHAIN ARCHITECTURE OVERVIEW                         │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    APPLICATION LAYER                                 │   │
│  │  DApps, Smart Contracts, Wallets                                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PROTOCOL LAYER                                    │   │
│  │  Consensus Mechanisms (PoW, PoS, etc.)                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    NETWORK LAYER                                     │   │
│  │  P2P Networking, Node Communication                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DATA LAYER                                        │   │
│  │  Blocks, Transactions, Hash Functions                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    BLOCK STRUCTURE                                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BLOCK HEADER                                      │   │
│  │  • Version Number                                                    │   │
│  │  • Previous Block Hash                                               │   │
│  │  • Merkle Root Hash                                                  │   │
│  │  • Timestamp                                                         │   │
│  │  • Difficulty Target                                                 │   │
│  │  • Nonce (Proof of Work)                                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BLOCK BODY                                        │   │
│  │  • Transaction Count                                                 │   │
│  │  • Transaction List                                                  │   │
│  │  • Smart Contract Code                                               │   │
│  │  • Additional Metadata                                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 1, LESSON 1: INTRODUCTION TO BLOCKCHAIN TECHNOLOGY
# ===================================================================

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

print("="*70)
print("INTRODUCTION TO BLOCKCHAIN TECHNOLOGY")
print("="*70)

# ----------------------------------------------------------------
# PART A: SIMPLE BLOCK IMPLEMENTATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Simple Block Implementation")
print("-"*60)

class Block:
    """Simple implementation of a blockchain block."""
    
    def __init__(self, index: int, transactions: List[Dict], timestamp: float = None):
        self.index = index
        self.transactions = transactions
        self.timestamp = timestamp or time.time()
        self.previous_hash = None
        self.nonce = 0
        self.hash = self.calculate_hash()
    
    def calculate_hash(self) -> str:
        """Calculate the SHA-256 hash of the block."""
        block_string = json.dumps({
            'index': self.index,
            'transactions': self.transactions,
            'timestamp': self.timestamp,
            'previous_hash': self.previous_hash,
            'nonce': self.nonce
        }, sort_keys=True)
        return hashlib.sha256(block_string.encode()).hexdigest()
    
    def mine_block(self, difficulty: int) -> None:
        """Mine the block with Proof of Work."""
        target = '0' * difficulty
        while self.hash[:difficulty] != target:
            self.nonce += 1
            self.hash = self.calculate_hash()
        print(f"Block {self.index} mined! Hash: {self.hash[:10]}...")
    
    def __repr__(self):
        return f"Block(#{self.index}, Hash: {self.hash[:8]}..., Tx: {len(self.transactions)})"

# Create a sample block
sample_block = Block(0, [
    {'from': 'Alice', 'to': 'Bob', 'amount': 10},
    {'from': 'Bob', 'to': 'Charlie', 'amount': 5}
])

print(f"Created Block: {sample_block}")
print(f"Block Hash: {sample_block.hash}")
print(f"Timestamp: {datetime.datetime.fromtimestamp(sample_block.timestamp)}")

# ----------------------------------------------------------------
# PART B: SIMPLE BLOCKCHAIN IMPLEMENTATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Simple Blockchain Implementation")
print("-"*60)

class Blockchain:
    """Simple implementation of a blockchain."""
    
    def __init__(self, difficulty: int = 2):
        self.chain: List[Block] = []
        self.difficulty = difficulty
        self.pending_transactions = []
        self.create_genesis_block()
    
    def create_genesis_block(self) -> None:
        """Create the first block in the blockchain."""
        genesis_block = Block(0, ['Genesis Block'])
        genesis_block.mine_block(self.difficulty)
        self.chain.append(genesis_block)
    
    def get_latest_block(self) -> Block:
        """Get the most recent block in the chain."""
        return self.chain[-1]
    
    def add_transaction(self, transaction: Dict) -> None:
        """Add a transaction to the pending list."""
        self.pending_transactions.append(transaction)
    
    def mine_pending_transactions(self) -> None:
        """Mine all pending transactions into a new block."""
        if not self.pending_transactions:
            print("No pending transactions to mine.")
            return
            
        block = Block(
            index=len(self.chain),
            transactions=self.pending_transactions.copy()
        )
        block.previous_hash = self.get_latest_block().hash
        block.mine_block(self.difficulty)
        
        self.chain.append(block)
        self.pending_transactions = []
        print(f"Block {block.index} added to blockchain!")
    
    def is_chain_valid(self) -> bool:
        """Validate the integrity of the blockchain."""
        for i in range(1, len(self.chain)):
            current_block = self.chain[i]
            previous_block = self.chain[i-1]
            
            # Check if current block's hash is valid
            if current_block.hash != current_block.calculate_hash():
                print(f"Invalid hash in block {current_block.index}")
                return False
            
            # Check if previous block hash is correct
            if current_block.previous_hash != previous_block.hash:
                print(f"Invalid previous hash in block {current_block.index}")
                return False
            
            # Check if proof of work is valid
            if current_block.hash[:self.difficulty] != '0' * self.difficulty:
                print(f"Invalid PoW in block {current_block.index}")
                return False
        
        return True
    
    def __repr__(self):
        return f"Blockchain({len(self.chain)} blocks, {len(self.pending_transactions)} pending)"

# Create and test blockchain
print("Creating blockchain...")
blockchain = Blockchain(difficulty=2)

print(f"Genesis block created: {blockchain.get_latest_block()}")

# Add transactions
print("\nAdding transactions...")
blockchain.add_transaction({'from': 'Alice', 'to': 'Bob', 'amount': 10})
blockchain.add_transaction({'from': 'Bob', 'to': 'Charlie', 'amount': 5})
blockchain.add_transaction({'from': 'Charlie', 'to': 'David', 'amount': 3})

print(f"Pending transactions: {len(blockchain.pending_transactions)}")

# Mine block
print("\nMining block...")
blockchain.mine_pending_transactions()

print(f"Blockchain valid: {blockchain.is_chain_valid()}")

# Show blockchain
print(f"\nBlockchain: {blockchain}")

# ----------------------------------------------------------------
# PART C: BLOCKCHAIN TYPES COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Blockchain Types Comparison")
print("-"*60)

blockchain_types = pd.DataFrame({
    'Characteristic': [
        'Access Control',
        'Consensus Mechanism',
        'Speed (TPS)',
        'Security Level',
        'Cost',
        'Use Cases',
        'Examples'
    ],
    'Public': [
        'Permissionless',
        'PoW, PoS, etc.',
        '10-100',
        'Very High',
        'High',
        'Cryptocurrency, DeFi, NFTs',
        'Bitcoin, Ethereum, Solana'
    ],
    'Private': [
        'Permissioned',
        'PBFT, Raft',
        '1,000+',
        'High',
        'Low',
        'Enterprise, Supply Chain',
        'Hyperledger Fabric, Corda'
    ],
    'Consortium': [
        'Semi-permissioned',
        'PBFT, IBFT',
        '500+',
        'High',
        'Medium',
        'Industry Consortia',
        'R3 Corda, Energy Web'
    ]
})

print("Blockchain Types Comparison:")
print(blockchain_types.to_string(index=False))

# ----------------------------------------------------------------
# PART D: BLOCKCHAIN ARCHITECTURE VISUALISATION
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Blockchain Architecture Visualisation")
print("-"*60)

# Create architecture layers data
architecture_data = {
    'Layer': ['Application', 'Protocol', 'Network', 'Data'],
    'Components': [
        'DApps, Smart Contracts, Wallets, Oracles',
        'Consensus Mechanisms, Validation Rules, Incentives',
        'P2P Networking, Node Communication, Propagation',
        'Blocks, Transactions, Hash Functions, Merkle Trees'
    ],
    'Examples': [
        'Uniswap, Aave, MetaMask',
        'PoW, PoS, DPoS, PBFT',
        'LibP2P, DevP2P, Gossip Protocol',
        'SHA-256, Merkle Root, Block Headers'
    ]
}

architecture_df = pd.DataFrame(architecture_data)
print("Blockchain Architecture Layers:")
print(architecture_df.to_string(index=False))

# Visualise architecture as a pyramid
fig, ax = plt.subplots(figsize=(10, 6))

layers = ['Application Layer', 'Protocol Layer', 'Network Layer', 'Data Layer']
y_pos = np.arange(len(layers))
widths = [0.8, 0.6, 0.4, 0.2]

for i, (layer, width) in enumerate(zip(layers, widths)):
    left = (1 - width) / 2
    ax.barh(y_pos[i], width, left=left, height=0.3, 
            color=plt.cm.Blues(0.3 + 0.7 * (i / len(layers))),
            alpha=0.8, edgecolor='black')
    ax.text(0.5, y_pos[i], layer, ha='center', va='center', 
            fontsize=10, fontweight='bold')

ax.set_yticks(y_pos)
ax.set_yticklabels(layers)
ax.set_xlim(0, 1)
ax.set_xlabel('Relative Layer Width')
ax.set_title('Blockchain Technology Stack')
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('blockchain_architecture.png', dpi=300, bbox_inches='tight')
plt.show()
print("Architecture visualisation saved as 'blockchain_architecture.png'")

# ----------------------------------------------------------------
# PART E: BLOCKCHAIN METRICS DASHBOARD
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Blockchain Metrics Dashboard")
print("-"*60)

blockchain_metrics = pd.DataFrame({
    'Metric': [
        'Total Blocks',
        'Transaction Throughput',
        'Average Block Time',
        'Transaction Latency',
        'Network Hash Rate',
        'Active Nodes',
        'Block Size',
        'Transaction Fees'
    ],
    'Bitcoin': [
        '800,000+',
        '7 TPS',
        '10 minutes',
        '10-60 minutes',
        '350 EH/s',
        '15,000+',
        '1 MB',
        '$0.50-$50'
    ],
    'Ethereum': [
        '19,000,000+',
        '15-30 TPS',
        '12-15 seconds',
        '15-60 seconds',
        '800 TH/s',
        '5,000+',
        'Variable',
        '$0.10-$10'
    ],
    'Solana': [
        '200,000,000+',
        '2,000+ TPS',
        '400ms',
        '1-2 seconds',
        'N/A',
        '1,000+',
        'Variable',
        '$0.001-$0.01'
    ]
})

print("Blockchain Network Metrics:")
print(blockchain_metrics.to_string(index=False))

# ----------------------------------------------------------------
# PART F: BLOCKCHAIN ADOPTION ROADMAP FOR FINANCIAL SERVICES
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Blockchain Adoption Roadmap for Financial Services")
print("-"*60)

adoption_roadmap = {
    "Phase 1 (0-6 months) – Assessment & Education": {
        "Focus": "Build foundational understanding.",
        "Activities": [
            "Assess business processes for blockchain opportunities.",
            "Educate stakeholders on blockchain capabilities.",
            "Identify use cases with highest ROI.",
            "Conduct feasibility studies."
        ],
        "Success Metrics": ["Blockchain strategy approved", "Key use cases identified"]
    },
    "Phase 2 (6-12 months) – Pilot & Proof of Concept": {
        "Focus": "Validate blockchain solutions.",
        "Activities": [
            "Build pilot projects for selected use cases.",
            "Develop smart contract prototypes.",
            "Test integration with existing systems.",
            "Measure performance and business impact."
        ],
        "Success Metrics": ["2-3 pilots successful", "Integration patterns defined"]
    },
    "Phase 3 (12-24 months) – Scale & Integration": {
        "Focus": "Scale successful pilots to production.",
        "Activities": [
            "Deploy production-grade blockchain solutions.",
            "Build regulatory compliance framework.",
            "Develop internal blockchain expertise.",
            "Integrate with core banking systems."
        ],
        "Success Metrics": ["Live production systems", "Regulatory compliance achieved"]
    },
    "Phase 4 (24+ months) – Ecosystem & Innovation": {
        "Focus": "Build ecosystem and drive innovation.",
        "Activities": [
            "Create industry partnerships and consortia.",
            "Develop innovative blockchain-enabled products.",
            "Build developer ecosystem.",
            "Achieve market leadership."
        ],
        "Success Metrics": ["Ecosystem established", "Industry recognition gained"]
    }
}

for phase, details in adoption_roadmap.items():
    print(f"\n{phase}:")
    print(f"  Focus: {details['Focus']}")
    print("  Activities:")
    for activity in details['Activities']:
        print(f"    • {activity}")
    print("  Success Metrics:")
    for metric in details['Success Metrics']:
        print(f"    • {metric}")

# ----------------------------------------------------------------
# PART G: BLOCKCHAIN USE CASES IN FINANCE
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART G: Blockchain Use Cases in Digital Finance")
print("-"*60)

use_cases = {
    "Cross-Border Payments": {
        "Description": "Enable faster, cheaper international transfers.",
        "Benefits": ["Reduced costs", "Faster settlement", "Increased transparency"],
        "Examples": ["Ripple", "Stellar", "JPM Coin"]
    },
    "Trade Finance": {
        "Description": "Streamline trade finance processes with smart contracts.",
        "Benefits": ["Reduced fraud", "Faster documentation", "Better traceability"],
        "Examples": ["TradeLens", "Corda Trade Finance"]
    },
    "Securities Settlement": {
        "Description": "Enable instant settlement of securities trades.",
        "Benefits": ["Reduced counterparty risk", "Faster settlement", "Lower costs"],
        "Examples": ["ASX CHESS", "tZERO", "Securitize"]
    },
    "Digital Identity": {
        "Description": "Provide secure, self-sovereign identity for KYC/AML.",
        "Benefits": ["Enhanced security", "User control", "Reduced fraud"],
        "Examples": ["Civic", "uPort", "SelfKey"]
    },
    "Smart Contracts": {
        "Description": "Automate financial agreements and processes.",
        "Benefits": ["Automation", "Trust minimisation", "Programmability"],
        "Examples": ["Ethereum", "Chainlink", "Aave"]
    }
}

for use_case, details in use_cases.items():
    print(f"\n{use_case}:")
    print(f"  Description: {details['Description']}")
    print("  Benefits:")
    for benefit in details['Benefits']:
        print(f"    • {benefit}")
    print("  Examples:")
    for example in details['Examples']:
        print(f"    • {example}")

# ----------------------------------------------------------------
# PART H: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

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

print("""
Introduction to Blockchain Technology – Key Takeaways:

1. Blockchain is a distributed, decentralised, and immutable digital ledger.
2. Key characteristics: decentralisation, immutability, transparency, security.
3. Three types: public, private, and consortium blockchains.
4. Blockchain architecture: data → network → protocol → application layers.
5. The blockchain trilemma: balancing decentralisation, scalability, security.
6. Key metrics: block time, TPS, hash rate, transaction fees.
7. Use cases in finance: cross-border payments, trade finance, settlement, identity.
8. Adoption roadmap: assessment → pilot → scale → ecosystem.

Recommendations:
  - Begin with understanding business problems blockchain can solve.
  - Start with small pilots to validate concepts.
  - Build regulatory compliance into blockchain initiatives.
  - Develop internal blockchain expertise.
  - Participate in industry consortia and standards.
  - Consider interoperability and integration requirements.
""")

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