What is a modular blockchain? Layers and modular vs monolithic

Covalent TeamUpdated 16 min read

A modular blockchain splits execution, settlement, consensus and data availability into layers. How each works, examples, and modular vs monolithic chains.

A modular blockchain is a blockchain design that splits the core jobs of a chain (executing transactions, settling them, agreeing on their order, and keeping the data available) across separate, specialised layers, often run by different networks. A rollup that executes transactions itself, posts its data to Celestia and settles its proofs on Ethereum is a modular chain. A monolithic blockchain, such as Solana or Ethereum before rollups, does all four jobs on one network of nodes.

This guide explains the four layers and what each one does, the main projects at each layer, how modular and monolithic blockchains compare, and what changes when you build on a modular stack, including how to read data back from the many chains it produces.

The four layers of a blockchain

Every blockchain does the same four jobs. The difference between designs is whether one set of nodes does all of them or each is handed to a specialised layer.

Layer What it does Examples in a modular stack
Execution Runs transactions and smart contracts and computes the new state Rollups such as Base, Arbitrum One, OP Mainnet, ZKsync Era
Settlement Verifies execution (fraud or validity proofs), resolves disputes, anchors bridges Ethereum for most rollups; an L2 for L3 chains
Consensus Agrees on which transactions are included and in what order, and when they are final Ethereum's proof of stake, CometBFT in Cosmos chains and Celestia
Data availability Publishes the transaction data so anyone can check or rebuild the state Ethereum blobs, Celestia, Avail, EigenDA

Settlement and consensus are often provided by the same chain. Ethereum, for example, orders and finalises its own blocks (consensus), hosts the rollup contracts that verify proofs (settlement), and carries rollup data in blobs (data availability), while rollups do the execution.

Execution layer

The execution layer is where transactions run. It takes an ordered list of transactions, executes each one against the current state, including smart contract calls, and produces the new state: balances, contract storage and event logs. It also meters resources, such as gas on EVM chains, so that every computation is paid for.

In a modular stack, the execution layer is usually a rollup: a chain that executes transactions off the base layer, then posts the transaction data and a commitment to the resulting state back to it. The execution environment is the virtual machine the chain runs:

  • EVM: the Ethereum Virtual Machine, used by Ethereum and most rollups, so Solidity contracts and Ethereum tooling work unchanged.
  • SVM: the Solana Virtual Machine, which executes transactions that don't touch the same accounts in parallel. Some rollups now use it as their execution environment.
  • WebAssembly (Wasm): used by CosmWasm smart contracts in Cosmos chains and by Polkadot's runtimes.
  • MoveVM: the Move language's virtual machine, used by Aptos and Sui.

Separating execution is what lets a modular chain change its virtual machine, gas pricing or block time without changing the layers beneath it.

Settlement layer

The settlement layer is where an execution layer's results become final and enforceable. For a rollup, settlement means a set of contracts on a base chain that accept the rollup's state commitments, check that they are correct, and let users withdraw assets based on them. It is also the place disputes are resolved and the trust anchor for the rollup's canonical bridge.

How the check works depends on the rollup type:

  • Optimistic rollups, such as those built with the OP Stack or Arbitrum's Nitro stack, post state commitments that are assumed valid. Anyone can challenge one with a fraud proof during a challenge window, which is why withdrawals to the base chain wait for that window (about a week on most public optimistic rollups) to close. See optimistic rollups.
  • ZK rollups, such as ZKsync Era, post a validity proof with each batch, a cryptographic proof that the state transition was executed correctly. Once the proof is verified on the settlement layer, the batch is final, with no challenge window. See zero-knowledge rollups.

Ethereum is the settlement layer for most rollups today. Chains can also settle on another rollup: an L3 built with Arbitrum's stack can settle on Arbitrum One, and that rollup in turn settles on Ethereum. A sovereign rollup, by contrast, has no settlement contract at all: it posts data to a data availability layer and its own nodes decide which chain is canonical.

Consensus layer

The consensus layer is how a network's nodes agree on which transactions are included, in what order, and when a block can no longer be reverted. In a modular stack, the rollup usually doesn't run its own consensus. A sequencer orders its transactions, and the rollup inherits the final ordering from the layer it posts data to: once that layer finalises the block containing the rollup's data, the order is fixed.

The main consensus mechanisms differ in how they pick the next block producer and in the kind of finality they give:

Mechanism How the block producer is chosen Finality Example
Proof of work (PoW) Miners race to find a hash below a target; the first to find one proposes the block Probabilistic: a block gets safer as more blocks are built on top of it Bitcoin
Proof of stake (PoS) Validators who lock up (stake) the native token are selected pseudo-randomly to propose Deterministic once a supermajority of stake votes to finalise; stake can be slashed Ethereum
Delegated proof of stake (DPoS) Token holders vote for a small set of delegates, who take turns producing blocks Deterministic once a supermajority of the elected producers confirms Tron
BFT-style PoS (CometBFT) A known validator set weighted by stake takes turns to propose; validators vote in rounds Instant and deterministic: a block is final once over two-thirds of voting power commits Cosmos Hub, Celestia
Proof of authority (PoA) A fixed list of approved validators, known by identity, take turns Depends on the protocol; trust rests on the validator list, not on stake or work Private and consortium networks

Ethereum's proof of stake is called Gasper. It combines two pieces: LMD-GHOST, the fork-choice rule that picks the head of the chain from the latest validator votes, and Casper FFG, the finality gadget that finalises checkpoints once validators holding two-thirds of the stake have voted for them, which normally takes two epochs (about 13 minutes). Reverting a finalised block would require at least a third of all staked ETH to be slashed. For the full list of mechanisms, see ethereum.org's consensus mechanisms page.

The type of finality matters when you build across layers. A bridge or indexer reading a probabilistic chain has to wait for enough confirmations; on a BFT chain, a committed block is final immediately; on a rollup, a transaction is only as final as the batch that contains it on the settlement and data availability layers.

Data availability layer

The data availability (DA) layer guarantees that the data behind every block has been published, so anyone can check the execution and rebuild the state. This is what makes a rollup safe: if a sequencer posted a state commitment but withheld the transaction data, no one could produce a fraud proof or recover their funds. Data availability is not long-term storage: it means the data was published and could be downloaded for a while, not that it is kept forever. ethereum.org's data availability page explains the problem in depth.

The main DA layers today:

  • Ethereum blobs. Since EIP-4844 (the Dencun upgrade, March 2024), rollups post their data to Ethereum in blobs: temporary data attached to blocks, priced in their own fee market and pruned by nodes after about 18 days. Rollups that use blobs inherit Ethereum's full security for data availability.
  • Celestia. A blockchain built only for ordering and publishing data. It doesn't execute smart contracts. Block producers erasure-code the data into a two-dimensional matrix and commit to every row and column, so light nodes can check availability by sampling (Celestia docs). Its consensus is CometBFT.
  • Avail. A DA blockchain that began at Polygon under the name Polygon Avail and has been an independent project, called simply Avail, since 2023. It uses KZG polynomial commitments with erasure coding, so light clients can verify samples against the commitment (Avail docs).
  • EigenDA. A data availability service secured through EigenLayer restaking: operators who have restaked ETH store pieces of the rollup's erasure-coded data and attest that they hold them. It is a service with a set of operators rather than a blockchain of its own.
  • Data availability committees (DACs). A small set of known parties sign that they hold the data, as in Arbitrum's AnyTrust chains. Cheaper, but users trust the committee instead of a chain.

The technique that lets a DA layer grow without every node downloading every block is data availability sampling (DAS). Data is erasure-coded so that the full block can be rebuilt from only part of the extended data, which means withholding even a small piece forces a producer to hide a large share of it; a light node then downloads a few random small pieces. If every sample comes back, the chance that a meaningful part of the block is being withheld becomes vanishingly small after a modest number of samples. Celestia and Avail use DAS today, and Ethereum added a form of it, PeerDAS (EIP-7594), in the Fusaka upgrade that went live on 3 December 2025. For how PeerDAS splits blob data into columns across nodes, see Mastering PeerDAS.

A light client samples small pieces of several Avail blocks through data availability sampling instead of downloading the blocks in full.
Data availability sampling by a light client. Figure: Avail Project.

Modular vs monolithic blockchains

A monolithic blockchain runs execution, settlement, consensus and data availability on the same set of nodes. Every full node executes every transaction, takes part in or follows consensus, and stores the data. Bitcoin and Solana are monolithic, and so was Ethereum before rollups. A modular blockchain hands one or more of those jobs to a separate layer.

Both designs are answers to the blockchain trilemma, a framing popularised by Vitalik Buterin: a simple blockchain can easily have two of decentralisation, security and scalability, but not all three (Why sharding is great). Monolithic chains scale by making each node more powerful; modular chains scale by splitting the work so that no single node has to do all of it, and by letting light nodes verify data availability with sampling.

Dimension Monolithic Modular
Scalability Limited by what one node can execute, verify and store; scaled by raising hardware requirements Execution scales across many rollups; DA layers with sampling grow block space without every node downloading it
Sovereignty and customisation One VM, fee market and upgrade path shared by every app Each chain chooses its VM, gas token, block time, sequencer and DA layer
Security model One validator set secures everything Inherited from the settlement and DA layers; weakest link (sequencer, bridge, DA choice) matters
Composability Synchronous: any contract can call any other in the same transaction Asynchronous across chains: calls between rollups go through bridges or messaging protocols
Complexity One protocol and one set of nodes to run and reason about More moving parts: sequencers, provers, bridges, several fee markets
Examples Solana, Bitcoin, Ethereum L1 before rollups Celestia plus the rollups that post to it; Ethereum plus its rollups

Advantages of monolithic chains:

  • Simplicity. One protocol, one node software, one place to read state. Developers and node operators reason about a single system.
  • Integrated security. Every node checks everything, and no data passes between layers that could fail or be attacked separately.
  • Synchronous composability. Contracts call one another atomically, which DeFi protocols in particular depend on.

Limitations of monolithic chains:

  • Throughput is capped by the node. Raising it means raising hardware requirements, which shrinks the set of people who can run a full node.
  • Shared block space. One popular app can push up fees for every other app on the chain.
  • Slower, all-or-nothing upgrades. A change to the protocol is a hard fork that every node must adopt at once.

Trade-offs of modular chains: composability across chains is asynchronous, users and liquidity are split across many rollups, and each extra component (a centralised sequencer, a bridge, a committee-based DA layer) adds a trust assumption that has to be checked rather than assumed. Networks of interconnected sovereign chains, such as Cosmos chains linked by IBC and Polkadot's parachains, are sometimes described as a third, "polylithic" model; in practice they are modular at the network level, with each chain still monolithic inside.

Neither design wins outright. Monolithic chains suit apps that need one shared state with low latency, such as order books; modular stacks suit teams that want their own chain, their own fee market or a specialised execution environment, while borrowing security from an established base layer.

Building on a modular stack

Building a chain on a modular stack is mostly a set of choices, one per layer, plus the plumbing between them.

Choose an execution environment and rollup framework

Most new chains start from a framework rather than writing a node from scratch:

  • OP Stack: Optimism's open-source optimistic rollup stack, EVM-equivalent, used by OP Mainnet and Base among others.
  • Arbitrum chains (formerly Arbitrum Orbit): chains built with Arbitrum's Nitro stack, run as a Rollup or as AnyTrust, settling on Ethereum or on an Arbitrum chain.
  • ZK Stack: ZKsync's framework for ZK rollups that settle with validity proofs.
  • Polygon CDK: Polygon's chain development kit, which connects chains to Polygon's Agglayer.
  • Cosmos SDK: a framework for sovereign application-specific chains with CometBFT consensus, connected to other chains by IBC.

Pick the execution environment first (EVM for existing Solidity code and tooling; another VM if your app needs it), then a framework that supports it and the proof system you want: optimistic (cheaper to run, slower withdrawals) or ZK (faster finality to the base chain, heavier proving).

Choose a data availability and settlement layer

The DA layer is usually the largest running cost of a rollup and the main factor in its security. Posting to Ethereum blobs gives Ethereum's guarantees; Celestia, Avail and EigenDA offer separate block space with their own security assumptions; a DAC is the cheapest and the most trusted. Several frameworks support more than one: the OP Stack has an Alt-DA mode and Arbitrum chains can use AnyTrust or an alternative DA provider.

The settlement layer decides where your bridge contracts and proofs live and where users withdraw to. Settling on Ethereum puts the chain next to Ethereum's liquidity; settling on an L2 as an L3 is cheaper but adds a hop.

Rollup-as-a-service

If you don't want to run sequencers, provers and nodes yourself, rollup-as-a-service (RaaS) providers such as Conduit, Caldera, Gelato and AltLayer deploy and operate a chain on these frameworks for you. You still choose the framework, DA layer and settlement layer; the provider runs the infrastructure, block explorers and bridges.

Connect the modules: bridging and messaging

A modular chain needs to move assets and messages to other chains:

  • Native (canonical) bridges lock assets in a contract on the settlement layer and mint them on the rollup. Withdrawals follow the rollup's proof system, so they wait out the challenge window on optimistic rollups.
  • IBC (Inter-Blockchain Communication) passes packets between Cosmos chains, verified by light clients of each chain.
  • General messaging protocols, such as Chainlink CCIP, LayerZero, Hyperlane and Wormhole, carry arbitrary messages between chains with their own verification models.

Treat every bridge and messaging protocol as part of your security model. Bridges have been some of the largest targets for exploits, and a message is only as final as the source chain's finality.

Read data across the chains you build on

A modular ecosystem turns one app into many chains: a user might hold tokens on Ethereum, Base, Arbitrum One and OP Mainnet at once. Reading that with raw RPC means a node or provider per chain, a call per token per chain, and your own decoding and pricing. An indexed blockchain data API answers it in one request.

The GoldRush wallet balance API returns one address's native and token balances, with USD quotes, across several EVM chains in one call. It costs 2.5 credits for the first page of results:

// Node 18+ (built-in fetch). Set GOLDRUSH_API_KEY in your environment.const API_KEY = process.env.GOLDRUSH_API_KEY; // Ethereum L1 and three rollups that settle on it.const CHAINS = ["eth-mainnet", "base-mainnet", "arbitrum-mainnet", "optimism-mainnet"]; function formatUnits(raw, decimals) {    const value = BigInt(raw ?? "0");    const base = 10n ** BigInt(decimals ?? 0);    const whole = value / base;    const fraction = (value % base)        .toString()        .padStart(Number(decimals ?? 0), "0")        .slice(0, 4);    return fraction ? `${whole}.${fraction}` : `${whole}`;} async function balancesByChain(address) {    const url = new URL(`https://api.covalenthq.com/v1/allchains/address/${address}/balances/`);    url.searchParams.set("chains", CHAINS.join(","));    url.searchParams.set("quote-currency", "USD");     const res = await fetch(url, { headers: { Authorization: `Bearer ${API_KEY}` } });    if (!res.ok) throw new Error(`GoldRush returned HTTP ${res.status}`);    const { data } = await res.json();     const byChain = {};    for (const item of data.items) {        if (item.is_spam) continue;        const chain = (byChain[item.chain_name] ??= { usd: 0, tokens: [] });        chain.usd += item.quote ?? 0;        chain.tokens.push(`${item.contract_ticker_symbol} ${formatUnits(item.balance, item.contract_decimals)}`);    }    return byChain;} const byChain = await balancesByChain("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045");for (const [chain, { usd, tokens }] of Object.entries(byChain)) {    console.log(`${chain}: $${usd.toFixed(2)} across ${tokens.length} tokens`);}

Each item carries its chain_name, so the code groups balances per chain without knowing anything about how each chain is built. The address must be a hex address (ENS names aren't accepted on this endpoint); leave out chains to query the default set. To find which chains an address has used before querying them, call address activity. The GoldRush Foundational API covers the rest of the data an app needs per chain, such as transactions, token holders and NFTs, and the supported chains list shows which rollups and L1s each endpoint covers.

Frequently asked questions

What is a modular blockchain?

A modular blockchain splits the four jobs of a blockchain (execution, settlement, consensus and data availability) across separate layers instead of running them all on one network. A typical example is a rollup that executes transactions itself, posts its data to a data availability layer such as Ethereum blobs or Celestia, and settles its proofs on Ethereum.

What is the difference between modular and monolithic blockchains?

A monolithic blockchain, such as Solana or Bitcoin, runs execution, settlement, consensus and data availability on the same nodes, which keeps it simple and synchronously composable but caps throughput at what one node can handle. A modular blockchain hands some of those jobs to specialised layers, which lets each chain customise and scale independently, at the cost of more components, more trust assumptions and asynchronous calls between chains.

What does the consensus layer do in a modular blockchain?

The consensus layer agrees on which transactions are included, in what order, and when they are final. In a modular stack, a rollup's sequencer orders its own transactions, but the final order is fixed by the consensus of the layer the rollup posts its data to, such as Ethereum's proof of stake or Celestia's CometBFT.

What is the data availability layer?

The data availability layer guarantees that the data behind each block has been published, so anyone can verify execution and rebuild the state. Rollups post their transaction data there. Ethereum blobs, Celestia, Avail and EigenDA are the main options, and data availability sampling lets light nodes check availability without downloading whole blocks.

Is Ethereum modular or monolithic?

Ethereum started as a monolithic chain and now works as the settlement, consensus and data availability layer of a modular stack, with most user transactions executed on rollups. Its roadmap is rollup-centric: EIP-4844 added blobs for rollup data, and the Fusaka upgrade added PeerDAS so nodes can sample blob data instead of downloading all of it.

How do I get data from many rollups at once?

Use an indexed API instead of one RPC node per chain. GoldRush's multichain balances endpoint returns an address's token balances across several EVM chains in one call, each item tagged with its chain, and its other endpoints return transactions, holders and NFTs per chain in the same response format.

Next steps

Get new guides by email

New tutorials and best practices for building with blockchain data, sent as they're published.