Overview
free

Course Setup and the Incremental Ladder
Why "Blocks to Currencies"
How to Use This Course
The Incremental Ladder (Step 0 -> Step 7)
The Course Lenses
Diagram Legend and Notation Types

Mental Models: Ledgers, States, and Blocks
Ledger as State History
Blocks as Batched Transitions
Global vs Local Views

Cryptographic Primitives Overview
Hash Properties
Symmetric vs Asymmetric
Signatures and Authentication

Distributed Systems Fundamentals
Nodes, Messages, Timeouts
Asynchrony and Impossibility (High-Level)
Replicated State Machines

Peer-to-Peer and Overlay Networks
Overlay Topologies
Gossip and Broadcast
Discovery and Churn

Diagramming Cryptographic & Blockchain Systems
Protocol Message Sequence Charts
Ledger and Block Structure Diagrams
Economic Flow Diagrams

Hashes, Commitments, and Integrity
Hash Chains and Merkle Trees
Commitments Intuition
Content Addressing and Proofs

Public-Key Cryptography and Signatures
Signing and Verification
Addresses as Derived Identifiers
Multi-Sig and Thresholds (High-Level)

Key Management, Wallets, and Identity Models
Seeds and Hierarchical Keys
Custody Models
Identity and Pseudonymity

Replication and Consistency
Replication Styles and Failure Boundaries
Strong vs Eventual Consistency Under Delay
CAP as a Constraint Lens for Ledgers

Fault Models and Adversaries
Crash vs Byzantine Failures
Honest Majority Assumptions
Adversary Capabilities

Consensus as Log Agreement
Classical Consensus Intuition
Logs, Epochs, Leaders
Why Public Blockchains Differ

Overlay Networks and Node Discovery
Peer Tables and Discovery
Bootstrapping and Liveness
Churn and Peer Management

Gossip, Propagation, and Flooding Control
Gossip for Blocks and Transactions
Controlling Duplication
Modeling Propagation Delay

Network-Level Security and Abuse Resistance
Sybil Attacks at the Network Layer
Eclipse, Partition, Censorship
Mitigations

Transaction Models
UTXO Model: Inputs/Outputs and Parallel Validation
Account Model: Balances, Nonces, Ordering, and Replay
Trade-offs: Privacy, Complexity, and Future Scalability

Transaction Validation and Lifecycles
Validity Rules: Signatures, Balances, Replay Protection, and Local Acceptance vs Global Finality
Fees and Mempools: Gas/Fees, Prioritization, and What Mempool Policy Really Controls
Double-Spend Handling: Local Detection, Conflicts, and Why Forks Make Valid Time-Dependent

Block Structure and Merkle Trees
Block Headers and Metadata: Parent Links, Timestamps, Roots, and What They Commit To
Merkle Proofs and SPV: Inclusion Proofs and What Light Clients Can Safely Conclude
Multiple Roots and Extensions: Separating Transactions, Receipts, and State Commitments Conceptually

Chains, Forks, and Reorganizations
Chain as a Tree: Competing Branches and Why "the Tip" Is an Opinion Until Finalized
Temporary Forks and Orphans: Propagation Races as a Normal Condition
Confirmation Depth: Probabilistic Finality and What You Can Promise at Different Depths

Basic Chain Selection Rules
Longest/Heaviest Chain: Selection Rules as Incentive and Security Mechanisms
Difficulty and Target Times: Adjusting Work/Weight and the Stability of Issuance and Throughput
Attack Implications: How Selection Rules Interact With Selfish Behavior and Network Delay

Proof-of-Work (PoW)
Puzzle Design and Difficulty: Adjustable Work and Why Verification Must Be Cheap
Mining Economics: Rewards, Fees, and Energy as Part of the Security Budget
Security and Attacks (High-Level): Majority Power, Selfish Mining Intuition, and Reorg Realities

Proof-of-Stake (PoS)
Validators and Selection: Stake as Weight and the Implications for Membership
Slashing and Penalties: Aligning Incentives and Defining Punishable Behaviors
Finality and Checkpoints: Confirmations, Finality Gadgets, and What "Reorg Resistance" Means

BFT-Style Consensus
PBFT-Like Rounds: Proposals, Votes, Commits and Quorum Thresholds
Committees and Thresholds: Byzantine Limits and Why Committee Selection Is Security-Critical
Partial Synchrony: Liveness Conditions and the Timing Assumptions Hiding Inside Protocols

Hybrid and Novel Consensus Designs
Layering PoS and BFT: Separating Block Production from Finalization
DAG-Style Protocol Intuition: Non-Linear Histories and Why They Complicate Reasoning
Randomness and VRFs: Leader Election, Unpredictability, and Grinding Risks at a High Level

Security, Finality, and Fault Tolerance
Safety, Liveness, Finality: Defining the Guarantees Precisely Before Arguing About Them
Economic Security: When Incentives Substitute for (or Weaken) Mathematical Guarantees
Long-Range and "Nothing-at-Stake": Attack Classes and Why Governance and Social Recovery Matter

Execution Models and Virtual Machines
Deterministic Execution: Why "Same Input, Same Output" Must Hold Across All Nodes
VM Design Choices: Stack vs Register Models and What They Imply for Tooling and Performance
Gas and Halting Guarantees: Metering as Denial-of-Service Prevention and Economic Control

On-Chain State and Storage
State Commitment Structures: Trie-like State Trees and the Difference Between "State" and "History"
Account Types: Contract Accounts vs Externally Owned Accounts as Security Boundaries
Logs/Events vs Persistent State: Indexing, Off-Chain Consumption, and Auditability

Contract Design Patterns
Ownership and Access Control: Authorization as the Most Common Failure Surface
Pausing and Configuration: Operational Control Planes for On-Chain Systems
Modularity and Composition: Call Graphs, Dependency Risks, and Upgrade Pressure

Oracles and Off-Chain Integration
The Oracle Problem: Why External Truth Is Adversarial by Default
Push vs Pull and Aggregation: Verification Strategies and Failure Containment
Incentives and Trust: Designing Oracle Systems as Economic Protocols, Not APIs

Contract Security and Common Pitfalls
Canonical Bugs: Reentrancy, Arithmetic Issues, and Authorization Mistakes as Patterns
MEV at Contract Level: Front-Running Dynamics and How Contract Structure Invites Extraction
Audit-Friendly Design: Defense-in-Depth, Invariants, and Making Behaviors Reviewable

Scaling On-Chain: Throughput and Data
Throughput Knobs: Block Size, Gas Limits, and What They Trade Against
State Growth: Pruning, Archival Models, and Why Storage Is Governance
Data Availability and Light Clients: What Must Be Available for Verification to Remain Meaningful

Layer-2 Protocols: Channels and Rollups
Channels: Lock-In, Update, Settle, and What Users Must Assume
Optimistic vs ZK Rollups (Conceptual): Challenges vs Proofs and What Each Shifts to Operators
Security Assumptions: Trust Models and How Failures Surface to End Users

Sharding and Parallel Execution
Sharding Choices: State Sharding vs Transaction Sharding and the Coordination Costs
Cross-Shard Communication: Message Passing, Receipts, and Consistency Expectations
Parallelism and Conflicts: Contention Detection and Why Independent Transactions Are Rare at Scale

Bridges and Cross-Chain Protocols
Bridge Mechanisms: Lock-and-Mint, Burn-and-Release, and Light-Client Approaches
Custodial vs Non-Custodial Bridges: Where Trust Lives and How It Fails
Bridge Risk Surfaces: Contract Risk, Replay, Centralization Pressure, and Operational Monitoring

Privacy in Blockchain Systems
Transparency Limits: Why Naive Ledgers Leak Structure Even Without Names
Privacy Techniques: Mixers, Stealth Addresses, Confidential Transactions, and What They Hide
Zero-Knowledge at a High Level: Shielded Pools, Proof Costs, and Integration Trade-Offs

MEV, Ordering, and Fairness
Ordering as Power: How Transaction Ordering Becomes Extractable Value
MEV Patterns: Front-Running, Sandwiching, Back-Running, and Why They Persist
Mitigations (Conceptual): Auctions, Commit-Reveal, Encrypted Mempools, and What They Shift Elsewhere

Native Currencies and Monetary Policy
Native Coin vs Tokens: Base Asset Roles and What Must Be Special in the Protocol
Issuance Schedules: Inflation, Deflation, Halvings, and Long-Term Security Budgets
Economic Roles: Medium of Exchange, Store of Value, Gas Unit, and How Role Conflicts Appear

Tokens, Assets, and Representation Models
Fungible and Non-Fungible Assets - Representation Choices and Their Implied Invariants
Token Standards (Conceptual) - Balance Tracking, Metadata, and Interoperability Expectations
Asset Semantics - Transfer Restrictions, Ownership Meaning, and Edge Cases

Incentive Design for Validators and Users
Rewards and Fees - Block Rewards, Fee Markets, Tips, and User Behavior Shaping
Slashing and Incentive Compatibility - Punishments, False Positives, and Participation Risk
Modeling Rational Behavior - Assumptions You Must State to Claim "Secure"

Governance, Upgrades, and DAOs
Governance Models: Off-Chain Coordination vs On-Chain Voting and Their Failure Modes
Upgrades: Forks, Versioning, and What Continuity Means for Users and Contracts
DAO Mechanics: Treasuries, Voting, Incentives and How Governance Becomes an Attack Surface

Designing End-to-End Blockchain Systems
Reference Architectures: Simple Coin, General Smart-Contract Chain, and App-Specific Chain
Decentralize vs Centralize: Choosing What Must Be Trustless and What Can Be Operationally Managed
End-to-End Threat and Incentive Review: Ensuring Ledger, Consensus, Networking, Contracts, and Economics Align

Application Domains and Use-Cases
Payments and Remittances: Constraints, UX Realities, and Trust Boundaries
DeFi, Supply Chain, Identity (High-Level): What the Ledger Adds and What It Does Not Solve
When Not to Use a Blockchain: Negative Criteria, Opportunity Cost, and Simpler Alternatives

Security Patterns and Threat Modeling
Attacker Models: Protocol-Level, Network-Level, Economic-Level and How They Compose
Defense-in-Depth: Cryptographic, Protocol, Economic, Operational Layers and What Each Can Realistically Prevent
Threat Modeling Templates: Turning Assumptions into Explicit Test Plans for New Designs

Observability, Monitoring, and Operations
Node and Network Health: Peers, Performance, Forks, and Chain Liveness Indicators
Indexing and Querying: Turning Append-Only Data into Operational Visibility and Product Features
Incident Response: Handling Protocol Incidents, Economic Attacks, and Coordinated Remediation

Testing, Simulation, and Formal Methods
Testing Layers: Unit Tests, Integration Tests, Testnets and What Each Catches
Adversarial Simulation: Network Conditions, Byzantine Behavior, and Economic Stress Testing
Formal Methods (High-Level): What Can Be Proven About Contracts and Protocols, and Where Proofs Stop

Design Checklists for New Blockchain Systems
Cryptography, Consensus, and the Network Model: Choices, Assumptions, and Explicit Trade-offs
Tokenomics and Governance: Incentives, Upgrade Paths, and Attacker Profit Models
Interoperability and Regulatory Constraints: Upgradeability, Bridge Risk, and Operating in Real Jurisdictions

/blocks-to-currencies/blocks-to-currencies

Multi-Sig and Thresholds (High-Level)

Sign in to access this lesson.

Sign in Create account