The L2 & Scaling Frontier

Lightning is Bitcoin’s answer to a hard fact: a base layer that asks every node on Earth to store every payment forever can never be fast and cheap and keep that property. So you move activity off the base layer while keeping its trust model as the backstop. Every major chain now wrestles with the same question — how do you scale without quietly re-introducing the trusted middlemen you removed? — but they’re betting on very different answers. This page surveys the frontier, and flags clearly which ideas are live and which are still proposals.

Frontier means uncertain — read the labels

Several ideas below (BitVM, drivechains, most Bitcoin covenant proposals) are research or unactivated proposals, not deployed systems. They may change shape, get rejected, or never ship. Where something is live, this page says so; where it’s speculative, it says that too. Treat any “could enable…” as conditional.

The core idea: keep verification on L1, push execution off it

A Layer 2 (L2) does work off the main chain but inherits the main chain’s security by settling to it. The art is making sure that if the L2 misbehaves, users can still appeal to the base layer and get their money. The chains differ on how much they’re willing to change the base layer to make that possible.

   Philosophy          Base layer stays…        Scaling happens…
   ──────────          ─────────────────        ────────────────
   Bitcoin             very conservative         off-chain (Lightning), proposals debated for years
   Ethereum            modest, L2-friendly       on rollups (the official roadmap)
   Solana              changes freely            on the L1 itself (monolithic)

Bitcoin: a slow, conservative frontier

Bitcoin’s culture treats base-layer changes as near-irreversible and therefore rare. Scaling has mostly meant maturing Lightning — better routing, larger capacity, easier custody tradeoffs — rather than altering consensus. Beyond Lightning, several ideas are under discussion; it’s important to hold them at the right level of certainty.

• Covenants (live debate, not yet activated as of early 2026). Proposals like OP_CTV (CheckTemplateVerify) and re-enabling OP_CAT would let a coin restrict how it can be spent next. They could enable vaults, congestion control, and more expressive L2s — but they require a soft fork and are still contested. A CTV BIP-9 miner-signaling window opened in March 2026, but the required threshold has not been reached. See covenants for the mechanics and the for/against debate.
• BitVM (early-stage research). Proposed by Robin Linus in 2023, BitVM is a scheme for expressing arbitrary computation that can be verified on Bitcoin through a challenge–response (fraud-proof) game, without changing consensus rules. In principle it could underpin trust-minimized bridges or rollup-like systems. In practice it is complex, evolving, and unproven at scale — treat it as a promising direction, not a product.
• Drivechains (proposal, unactivated). BIP-300/301 by Paul Sztorc would let miners secure sidechains via a special peg, so coins could move to chains with different rules and back. It needs a soft fork and is genuinely controversial (critics worry it changes miners’ role). It has not been activated. The simpler, already-deployed cousins — federated sidechains and statechains — are covered in sidechains & statechains.

The throughline: Bitcoin would rather under-promise at the base layer and let L2s do the heavy lifting, even if that makes the roadmap feel slow.

Ethereum: the rollup-centric roadmap

Ethereum made an explicit strategic choice: don’t scale execution on L1 — scale it on rollups. A rollup runs transactions off-chain in bulk, then posts compressed data and a proof back to Ethereum, which acts as the settlement and data-availability layer. Two families:

• Optimistic rollups (e.g. Arbitrum, Optimism, Base). They assume posted batches are valid and allow a challenge window (commonly ~7 days) during which anyone can submit a fraud proof to revert a bad batch. Cheap to run; withdrawals back to L1 are slow because you must wait out the window.
• ZK (validity) rollups (e.g. zkSync, Starknet, Polygon zkEVM, Scroll, Linea). Each batch ships a cryptographic validity proof that the transactions were executed correctly. No challenge window is needed, so finality is faster — but generating the proofs is computationally heavy.

   Optimistic:  post batch ──► assume valid ──► (7-day window to dispute via fraud proof)
   ZK / validity: post batch + validity proof ──► verified immediately, no dispute window

The base layer’s job became making rollup data cheap. The Dencun upgrade (13 March 2024) shipped EIP-4844 (“proto-danksharding”), adding a new, cheaper kind of data called blobs specifically for rollups, with a future path toward full “danksharding.” (For why Ethereum needs all this expressiveness in the first place, see smart contracts & the EVM.)

By the numbers — blobs (EIP-4844)

Blobs are a separate, metered resource from regular gas, with their own EIP-1559-style fee market:

   at Dencun launch (2024)  :  target 3 / max 6 blobs per block
   raised since             :  target 6 / max 9 with Pectra (May 2025), higher again in later forks
   size per blob            ≈ 128 KiB
   retention               ~18 days, then pruned (not stored forever)

The key trick: blob data is not kept by Ethereum permanently — it’s available long enough for anyone to verify or challenge a rollup, then discarded. That’s why blobspace is far cheaper than putting the same data in ordinary calldata, and why rollup fees dropped sharply after Dencun.

It actually happened — Dencun cut rollup fees (March 2024)

Before EIP-4844, rollups paid for data as expensive L1 calldata, and a single rollup transaction could cost a meaningful fraction of a dollar even when the rollup itself was “cheap.” After the Dencun upgrade on 13 March 2024 introduced blobs, typical fees on major rollups fell dramatically — in many cases to a small fraction of a cent. It’s a concrete example of the base layer changing specifically to make L2s cheaper, exactly as the rollup-centric roadmap intended.

Solana: the monolithic bet

Solana rejects the L2 premise. Its wager is that with enough engineering you can do everything on one fast base layer — a single global state machine, no rollups, no payment channels. Scaling means making the L1 itself faster: parallel execution, a pipelined validator, and ongoing work like the Firedancer validator client (an independent, high-performance implementation from Jump Crypto — its hybrid ran on mainnet from 2024, and the full client went live on mainnet in late 2025) to raise throughput and client diversity.

The bet’s cost is the same one from fees, throughput & blockspace: keeping all that throughput on one layer demands heavier validator hardware, which narrows who can participate. Where Bitcoin and Ethereum export load to other layers to protect base-layer decentralization, Solana spends decentralization to keep a single, unified state. (The architecture behind the bet is detailed in Solana architecture.)

The thread

How does scaling preserve untrusting strangers’ ability to share one ledger? That’s the whole game. An L2 is only honest scaling if a user who gets cheated can fall back to the base layer and recover their funds without trusting the operator — Lightning’s penalty transactions, a rollup’s fraud or validity proof. The danger at every frontier is “scaling” that quietly swaps verification for trust: a bridge you must trust, a sequencer that can’t be challenged, a sidechain with a federation that can freeze you. So the right question for any of these ideas — live or speculative — is not “how fast is it?” but “if it lies, can I still appeal to a chain I don’t have to trust?” That test is exactly why this page insists on labeling proposals as proposals.

The architect’s lens

The Layer-2 pattern is a deliberate division of labor — interrogate it before chasing TPS numbers:

• Why does it exist? Because a base layer that asks every node to store every transaction forever can’t be fast, cheap, and keep that property — an L2 does the work off-chain and inherits L1’s security by settling to it.
• What problem does it solve? Scaling without re-introducing trusted middlemen: a cheated user can fall back to the base layer and recover funds — Lightning’s penalty transactions, an optimistic rollup’s fraud proof (within a ~7-day window), a ZK rollup’s validity proof. EIP-4844 blobs exist to make rollup data cheap (pruned after ~18 days).
• What are the trade-offs? Each design imports its own assumption — a challenge window you must wait out, a sequencer that might censor, a bridge or federation that can freeze you — and much “scaling” quietly swaps verification for trust.
• When should I avoid it? The L2/rollup route is the wrong bet if you’d rather keep one unified state and accept heavier validators — Solana’s monolithic wager rejects the L2 premise entirely, spending decentralization to scale the L1 itself.
• What breaks if I remove it? Without L2s, scaling forces you to grow the base layer — bigger blocks, heavier nodes, fewer independent verifiers — exactly the centralization Bitcoin and Ethereum export off-chain to avoid. The right test for any L2: “if it lies, can I still appeal to a chain I don’t have to trust?”

Check your understanding

1. What makes something a genuine Layer 2, as opposed to just “another chain you bridge to”?
2. Of BitVM, drivechains, and OP_CTV covenants — which are live today? Describe the status of each.
3. Explain the core difference between optimistic and ZK rollups, including why their withdrawal speeds differ.
4. What did EIP-4844 (Dencun, March 2024) add, and why did it lower rollup fees?
5. How is Solana’s monolithic scaling bet different from Ethereum’s roadmap, and what does it cost?

Show answers

1. A real L2 does its work off-chain but settles to the base layer and inherits its security, so that if the L2 misbehaves a user can appeal to the base chain and recover funds. Without that fallback it’s just a separate chain you must trust — not L2 security.
2. None of the three is live as deployed Bitcoin consensus features. OP_CTV/OP_CAT covenants are proposals under active debate requiring a soft fork; BitVM is early-stage research (a challenge–response scheme, complex and unproven at scale); drivechains (BIP-300/301) are an unactivated, controversial proposal. Only Lightning and federated sidechains/statechains are actually deployed.
3. Optimistic rollups assume batches are valid and rely on a fraud proof within a challenge window (~7 days), so L1 withdrawals are slow. ZK/validity rollups attach a validity proof to each batch, so correctness is verified immediately and finality is faster — at the cost of heavy proof generation.
4. It added blobs — a cheaper, separate data resource for rollups that is pruned after ~18 days rather than stored forever. Because rollups no longer pay for permanent, expensive calldata, their data costs (and thus fees) dropped sharply.
5. Solana scales the L1 itself (parallel execution, faster clients like Firedancer) with no rollups or channels, whereas Ethereum keeps the L1 modest and pushes execution to rollups. Solana’s bet costs decentralization: a single fast base layer demands heavier validator hardware, narrowing participation.