Reuniting Ethereum - Shared Sequencing for a Cohesive Rollup Future

The Problem: Sequencing & Fragmentation in Ethereum

How Sequencing Works in Ethereum Rollups

                  ┌───────────────────┐
                  │   User Tx Pool    │
                  │  (pending txs)    │
                  └────────┬──────────┘
                           │
                           ▼
                  ┌───────────────────┐
                  │   Sequencer       │
                  │  (orders txs)     │
                  └────────┬──────────┘
                           │
            ┌──────────────┼──────────────┐
            ▼              ▼              ▼
    ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
    │ Rollup A     │ │ Rollup B     │ │ Rollup C     │
    │ (isolated)   │ │ (isolated)   │ │ (isolated)   │
    └──────┬───────┘ └──────┬───────┘ └──────┬───────┘
           │                │                │
           ▼                ▼                ▼
    Liquidity Fragmented ───┼─────> No shared state
    Assets + dApps isolated ─┘

Sequencing is the process of deciding the order in which transactions are included in blocks before they’re finalized on-chain. In practice, this means the sequencer (the actor ordering transactions for a chain or rollup) controls who gets included first, who must wait, who pays higher fees, and who can capture valuable MEV (Maximal Extractable Value) (medium). Today, each Ethereum Layer-2 rollup typically runs its own sequencer, and this model has created several major challenges:

• Fragmentation: Every rollup’s transactions are ordered in a isolated environment. Liquidity is fragmented across these isolated L2s, breaking the seamless composability that Ethereum applications once enjoyed (blockworks). Assets and data often cannot move or interact across rollups without clunky bridges, leading to a “multi-chain” ecosystem of islands rather than one unified network.
• Centralization Risks: Many current rollups use a single, centralized sequencer operated by the rollup team or a trusted party. This introduces a single point of failure and opens the door to censorship or monopoly control over transaction ordering. A sole sequencer could arbitrarily exclude or reorder transactions (intentionally or due to compromise), undermining Ethereum’s neutrality.
• MEV Extraction Imbalances: Maximal (or Miner) Extractable Value (MEV) refers to profit from reordering, inserting, or censoring transactions. In today’s rollups, the sequencer captures most MEV from user activity (e.g. via priority fees or sandwich attacks), rather than that value accruing to users or Ethereum’s validators (astria). Not only is this unfair, it threatens Ethereum’s security: if L1 validators get none of the value from L2 activity, they could be bribed to alter L1 to favor certain rollup transactions. To read an in-depth piece I wrote earlier on MEV, here is a comprehensive deep dive on MEV and its future projections From Flash Boys to Formalized Blockspace: The Evolution of MEV in Crypto
• Poor User Experience: The isolated L2 model also hurts UX. For example, bridging assets or composing dApps across rollups is slow and risky, with some optimistic rollups imposing 7-day withdrawal delays for security. Users face unaligned incentives (a sequencer maximizing its profit vs. user fairness) and inconsistent latency. This friction limits rollup adoption despite their lower fees.

In summary Ethereum L2 terrain today is like a cluster of walled cities, each with its own gatekeeper. This model sacrifices the seamless composability and trust-minimization that make Ethereum powerful. If left unresolved, it could balkanize the ecosystem, with liquidity and users scattering to whichever rollup offers the most privileges – or leaving due to frustration.

The Vision: Shared Sequencing to Reunite the Ecosystem

What if, instead of each L2 having its own isolated sequencer, they shared a common sequencing layer? A Shared Sequencer Network is essentially a decentralized set of sequencers that serve multiple rollups at once (sciencedirect).

Shared Sequencing

Users → Tx Pool → [Shared Sequencer Layer]
│
┌─────────────────────┼─────────────────────┐
▼ ▼ ▼
Rollup A Blocks Rollup B Blocks Rollup C Blocks

✅ Unified liquidity
✅ Seamless cross-rollup composability
✅ Fair MEV distribution (to users + Ethereum validators)
✅ Better UX (fast exits, aligned incentives, low latency)

The idea is to unify transaction ordering across many chains or rollups, bringing several key benefits:

• Atomic Composability Across Rollups: With a shared sequencer, cross-rollup transactions can be bundled atomically in one block. For instance, a transaction on Rollup A can be made conditional on one on Rollup B, and the sequencer will only include them if both can execute together. This eliminates the fragmentation of liquidity – effectively, rollups start to behave like one network at the transaction ordering level, enabling multi-rollup dApps and arbitrage that were previously impossible.
• Stronger Decentralization and Censorship Resistance: A shared sequencing layer would ideally be run by many nodes (or by Ethereum’s global validator set via restaking), rather than a single server. This removes the single point of failure. Censorship becomes far more difficult because no one party controls ordering. It also means fast liveness recovery – if any sequencer node fails, others take over, keeping the rollups running without lengthy downtime .
• Fair MEV Distribution and Aligned Incentives: Instead of one sequencer extracting all MEV, a shared system can redistribute MEV to the broader community. For example, fees and MEV revenue from rollup transactions could be shared with Ethereum L1 validators (if they participate in sequencing) or returned to users/apps via auctions (flashbots). This aligns L2 activity with L1 security – making Ethereum stronger as rollups grow. It also enables cross-domain MEV opportunities to be captured in open, fair auctions rather than secret deals (flashbots), so profit isn’t only going to the most privileged actors.
• Better User Experience (UX): Shared sequencers can offer fast confirmations and faster exits. By coordinating with L1 or using optimistic consensus, users can get sub-second “pre-confirmations” of their transactions with strong guarantees (medium). Some designs even enable instant L1 withdrawals for rollups, eliminating the long exit wait of optimistic rollups (puffer). Moreover, if rollups share infrastructure, users can interact with multiple L2s seamlessly without juggling different bridging UX or trust assumptions (One of the many ways to solve liquidity fragmentation, A subject we would examine in future article publications)

In short, a shared sequencing layer aims to have our cake and eat it too: we retain the scalability of many parallel rollups, but regain the unity, security, and composability of a single network. This is a hot area of research and development. Let’s spotlight a few leading projects that are pioneering solutions, each approaching the problem from a different angle.

Case Studies: Protocol Deep Dives

This framework serves as a guide for understanding the specific innovations of each project. The detailed analyses below explain how each protocol implements its unique vision.

Flashbots – SUAVE (Single Unifying Auction for Value Expression)

Flashbots is an R&D organization known for mitigating MEV on Ethereum (e.g. via MEV-Boost). Their latest initiative, SUAVE, is essentially a decentralized block builder network aimed at serving all chains. Flashbots identified that after separating the block-building role from validators (through MEV-Boost), the new centralization risk is block builders themselves. SUAVE is their answer to decentralize transaction sequencing and block building across domains (flashbots).

At its core, SUAVE unbundles the mempool and block-builder roles from existing blockchains and offers them as a “plug-and-play” external network (flashbots). Users will send transactions into the SUAVE network (often encrypted to hide contents from potential frontrunners). SUAVE conducts a global auction for transaction order preferences – effectively a single marketplace for MEV and order flow spanning all connected chains. It then outputs an ordered bundle of transactions (a block or partial block) that can be inserted into any chain’s next block by that chain’s validator (blockchain).

By sharing the same sequencing layer (SUAVE), all participating domains benefit: it keeps crypto decentralized by removing exclusive control over order flow, lets block builders capture cross-domain MEV opportunities that require coordinating transactions on multiple chains, maximizes validators’ revenue (since they get blocks with MEV already extracted across domains), and gives users the best execution (their transactions are protected in an encrypted mempool and included in an optimal cross-chain block) (flashbots). In Flashbots’ words, SUAVE ensures MEV stays decentralized – preventing the rise of exclusive “dark pools” and centralized builder monopolies that could threaten Ethereum’s security (flashbots).

Importantly, SUAVE is being built as an independent blockchain (an L2 of sorts) that is chain-agnostic. This means Ethereum L2s, Ethereum L1, or even other layer-1s could delegate their transaction ordering to SUAVE’s auction. This project is still in development, but its vision is to become a universal sequencing layer that brings transparency and fairness to MEV across the entire crypto ecosystem (flashbots).

Espresso Systems: The Credibly Neutral Confirmation Layer

Espresso Systems is a project that embodies the shared sequencing philosophy, building a "global confirmation layer" that provides L2s with fast and reliable transaction confirmations. The network is not an all-or-nothing solution; rather, it's designed as a modular component that rollups can integrate to either serve as a decentralized sequencer or simply to provide stronger, faster confirmations for their existing centralized model (Espresso Systems)

The Espresso Network's core technology is a Byzantine Fault Tolerant (BFT) consensus protocol called HotShot. HotShot is engineered to provide finality in a matter of seconds, which is a substantial improvement over the 15-minute wait time for Ethereum L1 finality. This speed is crucial for improving user experience and enabling high-speed bridging between chains integrated with Espresso. The network is currently run by a permissioned, decentralized set of 100 node operators in its Mainnet 0 release, with a plan to transition to a permissionless proof-of-stake model to enhance economic security. Espresso's strategic position is as a versatile, additively compatible infrastructure for the modular stack (Espresso Docs). It can be integrated with various rollup frameworks, including Arbitrum Orbit, OP Stack, and Polygon CDK. This allows chains to leverage Espresso for decentralized sequencing, low-cost data availability, and fast confirmations, all while retaining the flexibility to also use other solutions like EigenDA or Celestia for data availability. The system is designed to provide "credible neutrality," which is critical for fostering cross-chain composability and interoperability. The fast, reliable confirmations provided by Espresso give applications and users greater certainty in real time which is essential for complex cross-chain activities and intent-based systems (HackMD).

Here are a few examples of how Ethereum rollups can use the Espresso network sauce: here

Astria: The Lazy Sequencer

The Astria stack source: here

Astria is a shared sequencing network that allows multiple rollups to share a single, decentralized network of sequencers (Alchemy). The project's vision is to provide rollups with censorship resistance, fast finality, and atomic cross-rollup composability while still allowing them to maintain their sovereignty (i.e apps on different rollups can work together seamlessly and safely, without giving up their independence).

The network is a Proof-of-Stake (PoS) system that uses CometBFT for consensus. A defining feature of Astria's architecture is its role as a "lazy sequencer". This means the network sequences and commits transaction data, but it does not execute the transactions itself. The execution is delayed and left to the individual rollup. This design choice de-couples the execution logic from the consensus logic, which removes consensus bottlenecks and provides greater flexibility for rollup developers (Astria). By separating these concerns, the sequencer's role is simplified to ordering and committing raw data for inclusion, enhancing censorship resistance.

However, this design introduces a crucial trade-off. While the system can guarantee "atomic cross-rollup inclusion" (that a transaction on one rollup and a transaction on another will be included in the same batch), it cannot guarantee "atomic cross-rollup execution" (that both will be executed successfully). This is because the sequencer does not execute the transactions and therefore cannot confirm their outcome (Astria). For synchronous messaging or atomic bridging, this is a significant limitation that requires further research and innovation to overcome. In spite of this, Astria's model provides a robust solution for a wide range of use cases by offering a straightforward and permissionless way for rollups to join a shared sequencing network (Alchemy).

Astria is being built with the ethos of Ethereum’s modular future in mind – it pairs well with modular data availability layers like Celestia (Astria can post the rollup data to a shared DA chain).

Radius: Fair Order Sequencing with MEV Control

Radius is approaching the sequencer problem with an emphasis on MEV fairness and user protection. Billed as a “trustless zk-based shared sequencing layer” (ethresearch), Radius’s design is a bit unique: it doesn’t immediately decentralize who the sequencer is, but instead changes how transactions are ordered to enforce fairness. In other words, Radius could use a single sequencer node, but through clever cryptography that sequencer cannot exploit ordering for MEV (archetype).

The core idea is to use encryption and zero-knowledge proofs to enforce a fair ordering. When users submit transactions, they first encrypt their transaction in a time-lock puzzle (a cryptographic commitment that cannot be opened until a certain time or after a certain amount of computation) (ethresearch). They also provide a zk-proof that the encrypted transaction is valid (e.g. not malformed or spam) without revealing its contents (ethresearch). The sequencer (even if just one machine) then must include these encrypted transactions and decide an order without knowing what the transactions actually do. Only after the order is decided (and communicated) do the puzzles resolve and reveal the actual transactions, which are then executed in the predetermined order (ethresearch). This prevents the sequencer from reordering transactions to, say, sandwich attack a user – because the sequencer couldn’t read the contents when ordering them.

Radius extends this with a two-tier blockspace model:

Radius Blockspace Model. Source-here

• The “Top” blockspace is for normal user transactions and is protected by the cryptographic scheme (ensuring first-come-first-served, encrypted ordering – no harmful frontrunning) (ethresearch, Radius docs).
• The “Bottom” blockspace is left for MEV builders/searchers in a more traditional auction, to capture the productive MEV like arbitrage that doesn’t harm specific users (ethresearch, Radius docs). This way, rollups can still earn revenue from MEV (by selling this bottom blockspace via something like MEV-Boost) without exposing regular users to unfair exploitation.

By combining these, Radius aims to “eliminate harmful MEV” while still enabling a profitable market for block space (ethresearch). This approach uses Practical Verifiable Delay Encryption (PVDE) and zk-proofs to create what is effectively a verifiably fair sequencing service. In the long run, Radius could be decentralized further (multiple sequencer nodes all following the protocol), but even in the near term it provides a trust-minimized sequencer that any rollup could use to assure its users of fairness. It’s like having a sequencer that’s cryptographically blinded from doing evil. As a bonus, by sharing such a sequencer across rollups, those rollups would also gain easier interoperability (since the sequencer can naturally coordinate cross-rollup order when users submit bundled transactions).

Puffer Finance – UniFi (Based Rollup with L1 Sequencing)

UniFi (developed by Puffer Finance) takes a more radical approach called a “Based Rollup.” A based rollup leverages Ethereum L1 itself to do the heavy lifting of sequencing, instead of having a separate sequencer network. UniFi is essentially an Ethereum L2 that fully integrates its sequencing into Ethereum’s consensus, meaning Ethereum validators directly sequence the L2’s transactions as part of proposing L1 blocks (medium).This design addresses fragmentation by, in a sense, not creating another silo at all – it bases the rollup on the same foundation as the main chain.

In UniFi’s architecture, there is no separate sequencer node or committee. Instead, when it’s time to produce a new L2 block, that right is tied to the next Ethereum block proposer (or a network of restaked Ethereum validators). This yields several benefits:

• L1-Level Security and Liveness: The rollup’s liveness guarantees become the same as Ethereum L1’s. You don’t rely on a single company’s server; you rely on thousands of Ethereum validators worldwide (reddit) (medium). If Ethereum is producing blocks, the rollup is live and sequenced. Censorship is vastly mitigated – an attacker would have to censor at the Ethereum protocol level (far more difficult than attacking one rollup’s server).
• Synchronous Cross-Rollup Composability: If multiple rollups adopt this model (sharing Ethereum’s proposer sequence), then any transactions across those rollups can be included in the same L1 block. UniFi explicitly enables this “atomic interaction between different based rollups within a single transaction” (reddit) (medium). In practice, that means no more reliance on third-party bridges or waiting multiple blocks for a cross-chain transfer – a user could swap on Rollup X and use the output on Rollup Y in one step, as long as both are based on L1 sequencing.
• Lightning-Fast Confirmation & Withdrawal: UniFi introduces Preconfirmations (“Preconfs”) – users get a confirmation of their transaction inclusion in about 100 milliseconds on the L2 (reddit) (morning star)(medium). How? Puffer uses a network of its Ethereum validators (enhanced with secure hardware enclaves and eventually ZK proofs) to provide a quick optimistic confirmation that is later ratified by the L1 block. This gives a user experience akin to a centralized exchange – near-instant feedback – but with a cryptoeconomic guarantee behind it (validators are slashed if they mislead). Additionally, UniFi’s design allows instant L1 withdrawals of funds (puffer). Traditional optimistic rollups make users wait ~7 days for security; UniFi achieves security via Ethereum itself, so users can exit immediately without trusting a liquidity provider.
• Aligned Economics with Ethereum: Unlike isolated rollups where sequencers keep all fees, a based rollup like UniFi funnels transaction fees and MEV revenue back to Ethereum’s validators/block proposers (reddit). Essentially, if there is MEV to be made from ordering transactions on the rollup, it’s captured by the Ethereum proposer (and shared with the community via PBS auctions) instead of a separate entity. This strengthens Ethereum by increasing rewards to validators (potentially offsetting ETH issuance) (medium), and it prevents value leakage – value generated on L2 helps secure L1.
• Improved UX Through Native Integration: UniFi is experimenting with features like EIP-7702 smart wallets (account abstraction) to allow users on the rollup to benefit from contract-level flexibility with their L1 accounts (e.g. meta-transactions, sponsored fees). It also introduces a concept of gasless transactions subsidized by native yield: users hold a liquid restaking token (pufETH) that generates yield, and that yield can automatically cover gas fees, resulting in a near “feeless” experience (medium). All of this is aimed at making L2 usage seamless for the average user, removing the headaches of gas and bridging.

In sum, UniFi’s approach is to make Ethereum itself the shared sequencer for a new class of rollups. Rather than building a separate network of sequencers, it uses the strongest decentralization and composability engine we already have (Ethereum L1) as the base. This “based sequencing” model ensures any rollup built this way is not an island – it’s deeply connected to Ethereum and other based rollups at the consensus level.

Why This Matters for Ethereum’s Future

Ethereum is entering a new phase where scaling is achieved by multiple L2 chains. Ensuring those chains remain aligned and connected is crucial. Shared sequencing – whether via a third-party network or through Ethereum itself – is the key to avoiding an outcome where Ethereum becomes an archipelago of disconnected islands. The projects discussed (Flashbots SUAVE, Espresso, Astria, Radius, UniFi) are converging on a vision where Ethereum can have many execution environments but one meta-sequencing layer tying them together.

Such a development has profound implications:

• Unified Liquidity and DeFi Ecosystem: Traders and applications won’t have to worry about which rollup their assets or logic live on. With atomic composability across rollups, liquidity effectively pools together and markets become more efficient. Cross-rollup arbitrage and lending will happen in one block instead of over minutes or hours, making the whole ecosystem more capital-efficient (hackmd). We get back to the seamless composability that made Ethereum’s single-chain DeFi so powerful, but now scaled to multiple chains.
• Robust Decentralization & Security: A move to shared or L1-based sequencers means no more trusting single companies to run critical infrastructure. Decentralization isn’t postponed to later (“progressive decentralization”); it’s there from day one (blockchain.com). This greatly reduces the risk of censorship or outage. Furthermore, if Ethereum’s own validators are involved in sequencing (via restaking or based rollups), Ethereum’s security budget grows – it earns fees from L2 activity – making the whole network more resilient against attacks.
• Fairness and User Empowerment: By redesigning how transactions are ordered, these solutions can protect users from the worst abuses of MEV (no more surprise sandwich trades draining value). Techniques like encrypted mempools and fair ordering mean users regain trust that the system isn’t rigged against them. At the same time, MEV revenue is distributed more equitably – to those who secure the network or even back to users – rather than being pocketed by a privileged sequencer entity. This could foster a healthier economic loop where users, validators, and developers all benefit from growth, not just intermediaries.
• Simplified Development & Better UX: A shared sequencing layer can become a one-stop integration for new rollups, meaning teams launching an app-specific rollup can focus on their app logic and not on building a global sequencing operation. This lowers the barrier to entry for new chains (just like launching an ERC-20 is easier than launching a L1). For users, features like sub-second confirmations, instant exits, and gasless transactions make L2s as smooth to use as any Web2 app. That’s critical for adoption – users shouldn’t have to understand the intricacies of bridging or worry about a transaction hanging in limbo.

In a broader sense, solving the sequencing and fragmentation problem is about preserving Ethereum’s core value proposition in a multi-chain world. Ethereum aims to be the most secure, decentralized settlement layer. If much of the action moves off L1, it’s imperative that the spirit of Ethereum (open access, neutrality, composability) carries over. Shared sequencers are the glue for that. They ensure that even as we scale out with many chains, we scale together rather than apart.

The fact that so many teams are tackling this – from non-profits to venture-backed startups to theoretical researchers – underlines how crucial it is. We’re witnessing the early formation of what could be Ethereum’s “transaction ordering layer” above L1. If these efforts bear fruit, a few years from now users might not even need to know what sequencers are. They’ll simply enjoy a unified Ethereum experience: pick any rollup or app-chain and trust that their transaction will execute fairly and can seamlessly touch anything else in the ecosystem, as if it were all one chain. Ethereum will feel like Ethereum again – just much faster and more scalable.

Key Sources:

• Dartmouth Blockchain, “Shared Sequencers: An L2 Scaling Solution” https://medium.com/@dartmouthblockchain/shared-sequencers-an-l2-scaling-solution-948ac4afc089
• SUAVE Spec - HackMD, https://hackmd.io/@sxysun/suavespec
• FAQ - Espresso Systems, https://www.espressosys.com/faq
• INTRODUCTION | Espresso, https://docs.espressosys.com/
• Astria Blog, “Astria: The Shared Sequencer Network” https://www.astria.org/blog/astria-the-shared-sequencer-network
• Tariz (Radius), Ethereum R&D post, “Shared sequencer for MEV protection" https://ethresear.ch/t/shared-sequencer-for-mev-protection-and-profitable-marketplace/15313