Blockchain Technology — Foundations to Web3

A blockchain is an append-only, cryptographically linked ledger that is replicated across many independent computers (nodes) and updated only when those nodes agree on the next batch of records via a consensus algorithm. This combination — cryptography + peer-to-peer networking + economic incentives — enables strangers who do not trust each other to share a single source of truth without a central operator. It is important early to separate what blockchains ARE good at (verifiable state, censorship-resistant settlement, programmable digital assets, transparent audit trails) from what they are NOT good at (storing large files, private business data by default, and replacing every database). Most 'blockchain use-case failures' come from applying the technology to a problem that a well-run centralized database would solve for a fraction of the cost.

The industry has moved through three broad eras. Blockchain 1.0 (2009→) was Bitcoin — digital scarcity, sound money, and a proof-of-work consensus that pays miners to secure a payments ledger. Blockchain 2.0 (2015→) was Ethereum — a Turing-complete virtual machine (EVM) that runs smart contracts, unlocking programmable assets, ICOs, and DeFi. Blockchain 3.0 (2020→) is the multi-chain world: proof-of-stake (Ethereum merged in 2022), layer-2 rollups (Arbitrum, Optimism, Base, zkSync), alternative L1s (Solana, Avalanche, Cosmos, Aptos), interoperability (Polkadot, Chainlink CCIP), and the rise of NFTs, DAOs, and Web3 applications. Alongside public chains, permissioned/enterprise chains (Hyperledger Fabric, R3 Corda, Quorum) target supply chain, trade finance, and interbank settlement.

This course is organized around the layers of the blockchain stack: cryptography → data structures → consensus → smart contracts → applications (DeFi, NFTs, DAOs, Web3) → real-world integration and regulation. Because vocabulary is dense, treat every module's key-term list as flashcards. Because the space evolves fast, prefer primary sources (Bitcoin whitepaper, Ethereum yellow paper, project docs) over hype coverage. To learn blockchain deeply you must eventually WRITE and READ code — plan on installing MetaMask on a test wallet, using a public testnet (Sepolia), and stepping through a Solidity 'Hello World' contract in Remix. This course delivers all the conceptual foundation and pushes you to the point where the hands-on tutorials click.

Cryptographic hash functions are the foundation of every blockchain. A hash function (Bitcoin uses SHA-256; Ethereum uses Keccak-256, an early SHA-3 variant) takes any input and produces a fixed-length, deterministic, pseudo-random-looking output called a digest. The critical security properties are: (1) preimage resistance — given a hash, it is computationally infeasible to find an input that produces it; (2) second-preimage resistance — given input x, it is hard to find a different y with the same hash; (3) collision resistance — it is hard to find any two inputs with the same hash. These properties let a blockchain 'seal' each block: any change to a past block's data changes its hash, which changes every subsequent block's hash, which any full node instantly detects.

Public-key cryptography (asymmetric encryption) provides ownership and non-repudiation. Bitcoin and Ethereum use the ECDSA signature scheme over the secp256k1 elliptic curve; Ed25519 (Solana, Cardano, newer chains) is faster and easier to implement correctly. A user generates a private key (a 256-bit random number — NEVER share, NEVER commit to Git, NEVER type into a website), from which the public key is deterministically derived. The blockchain ADDRESS is a hashed and encoded version of the public key: Bitcoin uses double-SHA-256 and RIPEMD-160 with Base58Check or Bech32; Ethereum uses the last 20 bytes of Keccak-256(public_key) presented as a 0x-prefixed hex string. Signatures prove that the private-key holder authorized a transaction; anyone can verify the signature against the public key, but only the holder can produce it. Loss or theft of the private key = permanent loss of funds — there is no password reset.

Merkle trees are the data-structure trick that lets blockchains verify large batches of transactions with tiny proofs. Every leaf is the hash of a transaction; each internal node is the hash of its two children's hashes; the root of the tree is stored in the block header. A 'Merkle proof' shows that a specific transaction is included in a block by supplying only the log₂(n) sibling hashes on the path from the leaf to the root — dramatically cheaper than sending the whole block. Simplified Payment Verification (SPV) wallets and light clients rely on this property. Modern chains extend the idea: Ethereum uses a Merkle-Patricia trie to authenticate state (balances, contract storage, code), and zero-knowledge rollups compress thousands of transactions into a single SNARK proof that the resulting state root is valid.

A Bitcoin block has two parts: the header (~80 bytes: previous block hash, Merkle root, timestamp, difficulty target, nonce, version) and the body (a list of transactions, the first of which is the 'coinbase' transaction paying the miner). Each block's header includes the hash of the previous block header, which is exactly what makes the chain a chain — mutation of any past block breaks every subsequent hash. Bitcoin targets a 10-minute average block time by adjusting mining difficulty every 2016 blocks (~2 weeks). Block size soft-cap is ~1 MB (weight-based limit up to 4M weight units after SegWit). Every 210,000 blocks (~4 years) the coinbase reward halves — the 'halving' — and total supply is capped at 21,000,000 BTC.

Bitcoin uses the UTXO (Unspent Transaction Output) model. Your 'balance' is not a stored number; it is the sum of unspent outputs your keys can unlock. A transaction consumes prior outputs and creates new outputs; the difference between inputs and outputs is the miner fee. UTXOs are all-or-nothing — if you have a 1.0 BTC output and spend 0.3 BTC, the transaction creates one 0.3 BTC output to the payee and one ~0.7 BTC 'change' output back to a fresh address. Ethereum, by contrast, uses the ACCOUNT model — each address has a mutable balance and (for contracts) storage. UTXO makes parallel transaction validation trivial and privacy easier through address rotation; account model is more natural for smart contracts because state persists per contract.

Bitcoin transactions are unlocked by a small stack-based scripting language called Script — intentionally NOT Turing-complete (no loops) to avoid halting-problem risks. The most common patterns are P2PKH (Pay-to-Public-Key-Hash — 'send to a normal address'), P2SH (Pay-to-Script-Hash — enables multisig), P2WPKH / P2WSH (SegWit versions that move witness data outside the base transaction), and P2TR / Taproot (2021 — Schnorr signatures + MAST, enabling more private and cheaper multisig). The mempool is the queue of unconfirmed transactions each node holds; miners select the highest-fee-per-byte transactions to build the next block. If two miners find a block at the same time, the chain temporarily forks; nodes follow the chain with the most cumulative proof-of-work, and transactions on the losing 'orphan' block return to the mempool. Six confirmations (~1 hour) is the traditional threshold for high-value settlements.

Consensus is how nodes without a central authority agree on the next block. Proof of Work (PoW), used by Bitcoin and originally by Ethereum, requires miners to repeatedly hash the block header with a varying 'nonce' until they find a hash below the network's difficulty target. Finding such a hash is expensive (real electricity + specialized ASICs); verifying it is trivial. The winning miner earns the block reward and fees. Security comes from the cost of a 51% attack: to rewrite history an attacker must out-hash the rest of the network. PoW's main criticisms are energy consumption and slower finality — a 6-confirmation Bitcoin transaction is only 'probabilistically final.'

Proof of Stake (PoS), used by Ethereum (post-Merge, September 2022), Cardano, Solana (variant), Avalanche, and most modern chains, replaces electricity with economic stake. Validators lock (stake) a minimum amount of the native token (32 ETH on Ethereum) and are pseudo-randomly selected to propose or attest to blocks. Correct behavior earns rewards; misbehavior (double-signing, going offline) is punished by 'slashing' — burning part or all of the stake. Modern PoS chains achieve much lower energy cost and faster finality — Ethereum's Gasper combines LMD-GHOST fork choice with Casper FFG finality gadget, delivering economic finality after 2 epochs (~12.8 minutes).

Beyond PoW/PoS, permissioned and hybrid networks use Byzantine-Fault-Tolerant (BFT) family algorithms — PBFT (Practical BFT, tolerant of ⅓ malicious nodes but requiring O(n²) messages), Tendermint (Cosmos), HotStuff (Diem, Aptos), Raft (Hyperledger Fabric — crash-fault tolerant only, not byzantine). Trade-offs to memorize: PoW = high security & censorship resistance, high energy, probabilistic finality. PoS = lower energy, faster finality, but weak-subjectivity checkpoints required for new nodes. BFT = instant finality with known validator set, does not scale to thousands of open participants. Sybil resistance (preventing an attacker from spinning up fake identities) is essential: PoW makes fake identities pointless because each needs hashpower; PoS requires each identity to lock capital; permissioned chains require identity verification off-chain.

Ethereum is a decentralized computer whose state is replicated across every full node. The Ethereum Virtual Machine (EVM) is a 256-bit stack-based virtual machine executing bytecode compiled from higher-level languages like Solidity, Vyper, or Yul. Ethereum has two account types: Externally Owned Accounts (EOAs — controlled by private keys, hold ETH, initiate transactions) and Contract Accounts (created by deploying code; hold ETH and mutable storage; execute code only when called by another account). Every operation costs GAS, priced in gwei (10⁻⁹ ETH). A transaction specifies gasLimit (max gas willing to burn) and maxFeePerGas / maxPriorityFeePerGas (EIP-1559 fee model, active since Aug 2021). Running out of gas reverts state changes but the gas is still paid — it prevents infinite loops.

Solidity is a statically-typed, contract-oriented language syntactically inspired by JavaScript/C++. A minimal contract: `pragma solidity ^0.8.20; contract Counter { uint256 public count; function inc() external { count += 1; } }`. Every state-mutating call is a transaction that must be signed and mined. Common patterns include ERC-20 (fungible tokens like USDC), ERC-721 (NFTs — unique tokens like CryptoPunks), ERC-1155 (multi-token standard for games and collections). Deploy contracts through Remix IDE (browser-based) or Hardhat / Foundry (professional tooling with local testnet, TypeScript/Rust test suites). Use public testnets like Sepolia for realistic development — never deploy first to mainnet.

Smart-contract security is a graveyard of high-value bugs. Classic categories: (1) Reentrancy — a malicious contract calls back into your contract before its state updates (the 2016 DAO hack lost $60M in ETH); mitigate with Checks-Effects-Interactions pattern or ReentrancyGuard. (2) Integer overflow/underflow — automatically checked in Solidity ≥0.8, but still possible in `unchecked{}` blocks. (3) Access control — always restrict privileged functions with `onlyOwner` or role-based modifiers. (4) Front-running / MEV — miners/validators can reorder or insert transactions; mitigate with commit-reveal or private mempools. (5) Oracle manipulation — pulling price from a single AMM lets flash-loan attackers manipulate reads; use Chainlink or TWAP. Always audit contracts (Cyfrin, Trail of Bits, Consensys Diligence), maintain a bug-bounty program (Immunefi), and use formal verification (Certora, K-EVM) for high-value protocols. Every dollar saved on audit has cost tens of millions in real hacks.

Decentralized Finance (DeFi) rebuilds banking primitives — trading, lending, derivatives, insurance — as open, composable smart contracts. Automated Market Makers (AMMs) like Uniswap replace order-book exchanges with liquidity pools; the price is a function of pool balances (the constant-product formula x·y = k). Liquidity providers earn trading fees but face impermanent loss when relative prices diverge. Lending protocols (Aave, Compound) let users deposit collateral, borrow against it, and earn interest — all algorithmically priced by utilization. Loans are over-collateralized (typically 150%+); if collateral value falls below the maintenance ratio, liquidators repay part of the debt and take a bonus from the collateral. Stablecoins are the plumbing: fiat-backed (USDC, USDT — an off-chain issuer holds reserves), crypto-collateralized (DAI — locked ETH/USDC in Maker), and algorithmic (mostly failed — Terra/UST collapse of May 2022 lost $40B).

Non-Fungible Tokens (NFTs, mostly ERC-721) are unique on-chain deeds — each token has a unique ID and often points to off-chain metadata (image, video, JSON on IPFS or Arweave). The core innovation is verifiable digital scarcity and provable ownership; the 2020–22 boom mixed genuine use cases (art, tickets, in-game items, domain names, membership) with a lot of speculation. NFTs have expanded to include music royalties, dynamic NFTs (metadata updates based on real-world data via oracles), soulbound tokens (SBTs — non-transferable identity/credential tokens), and real-world-asset tokenization (real estate deeds, invoices). Common pitfalls: metadata stored on centralized servers can be taken down, breaking the NFT visually; royalties are unenforceable at the protocol level (only in marketplaces that opt in).

Decentralized Autonomous Organizations (DAOs) use token voting to govern smart-contract-based treasuries and protocol parameters. Governance tokens (UNI, AAVE, MKR, COMP) grant proportional voting rights. Common architectures: Snapshot for gas-free off-chain signalling, Compound-style Governor contracts (proposal → 3-day voting → 2-day timelock → execution), and multisig admin keys (Gnosis Safe) as safety valves. Tokenomics — the design of token supply, distribution, and incentives — determines whether a project can bootstrap and sustain a network. Key questions: total supply and inflation schedule; distribution (team, investors, treasury, community); vesting cliffs and unlocks; utility (governance, fees, staking, access); and value accrual (fee capture, buyback-and-burn, protocol-owned liquidity). Bad tokenomics = mercenary liquidity that leaves the moment incentives dry up; good tokenomics rewards long-term alignment (veTokens, staking multipliers, real-yield distribution).

The scalability trilemma (Vitalik Buterin's framing) says a base blockchain can optimize at most two of decentralization, security, and scalability. Ethereum L1 currently prioritizes decentralization and security at the cost of throughput (~15 TPS base), leaving scale to Layer-2 solutions. Sidechains (Polygon PoS, Ronin) run their own consensus and periodically checkpoint to Ethereum — cheap and fast, but with weaker security assumptions than Ethereum itself. State channels (Lightning on Bitcoin, Raiden on Ethereum) let two parties transact off-chain and settle net on-chain — great for payments, weak for general apps.

Rollups are the leading L2 scaling strategy: bundle thousands of transactions off-chain, post the compressed data and a validity/fraud proof to Ethereum, inherit Ethereum's security. Optimistic rollups (Arbitrum, Optimism, Base) assume transactions are valid and allow a 7-day 'challenge window' during which anyone can post a fraud proof; withdrawals to L1 take 7 days unless a fast-withdrawal bridge is used. ZK rollups (zkSync, StarkNet, Polygon zkEVM, Scroll, Linea) post a zero-knowledge validity proof with every batch — instant finality, no challenge period, but higher prover cost. EIP-4844 (Dencun, March 2024) introduced 'blobs' that make rollup data 10–100× cheaper; danksharding is the long-term follow-up. As of 2024–25, L2s already carry 5–10× the transaction volume of Ethereum L1.

Alternative Layer-1s make different trilemma trade-offs. Solana pursues throughput (~65k TPS theoretical) with Proof of History (a verifiable delay function ordering time), high-spec validators, and parallel execution — trade-off is periodic network halts and higher hardware requirements. Cosmos (with Tendermint BFT) and Polkadot (with GRANDPA/BABE) build 'internets of blockchains' with sovereign chains connected via IBC / XCMP. Avalanche uses a novel snowman consensus for sub-second finality. Cardano bets on peer-reviewed research and formal methods (Ouroboros PoS). Newer high-performance chains (Aptos, Sui, Monad, Berachain) push parallel execution and Move-based VMs. Which chain 'wins' will likely be a portfolio — pick the right chain per workload, and design apps with bridging in mind. Bridges themselves have been the biggest source of hacks in crypto (>$2B lost 2021–23) — prefer canonical bridges or Chainlink CCIP over unaudited cross-chain solutions.

Enterprise blockchains are permissioned networks where identity is known and participants are vetted. Hyperledger Fabric (Linux Foundation) uses a modular architecture with pluggable consensus (Raft) and 'channels' for data segregation; used by Walmart for food traceability and IBM/Maersk's (former) TradeLens. R3 Corda targets financial services with a transaction-only model (no global broadcast) and legal-agreement centricity. Quorum (originally JPMorgan, now Consensys) is a permissioned Ethereum fork used in payments. Real-world enterprise wins have been narrower than early hype suggested — most successful projects involve regulatory reporting, cross-border payments, or trade finance where multiple mutually distrustful parties benefit from a shared source of truth.

Central Bank Digital Currencies (CBDCs) are sovereign digital cash, not cryptocurrencies. Retail CBDCs (China's e-CNY, Nigeria's eNaira, Bahamas' Sand Dollar) target consumers; wholesale CBDCs (Project Agorá, mBridge) target interbank settlement. Design choices dramatically affect privacy and financial inclusion: token-based vs account-based, direct central-bank vs two-tier intermediated, offline vs online only. As of 2024–25, 130+ countries representing 98% of global GDP are exploring CBDCs; a smaller number have launched pilots. CBDCs are politically charged — proponents cite efficiency and inclusion; critics warn of surveillance, programmability enabling censorship, and disintermediation of commercial banks.

Regulation is where much of the industry's near-term future is decided. In the US: the SEC uses the Howey Test to classify tokens as securities (investment of money in a common enterprise with an expectation of profit derived primarily from the efforts of others); the CFTC treats Bitcoin and Ether as commodities. FinCEN requires MSBs (money service businesses) to run KYC (Know Your Customer) and AML (Anti-Money Laundering) programs, filing SARs (Suspicious Activity Reports). The Travel Rule requires VASPs to share sender/receiver info for transfers ≥ $3,000. In the EU: MiCA (Markets in Crypto-Assets, in force December 2024) creates a unified crypto-asset framework — issuers of stablecoins and CASPs (Crypto-Asset Service Providers) must be authorized; consumer protection and market-integrity rules apply. Also relevant: OFAC sanctions (Tornado Cash was sanctioned in 2022), IRS crypto tax reporting (Form 1099-DA from 2025), GDPR (immutability meets right-to-erasure — hash-and-off-chain the personal data). Compliance-forward projects (Circle's USDC, Coinbase, Kraken) generally do better in the long run than regulatory-arbitrage projects. Every serious blockchain professional should follow at least the SEC, CFTC, FinCEN, EU MiCA updates, and their local regulator.