Modular Blockchain

A modular blockchain is an architectural design that separates the core functions of a blockchain into independent, specialized layers rather than handling all functions in a single monolithic chain. These functions include execution, settlement, consensus, and data availability, which can be provided by different protocols optimized for their specific role, creating a flexible, scalable blockchain stack.

This architecture represents a shift in blockchain design philosophy, moving from the "do everything in one place" approach of Bitcoin and early Ethereum to a "best tool for each job" approach where execution happens on rollups, data is stored on DA layers, and settlement occurs on a secure base layer like Ethereum.

The modular blockchain concept, supported by projects like Celestia, Ethereum's rollup-centric roadmap, and the Cosmos ecosystem, argues that specialization enables better performance, security, and innovation than monolithic designs that must make fundamental tradeoffs between these properties.

The Four Core Functions

Modular blockchains separate blockchains into four distinct functions:

1. Execution

• Execution is the processing of transactions and execution of smart contracts, which changes blockchain state. In modular architecture:

  • Specialized Execution Layers: Rollups (Optimistic, ZK) or app-specific chains that execute transactions.
  • VM Flexibility: Different execution layers can use different virtual machines (EVM, SVM, MoveVM, custom).
  • Performance Optimization: Execution layers can optimize for throughput without worrying about data storage or consensus.
  • Examples: Arbitrum, Optimism, zkSync (rollups); Fuel, Eclipse (execution-focused chains).

2. Settlement

• Settlement is the process of verifying execution results and finalizing state transitions. Settlement layers:

  • Verify Proofs: Check fraud proofs (Optimistic) or validity proofs (ZK) from execution layers.
  • Resolve Disputes: Arbitrate disputes about execution correctness.
  • Maintain Canonical State: Keep track of the "official" state across all execution layers.
  • Bridge Security: Provide security for asset bridges between execution layers.
  • Examples: Ethereum L1 (primary settlement layer), Polygon AggLayer, Arbitrum One settling to Ethereum.

3. Consensus

• Consensus is the mechanism for agreeing on transaction ordering and block production. In modular systems:

  • Order Transactions: Determine the canonical order of transactions across the network.
  • Block Production: Coordinate validators/sequencers to produce blocks.
  • Finality: Provide guarantees that transactions won't be reversed.
  • Examples: Ethereum Beacon Chain consensus, Celestia's Tendermint consensus, shared sequencing networks.

4. Data Availability (DA)

• Data Availability ensures that transaction data is published and remains accessible for verification. DA layers:

  • Store Transaction Data: Maintain sufficient data for state reconstruction and fraud proof generation.
  • Guarantee Availability: Ensure anyone can download the data when needed.
  • Provide Proofs: Offer cryptographic proofs that data was made available.
  • Examples: Celestia, EigenDA, Avail, Ethereum calldata/blobs (EIP-4844).

Modular vs Monolithic Blockchains

The distinction between modular and monolithic architectures is fundamental:

Aspect	Modular Blockchain	Monolithic Blockchain
Architecture	Separate layers for each function	All functions in one layer
Scalability	High (each layer specialized)	Limited (single-layer bottleneck)
Flexibility	High (swap layers, multiple options)	Low (tied to L1 design)
Complexity	Higher (multiple layers to coordinate)	Lower (single protocol)
Trust Assumptions	Varies by layer combination	Unified (single consensus)
Upgrade Path	Flexible (upgrade layers independently)	Difficult (coordinate entire network)
Resource Requirements	Specialized per layer	Homogeneous (all nodes do everything)
Examples	Ethereum + rollups, Celestia ecosystem	Bitcoin, Solana, Ethereum L1 (pre-rollup era)

• Monolithic Blockchain (Bitcoin):

  • Execution: Bitcoin Script (limited)
  • Settlement: Bitcoin PoW consensus
  • Consensus: Nakamoto consensus
  • Data Availability: Full nodes store all data
  • All in one protocol, limited flexibility.

• Modular Stack (Ethereum Rollup):

  • Execution: Arbitrum rollup (EVM execution)
  • Settlement: Ethereum L1 (fraud proof verification)
  • Consensus: Ethereum Beacon Chain (PoS)
  • Data Availability: Celestia or EigenDA
  • Each layer specialized and optimized.

Benefits of Modular Architecture

Modular blockchains offer several advantages:

• Scalability: Each layer can be optimized for its function. Execution layers can process many transactions per second, DA layers can handle large amounts of data, and settlement layers can focus on security.

• Flexibility: Projects can choose the stack that fits their needs, such as EVM execution with Ethereum settlement or custom combinations.

• Specialization: Each layer can use the best available technology for its purpose without compromising on other functions.

• Resource Efficiency: Nodes don't need to do everything. Validators on DA layers don't need to execute transactions, and rollup nodes don't need to store all data forever.

• Innovation Velocity: Layers can be upgraded independently without coordinating the entire stack, enabling faster innovation.

• Sovereignty: Execution layers can maintain their own governance, economics, and community while using shared infrastructure for settlement and DA.

• Cost Efficiency: Using efficient DA layers and execution layers can reduce costs compared to doing everything on expensive L1s.

The Modular Stack in Practice

Here's how a typical modular blockchain stack operates:

• User Action:

1. User submits a transaction to a rollup (execution layer).
2. Rollup sequencer executes the transaction and updates local state.
3. User sees instant confirmation (soft commitment from sequencer).

• Batch Posting:

4. Rollup batches many transactions and posts batch data to DA layer (Celestia/EigenDA).
5. DA layer guarantees data availability and returns commitment.

• Settlement:

6. Rollup submits state root + DA commitment to settlement layer (Ethereum L1).
7. Settlement layer verifies proof (fraud or validity proof).
8. State root is finalized on L1, giving the rollup Ethereum security.

• Finality:

9. After challenge period (Optimistic) or proof verification (ZK), transaction has L1 finality.
10. User funds are secured by Ethereum consensus and can be withdrawn to L1.

This entire flow happens transparently. Users just see fast, cheap transactions with L1 security.

Modular Blockchain Projects

Several projects exemplify the modular approach:

• Ethereum (Rollup-Centric):

  • Settlement: Ethereum L1
  • Execution: Rollups (Arbitrum, Optimism, zkSync, Scroll, etc.)
  • Consensus: Beacon Chain (PoS)
  • DA: Ethereum blobs (EIP-4844) or external (Celestia, EigenDA).

• Celestia Ecosystem:

  • Settlement: Various (Ethereum, or rollups settle internally).
  • Execution: Sovereign rollups (custom VMs).
  • Consensus: Celestia (Tendermint).
  • DA: Celestia.

• Cosmos Hub (Interchain Security):

  • Settlement: Cosmos Hub.
  • Execution: Consumer chains.
  • Consensus: Cosmos Hub validators.
  • DA: Consumer chains post to Hub.

• Polygon 2.0:

  • Settlement: Polygon AggLayer.
  • Execution: Polygon zkEVM chains.
  • Consensus: Ethereum.
  • DA: Celestia or Avail.

• Fuel:

  • Settlement: Ethereum L1.
  • Execution: Fuel (optimized for parallel execution).
  • Consensus: Fuel (specialized for UTXO model).
  • DA: Ethereum or Celestia.

Challenges and Tradeoffs

Modular architectures introduce new challenges:

• Complexity: Coordinating multiple layers adds complexity for developers and users. Understanding which layer handles what, how they interact, and where failures can occur is essential.

• Composability: Cross-layer and cross-rollup composability is harder than same-chain composability. Atomic transactions across layers require sophisticated protocols like shared sequencing.

• Latency: Multi-layer verification introduces latency. Transactions are instant on the execution layer but may take time to finalize on the settlement layer.

• Trust Assumptions: Each layer introduces trust assumptions. Using an external DA layer means trusting its consensus; using a rollup means trusting its sequencer, though L1 settlement provides ultimate security.

• Fragmentation: Many execution layers can fragment liquidity, users, and developer mindshare. Standards and bridges help but don't fully solve this.

• Security Boundaries: Understanding where security comes from is non-obvious for users and requires education.

• Economic Sustainability: Each layer needs sustainable economics (fees, incentives) without over-extracting from users.

Philosophical Debates

The modular vs monolithic debate sparks discussions:

• Pro-Modular Arguments:

  • Specialization beats generalization.
  • Scalability is difficult on monolithic chains without sacrificing decentralization.
  • Flexibility enables innovation without forking L1.
  • Resource efficiency allows light clients to verify without running full nodes.

• Pro-Monolithic Arguments:

  • Simplicity is valuable for users and developers.
  • Synchronous composability is critical for DeFi.
  • Unified security is clearer.
  • Monolithic chains can show high performance without modularization.
  • Fewer layers lead to fewer trust assumptions.

The "right" answer likely depends on use case. High-value DeFi may prefer monolithic security, while gaming or social applications may prefer modular scalability.