Modular Blockchains Complete Guide 2026: Celestia, Modular Architecture

Introduction

By 2026, the modular blockchain thesis has moved from theory to production. Celestia, EigenDA, and Avail collectively secure hundreds of millions in value. Over 100 rollups now publish data to modular DA layers. The architecture has proven itself: modular designs deliver roughly 6x higher throughput at 64% lower cost compared to monolithic alternatives.

Yet the landscape is more nuanced than early proponents predicted. The monolithic vs modular debate has largely dissolved — pragmatic hybrids now dominate. Ethereum uses rollups (modular execution) with its own DA. Solana is exploring L2s. Even Celestia itself acknowledges that most successful rollups still default to Ethereum for DA.

This guide covers the modular blockchain landscape as it stands in 2026: the core concepts, the leading DA layers and their tradeoffs, Celestia’s evolving roadmap, architectural patterns, and the competitive dynamics shaping the space.

The Four Core Functions

Every blockchain must handle four functions. In monolithic designs, a single chain does all four. Modular architecture separates them into specialized layers.

flowchart LR
    subgraph Monolithic
        M1[Execution<br/>Settlement<br/>Consensus<br/>DA]
    end

    subgraph Modular
        E[Execution Layer<br/><i>Rollup</i>]
        S[Settlement Layer<br/><i>Ethereum L1</i>]
        C[Consensus Layer<br/><i>Celestia</i>]
        D[DA Layer<br/><i>Celestia / EigenDA</i>]
    end

    M1 -->|vs| E
    M1 -.-> S
    M1 -.-> C
    M1 -.-> D

    E --> S
    E --> D
    D --> C

    style M1 fill:#94a3b8,color:#fff
    style E fill:#3b82f6,color:#fff
    style S fill:#22c55e,color:#fff
    style C fill:#f59e0b,color:#fff
    style D fill:#8b5cf6,color:#fff

Modular blockchains specialize in one or more of these functions while delegating the rest to other layers. This specialization enables each layer to optimize for its specific role — Celestia optimizes DA throughput, rollups optimize execution speed, and Ethereum optimizes settlement security.

Monolithic vs Modular: The 2026 Reality

The framing has shifted. Most successful blockchains now use a hybrid approach rather than a pure monolithic or modular design.

Monolithic chains like Solana and Bitcoin handle all functions on a single layer. They benefit from simpler architecture and strong security guarantees but face scalability constraints — all nodes must process all transactions, creating a ceiling on throughput.

Modular chains separate functions into specialized layers, enabling horizontal scaling. Execution runs on rollups, consensus and DA run on a base layer. This allows each layer to optimize independently: rollups for execution speed, DA layers for throughput, settlement layers for security.

The practical reality in 2026 is a spectrum rather than a binary:

The modular approach excels at flexibility and scalability but introduces complexity — cross-layer communication overhead and a larger attack surface that must be carefully audited.

Celestia: The Modular Pioneer

What is Celestia?

Celestia is the first modular blockchain network designed as a dedicated data availability and consensus layer. Launched on mainnet in October 2023, it provides the foundational infrastructure for scaling blockchain applications through data availability sampling (DAS). As of mid-2026, Celestia has processed over 160 GB of rollup data, generates daily blob fees that have grown 10x since late 2024, secures approximately $206 million in DA value, and commands roughly 50% market share in the data availability sector. Over 100 production rollups now publish data to Celestia.

Protocol Upgrades

Celestia has shipped multiple significant upgrades:

Matcha (November 2025) — Increased block size to 128 MB and cut annual token inflation from ~5% to ~2.5%, improving network capacity while reducing sell pressure.

V8 “Hibiscus” (April 2026) — Enabled single-signature cross-chain transfers and ZK-verified messaging on testnet, laying groundwork for native interoperability between Celestia and other chains.

Lotus v4 (June 2026) — The largest upgrade to date. Lotus integrates Hyperlane as a Cosmos SDK module, enabling native TIA interoperability across multiple chains including Ethereum, Base, Arbitrum, and non-Celestia rollups with Hyperlane deployments. The upgrade also includes multiple CIPs: CIP-29 reduces TIA’s inflation schedule by 33%, lowering emissions while maintaining staking incentives; CIP-30 disables auto-claiming of staking rewards; CIP-31 locks staking rewards for locked tokens; and CIP-32 adds Hyperlane as a Cosmos SDK module directly into Celestia’s core protocol.

A 3-second block time upgrade is also on the roadmap for 2026, representing a 2x improvement over the current 6-second block time.

Key Technical Innovations

Data Availability Sampling (DAS): Light nodes verify DA without downloading entire blocks. Through random sampling of erasure-coded shares, a light node can be probabilistically certain that data is available. As the light node network grows, Celestia’s throughput capacity scales proportionally — more light nodes means more sampling capacity, which enables larger blocks.

The sampling process follows a simple probabilistic protocol. A light node requests random chunks of an erasure-coded block; if all chunks are returned, the node gains confidence that the full block is available. After enough samples, the probability of missed data drops below a threshold:

const SAMPLES_REQUIRED = 20;
const ERASURE_RATIO = 0.5; // 2x Reed-Solomon encoding

function probabilityDataUnavailable(
  adversarialFraction: number
): number {
  let probUnavailable = adversarialFraction;

  for (let i = 0; i < SAMPLES_REQUIRED; i++) {
    // Each sample has ERASURE_RATIO chance of hitting
    // an available share even if data is withheld
    probUnavailable *= (1 - ERASURE_RATIO);
  }

  return probUnavailable;
}

for (const adv of [0.5, 0.75, 0.9]) {
  const p = probabilityDataUnavailable(adv);
  console.log(
    `Adversarial: ${(adv * 100).toFixed(0)}% -> ` +
    `false positive: ${(p * 100).toExponential(2)}%`
  );
}

With 20 samples and 50% erasure coding, even an adversary controlling 90% of the block has only a ~0.001% chance of passing the sampling check without making the full block available. This cryptographic guarantee is what allows Celestia light nodes to secure large blocks without downloading them.

Namespaced Merkle Trees (NMTs): Rollups only download data relevant to their namespace, not the full block. This enables hundreds of rollups to share the same DA layer without each needing to process everyone else’s data — a critical scalability property.

Ecosystem and Adoption

Celestia’s primary DA competitors are Ethereum itself (which dominates with $35.5B in DA value secured), EigenDA ($705M), and Avail ($41M). Celestia’s position is strongest among sovereign rollups and appchains that prioritize cost efficiency and decentralization over Ethereum-alignment.

Notable Celestia DA adopters:

Important caveat: Most major Ethereum L2s (Arbitrum, Optimism, Base) use Ethereum as their DA layer, not Celestia. Celestia’s market is primarily sovereign rollups and non-Ethereum-settled chains — a smaller but growing segment.

Execution Layers: Rollups

Rollups are the execution component of the modular stack — they process transactions off-chain and post compressed data to a DA layer. For a full treatment of leading rollup implementations, see the Layer 2 Scaling Solutions guide.

From a modular architecture perspective, the key distinction is where a rollup posts its data:

• Ethereum-settled rollups (Arbitrum, Optimism, Base) post data to Ethereum blobs. They use Ethereum for both DA and settlement. This is the dominant pattern — over $35 billion in value secured.
• Sovereign rollups post data to an external DA layer like Celestia and handle settlement independently. They have their own consensus and can fork independently from any L1.
• Validiums use ZK proofs with off-chain DA, offering an intermediate tradeoff between security and cost.

Rollup Transaction Flow

The following sequence diagram traces a transaction through the modular stack, from user submission to final settlement:

sequenceDiagram
    actor User
    participant Rollup as Rollup Sequencer
    participant DA as DA Layer<br/>(Celestia)
    participant L1 as Settlement L1<br/>(Ethereum)

    User->>Rollup: Submit transaction
    Rollup->>Rollup: Execute & batch txs
    Rollup->>DA: Post compressed calldata blob
    DA->>DA: Erasure code & sample
    DA-->>Rollup: DA confirmation (inclusion proof)
    Rollup->>L1: Submit state root + DA proof
    L1->>L1: Verify proof against DA commitment
    L1-->>User: Finalized settlement

The sequencer batches user transactions, posts compressed data to Celestia (the DA layer), receives a data availability proof, then submits that proof alongside a state root to the settlement layer (typically Ethereum). This decouples execution throughput from L1 capacity — the sequencer can process thousands of TPS locally, constrained only by the DA layer’s bandwidth.

Data Availability Landscape

The DA market has segmented into distinct tiers by 2026. For a deeper treatment, see the Data Availability Layers guide.

Ethereum (Dominant)

Ethereum remains the dominant DA layer by a wide margin — $35.5 billion in value secured versus $206 million for Celestia. EIP-4844 (Dencun, 2024) introduced blob transactions with a separate fee market, slashing L2 posting costs by roughly 10x. The upcoming Glamsterdam upgrade will expand blob throughput further with enshrined proposer-builder separation (ePBS). Most major L2s — Arbitrum, Base, Optimism — continue to use Ethereum as their exclusive DA layer.

EigenDA (High-Throughput)

EigenDA, built on EigenLayer, achieves 1 GB/s throughput — over 100x most competitors — by leveraging restaked ETH for security. It secures $705 million in DA value and powers high-performance rollups including MegaETH, Fuel, Aevo, and Celo. Its tradeoff: higher throughput comes with a data availability committee (DAC) trust model rather than full on-chain verification.

Avail (Multichain)

Avail, spun out from Polygon, takes a multichain-neutral approach. It claims 70+ partnerships including integration commitments from Arbitrum, Optimism, Polygon, StarkWare, and zkSync. Avail DA processes 4MB per block with a roadmap to 10GB blocks, and its Nexus interoperability layer extends beyond pure DA into cross-chain coordination.

Celestia (Sovereign Rollups)

Celestia secures $206 million in DA value. Its strength is sovereign rollups — chains that want maximum independence from Ethereum while sharing security through Celestia’s validator set. The 128 MB block size (post-Matcha) and planned 3-second block time make it competitive on throughput.

DA Layer Comparison

The cost differential between DA layers is striking. Ethereum L2s pay approximately $3.83 per megabyte for blob space, while Celestia charges $0.07 for the same megabyte — a 55x cost advantage that compounds with volume. Eclipse, which uses Celestia for DA while settling to Ethereum, saved over $300,000 compared to Ethereum blob costs across 83 GB of rollup data.

Cost efficiency is the primary driver for rollups adopting external DA layers. For high-volume applications, the savings dwarf the additional complexity of integrating a non-Ethereum DA provider.

Modular Architecture Patterns

Settlement Rollups (Ethereum-Settled)

The dominant pattern. Rollups post execution data to Ethereum blobs and settle through Ethereum’s fraud or validity proof system. This gives them Ethereum-grade security for settlement while using an external DA layer optionally. Arbitrum, Optimism, and Base all follow this model. Most use Ethereum for both DA and settlement.

Sovereign Rollups

Sovereign rollups handle their own settlement and consensus while using an external DA layer (typically Celestia). They can fork independently, upgrade without L1 permission, and customize their fee market. The tradeoff is weaker settlement guarantees — there is no Ethereum-level proof verification. This pattern suits appchains that prioritize independence over maximum security.

Validiums

Validiums use ZK validity proofs for settlement but store data off-chain. This achieves the lowest cost at the expense of introducing data availability trust assumptions. If the DA committee withholds data, users cannot reconstruct state to withdraw funds. Suitable for high-frequency, low-value applications like gaming.

Rollup-as-a-Service Platforms

Platforms like Caldera, Conduit, and Dymension abstract away the complexity of deploying modular rollups. They provide one-click deployment with configurable execution environments (EVM, SVM, WASM), DA layers (Celestia, EigenDA, Ethereum), and settlement options. This is driving the proliferation of appchains — over 100+ production rollups now use modular infrastructure, with the RaaS model significantly lowering the barrier to entry.

Building on Modular Infrastructure

Choosing a DA Layer

The first decision is which DA layer to use. The choice depends on your settlement target and throughput requirements:

• Building an Ethereum-settled rollup? Use Ethereum blobs (default) or EigenDA (higher throughput).
• Building a sovereign rollup? Use Celestia for maximum decentralization or Avail for multichain interoperability.
• Building a high-frequency application? Consider EigenDA for its 1 GB/s throughput or a validium architecture.

Interacting with Celestia DA

Developers submit blob data to Celestia through its node API. The TypeScript example below connects to a Celestia light node, submits a blob for a rollup namespace, and retrieves the inclusion proof:

import { Celestia } from "@celestia/rollup-client";

async function submitBlob() {
  const client = await Celestia.connect({
    nodeUrl: "http://localhost:26658",
    authToken: process.env.CELESTIA_AUTH_TOKEN,
  });

  const namespace = "rollup-sys-1";
  const rollupData = {
    height: 1847291,
    transactions: [
      { from: "0xabc...", to: "0xdef...", value: "1.5 ETH" },
      { from: "0xghi...", to: "0xjkl...", value: "0.2 ETH" },
    ],
    stateRoot: "0x7e5f...b3a2",
  };

  const blob = await client.blob.submit(
    namespace,
    JSON.stringify(rollupData)
  );

  console.log(`Blob submitted at height: ${blob.height}`);
  console.log(`Commitment: ${blob.commitment}`);

  const proof = await client.blob.getProof(
    namespace,
    blob.height,
    blob.commitment
  );

  const verified = await client.blob.verifyProof(proof);
  console.log(`DA verified: ${verified}`);
}

submitBlob();

The flow mirrors the sequence diagram above: the rollup serializes its batch, submits it to Celestia under a unique namespace (so other rollups don’t process it), receives a commitment proof, and can later verify data availability before submitting to the settlement layer.

Celestia CLI for Node Operations

Celestia provides a CLI for running light nodes and interacting with the network. Below are common operations for rollup operators:

# Initialize a Celestia light node
celestia light init --p2p.network celestia

# Start the light node with RPC access
celestia light start \
  --core.ip rpc.celestia.pops.one \
  --p2p.network celestia \
  --gateway.deprecated=false \
  --gateway.addr 127.0.0.1 \
  --gateway.port 26659

# Query the node's account balance
celestia state balance --node.store ~/.celestia-light

# Submit a blob from file to a specific namespace
celestia blob submit \
  --namespace rollup-app-42 \
  --file ./batch-data.json \
  --gas 50000

# Get a blob by namespace and height
celestia blob get \
  --namespace rollup-app-42 \
  --height 1847291

# Verify data availability commitment
celestia blob verify \
  --namespace rollup-app-42 \
  --commitment 7b5f...a3c2 \
  --height 1847291

The CLI wraps the same node API that the TypeScript client uses. For production rollup deployments, operators typically automate blob submission through the RPC gateway rather than the CLI directly.

Blob Payload Structure

When a sequencer submits a batch to Celestia, the blob payload follows a structured format containing the compressed transactions, state commitment, and metadata:

{
  "blob_version": "v1",
  "namespace": "rollup-app-42",
  "height": 1847291,
  "timestamp": "2026-05-15T14:32:01Z",
  "batch": {
    "batch_index": 8921,
    "start_block": 1472000,
    "end_block": 1472050,
    "transaction_count": 340,
    "compression": "zstd",
    "compressed_size_bytes": 84721,
    "original_size_bytes": 412890
  },
  "state_commitment": {
    "pre_state_root": "0xa1b2...c3d4",
    "post_state_root": "0x7e5f...b3a2",
    "withdrawals_root": "0x9f8e...7d6c"
  },
  "metadata": {
    "sequencer_address": "celestia1abc...xyz",
    "chain_id": 98765,
    "da_cost_tia": "0.042"
  }
}

The settlement contract on Ethereum receives only the state root and a lightweight DA proof (a commitment to the blob), not the full blob content. This is what keeps settlement costs low — the heavy data lives on Celestia, while Ethereum merely verifies that the data was published and is available.

On-Chain DA Proof Verification

The settlement contract verifies that the sequencer included the correct state root in a Celestia blob before accepting it as final. Below is a simplified Solidity contract that performs this verification:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

interface ICelestiaBridge {
    function verifyBlobInclusion(
        bytes memory namespace,
        bytes32 commitment,
        uint256 height,
        bytes memory proof
    ) external view returns (bool);
}

contract RollupSettlement {
    ICelestiaBridge public celestiaBridge;
    bytes public namespace;
    uint256 public lastFinalizedHeight;

    event StateRootFinalized(
        bytes32 stateRoot,
        uint256 batchIndex,
        uint256 daHeight
    );

    function finalizeBatch(
        bytes32 _postStateRoot,
        uint256 _batchIndex,
        uint256 _daHeight,
        bytes32 _daCommitment,
        bytes calldata _daProof
    ) external {
        bool dataAvailable = celestiaBridge.verifyBlobInclusion(
            namespace,
            _daCommitment,
            _daHeight,
            _daProof
        );
        require(dataAvailable, "DA verification failed");

        lastFinalizedHeight = _daHeight;
        emit StateRootFinalized(
            _postStateRoot,
            _batchIndex,
            _daHeight
        );
    }
}

The contract calls Celestia’s bridge module to verify that a blob with the claimed commitment exists at the specified height. If verification passes, the state root is accepted — the rollup has proven that its data is available on Celestia without revealing the full contents on Ethereum. This pattern is what enables the modular architecture’s cost efficiency.

Rollup Deployment Configuration

When deploying a rollup with an external DA layer, the configuration specifies where to post blobs, the namespace, and settlement parameters. Below is an example YAML configuration using the OP Stack with Celestia as the DA backend:

chain:
  name: "my-celestia-rollup"
  chain_id: 98765
  execution_engine: "op-geth"

data_availability:
  backend: "celestia"
  node_url: "https://celestia-light-0.example.com:26658"
  namespace: "rollup-app-42"
  gas_price: 0.002
  max_blob_size_mb: 2

settlement:
  layer: "ethereum"
  rpc_url: "https://eth-mainnet.g.alchemy.com/v2/${ALCHEMY_KEY}"
  proof_contract: "0x1234...5678"
  batch_interval_seconds: 180

rollup:
  sequencer:
    max_tx_per_batch: 5000
    batch_compression: "zstd"
    submitter_address: "0xabcd...ef01"
  challenger:
    enabled: true
    challenge_window_seconds: 604800

Key parameters include the Celestia node endpoint, the namespace (which isolates this rollup’s data from others on the same DA layer), and the batch interval controlling how often compressed blobs are posted. The submission cost on Celestia is determined by gas_price and blob size, offering predictable economics compared to Ethereum’s variable blob fee market.

Rollup Frameworks

Most developers don’t deploy rollups from scratch. The primary frameworks in 2026:

• OP Stack (Optimism): The dominant framework for Ethereum-aligned optimistic rollups. Powers Base, World Chain, Unichain. Accounts for 62%+ of L2 transactions.
• ZK Stack (zkSync): ZK rollup framework with shared proving infrastructure through the Elastic Network.
• Rollkit (Celestia): Sovereign rollup framework using Celestia for DA. Supports any execution environment.
• Arbitrum Orbit: Custom L2/L3 chains settling to Arbitrum. Popular for gaming and enterprise use cases.
• SDK alternatives: Dymension, Caldera, Conduit offer managed RaaS with integrated DA configuration.

The Future of Modular Blockchains

Key Trends

1. The Reality Check: Astria’s Shutdown

In 2025, Astria — a Celestia-based shared sequencer — shut down. It was a sobering signal for the modular thesis. Shared sequencing, the idea that multiple rollups could share a single ordering service, proved too early for market demand. The project’s failure highlights that modular infrastructure is ahead of application demand in many segments. Celestia’s core DA layer continues to see adoption, but the broader modular ecosystem is consolidating faster than anticipated.

2. DA Market Segmentation

Rather than a single winner, the DA market is crystallizing around distinct use cases: Ethereum for security-maximal L2s, EigenDA for high-throughput rollups, Celestia for sovereign chains, Avail for multichain coordination. This segmentation is healthy — each layer optimizes for different priorities — but it limits any single DA layer’s total addressable market.

3. Rollup-as-a-Service Maturing

RaaS platforms have made rollup deployment accessible to non-infrastructure teams. The bottleneck has shifted from deployment to distribution — launching a rollup is easy; attracting users, liquidity, and applications to it is the hard part. Over 50+ rollups launched in 2025-2026 have seen negligible usage, reinforcing the winner-take-most dynamics of the L2 ecosystem.

4. Convergence with L2 Landscape

The modular and L2 conversations are converging. Most Ethereum L2s are technically modular — they separate execution from settlement. The remaining open question is whether they adopt external DA layers or stay within Ethereum’s orbit. Current trends favor Ethereum DA for the majority of value, with external DA serving the sovereign and experimental niches.

Conclusion

Modular blockchains have moved from theoretical paradigm to production infrastructure. The core insight — that separating execution, settlement, consensus, and DA enables each layer to specialize — has been validated across the ecosystem. Over 100 rollups use modular DA layers, and the architecture now underpins the majority of Ethereum transaction activity.

However, the market has not unfolded as early proponents predicted. Ethereum remains the dominant DA layer. Most L2 value settles through Ethereum, not modular alternatives. The shared sequencing thesis suffered a setback with Astria’s shutdown. DA layers are segmenting by use case rather than converging on a single winner.

The realistic outlook: modular architecture is essential infrastructure, but it serves specific niches — sovereign rollups, high-throughput validiums, and non-Ethereum-aligned chains. For the mainstream L2 ecosystem, Ethereum’s own DA and settlement layer remains the default choice. Developers should evaluate modular options based on concrete requirements rather than ideological commitment to modularity.

Resources

• Celestia Documentation
• L2BEAT Data Availability Summary
• Ethereum.org Rollups
• EigenDA Documentation
• Avail Documentation
• The Block - 2026 L2 Outlook

Related Articles

• Layer 2 Scaling Solutions 2026
• Data Availability Layers 2026
• Modular Blockchains and Rollups