Based Rollups & Ethereum L1 Sequencing

What Are Based Rollups?

A based rollup is a rollup where Ethereum Layer 1 validators act as sequencers. Instead of delegating transaction ordering to a centralized sequencer operator or a separate sequencer network, based rollups use the existing L1 validator set to sequence L2 transactions. This approach was formalized by Justin Drake and represents a fundamental departure from traditional rollup sequencing models.

Traditional rollups (optimistic and ZK) separate sequencing from L1 consensus. A sequencer receives transactions, orders them, and publishes a batch to L1. This architecture provides flexibility but introduces new trust assumptions: What if the sequencer censors transactions? What if the sequencer goes offline? Based rollups eliminate these concerns by making sequencing a property of L1 consensus itself.

Key characteristics of based rollups include:

• L1 Validators Are Sequencers: Any L1 validator can propose L2 transactions by including them in their block.
• Inherited Liveness: L2 liveness depends only on L1 liveness. No separate sequencer infrastructure is required.
• Censorship Resistance: Censoring an L2 transaction requires censoring the L1 itself, which is economically impractical.
• Credible Neutrality: No entity controls or operates the sequencer network. Sequencing follows L1 consensus rules.
• Synchronous Composability: L1 and L2 can read each other's state within the same block, enabling powerful composability patterns.

The tradeoff is that based rollups inherit L1's throughput constraints. They cannot exceed the L1 block gas limit or escape the 12-second block time of Ethereum. For applications requiring maximum throughput, this may be a limitation. For applications requiring credible neutrality and composability, it is a significant advantage.

How Based Sequencing Works

Understanding based sequencing requires examining the complete flow from L2 user to L1 finality. Unlike traditional rollups where a centralized sequencer batches transactions, based rollups integrate L2 transaction ordering directly into L1 block construction.

The Based Sequencing Flow

Step 1: Transaction Submission
Users submit L2 transactions to the L2 mempool. These transactions are broadcast to all L2 nodes, similar to how L1 transactions propagate through the Ethereum network.

Step 2: Block Proposal
When an L1 validator is chosen to propose a block, they construct both the L1 block and the L2 block simultaneously. They select transactions from the L2 mempool, order them according to protocol rules (or MEV-based rules), and include both L1 and L2 data in the proposed block.

Step 3: L1 Consensus
The L1 block containing L2 transactions is proposed and attested to by other validators. Once the block is finalized by L1 consensus (typically 2 epochs or ~13 minutes), the L2 block is also finalized.

Step 4: L2 State Execution
L2 nodes execute the sequenced transactions in order, updating the L2 state. This execution is deterministic and follows the L2 virtual machine rules (e.g., EVM for an Ethereum-compatible based rollup).

Sequencing Policy and MEV

Based rollups must define how L1 validators order L2 transactions. This can be done in several ways:

• FIFO Ordering: L2 transactions are included in the order they arrive, similar to L1 mempool behavior.
• MEV-Aware Sequencing: Validators order transactions to optimize MEV extraction, subject to protocol constraints.
• Encrypted Sequencing: Transactions are encrypted until inclusion, protecting against front-running (requires advanced cryptography).

The choice of sequencing policy affects both user experience and MEV distribution. Unlike traditional rollups where a single sequencer controls MEV, based rollups distribute MEV across the entire L1 validator set.

Preconfirmations & Fast Finality

One of the most exciting developments in based rollups is the emergence of preconfirmations. While based rollups inherit L1 finality (~13 minutes), preconfirmations provide near-instant soft guarantees that a transaction will be included in an upcoming block.

What Are Preconfirmations?

A preconfirmation is a cryptographic commitment from a validator that a specific transaction will be included in the validator's next block (or within a small window of future blocks). The validator backs this commitment with economic security—if they fail to include the transaction, they forfeit a portion of their staked ETH.

Preconfirmations are particularly powerful because they provide asymmetric security: users get near-instant finality for small-value transactions, while the economic cost of attacking is borne by validators who must slash their stake to break the commitment.

Preconfirmations and Restaking

Modern preconfirmation designs leverage restaking protocols like EigenLayer. Validators can opt into providing preconfirmations by restaking their ETH with an AVS (Actively Validated Service). If they fail to honor a preconfirmation, the AVS slashes their restaked balance, creating economic incentives for honest behavior.

The security model works as follows:

1. A validator restakes 32 ETH into an EigenLayer AVS designed for preconfirmations.
2. The validator commits to including a user's transaction in their next block (preconfirmation).
3. If the validator includes the transaction, both parties are satisfied. No slashing occurs.
4. If the validator fails to include the transaction, the AVS slash mechanism triggers, removing a portion of the validator's restaked ETH.

TEE-Based Preconfirmations

Another approach to preconfirmations uses Trusted Execution Environments (TEEs) like Intel SGX. A TEE-backed preconfirmation service runs inside a secure enclave and cryptographically commits to transaction inclusion. Because the code runs in hardware, the commitment is extremely difficult to break without the validator's private key.

TEE-based preconfirmations can provide sub-second latency and high throughput, making them suitable for high-frequency trading and other latency-sensitive applications. The security model differs from restaking: rather than economic penalties, the security comes from hardware attestation and cryptographic proofs.

Synchronous Composability

One of the most powerful benefits of based rollups is synchronous composability between L1 and L2. Because L2 transactions are sequenced at the L1 layer, L1 and L2 can read each other's state within the same block, enabling atomic cross-layer transactions.

What Is Synchronous Composability?

In traditional rollups, L1 and L2 are decoupled. L1 can observe L2 state only through posted commitments, and L2 can observe L1 state only through explicit message passing. This creates latency and requires complex bridge protocols.

In based rollups, because L1 and L2 share the same sequencer (the L1 validator), they can atomically interact within a single block:

• An L1 smart contract can call an L2 smart contract and read the result, all within a single transaction.
• An L2 transaction can be conditioned on L1 state, with the condition checked at the same L1 block height.
• Cross-layer MEV is eliminated because both layers are sequenced together.

Use Cases for Synchronous Composability

Unified Liquidity Pools: A DEX can maintain liquidity pools across L1 and L2 with atomic rebalancing. When prices diverge, the DEX can instantly rebalance without bridge delays.

Atomic Swaps: Users can swap assets between L1 and L2 atomically, without intermediaries or bridge fees.

Shared Collateral: Lending protocols can accept collateral on both L1 and L2 and count it toward a unified borrow limit, with collateral status checked synchronously.

Conditional Execution: L2 transactions can be made conditional on L1 oracle prices, governance votes, or state changes, checked at L1 finality.

Based Rollup Projects

Several projects are actively building and deploying based rollups. Here's an overview of the key players and their approaches.

Taiko

Taiko is the first based rollup to reach mainnet deployment. Launched in early 2025, Taiko Alethia serves as the proving ground for based rollup technology. Taiko is designed as an Ethereum-compatible rollup that uses Ethereum L1 validators as sequencers.

Key Features:

• Full EVM Compatibility: Taiko runs the EVM natively, enabling any Ethereum contract to deploy with minimal modifications.
• Native Preconfirmations: Taiko implements TEE-based preconfirmations for near-instant finality.
• Decentralized Proposers: Anyone can run a proposer to include transactions in L2 blocks.
• TVL Growth: As of April 2026, Taiko has accumulated over $200M in total locked value, demonstrating strong market validation.

Gwyneth

Gwyneth is a network of identical based rollups, all sequenced by Ethereum L1 validators. The innovation lies in Gwyneth's approach to cross-rollup composability: rather than bridging between separate rollups, Gwyneth enables synchronous composability across all rollups in the network.

Architecture:

• Identical Rollups: Each Gwyneth rollup is functionally identical, simplifying routing and composability logic.
• TEE-Based Cross-Rollup Messaging: Rollups communicate via TEE attestations, providing instant finality for cross-rollup transactions.
• AVS Provers: EigenLayer AVS operators verify cross-rollup state transitions, adding economic security.

Gwyneth's vision is to create a modular scaling layer where applications can spin up isolated execution environments while maintaining composability with the broader ecosystem.

Surge (Nethermind)

Surge, developed by Nethermind, is a based rollup template built on the Taiko stack. Launched in April 2025, Surge provides a modular framework for teams to deploy their own based rollups without building infrastructure from scratch.

Features:

• Taiko Stack Integration: Surge reuses Taiko's proven sequencing, proving, and preconfirmation infrastructure.
• Customizable Parameters: Teams can adjust gas limits, fee structures, and preconfirmation settings.
• Quick Deployment: Rolling out a new based rollup takes weeks instead of months.

Fabric Initiative

The Fabric initiative is a community-driven effort to standardize based rollup infrastructure. Rather than a single organization, Fabric is stewarded by researchers, developers, and organizations across the Ethereum ecosystem.

Fabric's goals include:

• Open Specifications: Define standard interfaces for based rollup sequencing, proving, and preconfirmations.
• Cross-Implementation Compatibility: Ensure that rollups built by different teams can interoperate seamlessly.
• Research Contribution: Advance the state of based rollup research through collaborative projects.

Based vs Traditional Rollups

To understand the significance of based rollups, it's helpful to compare them against optimistic and ZK rollups. The following table summarizes the key differences:

When to Choose Based vs Other Rollups

Choose Based Rollups If:

• Your application requires composability with L1 or other L2s (DeFi, oracles, liquidity pools).
• Censorship resistance and credible neutrality are critical requirements.
• You value simplicity over maximum throughput. A based rollup is simpler to operate than optimistic or ZK.
• You want to leverage preconfirmations for near-instant UX.

Choose Optimistic Rollups If:

• Maximum throughput is paramount (trading, gaming).
• You have mature fraud-proof infrastructure (Optimism, Arbitrum).
• You're willing to tolerate 7-day finality.

Choose ZK Rollups If:

• Faster finality (~1 hour) is necessary.
• You want zero-knowledge proving infrastructure (Starknet, Scroll).
• Proof generation latency is acceptable.

MEV & Economics

MEV (Maximal Extractable Value) plays a critical role in based rollup economics. Because L1 validators are the sequencers, MEV flows to the validator set rather than to a separate sequencer entity.

How MEV Flows in Based Rollups

In a traditional rollup, the sequencer is a separate entity that controls transaction ordering. The sequencer can extract MEV by:

• Front-running user transactions with their own orders
• Reordering transactions to exploit price changes
• Censoring transactions to influence market outcomes

The sequencer's MEV revenue is part of the rollup's economic model. Some rollups burn MEV (Optimism), some distribute it to governance (Arbitrum), and some keep it (various private sequencers).

In a based rollup, MEV extraction is pushed to the L1 layer. The L1 proposer sees all L1 and L2 transactions in the block they propose, so they can extract MEV across both layers. This MEV goes to the L1 validator set, not to an L2-specific sequencer.

Economics for Based Rollup Operators

A key difference in based rollup economics is that the rollup itself does not capture sequencer MEV. Instead, the rollup operator must fund operations through:

• Transaction Fees: Base layer fees paid by users for transactions. Unlike traditional rollups, these fees are lower because the operator doesn't capture MEV.
• Data Availability Fees: Costs for publishing batch data to L1 (Blobs, Calldata, etc.).
• Preconfirmation Fees: Users pay a small fee for preconfirmation services, which goes to validator-operators.
• Governance Revenue: Rollup tokens that capture future protocol value (if the rollup has a token).

MEV Minimization Strategies

To protect users from MEV exploitation, based rollups can implement:

• Encrypted Mempools: Transactions are encrypted until inclusion, preventing front-runners from seeing orders.
• MEV-Share: Validators share extracted MEV with affected users, reducing net extraction.
• Fair Ordering Services: Third-party services order transactions fairly, independent of MEV incentives.

Risks and Tradeoffs

While based rollups offer compelling benefits, they come with distinct tradeoffs and risks that users and developers should understand.

Throughput Constraints

Based rollups are bounded by L1 throughput. Ethereum's 12-second block time and 30M gas limit mean that based rollups can process roughly 20,000 transactions per second—far higher than L1 but lower than optimistic rollups (4k-10k) or ZK rollups (2k-5k).

For applications requiring maximum throughput (high-frequency trading, certain gaming scenarios), this may be insufficient. In such cases, a traditional rollup or sidechain might be more appropriate.

L1 Finality Latency

Based rollups inherit L1 finality latency (~13 minutes). While preconfirmations provide near-instant soft finality, applications requiring absolute finality must wait for L1 confirmation.

For most DeFi applications, preconfirmations are sufficient. But for applications where cryptographic finality is essential (atomic swaps, cross-chain bridges), the 13-minute latency may be problematic.

Preconfirmation Risks

Preconfirmations introduce new attack vectors:

• Slashing Attacks: If an attacker controls enough validators, they might trigger preconfirmation failures to slash restaked capital.
• Validator Centralization: If a few validators provide all preconfirmations, they become a centralization point.
• Economic Incentive Failures: If preconfirmation fees are too low, validators may not care about slashing penalties and fail to honor commitments.

Loss of Sequencer MEV Revenue

As noted earlier, based rollups don't capture sequencer MEV. This simplifies the architecture but removes a potential revenue source. For some rollup operators, this may make the business model challenging.

However, the loss of MEV revenue is often offset by reduced operational complexity and higher user adoption (due to composability benefits).

Cross-Layer MEV

While synchronous composability is powerful, it also exposes applications to cross-layer MEV. An MEV bot can now atomically manipulate prices across L1 and L2 in a single transaction, creating new exploitation opportunities.

Mitigation requires careful smart contract design and possibly MEV-minimization services (encrypted mempools, threshold encryption, etc.).

L1 Congestion Impact

If Ethereum L1 becomes congested, based rollups inherit that congestion directly. Unlike traditional rollups that can batch transactions, based rollups must fit L2 transactions into the same block space as L1 transactions.

This means that L1 network activity directly impacts L2 fees and throughput. In practice, this is mitigated by Ethereum's block space expansion (proto-danksharding, full danksharding) but remains a consideration.

Frequently Asked Questions

Conclusion

Based rollups represent a paradigm shift in Ethereum scaling. By using L1 validators as sequencers, they achieve a rare combination of properties: credible neutrality, censorship resistance, synchronous composability, and simplified architecture. While they inherit L1 throughput constraints and lose sequencer MEV revenue, these tradeoffs are increasingly acceptable as Ethereum's roadmap enables expanded block space and users demand composability and credible neutrality.

Projects like Taiko, Gwyneth, Surge, and Fabric are actively proving the viability of based rollups at scale. As the ecosystem matures, expect to see based rollups become a primary scaling solution for DeFi, liquidity provision, and applications requiring cross-layer atomicity.

For developers considering a scaling solution, based rollups offer a compelling choice for applications where composability and neutrality outweigh maximum throughput. For users, based rollups provide access to Ethereum-native scaling with stronger guarantees than traditional sequencer-based rollups.

The future of Ethereum scaling is likely to be modular and multi-layered, with based rollups, optimistic rollups, ZK rollups, and sidechains coexisting and specializing for different use cases. Understanding based rollups is essential for anyone working in the Ethereum ecosystem today.

Related Reading