🧠 Blockchain Fundamentals

Q: What is blockchain?

Blockchain is a distributed, decentralized, immutable ledger that records transactions across a network of computers. Each block contains a cryptographic hash of the previous block, a timestamp, and transaction data, forming a chain. It enables trustless, transparent, and tamper-resistant record-keeping without a central authority.

Q: What is the difference between Proof of Work and Proof of Stake?

Proof of Work (PoW) requires miners to solve computational puzzles to validate blocks, consuming significant energy (e.g., Bitcoin). Proof of Stake (PoS) selects validators based on the amount of cryptocurrency they stake, consuming far less energy (e.g., Ethereum 2.0). PoS is faster and more energy-efficient.

Q: What is a smart contract?

A smart contract is a self-executing program stored on a blockchain that automatically enforces and executes the terms of an agreement when predefined conditions are met. Smart contracts are written in languages like Solidity (Ethereum) and enable decentralized applications (dApps), DeFi, and NFTs.

Q: What is the difference between public and private blockchains?

Public blockchains (e.g., Bitcoin, Ethereum) are open to anyone, permissionless, and decentralized. Private blockchains (e.g., Hyperledger Fabric) are restricted, permissioned, and controlled by an organization. Consortium blockchains are semi-decentralized, governed by a group.

Q: What is Web3?

Web3 refers to a decentralized internet built on blockchain technology, where users own their data and digital assets. It includes DeFi (decentralized finance), NFTs (non-fungible tokens), DAOs (decentralized autonomous organizations), and dApps (decentralized applications).

🎯 What is Blockchain?

Blockchain is a distributed, decentralized, immutable ledger that records transactions across a network of computers. Each block contains a cryptographic hash of the previous block, a timestamp, and transaction data, forming a chain. It enables trustless, transparent, and tamper-resistant record-keeping without a central authority. Since the introduction of Bitcoin in 2008, blockchain has evolved into a foundational technology for cryptocurrencies, smart contracts, DeFi, NFTs, and Web3.

Why Blockchain Matters

Decentralization: No central authority. Immutability: Tamper-resistant. Transparency: Public ledger. Trustless: No intermediaries. Programmable: Smart contracts. Global: Borderless.

📌 Decentralization📌 Immutability📌 Transparency📌 Trustless

# Blockchain Fundamentals — the big picture
# Distributed, decentralized, immutable ledger.

print("""
=== Blockchain Fundamentals ===

What it is:
  - Distributed ledger
  - Decentralized
  - Immutable
  - Cryptographic
  - Chain of blocks

Why it matters:
  - Decentralization
  - Immutability
  - Transparency
  - Trustless
  - Programmable
  - Global

Key concepts:
  - Distributed ledger (DLT)
  - Cryptography
  - Hashing
  - Blocks and chain
  - Consensus
  - Proof of Work (PoW)
  - Proof of Stake (PoS)
  - Smart contracts
  - Wallets
  - Transactions
  - Public vs private

Applications:
  - Cryptocurrencies (Bitcoin, Ethereum)
  - DeFi (Decentralized Finance)
  - NFTs (Non-Fungible Tokens)
  - DAOs (Decentralized Autonomous Organizations)
  - Supply chain
  - Healthcare
  - Voting
  - Identity
  - Web3
""")

print("=== Historical Context ===")
print("""
1991: Haber & Stornetta — cryptographically secured chain
2008: Bitcoin whitepaper (Satoshi Nakamoto)
2009: Bitcoin genesis block
2013: Ethereum whitepaper (Vitalik Buterin)
2015: Ethereum mainnet
2017: ICO boom, CryptoKitties
2020: DeFi summer
2021: NFT boom
2022: Ethereum Merge (PoS)
2025: Web3, Layer 2, AI + blockchain
""")

print("=== Why It's Hard ===")
print("""
1. SCALABILITY
   - Bitcoin: 7 TPS
   - Ethereum: 15 TPS
   - Visa: 65,000 TPS

2. ENERGY
   - PoW consumes energy
   - Bitcoin: ~150 TWh/year
   - Environmental concerns

3. COMPLEXITY
   - Cryptography
   - Consensus
   - Smart contracts

4. REGULATION
   - Legal uncertainty
   - Compliance
   - KYC/AML

5. UX
   - Wallets
   - Private keys
   - Gas fees
""")

🎯 Why Blockchain Matters

🎯 The Value of Blockchain

Blockchain is a foundational technology that enables trustless, transparent, and tamper-resistant systems, with applications far beyond cryptocurrencies.

Key Benefits

Decentralization: No single point. Immutability: Cannot change. Transparency: Auditable. Trustless: No intermediaries. Programmable: Smart contracts. Global: Borderless.

🎯 Decentralization🎯 Immutability🎯 Transparency🎯 Trustless

# Why Blockchain Matters
print("=== 1. Decentralization ===")
print("""
Decentralization:
  - No central authority
  - Distributed network
  - Peer-to-peer
  - Censorship-resistant

Example:
  Bitcoin
  → No central bank
  → Peer-to-peer
""")

print("\n=== 2. Immutability ===")
print("""
Immutability:
  - Cannot change
  - Tamper-resistant
  - Append-only
  - Cryptographic

Example:
  Block hash
  → Cannot modify
  → Audit trail
""")

print("\n=== 3. Transparency ===")
print("""
Transparency:
  - Public ledger
  - Auditable
  - Verifiable
  - Open

Example:
  Bitcoin
  → Public blockchain
  → Anyone can verify
""")

print("\n=== 4. Trustless ===")
print("""
Trustless:
  - No intermediaries
  - No trust needed
  - Code is law
  - Mathematics

Example:
  Smart contract
  → Auto-executes
  → No lawyer
""")

print("\n=== 5. Programmable ===")
print("""
Programmable:
  - Smart contracts
  - dApps
  - DeFi
  - NFTs

Example:
  Ethereum
  → Solidity
  → Smart contracts
""")

print("\n=== 6. Global ===")
print("""
Global:
  - Borderless
  - 24/7
  - Fast
  - Low cost

Example:
  Remittance
  → Seconds
  → Low fee
""")

print("\n=== 7. Financial Inclusion ===")
print("""
Inclusion:
  - Unbanked
  - 1.7 billion
  - Access
  - Mobile

Example:
  Africa
  → Mobile money
  → Blockchain
""")

print("\n=== 8. Supply Chain ===")
print("""
Supply chain:
  - Traceability
  - Provenance
  - Anti-counterfeit
  - Transparency

Example:
  Food
  → Farm to table
  → Blockchain
""")

print("\n=== 9. Healthcare ===")
print("""
Healthcare:
  - Records
  - Privacy
  - Interoperability
  - Consent

Example:
  Patient records
  → Blockchain
  → Secure
""")

print("\n=== 10. Voting ===")
print("""
Voting:
  - Transparent
  - Verifiable
  - Tamper-proof
  - Accessible

Example:
  Elections
  → Blockchain
  → Trust
""")

📒 Distributed Ledger

🎯 Distributed Ledger Technology (DLT)

A distributed ledger is a database that is consensually shared, replicated, and synchronized across multiple sites, institutions, or geographies. Blockchain is a type of DLT.

DLT

Distributed: Multiple nodes. Replicated: Copies. Consensus: Agreement. Immutable: Append-only. Decentralized: No central. Transparent: Auditable.

📒 Distributed📒 Replicated📒 Consensus📒 Immutable

# Distributed Ledger
print("=== What is a Distributed Ledger? ===")
print("""
Distributed Ledger:
  - Shared database
  - Multiple nodes
  - Replicated
  - Synchronized
  - Consensus

Example:
  Node 1: [Block 1, Block 2, Block 3]
  Node 2: [Block 1, Block 2, Block 3]
  Node 3: [Block 1, Block 2, Block 3]
  → All same
""")

print("\n=== Types of DLT ===")
print("""
Types:
  1. Blockchain
     - Chain of blocks
     - Bitcoin, Ethereum

  2. Directed Acyclic Graph (DAG)
     - IOTA, Hedera

  3. Hashgraph
     - Hedera Hashgraph

  4. Holochain
     - Agent-centric
""")

print("\n=== Blockchain vs DLT ===")
print("""
Blockchain:
  - Chain of blocks
  - Linear
  - Example: Bitcoin

DLT:
  - Broader
  - Includes blockchain
  - DAG, hashgraph

Blockchain is a DLT.
""")

print("\n=== Nodes ===")
print("""
Nodes:
  - Full node
  - Light node
  - Mining node
  - Validator node

Full node:
  - Full blockchain
  - Validates
  - Relays

Light node:
  - Headers only
  - Wallets
  - Mobile
""")

print("\n=== Replication ===")
print("""
Replication:
  - Every node has copy
  - Consensus
  - Synchronization

Example:
  New block
  → Broadcast
  → All nodes update
""")

print("\n=== Consensus ===")
print("""
Consensus:
  - Agreement
  - All nodes agree
  - Protocol

Types:
  - PoW
  - PoS
  - DPoS
  - PBFT
  - Raft
""")

print("\n=== Immutability ===")
print("""
Immutability:
  - Append-only
  - Cannot change
  - Cannot delete
  - Cryptographic

Example:
  Block hash
  → Change → different hash
  → Chain breaks
""")

print("\n=== Transparency ===")
print("""
Transparency:
  - Public ledger
  - Auditable
  - Verifiable
  - Open

Example:
  Bitcoin
  → Anyone can verify
  → Block explorer
""")

print("\n=== Python DLT ===")
print("""
import hashlib
import json

class Block:
    def __init__(self, index, timestamp, data, previous_hash):
        self.index = index
        self.timestamp = timestamp
        self.data = data
        self.previous_hash = previous_hash
        self.hash = self.compute_hash()
    
    def compute_hash(self):
        block_string = json.dumps(self.__dict__, sort_keys=True)
        return hashlib.sha256(block_string.encode()).hexdigest()

# Example
# block = Block(1, "2025-01-01", {"amount": 100}, "0")
# print(block.hash)
""")

print("\n=== Use Cases ===")
print("""
Use cases:
  - Cryptocurrency
  - Supply chain
  - Healthcare
  - Voting
  - Identity
  - Land registry
""")

🔐 Cryptography

🎯 Cryptographic Foundations

Blockchain relies on cryptography for security, privacy, and integrity. Key concepts include hash functions, public-key cryptography, and digital signatures.

Cryptography

Hash: One-way. Public key: Encrypt/verify. Private key: Decrypt/sign. Digital signature: Authenticate. ECDSA: Bitcoin/Ethereum. SHA-256: Hashing.

🔐 Hash🔐 Public key🔐 Private key🔐 Signature

# Cryptography
print("=== 1. Hash Functions ===")
print("""
Hash:
  - One-way
  - Fixed size
  - Deterministic
  - Collision-resistant

Properties:
  - Same input → same output
  - Different input → different output
  - Cannot reverse
  - Fast

Examples:
  - SHA-256
  - Keccak-256 (Ethereum)
  - RIPEMD-160
""")

print("\n=== 2. SHA-256 ===")
print("""
SHA-256:
  - Bitcoin
  - 256-bit
  - Secure

Example:
  "hello" → 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
""")

print("\n=== 3. Public-Key Cryptography ===")
print("""
Public-key:
  - Key pair
  - Public: share
  - Private: secret
  - Asymmetric

Algorithms:
  - RSA
  - ECDSA
  - EdDSA
""")

print("\n=== 4. ECDSA ===")
print("""
ECDSA:
  - Elliptic Curve Digital Signature Algorithm
  - Bitcoin
  - Ethereum
  - secp256k1

Key:
  - Private: 256-bit
  - Public: 512-bit (uncompressed)
""")

print("\n=== 5. Digital Signatures ===")
print("""
Signature:
  - Sign with private key
  - Verify with public key
  - Authenticate
  - Non-repudiation

Example:
  Sign(tx, private_key)
  → signature
  Verify(tx, signature, public_key)
  → true/false
""")

print("\n=== 6. Addresses ===")
print("""
Address:
  - Derived from public key
  - Hash
  - Base58 (Bitcoin)
  - Hex (Ethereum)

Example:
  Bitcoin: 1A1zP1...
  Ethereum: 0x742d35...
""")

print("\n=== 7. Wallets ===")
print("""
Wallet:
  - Stores keys
  - Signs transactions
  - Not coins

Types:
  - Hot wallet
  - Cold wallet
  - Hardware
  - Paper
""")

print("\n=== 8. Python Crypto ===")
print("""
import hashlib
from ecdsa import SigningKey, SECP256k1

# Hash
def sha256(data):
    return hashlib.sha256(data.encode()).hexdigest()

# Key pair
private_key = SigningKey.generate(curve=SECP256k1)
public_key = private_key.get_verifying_key()

# Sign
signature = private_key.sign(b"message")

# Verify
assert public_key.verify(signature, b"message")

# Example
print(sha256("hello"))
""")

print("\n=== 9. Merkle Trees ===")
print("""
Merkle Tree:
  - Hash tree
  - Efficient verification
  - Root hash
  - Bitcoin

Example:
    Root
   /    \\
  H12    H34
  / \\    / \\
 H1 H2  H3 H4
""")

print("\n=== 10. Use Cases ===")
print("""
Use cases:
  - Signatures
  - Addresses
  - Wallets
  - Merkle trees
  - Zero-knowledge proofs
""")

#️⃣ Hashing

🎯 Hash Functions

A hash function takes an input and produces a fixed-size output (hash). It's one-way, deterministic, and collision-resistant. Hashing is fundamental to blockchain.

Hashing

One-way: Cannot reverse. Fixed: Fixed output. Deterministic: Same input. Collision: Rare. SHA-256: Standard. Keccak: Ethereum.

#️⃣ One-way#️⃣ Fixed#️⃣ Deterministic#️⃣ SHA-256

# Hashing
print("=== 1. What is a Hash? ===")
print("""
Hash:
  - Input → output
  - Fixed size
  - One-way
  - Deterministic

Example:
  "hello" → 2cf24dba...
  "hello" → 2cf24dba... (same)
  "world" → 486ea462... (different)
""")

print("\n=== 2. Properties ===")
print("""
Properties:
  1. Deterministic
  2. Fast
  3. One-way
  4. Avalanche effect
  5. Collision-resistant
""")

print("\n=== 3. SHA-256 ===")
print("""
SHA-256:
  - Secure Hash Algorithm
  - 256-bit
  - Bitcoin

Example:
  import hashlib
  hashlib.sha256(b"hello").hexdigest()
""")

print("\n=== 4. Keccak-256 ===")
print("""
Keccak-256:
  - Ethereum
  - SHA-3
  - 256-bit

Example:
  from Crypto.Hash import keccak
  k = keccak.new(digest_bits=256)
  k.update(b"hello")
  k.hexdigest()
""")

print("\n=== 5. Merkle Tree ===")
print("""
Merkle:
  - Hash tree
  - Efficient
  - Root hash
  - Verify

Example:
    Root
   /    \\
  H12    H34
  / \\    / \\
 H1 H2  H3 H4
""")

print("\n=== 6. Block Hash ===")
print("""
Block hash:
  - Block header
  - Previous hash
  - Timestamp
  - Nonce
  - Merkle root

Example:
  hash = SHA256(header)
""")

print("\n=== 7. Mining ===")
print("""
Mining:
  - Find nonce
  - Hash < target
  - Proof of Work

Example:
  nonce = 0
  while hash > target:
    nonce += 1
    hash = SHA256(header + nonce)
""")

print("\n=== 8. Python Hash ===")
print("""
import hashlib

def hash_block(block):
    \"\"\"Hash a block.\"\"\"
    block_string = json.dumps(block, sort_keys=True).encode()
    return hashlib.sha256(block_string).hexdigest()

def mine(block, difficulty=4):
    \"\"\"Mine a block.\"\"\"
    target = "0" * difficulty
    nonce = 0
    while True:
        block['nonce'] = nonce
        h = hash_block(block)
        if h.startswith(target):
            return nonce, h
        nonce += 1

# Example
# block = {'index': 1, 'data': 'tx', 'prev': '0'}
# nonce, h = mine(block, 4)
""")

print("\n=== 9. Avalanche Effect ===")
print("""
Avalanche:
  - Small change
  - Large difference
  - 50% bits

Example:
  "hello" → 2cf24dba...
  "hellp" → 5d41402a...
  → Completely different
""")

print("\n=== 10. Use Cases ===")
print("""
Use cases:
  - Block hashing
  - Mining
  - Merkle trees
  - Addresses
  - Signatures
""")

🧱 Blocks & Chain

🎯 Block Structure

A block contains a header (metadata) and a body (transactions). Each block references the previous block's hash, forming a chain.

Blocks

Header: Metadata. Previous hash: Link. Merkle root: Transactions. Timestamp: Time. Nonce: Mining. Transactions: Data.

🧱 Header🧱 Previous hash🧱 Merkle root🧱 Nonce

# Blocks & Chain
print("=== 1. Block Structure ===")
print("""
Block:
  - Header
    - Version
    - Previous block hash
    - Merkle root
    - Timestamp
    - Difficulty
    - Nonce
  - Body
    - Transactions

Example:
  Block #1
  → Header
  → Transactions
""")

print("\n=== 2. Genesis Block ===")
print("""
Genesis:
  - First block
  - No previous
  - Hardcoded
  - Special

Bitcoin:
  - Block 0
  - 2009-01-03
  - "The Times 03/Jan/2009"
""")

print("\n=== 3. Block Header ===")
print("""
Header:
  - 80 bytes
  - SHA-256 twice
  - Unique

Fields:
  - Version (4 bytes)
  - Previous hash (32 bytes)
  - Merkle root (32 bytes)
  - Timestamp (4 bytes)
  - Difficulty (4 bytes)
  - Nonce (4 bytes)
""")

print("\n=== 4. Merkle Root ===")
print("""
Merkle:
  - Hash of all transactions
  - Efficient
  - Verify

Example:
  Tx1, Tx2, Tx3, Tx4
  → H1, H2, H3, H4
  → H12, H34
  → Root
""")

print("\n=== 5. Chain ===")
print("""
Chain:
  - Block 0 → Block 1 → Block 2
  - Each references previous
  - Immutable

Example:
  Block 2.previous = Block 1.hash
  Block 1.previous = Block 0.hash
""")

print("\n=== 6. Immutability ===")
print("""
Immutability:
  - Change block
  - Hash changes
  - Chain breaks
  - Need re-mine

Example:
  Change Tx in Block 1
  → Hash changes
  → Block 2 invalid
  → Re-mine all
""")

print("\n=== 7. Fork ===")
print("""
Fork:
  - Two blocks
  - Same height
  - Network splits
  - Longest chain wins

Types:
  - Soft fork
  - Hard fork
""")

print("\n=== 8. Python Block ===")
print("""
import hashlib
import json
import time

class Block:
    def __init__(self, index, transactions, previous_hash):
        self.index = index
        self.timestamp = time.time()
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.nonce = 0
        self.hash = self.compute_hash()
    
    def compute_hash(self):
        block_string = json.dumps({
            'index': self.index,
            'timestamp': self.timestamp,
            'transactions': self.transactions,
            'previous_hash': self.previous_hash,
            'nonce': self.nonce
        }, sort_keys=True)
        return hashlib.sha256(block_string.encode()).hexdigest()
    
    def mine(self, difficulty=4):
        target = "0" * difficulty
        while not self.hash.startswith(target):
            self.nonce += 1
            self.hash = self.compute_hash()

# Example
# block = Block(1, ["tx1", "tx2"], "0")
# block.mine(4)
""")

print("\n=== 9. Blockchain ===")
print("""
class Blockchain:
    def __init__(self):
        self.chain = [self.create_genesis()]
        self.difficulty = 4
    
    def create_genesis(self):
        return Block(0, ["genesis"], "0")
    
    def add_block(self, block):
        block.previous_hash = self.chain[-1].hash
        block.mine(self.difficulty)
        self.chain.append(block)
    
    def is_valid(self):
        for i in range(1, len(self.chain)):
            current = self.chain[i]
            previous = self.chain[i-1]
            if current.hash != current.compute_hash():
                return False
            if current.previous_hash != previous.hash:
                return False
        return True
""")

print("\n=== 10. Use Cases ===")
print("""
Use cases:
  - Cryptocurrency
  - Supply chain
  - Voting
  - Identity
  - Records
""")

🤝 Consensus

🎯 Reaching Agreement

Consensus is the process by which all nodes in a blockchain network agree on the state of the ledger. It's essential for decentralization and security.

Consensus

PoW: Mining. PoS: Staking. DPoS: Delegates. PBFT: Byzantine. PoA: Authority. Raft: Leader.

🤝 PoW🤝 PoS🤝 DPoS🤝 PBFT

# Consensus
print("=== 1. What is Consensus? ===")
print("""
Consensus:
  - Agreement
  - All nodes
  - Ledger state
  - Protocol

Goal:
  - Trustless
  - Decentralized
  - Secure
  - Byzantine fault tolerant
""")

print("\n=== 2. Byzantine Generals ===")
print("""
Byzantine:
  - Fault tolerance
  - Malicious nodes
  - Agreement

Problem:
  - Generals
  - Traitors
  - Consensus

Solution:
  - PoW
  - PBFT
""")

print("\n=== 3. Proof of Work (PoW) ===")
print("""
PoW:
  - Mining
  - Computational puzzle
  - Energy
  - Bitcoin

Example:
  Hash < target
  → 0x00000...
""")

print("\n=== 4. Proof of Stake (PoS) ===")
print("""
PoS:
  - Validators
  - Stake
  - Energy efficient
  - Ethereum 2.0

Example:
  Stake 32 ETH
  → Validator
""")

print("\n=== 5. Delegated PoS (DPoS) ===")
print("""
DPoS:
  - Delegates
  - Voting
  - Fast
  - EOS

Example:
  Vote delegates
  → Block producers
""")

print("\n=== 6. PBFT ===")
print("""
PBFT:
  - Practical Byzantine Fault Tolerance
  - Permissioned
  - Fast
  - Hyperledger

Example:
  N = 3f + 1
  → f faulty
""")

print("\n=== 7. Proof of Authority (PoA) ===")
print("""
PoA:
  - Authority
  - Permissioned
  - Fast
  - Reputation

Example:
  Validators
  → Known
  → Trusted
""")

print("\n=== 8. Raft ===")
print("""
Raft:
  - Leader election
  - Permissioned
  - Fast
  - Hyperledger

Example:
  Leader
  → Replicates
  → Followers
""")

print("\n=== 9. Comparison ===")
print(f"{'Consensus':<20} {'Type':<15} {'Speed':<15} {'Energy':<15}")
print("-" * 65)
print(f"{'PoW':<20} {'Permissionless':<15} {'Slow':<15} {'High':<15}")
print(f"{'PoS':<20} {'Permissionless':<15} {'Fast':<15} {'Low':<15}")
print(f"{'DPoS':<20} {'Permissionless':<15} {'Very fast':<15} {'Low':<15}")
print(f"{'PBFT':<20} {'Permissioned':<15} {'Fast':<15} {'Low':<15}")
print(f"{'PoA':<20} {'Permissioned':<15} {'Fast':<15} {'Low':<15}")
print(f"{'Raft':<20} {'Permissioned':<15} {'Very fast':<15} {'Low':<15}")

print("\n=== 10. Use Cases ===")
print("""
Use cases:
  - PoW: Bitcoin
  - PoS: Ethereum
  - DPoS: EOS
  - PBFT: Hyperledger
  - PoA: VeChain
  - Raft: Private
""")

⛏️ Proof of Work

🎯 Mining

Proof of Work (PoW) requires miners to solve computational puzzles to validate blocks. It's secure but energy-intensive.

PoW

Mining: Solve puzzle. Nonce: Variable. Target: Difficulty. Hash: SHA-256. Reward: Bitcoin. Energy: High.

⛏️ Mining⛏️ Nonce⛏️ Target⛏️ SHA-256

# Proof of Work
print("=== 1. What is PoW? ===")
print("""
PoW:
  - Mining
  - Puzzle
  - Hash
  - Nonce

Goal:
  - Find nonce
  - Hash < target
  - Difficulty
""")

print("\n=== 2. Mining ===")
print("""
Mining:
  - Nonce
  - Hash
  - Target

Example:
  nonce = 0
  while True:
    hash = SHA256(block + nonce)
    if hash < target:
      break
    nonce += 1
""")

print("\n=== 3. Difficulty ===")
print("""
Difficulty:
  - Target
  - Adjust
  - Every 2016 blocks
  - 2 weeks

Example:
  Difficulty 1: 0x00000fff...
  Difficulty 2: 0x000007ff...
""")

print("\n=== 4. Reward ===")
print("""
Reward:
  - Block reward
  - Fees
  - Halving

Bitcoin:
  2009: 50 BTC
  2012: 25 BTC
  2016: 12.5 BTC
  2020: 6.25 BTC
  2024: 3.125 BTC
""")

print("\n=== 5. Mining Pools ===")
print("""
Pools:
  - Combine
  - Share reward
  - Faster

Example:
  Pool
  → Miners
  → Share
""")

print("\n=== 6. ASICs ===")
print("""
ASICs:
  - Application-Specific
  - Bitcoin
  - SHA-256
  - Fast

Example:
  Antminer
  → 100 TH/s
""")

print("\n=== 7. Energy ===")
print("""
Energy:
  - High
  - Bitcoin: ~150 TWh/year
  - Environmental

Example:
  Bitcoin
  → Argentina
  → Energy
""")

print("\n=== 8. Python PoW ===")
print("""
import hashlib

def proof_of_work(block, difficulty=4):
    \"\"\"Find nonce.\"\"\"
    target = "0" * difficulty
    nonce = 0
    while True:
        block_string = f"{block}{nonce}".encode()
        h = hashlib.sha256(block_string).hexdigest()
        if h.startswith(target):
            return nonce, h
        nonce += 1

# Example
# nonce, h = proof_of_work("block_data", 4)
""")

print("\n=== 9. 51% Attack ===")
print("""
51%:
  - Majority hash
  - Double spend
  - Reorg
  - Rare

Example:
  Attacker 51%
  → Control
  → Attack
""")

print("\n=== 10. Use Cases ===")
print("""
Use cases:
  - Bitcoin
  - Litecoin
  - Dogecoin
  - Monero
""")

💰 Proof of Stake

🎯 Staking

Proof of Stake (PoS) selects validators based on the amount of cryptocurrency they stake. It's energy-efficient and faster than PoW.

PoS

Stake: Deposit. Validator: Node. Reward: Interest. Slashing: Penalty. Energy: Low. Ethereum: PoS.

💰 Stake💰 Validator💰 Reward💰 Slashing

# Proof of Stake
print("=== 1. What is PoS? ===")
print("""
PoS:
  - Validators
  - Stake
  - Reward
  - Energy efficient

Goal:
  - Select validator
  - Based on stake
  - Random
""")

print("\n=== 2. Staking ===")
print("""
Staking:
  - Lock tokens
  - Validator
  - Reward

Example:
  Stake 32 ETH
  → Validator
  → Reward
""")

print("\n=== 3. Validator Selection ===")
print("""
Selection:
  - Random
  - Weighted
  - Stake

Example:
  Validator A: 100 ETH
  Validator B: 200 ETH
  → B more likely
""")

print("\n=== 4. Reward ===")
print("""
Reward:
  - Block reward
  - Fees
  - Interest

Ethereum:
  - ~4-5% APY
  - Validator
""")

print("\n=== 5. Slashing ===")
print("""
Slashing:
  - Penalty
  - Malicious
  - Downtime

Example:
  Double sign
  → Slashed
  → Lose stake
""")

print("\n=== 6. Delegated PoS ===")
print("""
DPoS:
  - Delegates
  - Vote
  - Fast

Example:
  EOS
  → 21 delegates
""")

print("\n=== 7. Liquid Staking ===")
print("""
Liquid:
  - Stake
  - Token
  - DeFi

Example:
  Lido
  → stETH
  → Trade
""")

print("\n=== 8. Ethereum Merge ===")
print("""
Merge:
  - 2022
  - PoW → PoS
  - 99.95% less energy

Example:
  Ethereum
  → PoS
  → Green
""")

print("\n=== 9. Python PoS ===")
print("""
import random

def select_validator(validators):
    \"\"\"Select validator based on stake.\"\"\"
    total = sum(v['stake'] for v in validators)
    r = random.uniform(0, total)
    upto = 0
    for v in validators:
        if upto + v['stake'] >= r:
            return v
        upto += v['stake']

# Example
# validators = [
#     {'name': 'A', 'stake': 100},
#     {'name': 'B', 'stake': 200},
# ]
# selected = select_validator(validators)
""")

print("\n=== 10. Use Cases ===")
print("""
Use cases:
  - Ethereum
  - Cardano
  - Solana
  - Polkadot
  - Cosmos
""")

📜 Smart Contracts

🎯 Self-Executing Contracts

Smart contracts are self-executing programs stored on a blockchain that automatically enforce and execute agreements when conditions are met.

Smart Contracts

Self-executing: Automatic. Immutable: Cannot change. Transparent: Public. Solidity: Language. EVM: Runtime. Gas: Fee.

📜 Self-executing📜 Immutable📜 Solidity📜 Gas

# Smart Contracts
print("=== 1. What is a Smart Contract? ===")
print("""
Smart contract:
  - Program
  - Blockchain
  - Self-executing
  - Immutable

Example:
  if condition:
    execute
  → Automatic
""")

print("\n=== 2. Solidity ===")
print("""
Solidity:
  - Language
  - Ethereum
  - C-like
  - Compiled

Example:
  pragma solidity ^0.8.0;
  
  contract SimpleStorage {
      uint256 storedData;
      
      function set(uint256 x) public {
          storedData = x;
      }
      
      function get() public view returns (uint256) {
          return storedData;
      }
  }
""")

print("\n=== 3. EVM ===")
print("""
EVM:
  - Ethereum Virtual Machine
  - Runtime
  - Bytecode
  - Gas

Example:
  Solidity → Bytecode
  → EVM
  → Execute
""")

print("\n=== 4. Gas ===")
print("""
Gas:
  - Fee
  - Computation
  - Storage
  - Prevent spam

Example:
  Simple transfer: 21,000 gas
  Complex: more
""")

print("\n=== 5. Deployment ===")
print("""
Deployment:
  - Compile
  - Deploy
  - Address
  - Immutable

Example:
  Remix
  → Deploy
  → Address
""")

print("\n=== 6. ERC-20 ===")
print("""
ERC-20:
  - Token standard
  - Fungible
  - Ethereum

Functions:
  - transfer
  - balanceOf
  - approve
  - transferFrom
""")

print("\n=== 7. ERC-721 ===")
print("""
ERC-721:
  - NFT standard
  - Non-fungible
  - Unique

Functions:
  - ownerOf
  - transferFrom
  - tokenURI
""")

print("\n=== 8. Security ===")
print("""
Security:
  - Reentrancy
  - Overflow
  - Access control
  - Audit

Example:
  The DAO hack
  → Reentrancy
  → $60M
""")

print("\n=== 9. Python Web3 ===")
print("""
from web3 import Web3

# Connect
w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_KEY'))

# Contract
abi = [...]
address = '0x...'
contract = w3.eth.contract(address=address, abi=abi)

# Call
result = contract.functions.balanceOf('0x...').call()

# Transact
tx = contract.functions.transfer('0x...', 100).buildTransaction({
    'from': '0x...',
    'nonce': w3.eth.getTransactionCount('0x...'),
    'gas': 200000,
    'gasPrice': w3.toWei('50', 'gwei')
})
""")

print("\n=== 10. Use Cases ===")
print("""
Use cases:
  - DeFi
  - NFTs
  - DAOs
  - Supply chain
  - Voting
  - Identity
""")

💎 Ethereum & Solidity

🎯 Ethereum Platform

Ethereum is a decentralized platform that runs smart contracts. It's the second-largest cryptocurrency and the foundation of DeFi, NFTs, and Web3.

Ethereum

EVM: Runtime. Solidity: Language. Gas: Fee. ETH: Currency. Smart contracts: dApps. Layer 2: Scaling.

💎 EVM💎 Solidity💎 Gas💎 Layer 2

# Ethereum & Solidity
print("=== 1. What is Ethereum? ===")
print("""
Ethereum:
  - Platform
  - Smart contracts
  - dApps
  - 2015

Founder:
  - Vitalik Buterin
  - 2013 whitepaper
  - 2015 mainnet
""")

print("\n=== 2. ETH ===")
print("""
ETH:
  - Cryptocurrency
  - Gas
  - Staking
  - 2nd largest

Example:
  1 ETH = $...
""")

print("\n=== 3. EVM ===")
print("""
EVM:
  - Ethereum Virtual Machine
  - Runtime
  - Bytecode
  - Deterministic

Example:
  Solidity → Bytecode
  → EVM
  → Execute
""")

print("\n=== 4. Solidity ===")
print("""
Solidity:
  - Language
  - C-like
  - Compiled
  - Smart contracts

Example:
  pragma solidity ^0.8.0;
  
  contract Hello {
      string public greeting = "Hello";
      
      function setGreeting(string memory _greeting) public {
          greeting = _greeting;
      }
  }
""")

print("\n=== 5. Gas ===")
print("""
Gas:
  - Fee
  - Computation
  - Storage
  - EIP-1559

Example:
  Base fee + priority fee
  → Gas price
""")

print("\n=== 6. Layer 2 ===")
print("""
Layer 2:
  - Scaling
  - Off-chain
  - Rollups
  - Fast

Types:
  - Optimistic
  - ZK
  - Sidechains

Examples:
  - Arbitrum
  - Optimism
  - Polygon
  - zkSync
""")

print("\n=== 7. DeFi ===")
print("""
DeFi:
  - Decentralized Finance
  - Lending
  - DEX
  - Yield

Examples:
  - Uniswap
  - Aave
  - Compound
  - MakerDAO
""")

print("\n=== 8. NFTs ===")
print("""
NFT:
  - Non-Fungible Token
  - Unique
  - ERC-721
  - Digital ownership

Examples:
  - CryptoPunks
  - Bored Apes
  - Art
""")

print("\n=== 9. DAOs ===")
print("""
DAO:
  - Decentralized Autonomous Organization
  - Governance
  - Token
  - Voting

Examples:
  - MakerDAO
  - Uniswap
  - Aragon
""")

print("\n=== 10. Python Web3 ===")
print("""
from web3 import Web3

# Connect
w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_KEY'))

# Check connection
print(w3.isConnected())

# Get balance
balance = w3.eth.getBalance('0x...')
print(w3.fromWei(balance, 'ether'))

# Get block
block = w3.eth.getBlock('latest')
print(block.number)
""")

👛 Wallets & Transactions

🎯 Keys and Transactions

Wallets store private keys and sign transactions. Transactions transfer value or call smart contracts on the blockchain.

Wallets

Private key: Secret. Public key: Share. Address: Receive. Hot: Online. Cold: Offline. Hardware: Secure.

👛 Private key👛 Public key👛 Address👛 Hardware

# Wallets & Transactions
print("=== 1. Wallet ===")
print("""
Wallet:
  - Stores keys
  - Signs transactions
  - Not coins

Types:
  - Hot wallet
  - Cold wallet
  - Hardware
  - Paper
""")

print("\n=== 2. Keys ===")
print("""
Keys:
  - Private key: secret
  - Public key: derived
  - Address: derived

Example:
  Private: 0x...
  Public: 0x...
  Address: 0x...
""")

print("\n=== 3. Address ===")
print("""
Address:
  - Derived from public key
  - Hash
  - Base58 (Bitcoin)
  - Hex (Ethereum)

Example:
  Bitcoin: 1A1zP1...
  Ethereum: 0x742d35...
""")

print("\n=== 4. Transaction ===")
print("""
Transaction:
  - From
  - To
  - Value
  - Gas
  - Nonce
  - Signature

Example:
  {
    from: '0x...',
    to: '0x...',
    value: 100,
    gas: 21000,
    nonce: 0
  }
""")

print("\n=== 5. Signing ===")
print("""
Signing:
  - Private key
  - Transaction
  - Signature
  - Broadcast

Example:
  sign(tx, private_key)
  → signature
  → broadcast
""")

print("\n=== 6. Nonce ===")
print("""
Nonce:
  - Transaction count
  - Prevent replay
  - Order

Example:
  Nonce 0: first
  Nonce 1: second
""")

print("\n=== 7. Gas ===")
print("""
Gas:
  - Fee
  - Limit
  - Price

Example:
  Gas limit: 21000
  Gas price: 50 gwei
  Fee: 0.00105 ETH
""")

print("\n=== 8. Python Wallet ===")
print("""
from eth_account import Account
from web3 import Web3

# Create account
acct = Account.create()
print(acct.address)
print(acct.key.hex())

# Sign transaction
tx = {
    'to': '0x...',
    'value': Web3.toWei(0.01, 'ether'),
    'gas': 21000,
    'gasPrice': Web3.toWei(50, 'gwei'),
    'nonce': 0,
    'chainId': 1
}
signed = acct.sign_transaction(tx)
print(signed.rawTransaction.hex())
""")

print("\n=== 9. Hardware Wallets ===")
print("""
Hardware:
  - Ledger
  - Trezor
  - Cold storage
  - Secure

Example:
  Ledger
  → Private key
  → Offline
""")

print("\n=== 10. Use Cases ===")
print("""
Use cases:
  - Store crypto
  - Sign transactions
  - DeFi
  - NFTs
  - Identity
""")

🏢 Public vs Private

🎯 Types of Blockchains

Blockchains can be classified as public (permissionless), private (permissioned), or consortium (semi-decentralized).

Types

Public: Open. Private: Restricted. Consortium: Group. Permissionless: Anyone. Permissioned: Approved. Hybrid: Mixed.

🏢 Public🏢 Private🏢 Consortium🏢 Hybrid

# Public vs Private
print("=== 1. Public Blockchain ===")
print("""
Public:
  - Open
  - Permissionless
  - Decentralized
  - Anyone

Examples:
  - Bitcoin
  - Ethereum
  - Litecoin

Pros:
  - Trustless
  - Transparent
  - Censorship-resistant

Cons:
  - Slow
  - Energy
  - Privacy
""")

print("\n=== 2. Private Blockchain ===")
print("""
Private:
  - Restricted
  - Permissioned
  - Centralized
  - Approved

Examples:
  - Hyperledger Fabric
  - Corda
  - Quorum

Pros:
  - Fast
  - Private
  - Controlled

Cons:
  - Less decentralized
  - Trust needed
""")

print("\n=== 3. Consortium ===")
print("""
Consortium:
  - Group
  - Semi-decentralized
  - Governed
  - Approved

Examples:
  - R3 Corda
  - Energy Web
  - Marco Polo

Pros:
  - Balanced
  - Efficient
  - Collaborative

Cons:
  - Complexity
  - Governance
""")

print("\n=== 4. Hybrid ===")
print("""
Hybrid:
  - Public + private
  - Best of both
  - Flexible

Examples:
  - Dragonchain
  - XinFin
  - Kadena
""")

print("\n=== 5. Permissionless ===")
print("""
Permissionless:
  - Anyone
  - No approval
  - Public

Example:
  Bitcoin
  → Anyone can join
""")

print("\n=== 6. Permissioned ===")
print("""
Permissioned:
  - Approval
  - Known
  - Private

Example:
  Hyperledger
  → Approved
""")

print("\n=== 7. Comparison ===")
print(f"{'Type':<20} {'Access':<15} {'Speed':<15} {'Privacy':<15}")
print("-" * 65)
print(f"{'Public':<20} {'Open':<15} {'Slow':<15} {'Low':<15}")
print(f"{'Private':<20} {'Restricted':<15} {'Fast':<15} {'High':<15}")
print(f"{'Consortium':<20} {'Group':<15} {'Fast':<15} {'Medium':<15}")
print(f"{'Hybrid':<20} {'Mixed':<15} {'Medium':<15} {'Medium':<15}")

print("\n=== 8. Use Cases ===")
print("""
Public:
  - Cryptocurrency
  - DeFi
  - NFTs

Private:
  - Enterprise
  - Supply chain
  - Healthcare

Consortium:
  - Banking
  - Trade finance
  - Energy
""")

print("\n=== 9. Choosing ===")
print("""
Choose:
  - Public: trustless, open
  - Private: fast, private
  - Consortium: collaborative
  - Hybrid: flexible
""")

print("\n=== 10. Python Hyperledger ===")
print("""
# Hyperledger Fabric SDK
# Python: fabric-sdk-py

from hfc.fabric import Client

cli = Client(net_profile="network.json")
org = cli.get_org("Org1")
user = cli.get_user(org, "Admin")

# Query
response = cli.query_chaincode(
    requestor=user,
    channel_name="mychannel",
    chaincode_name="mycc",
    fcn="query",
    args=["a"]
)
""")

🐍 Python Implementation

🎯 Building a Blockchain in Python

You can implement a simple blockchain in Python to understand the fundamentals. Here's how.

Python

Block: Class. Chain: List. Hash: SHA-256. PoW: Mining. Web3: Ethereum. Test: Unit.

🐍 Block🐍 Chain🐍 Hash🐍 Web3

# Python Implementation
print("=== 1. Block Class ===")
print("""
import hashlib
import json
import time

class Block:
    def __init__(self, index, transactions, previous_hash, timestamp=None):
        self.index = index
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.timestamp = timestamp or time.time()
        self.nonce = 0
        self.hash = self.compute_hash()
    
    def compute_hash(self):
        block_string = json.dumps({
            'index': self.index,
            'transactions': self.transactions,
            'previous_hash': self.previous_hash,
            'timestamp': self.timestamp,
            'nonce': self.nonce
        }, sort_keys=True)
        return hashlib.sha256(block_string.encode()).hexdigest()
    
    def mine(self, difficulty=4):
        target = "0" * difficulty
        while not self.hash.startswith(target):
            self.nonce += 1
            self.hash = self.compute_hash()
        return self.hash
""")

print("\n=== 2. Blockchain Class ===")
print("""
class Blockchain:
    def __init__(self, difficulty=4):
        self.chain = [self.create_genesis()]
        self.difficulty = difficulty
        self.pending_transactions = []
    
    def create_genesis(self):
        return Block(0, ["Genesis Block"], "0")
    
    def get_last_block(self):
        return self.chain[-1]
    
    def add_block(self, block):
        block.previous_hash = self.get_last_block().hash
        block.mine(self.difficulty)
        self.chain.append(block)
        return block
    
    def add_transaction(self, transaction):
        self.pending_transactions.append(transaction)
        return True
    
    def mine_pending(self):
        block = Block(
            len(self.chain),
            self.pending_transactions,
            self.get_last_block().hash
        )
        self.add_block(block)
        self.pending_transactions = []
        return block
    
    def is_valid(self):
        for i in range(1, len(self.chain)):
            current = self.chain[i]
            previous = self.chain[i-1]
            if current.hash != current.compute_hash():
                return False
            if current.previous_hash != previous.hash:
                return False
        return True
""")

print("\n=== 3. Usage ===")
print("""
# Create blockchain
bc = Blockchain(difficulty=4)

# Add transactions
bc.add_transaction({"from": "Alice", "to": "Bob", "amount": 10})
bc.add_transaction({"from": "Bob", "to": "Charlie", "amount": 5})

# Mine
block = bc.mine_pending()
print(f"Mined block: {block.hash}")

# Verify
print(f"Valid: {bc.is_valid()}")

# Print chain
for b in bc.chain:
    print(f"Block {b.index}: {b.hash[:16]}...")
""")

print("\n=== 4. Web3 Ethereum ===")
print("""
from web3 import Web3

# Connect
w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_KEY'))

# Check
print(f"Connected: {w3.isConnected()}")

# Balance
balance = w3.eth.getBalance('0x...')
print(f"Balance: {w3.fromWei(balance, 'ether')} ETH")

# Block
block = w3.eth.getBlock('latest')
print(f"Block: {block.number}")

# Transaction
tx = w3.eth.getTransaction('0x...')
print(f"From: {tx['from']}")
print(f"To: {tx['to']}")
print(f"Value: {w3.fromWei(tx['value'], 'ether')} ETH")
""")

print("\n=== 5. Smart Contract ===")
print("""
from web3 import Web3
import json

# Connect
w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_KEY'))

# Load ABI
with open('abi.json') as f:
    abi = json.load(f)

# Contract
address = '0x...'
contract = w3.eth.contract(address=address, abi=abi)

# Call
name = contract.functions.name().call()
symbol = contract.functions.symbol().call()
total = contract.functions.totalSupply().call()

print(f"Name: {name}")
print(f"Symbol: {symbol}")
print(f"Total: {total}")
""")

print("\n=== 6. Sign Transaction ===")
print("""
from eth_account import Account
from web3 import Web3

# Account
acct = Account.from_key('0x...')

# Transaction
tx = {
    'to': '0x...',
    'value': Web3.toWei(0.01, 'ether'),
    'gas': 21000,
    'gasPrice': Web3.toWei(50, 'gwei'),
    'nonce': 0,
    'chainId': 1
}

# Sign
signed = acct.sign_transaction(tx)
print(signed.rawTransaction.hex())

# Send
# w3.eth.sendRawTransaction(signed.rawTransaction)
""")

print("\n=== 7. Unit Test ===")
print("""
import unittest

class TestBlockchain(unittest.TestCase):
    def test_genesis(self):
        bc = Blockchain()
        self.assertEqual(len(bc.chain), 1)
        self.assertEqual(bc.chain[0].index, 0)
    
    def test_add_block(self):
        bc = Blockchain()
        bc.add_transaction({"from": "A", "to": "B", "amount": 10})
        bc.mine_pending()
        self.assertEqual(len(bc.chain), 2)
    
    def test_valid(self):
        bc = Blockchain()
        bc.add_transaction({"from": "A", "to": "B", "amount": 10})
        bc.mine_pending()
        self.assertTrue(bc.is_valid())
    
    def test_tamper(self):
        bc = Blockchain()
        bc.add_transaction({"from": "A", "to": "B", "amount": 10})
        bc.mine_pending()
        bc.chain[1].transactions = [{"from": "A", "to": "B", "amount": 100}]
        self.assertFalse(bc.is_valid())

if __name__ == '__main__':
    unittest.main()
""")

print("\n=== 8. Libraries ===")
print("""
Libraries:
  - web3.py: Ethereum
  - eth-account: Accounts
  - pycryptodome: Crypto
  - ecdsa: Signatures
  - bitcoinlib: Bitcoin
  - solcx: Solidity
  - brownie: Framework
  - eth-tester: Testing
""")

print("\n=== 9. Complete Example ===")
print("""
# Simple blockchain
import hashlib
import json
import time

class Block:
    def __init__(self, index, transactions, previous_hash):
        self.index = index
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.timestamp = time.time()
        self.nonce = 0
        self.hash = self.compute_hash()
    
    def compute_hash(self):
        block_string = json.dumps(self.__dict__, sort_keys=True)
        return hashlib.sha256(block_string.encode()).hexdigest()
    
    def mine(self, difficulty=4):
        target = "0" * difficulty
        while not self.hash.startswith(target):
            self.nonce += 1
            self.hash = self.compute_hash()

# Create
block = Block(1, ["tx1", "tx2"], "0")
block.mine(4)
print(f"Block: {block.hash}")
""")

print("\n=== 10. Use Cases ===")
print("""
Use cases:
  - Learning
  - Prototyping
  - Testing
  - dApps
  - DeFi
  - NFTs
""")

⚖️ Comparison

🎯 Blockchain Platforms

Choosing the right blockchain platform depends on your use case, scalability needs, and development ecosystem.

Comparison

Bitcoin: Store of value. Ethereum: Smart contracts. Solana: Speed. Cardano: Research. Polygon: Layer 2. Hyperledger: Enterprise.

⚖️ Bitcoin⚖️ Ethereum⚖️ Solana⚖️ Hyperledger

Platform	Consensus	TPS	Smart Contracts	Best For
Bitcoin	PoW	7	Limited	Store of value
Ethereum	PoS	15-30	Yes	dApps, DeFi
Solana	PoH + PoS	65,000	Yes	High speed
Cardano	PoS	250	Yes	Research
Polygon	PoS	7,000	Yes	Layer 2
Binance Smart Chain	PoSA	160	Yes	Low fees
Hyperledger	PBFT/Raft	3,500	Yes	Enterprise
Avalanche	PoS	4,500	Yes	DeFi
Polkadot	NPoS	1,000	Yes	Interoperability
Cosmos	Tendermint	10,000	Yes	Interoperability

# Decision Guide
print("=== Choose Platform by Use Case ===")
print("""
Store of value:
  → Bitcoin

dApps / DeFi:
  → Ethereum
  → Polygon
  → Solana

High speed:
  → Solana
  → Avalanche

Low fees:
  → Polygon
  → BSC
  → Solana

Enterprise:
  → Hyperledger
  → Corda
  → Quorum

Interoperability:
  → Polkadot
  → Cosmos

Research:
  → Cardano
""")

print("\n=== Speed Comparison ===")
print(f"{'Platform':<20} {'TPS':<15} {'Block Time':<15} {'Finality':<15}")
print("-" * 65)
print(f"{'Bitcoin':<20} {'7':<15} {'10 min':<15} {'60 min':<15}")
print(f"{'Ethereum':<20} {'15-30':<15} {'12 sec':<15} {'6 min':<15}")
print(f"{'Solana':<20} {'65,000':<15} {'400 ms':<15} {'~1 sec':<15}")
print(f"{'Polygon':<20} {'7,000':<15} {'2 sec':<15} {'30 min':<15}")
print(f"{'BSC':<20} {'160':<15} {'3 sec':<15} {'15 sec':<15}")
print(f"{'Avalanche':<20} {'4,500':<15} {'2 sec':<15} {'1 sec':<15}")

print("\n=== When to Use Which ===")
print("""
USE Bitcoin:
  ✓ Store of value
  ✓ Digital gold
  ✓ Security

USE Ethereum:
  ✓ Smart contracts
  ✓ DeFi
  ✓ NFTs
  ✓ dApps

USE Solana:
  ✓ High speed
  ✓ Low fees
  ✓ DeFi

USE Polygon:
  ✓ Layer 2
  ✓ Ethereum scaling
  ✓ Low fees

USE Hyperledger:
  ✓ Enterprise
  ✓ Permissioned
  ✓ Supply chain
""")

❓ FAQ

🎯 Frequently Asked Questions

Answers to common questions about blockchain.

What is blockchain?

What is the difference between Proof of Work and Proof of Stake?

Proof of Work (PoW) requires miners to solve computational puzzles to validate blocks, consuming significant energy (e.g., Bitcoin). Proof of Stake (PoS) selects validators based on the amount of cryptocurrency they stake, consuming far less energy (e.g., Ethereum 2.0). PoS is faster and more energy-efficient.

What is a smart contract?

A smart contract is a self-executing program stored on a blockchain that automatically enforces and executes the terms of an agreement when predefined conditions are met. Smart contracts are written in languages like Solidity (Ethereum) and enable decentralized applications (dApps), DeFi, and NFTs.

What is the difference between public and private blockchains?

Public blockchains (e.g., Bitcoin, Ethereum) are open to anyone, permissionless, and decentralized. Private blockchains (e.g., Hyperledger Fabric) are restricted, permissioned, and controlled by an organization. Consortium blockchains are semi-decentralized, governed by a group.

What is Web3?

Web3 refers to a decentralized internet built on blockchain technology, where users own their data and digital assets. It includes DeFi (decentralized finance), NFTs (non-fungible tokens), DAOs (decentralized autonomous organizations), and dApps (decentralized applications).

What is a hash function?

A hash function takes an input and produces a fixed-size output (hash). It's one-way, deterministic, and collision-resistant. Blockchain uses SHA-256 (Bitcoin) and Keccak-256 (Ethereum) for block hashing, Merkle trees, and mining.

What is a Merkle tree?

A Merkle tree is a hash tree where each leaf node is a hash of a transaction, and each non-leaf node is a hash of its children. The root hash (Merkle root) represents all transactions in a block, enabling efficient verification.

What is gas in Ethereum?

Gas is the fee required to execute transactions or smart contracts on Ethereum. It's measured in gas units, and the price is denominated in gwei (1 gwei = 10⁻⁹ ETH). Gas prevents spam and compensates validators.

What is a 51% attack?

A 51% attack occurs when a single entity controls more than 50% of the network's mining power (PoW) or stake (PoS). This allows them to double-spend, censor transactions, or reorganize the chain. It's rare but possible on smaller networks.

What is the difference between a hot wallet and a cold wallet?

A hot wallet is connected to the internet (e.g., MetaMask, exchange wallets) and convenient but less secure. A cold wallet is offline (e.g., Ledger, Trezor, paper wallets) and more secure but less convenient. Use cold wallets for large amounts.

# Quick Reference
print("=== Quick Answers ===")
print("""
Q: What is blockchain?
A: Distributed, decentralized, immutable ledger.

Q: What is a block?
A: Header + transactions + previous hash.

Q: What is a hash?
A: One-way fixed-size output.

Q: What is consensus?
A: Agreement on ledger state.

Q: PoW vs PoS?
A: PoW = mining; PoS = staking.

Q: What is a smart contract?
A: Self-executing program on blockchain.

Q: What is Ethereum?
A: Platform for smart contracts.

Q: What is Solidity?
A: Language for Ethereum smart contracts.

Q: What is a wallet?
A: Stores private keys.

Q: What is gas?
A: Fee for Ethereum transactions.

Q: What is Web3?
A: Decentralized internet.

Q: Free?
A: Yes — most blockchains are open source.
""")

🚀 Future

🎯 Where Blockchain Is Going

The future is scalability, interoperability, AI + blockchain, DeFi, Web3, and regulation.

Future Directions

Scalability: Layer 2. Interoperability: Cross-chain. AI: Integration. DeFi: Growth. Web3: Decentralized. Regulation: Clear.

🚀 Scalability🚀 Interoperability🚀 AI🚀 Web3

# Future of Blockchain
print("=== 1. Scalability ===")
print("""
Trend: Scalability

Current:
  - Bitcoin: 7 TPS
  - Ethereum: 15 TPS

Future:
  - Layer 2
  - Rollups
  - Sharding
  - 100,000+ TPS

Examples:
  - Arbitrum
  - Optimism
  - zkSync
  - Polygon

Future:
  - Fast
  - Cheap
  - Scalable
""")

print("\n=== 2. Interoperability ===")
print("""
Trend: Cross-chain

Current:
  - Isolated chains

Future:
  - Interoperable
  - Cross-chain
  - Bridges

Examples:
  - Polkadot
  - Cosmos
  - LayerZero
  - Wormhole

Future:
  - Unified
  - Connected
  - Seamless
""")

print("\n=== 3. AI + Blockchain ===")
print("""
Trend: AI + blockchain

Ideas:
  - AI agents
  - Decentralized AI
  - Federated learning
  - Data marketplaces

Examples:
  - Fetch.ai
  - SingularityNET
  - Ocean Protocol

Future:
  - AI on-chain
  - Decentralized
  - Autonomous
""")

print("\n=== 4. DeFi ===")
print("""
Trend: DeFi

Current:
  - Lending
  - DEX
  - Yield

Future:
  - Institutional
  - Real-world assets
  - Regulation

Examples:
  - Uniswap
  - Aave
  - Compound
  - MakerDAO

Future:
  - Mainstream
  - Regulated
  - Integrated
""")

print("\n=== 5. Web3 ===")
print("""
Trend: Web3

Current:
  - Early

Future:
  - Decentralized
  - User-owned
  - Privacy

Examples:
  - dApps
  - DAOs
  - NFTs
  - Metaverse

Future:
  - Mainstream
  - Decentralized
  - User-centric
""")

print("\n=== 6. Regulation ===")
print("""
Trend: Regulation

Current:
  - Uncertain

Future:
  - Clear
  - Compliance
  - CBDCs

Examples:
  - SEC
  - MiCA (EU)
  - CBDCs

Future:
  - Clear rules
  - Institutional
  - Mainstream
""")

# TIMELINE
print("\n=== Timeline ===")
print("""
Past:
  2008: Bitcoin whitepaper
  2009: Genesis block
  2015: Ethereum
  2017: ICO boom
  2020: DeFi summer
  2021: NFT boom
  2022: Ethereum Merge

Present:
  2025: Layer 2
  2026: Interoperability

Future:
  2030: AI + blockchain
  2035: Web3
  2040: Mainstream?
""")

print("\n=== Final Thoughts ===")
print("""
Blockchain is:
  - Transforming trust
  - Decentralized
  - Transparent
  - Evolving

The future is:
  - Scalable
  - Interoperable
  - AI-powered
  - DeFi
  - Web3
  - Regulated

"The blockchain is the trust machine."

Keep exploring. Keep building.
""")