02 — Blockchain Fundamentals

Concepts, vocabulary, design principles, theoretical models. Prerequisite for understanding the other files.

1. Definition

Blockchain = an append-only distributed ledger where blocks of transactions are chained by cryptographic hashes, with decentralized consensus for ordering and validity.

Minimum components:

1. Chained data structure: block \(n\) contains the hash of block \(n-1\).
2. Consensus mechanism: a rule for accepting the next block among nodes without central coordination.
3. Incentive system: native tokens to align miners/validators.
4. Cryptographic identity: public keys as pseudonyms.

Differences from traditional databases

2. Basic vocabulary

3. Fundamental properties

Immutability

Block \(n\) contains \(H(\text{block}_{n-1})\). Changing an old block = recompute all subsequent hashes + outvalue the work of the entire network.

It is not absolute: hard forks rewrite (DAO 2016, BSVBCHBTC). "Immutability" is practical resistance to tampering, not mathematical impossibility.

Decentralization

3 dimensions (Vitalik 2017, The Meaning of Decentralization):

1. Architectural: number of physical machines (Bitcoin: ~15k full nodes, millions of SPV).
2. Political: number of individuals/organizations in control.
3. Logical: the state is unique (≠ logically decentralized).

Blockchain: architecturally + politically decentralized; logically centralized (1 ledger).

Censorship resistance

An attacker can pay more to exclude your tx temporarily (front-running through the fee market), but eventually another miner/validator includes it. Nakamoto consensus assumes 50%+ honest.

Trustlessness (partial)

"Don't trust, verify". You verify mathematics + consensus, not a person. But: trust in the protocol design, in the code, in the majority of validators being honest, in the compiler, in the hardware...

Final settlement

A tx confirmed after \(k\) blocks is (probabilistically in PoW, deterministically in BFT) immutable.

4. Vitalik's Trilemma (Scalability Trilemma)

Vitalik Buterin, 2017: a blockchain can optimize 2 of 3:

1. Decentralization — anyone can validate.
2. Security — resistance to attack at a reasonable hardware cost.
3. Scalability — high throughput (TPS).

Bitcoin/Ethereum L1: dec + sec, sacrifices scalability. Solana: sec + scalability, sacrifices dec (high HW cost to validate). Permissioned chains: scalability + sec, sacrifice decentralization.

Modern solutions: rollups (L2) attack the trilemma by assuming L1 dec+sec, but moving execution off to an L2 that can optimize scalability without compromising the L1.

5. CAP / FLP / Byzantine generals

CAP (Brewer 2000)

A distributed system under network partition can guarantee 2 of:

• Consistency
• Availability
• Partition tolerance

In blockchain (always P), one chooses between C (BFT, finality) and A (Nakamoto, eventual consistency).

FLP (Fischer-Lynch-Paterson 1985)

In an asynchronous network with 1 failure, deterministic consensus is impossible. Workarounds:

• Synchronous (assumes timing bounds): PBFT, Tendermint.
• Probabilistic: Nakamoto consensus.
• Randomized: Algorand (VRF-based).

Byzantine Generals Problem (Lamport-Shostak-Pease 1982)

Given \(n\) generals, \(f\) traitors, reach consensus:

• Synchronous authenticated: \(n \geq f + 1\) suffices.
• Synchronous unauthenticated: \(n \geq 3f + 1\) (Lamport's bound).
• Asynchronous authenticated: \(n \geq 3f + 1\) (Castro-Liskov PBFT).

Blockchain: assumes a Byzantine adversarial environment (miners can lie, censor, mining pools cooperate).

6. Tx models

UTXO (Bitcoin)

State = a set of UTXOs (Unspent Transaction Outputs). Each UTXO has (value, script).

A tx consumes UTXOs (inputs) and creates UTXOs (outputs). Total in ≥ total out (the difference = fee).

Advantages:

• Parallelism (independent txs can process simultaneously).
• Privacy (each UTXO goes to a new address).
• Stateless per-tx validation (input scripts are self-sufficient).

Disadvantages:

• Complex smart contracts are hard (no persistent state).
• The UTXO set grows; a storage challenge.

Account-based (Ethereum)

State = map[address] → (balance, nonce, code, storage).

Tx = (from, to, value, data, gas, signature).

Advantages:

• Natural smart contracts.
• Replay protection via nonce.
• Storage rent / state expiry possible.

Disadvantages:

• Sequential (txs from the same from need ordering).
• Replay across chains: needs a chain ID (EIP-155).
• Complex state management.

Hybrid / others

• Cardano (eUTXO): UTXO + more expressive scripts.
• Sui (object-centric): objects instead of accounts.
• MimbleWimble (Beam, Grin): confidential UTXOs + cut-through.

7. Cryptographic primitives (review)

For details see ../cryptography/. Usage summary:

8. Wallets

Self-custody (non-custodial)

The user controls the private keys. Not your keys, not your coins.

• Hot wallets: software, connected to the internet. MetaMask, Phantom, Rabby, Frame.
• Cold wallets: offline. Hardware (Ledger, Trezor, Coldcard, Keystone), paper wallets, air-gapped computers.
• Smart wallets / smart contract wallets: ERC-4337 (account abstraction). Argent, Safe (Gnosis), Coinbase Smart Wallet.

Custodial

The operator holds the keys. Coinbase, Binance, exchanges. Convenience vs counterparty risk.

Backup standards

• BIP-32: hierarchical deterministic.
• BIP-39: 12/24-word mnemonic seed.
• BIP-44: multi-coin / account derivation paths.
• SLIP-39: Shamir secret sharing backup (Trezor).

Smart contract wallets

ERC-4337 (Account Abstraction) features:

• Multisig.
• Social recovery.
• Spend limits.
• Batched txs.
• Custom signature schemes (passkey, hardware).
• Paymasters (someone pays gas for the user — sponsorship).

9. Network topology

P2P architecture

• Full node: stores the entire chain, validates everything.
• Pruned node: the entire chain but discards old data.
• Light client / SPV: only headers + Merkle proofs on demand (BIP-37, BIP-157/158 Compact Filters).
• Archive node: the entire chain + historical state of each block.
• Relay node: forwards without validating (mining pools).

Bootstrap

Bitcoin: hardcoded DNS seeds (seed.bitcoinstats.com, etc.) → discover peers. Ethereum: ENR (Ethereum Node Records, EIP-778) + DHT discovery.

Networking

• Bitcoin: TCP port 8333, plain (Tor optional).
• Ethereum: devp2p RLPx (encrypted), execution layer port 30303; consensus layer libp2p port 9000.
• Solana: custom UDP gossip protocol.

10. Encoding and serialization

11. Address formats

ENS (Ethereum Name Service): vitalik.eth resolves to 0xd8dA... — human-readable on Ethereum.

12. Addresses + privacy

A public chain = everyone sees:

• The balance of each address.
• The complete tx history.
• Counterparties.
• Timing patterns.

Pseudonymity ≠ anonymity. Chain analysis heuristics (Chainalysis, TRM, Elliptic):

• Common input ownership: txs with multiple inputs probably belong to the same owner.
• Change address detection: identifying change vs receiver.
• Address clustering: grouping addresses of the same owner.
• Off-chain data: exchange KYC + on-chain links.

Mitigations:

• CoinJoin (Wasabi, Samourai, Whirlpool).
• Privacy coins (Monero, Zcash, Dash PrivateSend).
• Tornado Cash (sanctioned).
• Wrapping in privacy-focused rollups (Aztec).

13. Typical Web3 stack

┌──────────────────────────────────────────────┐
│  Frontend (React, Next.js, Vue)              │
│  + WalletConnect, RainbowKit, ConnectKit     │
├──────────────────────────────────────────────┤
│  Wallet (MetaMask, Phantom, Rabby, Coinbase) │
├──────────────────────────────────────────────┤
│  RPC provider (Alchemy, Infura, QuickNode,   │
│  self-hosted node)                           │
├──────────────────────────────────────────────┤
│  Smart contracts (Solidity, Vyper, Rust)     │
│  + libraries (OpenZeppelin, Solady)          │
├──────────────────────────────────────────────┤
│  L1/L2 chain                                 │
└──────────────────────────────────────────────┘

Indexers/data: The Graph, Goldsky, Subsquid, Dune Analytics. Oracles: Chainlink, Pyth, RedStone, API3. Dev tools: Hardhat, Foundry, Truffle (legacy), Anchor (Solana), Anvil/forge. Testing: Foundry (Solidity-native), Hardhat + Mocha, Brownie (Python).

14. State of the art 2026

• Bitcoin: monetary Layer 1; L2 evolution (Lightning + Stacks + Arch + Babylon).
• Ethereum: settlement + DA layer; execution on L2s (Arbitrum, Base, OP, Scroll, zkSync).
• Solana: high-perf monolithic L1; competitive in UX + speed.
• Cosmos: app-chain ecosystem; IBC interoperability.
• Polkadot: parachains, shared security, relay chain.
• Modular thesis: separation of execution / settlement / DA / consensus (Celestia, EigenDA, Avail).

Statistics (~May 2026):

• Bitcoin marketcap: ~US$ 2.5T.
• Ethereum marketcap: ~US$ 600B.
• Total crypto marketcap: ~US$ 4T.
• Stablecoin marketcap: ~US$ 250B.
• DeFi TVL: ~US$ 200B.
• Daily DEX volume: ~US$ 10B.

15. Bibliography

• Antonopoulos, Mastering Bitcoin, O'Reilly 2017 (free github), 3rd ed.
• Antonopoulos + Wood, Mastering Ethereum, O'Reilly 2018.
• Narayanan, Bonneau, Felten, Miller, Goldfeder, Bitcoin and Cryptocurrency Technologies, Princeton 2016 (free).
• Werner, Perez, Gudgeon, Klages-Mundt, Harz, Knottenbelt, SoK: Decentralized Finance (DeFi), AFT 2022.
• Zamyatin et al., SoK: Communication Across Distributed Ledgers (2021).
• Vitalik Buterin's blog: vitalik.ca / vitalik.eth.limo.
• Bitcoin Optech newsletter (bitcoinops.org/en/newsletters/).
• Ethereum Research forum: ethresear.ch.
• 0xResearch (Blockworks) podcast.
• Bankless newsletter/podcast.
• Messari research reports.

16. Cross-reference

• Crypto primitives: ../cryptography/10-criptomoeda.md.
• Consensus detail: 03-consensus.md.
• Specific chains: 04-l1-bitcoin.md, 05-l1-ethereum.md, 06-l1-alt.md.
• DeFi: 09-defi.md.
• Regulation: 13-regulation.md.