Layer 0 vs Layer 2: Rethinking Ethereum's Scaling Architecture

Good design is unobtrusive.

The Ethereum scaling narrative has calcified around Layer 2 rollups. The pitch is simple: move execution off-chain, post compressed state to L1, inherit security.

The result: 17× transaction capacity. 95% fee reduction. Billions in TVL.

Also: fragmented liquidity, broken composability, $2 billion stolen from bridges.

The question is not whether L2s scale Ethereum. They do.

The question is: what are we scaling toward?

What Layer 2 actually solves

Layer 2 rollups solve one problem: execution bottleneck.

Ethereum L1 can process ~15-30 transactions per second. This is not a bug. This is the deliberate tradeoff for decentralization—thousands of nodes validating every computation.

L2s move execution elsewhere. Transactions happen off-chain on a separate state machine. A sequencer orders them, batches them, compresses them. A proof (fraud or validity) attests to correctness. The compressed state posts to L1.

This works. Arbitrum, Optimism, zkSync, StarkNet—all functional, all scaling, all delivering lower fees.

But execution is not the only bottleneck.

What Layer 2 fragments

Every L2 is a separate blockchain. Separate state. Separate consensus. Separate liquidity.

The composability problem:

On Ethereum L1, smart contracts call each other atomically. Uniswap trades trigger Aave liquidations trigger Compound rebalancing—all in one transaction, one block, one atomic state transition.

This is "money legos." This is why DeFi exists.

On L2s, this breaks. A contract on Arbitrum cannot call a contract on Optimism. You need:

• -A bridge (introduces latency, cost, risk)
• -Asynchronous messaging (no atomicity)
• -Trust assumptions (multisigs, relayers, oracles)

Composability in Practice

Scenario: Swap on Uniswap → Deposit to Aave

L1 / L0 — Atomic Composability:

L2 — Broken Composability:

The result: liquidity fragmentation.

DeFi protocols must choose: deploy on Base, Arbitrum, Optimism, zkSync, or StarkNet? Each choice silos liquidity. A $10M pool on Arbitrum is not composable with a $10M pool on Optimism. You have two $10M pools, not one $20M pool.

Capital efficiency collapses.

The user experience problem:

Users navigate bridges. Developers choose L2s. Liquidity scatters across walled gardens.

The industry's solution: more bridges, shared sequencers, based rollups, cross-chain standards (ERC-7683), inter-rollup messaging.

These are patches. They treat the symptom, not the cause.

The cause is architectural.

The bridge problem is structural

Bridges are the single largest source of financial loss in Web3 security.

Facts:

• -$2 billion stolen across 13 bridge incidents in 2022
• -69% of total DeFi funds stolen in 2022 came from bridge hacks
• -Notable incidents:
  • -Poly Network: $610M
  • -Ronin: $625M
  • -Wormhole: $326M

The vulnerabilities are structural:

• -Private key compromise: Multisigs controlling bridge custody
• -Smart contract exploits: Complex cross-chain verification logic
• -Economic attacks: Oracle manipulation, MEV extraction

The industry's response: "Make bridges more secure."

This is incomplete. Bridges are honeypots—billions in TVL concentrated in trust-minimized (but not trustless) smart contracts.

The only secure bridge is no bridge.

Rollup bridges (L1↔L2) are safe. Canonical, cryptographically verified, no multisigs.

Cross-rollup bridges (L2↔L2) are not. They introduce new trust assumptions every time.

Layer 0 vs Layer 2

The industry uses "Layer 0" ambiguously. Polkadot, Cosmos, Avalanche—multi-chain interoperability protocols.

I propose a different framing:

Layer 0: Settlement infrastructure that operates on L1 but does not execute transactions.

Layer 2: Execution infrastructure that operates off-chain and settles to L1.

Note: This framing of "Layer 0" as settlement infrastructure is proposed here for clarity, not as established industry terminology.

Architecture Comparison

Execution Scaling (Layer 2):

Settlement Scaling (Layer 0):

The distinction:

Layer 2 is a new blockchain. It has its own execution environment, state, and consensus (sequencer). It settles to Ethereum but is not Ethereum.

Layer 0 is a verification service. It proves batch correctness on L1 without moving execution elsewhere. It does not create a new chain. It does not fragment liquidity. It does not require bridges.

What settlement layers actually do

A settlement layer does one thing: attest to the correctness of a batch of transactions.

Not:

• -Execute transactions (that happens elsewhere—wallets, matchers, aggregators)
• -Store state (that happens on L1)
• -Sequence transactions (that happens off-chain or via existing L1 ordering)

Only:

• -Accept a batch commitment (Merkle root, state diff, transaction list)
• -Verify a cryptographic proof (STARK, SNARK, fraud proof)
• -Record the attestation on-chain

The transactions themselves execute on L1. The settlement layer just compresses the verification cost.

Example:

100 ERC20 transfers normally cost 100 × 21,000 gas = 2,100,000 gas.

A settlement layer:

1. -Accepts a Merkle root representing those 100 transfers
2. -Verifies a zero-knowledge proof of correctness (~300,000 gas)
3. -Emits an event: "Batch verified"

The transfers settle on L1. The tokens move on L1. The composability remains on L1.

No new chain. No bridge. No fragmentation.

Why this matters: Composability at scale

The Ethereum community treats composability loss as an acceptable tradeoff for scalability.

This is a false dichotomy.

Settlement layers scale without fragmenting composability. Transactions execute on L1 (or are batched via existing aggregators like CoW Protocol, 1inch, Flashbots). The settlement layer compresses verification, not execution.

DeFi protocols remain composable:

• -Uniswap on L1 ↔ Aave on L1 (atomic)
• -No bridges, no asynchronous messaging, no additional trust assumptions

Liquidity remains unified:

• -One canonical state on Ethereum
• -No "Arbitrum liquidity" vs "Optimism liquidity"
• -Capital efficiency intact

Users interact with Ethereum:

• -Wallets point to L1 contracts
• -No bridge UX, no "which L2?" decisions
• -Transactions cheaper due to batching, but fundamentally L1 transactions

The tradeoff:

Settlement layers do not scale execution. You cannot run a game or a high-frequency DEX on a settlement layer.

But most Ethereum transactions are transfers, swaps, and simple state updates. These do not need dedicated execution environments. They need cheap verification.

Settlement layers are not a replacement for L2s. They are a complement.

The architectural choice

Ethereum's scaling roadmap is L2-centric. This is pragmatic—L2s exist, they work, they scale.

But the roadmap assumes: the only way to scale Ethereum is to move execution off L1.

This is also incomplete. There is another dimension: compress verification cost on L1.

Two architectures:

1. Execution scaling (L2 rollups):

• -New chain, new state machine
• -High throughput, isolated liquidity
• -Requires bridges for composability
• -Best for: applications, games, high-frequency trading

2. Settlement scaling (L0 batching):

• -Same chain, compressed verification
• -Lower throughput, unified liquidity
• -No bridges, native composability
• -Best for: transfers, swaps, payments

The industry chose (1) exclusively. The question is: why not both?

What Ethereum could be

Imagine Ethereum in 2027:

L2 rollups handle execution-heavy workloads:

• -Games, social apps, high-frequency DEXs
• -10,000+ TPS per rollup
• -Cross-rollup standards emerging (based rollups, shared sequencers)

Settlement layers handle verification-heavy workloads:

• -ERC20 transfers, simple swaps, payments
• -Significant cost reduction via batching
• -Native L1 composability, no bridges

Users do not care which is which:

• -Wallets abstract the complexity
• -Transactions route intelligently (execution → L2, settlement → L0)
• -Liquidity unified where it matters (DeFi core on L1)

The result:

• -Scalability without fragmentation
• -Composability without sacrificing throughput
• -Security without new trust assumptions

This is not speculative. The primitives exist.

Zero-knowledge proofs verify batches cheaply. EIP-4844 makes data posting cheap. Ethereum's architecture supports both L2s and on-chain verification.

What is missing is not technology. It is framing.

The path forward

The Ethereum community is pragmatic. L2s work. Billions flow through them. The roadmap is set.

But pragmatism is not the same as optimality.

The question is not: "Should we abandon L2s?"

The question is: "What else is possible?"

Settlement layers are possible. The concept is sound. They solve a different problem than L2s.

The principles:

1. -Not all scaling requires new chains. Verification can scale on L1.
2. -Composability is not negotiable. DeFi only works with atomic state transitions.
3. -Bridges are structural risk. Every cross-chain hop introduces attack surface.
4. -Users do not care about architecture. They care about cost, speed, security.
5. -Ethereum's strength is its unified state. Fragmenting it has costs.

Settlement layers preserve what makes Ethereum valuable—composability, security, unified liquidity—while compressing the cost of verification.

L2s scale execution. L0s scale settlement.

Ethereum needs both.

Good design is thorough down to the last detail.

The blockchain industry moves fast. L2s launched, scaled, captured billions in TVL. The narrative solidified: "L2s are Ethereum's scaling solution."

But narratives are not architecture.

Ethereum's design space is larger than the current roadmap suggests. Settlement layers are not competitors to L2s. They are complements—addressing a different bottleneck, preserving different properties.

The question for builders is not: "L2 or L1?"

The question is: "What are we optimizing for?"

If execution throughput: L2.

If composability and unified liquidity: L0.

If both: use both.

The rest is implementation.

Sources & Further Reading

L2 Fragmentation & Composability:

• -The Block - Ethereum layer-2 proliferation causing liquidity fragmentation concerns
• -Medium - Ethereum's fragmentation and the future of modular scaling
• -Cointelegraph - Based rollups make Ethereum feel Ethereum again

Bridge Security & Incidents:

• -Chainalysis - Cross-Chain Bridge Hacks Emerge as Top Security Risk
• -Immunefi - Common cross-chain bridge vulnerabilities
• -Presto Research - Cross-chain bridge exploits
• -Chainlink - Cross-chain bridge vulnerabilities

L1 vs L2 Scaling Tradeoffs:

• -Vitalik Buterin - Making Ethereum alignment legible
• -Sygnum Bank - Are based rollups the answer to Ethereum's layer-2 conundrum?

Blockchain Layer Architecture:

• -O2K - A deep dive into blockchain layers
• -Bitpowr - Blockchain layers explained

All data reflects 2022-2025 ecosystem conditions and is subject to change as Ethereum's architecture evolves.

What are you building toward?