Based vs Shared Sequencing: Rollup Trade-offs in 2026
The debate between based rollup vs shared sequencing defines the next frontier of rollup architecture. As Ethereum scales via L2s, the mechanism that orders transactions—the sequencer—becomes the critical point of centralization or resilience. Based sequencing, pioneered by Taiko, delegates block production to L1 validators, inheriting Ethereum’s full security and liveness. Shared sequencing, implemented by Espresso and Astria, creates a separate set of sequencers that order transactions across multiple rollups, offering faster pre-confirmations and atomic composability at the cost of new economic and trust assumptions.
By mid-2026, the landscape has crystallized: both approaches coexist, each optimized for different rollup priorities. This guide dissects the trade-offs in security, decentralization, liveness, MEV handling, and composability, using concrete protocol examples and research. Whether you’re a rollup builder, a DeFi developer, or a power user, understanding these trade-offs is essential for navigating the modular ecosystem.
- Based sequencing ties rollup ordering directly to L1 validators, maximizing security and liveness at the cost of 12-second latency.
- Shared sequencing uses a dedicated PoS network for sub-second pre-confirmations and atomic cross-rollup composability.
- No approach solves the sequencing trilemma; each excels in two dimensions while trading off the third.
- Real-world implementations: Taiko (based), Espresso/Astria (shared), and Radius (hybrid) demonstrate the spectrum.
- By 2026, hybrid models that combine based fallback with shared fast ordering are becoming common.
- The choice depends on whether your rollup prioritizes Ethereum alignment (based) or low-latency composability (shared).
The Sequencing Trilemma: Decentralization, Liveness, Composability
Every rollup faces a trilemma in sequencing: it cannot simultaneously maximize decentralization (permissionless participation), liveness (guaranteed transaction inclusion under any conditions), and composability (fast cross-rollup atomicity). Based sequencing excels at decentralization and liveness by piggybacking on L1 validators, but native composability is limited to L1 synchrony. Shared sequencing prioritizes composability and fast pre-confirmations, but its liveness depends on a separate validator set and its decentralization is bounded by the sequencer network’s design.
Understanding where each approach sits on this trilemma is the foundation for choosing. For example, a rollup like Taiko (based) provides censorship resistance identical to Ethereum’s, while a shared sequencer like Espresso offers sub-second confirmations to enable seamless swaps between L2s. Neither is strictly better—the trade-off is inherent.
Shared Sequencing: Network-Level Ordering with Fast Pre-Confirmations
Shared sequencing decouples block building from any single rollup’s settlement layer. A dedicated network of sequencers—often using a proof-of-stake consensus (e.g., Astria’s Tendermint-based chain or Espresso’s HotStuff) — orders transactions and issues pre-confirmations within milliseconds. These pre-confirmations are economic commitments: a sequencer bond (e.g., 100 ETH) can be slashed if a pre-confirmation is reversed, giving users a conditional finality guarantee before L1 settlement.
Key liveness assumption: the sequencer set must stay above a threshold (e.g., 2/3 of stake) to produce blocks. If the network stalls (due to network partition or economic attack), rollups cannot progress until sequencing resumes. To mitigate this, protocols like Radius incorporate fallback to L1 ordering after a timeout. Shared sequencing also enables cross-rollup atomic execution: a single sequencer can order a bundle touching multiple L2s, as seen in Espresso’s “Atomic Settlement” mode. However, this introduces a new trust root: users trust that the sequencer set does not collude to censor or reorder transactions across rollups.
Based Sequencing: L1-Anchored Block Production
Based sequencing flips the model: every rollup block is proposed by an L1 validator during their slot. In Taiko, for example, any Ethereum proposer can include a Taiko block in their beacon block. The rollup inherits Ethereum’s proposer-builder separation (PBS), MEV-boost, and, crucially, its liveness—if Ethereum finalizes, the based rollup finalizes. There is no separate sequencer set, no additional staking, and no new slashing conditions.
The trade-off is latency: a based rollup block can be proposed only once per L1 slot (12 seconds on Ethereum). Pre-confirmations must be designed differently—e.g., using Taiko’s “based pre-conf” via L1 validators’ commitments, or relying on a separate fast-track that still settles to L1. Censorship resistance is maximal: an L1 proposer cannot censor an L2 transaction without violating their L1 duties. Composability across rollups, however, is limited to L1 synchronous composability (e.g., proving cross-rollup state during the same L1 slot). For asynchronous composability, based rollups rely on L1 as a shared settlement layer, which introduces the 12-second minimum delay.
Security Models: Economic vs. Protocol-Level Guarantees
Shared sequencing relies on economic security. Sequencers post bonds, and any malicious finality violation (e.g., reneging on a pre-confirmation) triggers slashing. The value at stake must exceed the profit from attacking—a condition that depends on the sequencer pool’s total stake. In practice, a mature shared sequencer network can accumulate substantial collateral across its validator set. Yet this is still weaker than Ethereum’s multi-billion-dollar security budget. Shared sequencing also introduces a new trust assumption: the sequencer network’s consensus must be honest-majority, similar to a sidechain.
Based sequencing inherits Ethereum’s full protocol-level security: no additional economic layer is required. The rollup’s safety depends on L1 transaction inclusion and reorg resistance. An L1 proposer cannot maliciously reorder the based rollup block without being penalized by the L1 protocol itself. This reduces the attack surface to Ethereum’s own security model. For rollups that prioritize maximal security and alignment with Ethereum, based sequencing is the natural choice. The cost is that based rollups cannot easily provide fast pre-confirmations without trust—some based preconfirmation designs are exploring committing to future L1 slots but still require the proposer to behave honestly in the short term.
Liveness Analysis: Shared Sequencer Failures vs. L1 Reorgs
Liveness in shared sequencing depends on the sequencer set’s ability to produce blocks. Consider a scenario where a large sequencer, representing 20% of stake, goes offline. The network must wait for a timeout (e.g., 1 minute) and then continue with less than 2/3 active? That’s a liveness failure until the timeout expires. If 1/3+ of stake becomes Byzantine and stops producing blocks, the network halts indefinitely until recovery. While fallback mechanisms exist (e.g., Astria’s “L1 fallback” after a 10-block timeout), they introduce delays and complexity.
Based sequencing liveness is identical to Ethereum’s. As long as L1 validators are online (99.9% uptime historically), the rollup continues. The only liveness risk is a deep Ethereum reorg, which could revert finalized rollup blocks—but this is extremely rare (even 2-block reorgs happen less than once a month). In a based rollup, a user’s transaction is included as soon as an L1 proposer picks it up, which could be the next slot if there is demand. The worst-case forced inclusion delay is bounded by the rollup’s ordering rules (e.g., Taiko’s “greedy” inclusion). Overall, based sequencing offers stronger liveness guarantees for rollups that can tolerate 12-second latency.
Composability and Atomic Execution: Shared Mempools vs. L1 Synchrony
Atomic cross-rollup composability is the killer feature of shared sequencing. By ordering transactions from multiple rollups in the same sequencer block, a single DeFi operation—e.g., swapping token A on rollup X for token B on rollup Y—can be executed atomically. Espresso achieves this via a shared mempool where sequencers coordinate order across L2s. Astria calls this “shared ordering.” The rollups themselves still validate state independently, but the sequencer guarantees the order of cross-rollup messages, enabling atomic settlement within the shared sequencer’s finality window (e.g., 3–4 seconds).
Based rollups cannot offer atomic cross-rollup composability in the same fast manner. Instead, they rely on synchronous composability via L1: if two rollups share an L1 block, they can read each other’s state (e.g., via L1 messaging). But this forces both rollups to block until the L1 slot is produced (12+ seconds). For many DeFi use cases (lending, DEX aggregators), this latency is acceptable. However, for high-frequency, cross-rollup arbitrage, shared sequencing is superior. Some projects, like Omni Network, are building L1-based atomic settlement frameworks that mimic shared sequencing using L1 as a notary, but these are still research-stage.
MEV Dynamics: Shared Sequencing Auctions vs. Based PBS
MEV (maximal extractable value) distribution differs fundamentally. In shared sequencing, the sequencer set typically runs an MEV auction (e.g., Espresso’s “Sequencer Builder Marketplace”) where builders bid for the right to propose blocks. The sequencer network captures a portion of MEV through these bids, and the proceeds are distributed to sequencer delegators or to the rollup’s treasury. This creates an additional revenue stream for the sequencer network, but also introduces centralization pressure: large builders may dominate the auction, and sequencers might collude with builders to extract more value.
Based sequencing inherits Ethereum’s proposer-builder separation (PBS). The L1 proposer of the slot can choose a block from a builder (either L1 or L2). The L2 builder can submit a block that contains L2 transactions. The MEV from the based rollup block flows to whoever builds that block—usually a specialized L2 builder competing in the L1 PBS ecosystem. This aligns with Ethereum’s norms but means based rollups have no direct control over MEV distribution; it’s decided by L1 market dynamics. Some based rollups, like Taiko, allow L1 proposers to optionally include pre-confirmation bundles, creating a secondary MEV layer that builders can target.
Real-World Implementations: Taiko vs. Espresso/Astria
Let’s examine concrete protocols. Taiko (based, mainnet since 2024) is the canonical based rollup. Its block production is entirely driven by L1 proposers. The user experience: wallet sends transaction → transaction enters L2 mempool → L1 proposer includes it in a rollup block during their slot. Taiko’s pre-confirmations are achieved via “based preconf” commitments from L1 validators who promise to include certain transactions in their upcoming slot—if they fail, they lose their L1 proposer chance, but no slashing occurs yet. This is a soft guarantee.
Espresso (shared, with several rollups integrated) uses a HotStuff-based consensus. It provides <1s pre-confirmations. Rollup stacks like Arbitrum Orbit and the OP Stack have explored Espresso integration. Astria (Cosmos-based shared sequencer) uses Tendermint for ordering and is integrated with rollups like Celestia-based sovereign rollups. These implementations show that shared sequencing requires rolling out a new decentralized network—an operational overhead that based sequencing avoids by leaning on the existing L1.
| Dimension | Based (Taiko) | Shared (Espresso) |
|---|---|---|
| Security root | Ethereum PoS | Sequencer set PoS |
| Liveness source | Ethereum validators | Sequencer network |
| Pre-confirmation latency | ~6-12s (soft) | ~0.5-1s (economic) |
| Cross-rollup atomicity | Via L1 (12s+) | Sub-second |
| MEV distribution | L1 PBS | Auction to sequencers |
| New trust assumptions | Minimal | Sequencer set honesty |
Trade-off Summary: Which Path for 2026?
By 2026, the Ethereum ecosystem has converged on a pattern: layer-2 rollups that prioritize sovereignty and security gravitate toward based sequencing, while those that need low-latency composability adopt shared sequencing. Many rollups operate hybrid models: using a shared sequencer for fast pre-confirmations and falling back to L1 ordering for settlement. For example, Radius offers a shared sequencer that also supports fallback to based-like ordering if the sequencer stalls—a pragmatic compromise.
For developers: if your application requires atomic swaps across L2s (e.g., a cross-rollup DEX), shared sequencing is necessary today. If your rollup aims for maximal Ethereum alignment and low operational overhead, based sequencing is the cleaner path. The shared vs based trade-off is not settled—expect more innovation in “hybrid based sequencing” and “based shared sequencing” over the coming year. Ultimately, both are winning approaches, and the choice depends on your specific decentralization, liveness, and performance requirements.
Common mistakes to avoid
- Assuming shared sequencing offers L1-level security – it relies on a separate validator set and slashing, not Ethereum's consensus.
- Believing based rollups cannot offer any pre-confirmations – protocols like Taiko use soft commitments from L1 proposers.
- Ignoring the composability ceiling: based rollups cannot do fast atomic cross-rollup operations without extra infrastructure.
- Underestimating liveness risks of shared sequencers – a 2/3 stake failure halts all dependent rollups until fallback kicks in.
- Confusing shared sequencing with centralized sequencers: shared is distributed but still introduces new trust assumptions.
- Overlooking that based rollups inherit L1 MEV distribution, which may not align with the rollup’s own incentive design.
Frequently asked questions
Is based sequencing more decentralized than shared sequencing?
Yes—based sequencing inherits Ethereum's full validator set (hundreds of thousands), while shared sequencing relies on a smaller set (typically 32–100 validators).
Can a rollup use both based and shared sequencing at the same time?
Yes, some rollups like Radius implement a hybrid: fast pre-confirmations via shared sequencer with automatic fallback to L1-based ordering if the sequencer stalls.
How do based rollups handle MEV compared to shared sequencers?
Based rollups use Ethereum’s PBS—MEV flows to L1 builders. Shared sequencers run their own MEV auctions, capturing value for sequencer stakers.
Does shared sequencing introduce new trust assumptions for users?
Yes, users must trust the sequencer set not to collude or censor, and rely on economic slashing for safety, rather than protocol-level finality.
Which type of rollup is better for a high-frequency trading application?
Shared sequencing is currently better for low-latency needs due to sub-second pre-confirmations and atomic cross-rollup execution.
Related reading
Track the entities behind the concepts
DeFi Intel maps 11,000+ protocols, tokens and companies to a typed knowledge graph — with live data, incidents and regulation.