Cross-Rollup Sequencing: Solving the Shared Sequencer Problem

Why Rollups Need Shared Sequencing

Isolated rollups operate like separate silos. Each layer-2 chain has its own sequencer, creating private ordering domains that fragment liquidity and hinder composability. When users move assets between chains, they face slow bridge times and high costs. Worse, isolated ordering allows searchers to extract maximum extractable value (MEV) within each silo, driving up fees for everyone.

A shared sequencer solves this by providing a common transaction-ordering layer. Instead of each rollup processing transactions in isolation, a shared network of nodes orders transactions across multiple rollups simultaneously. This replaces isolated domains with a unified flow, enabling faster coordination and better cross-rollup composability.

By synchronizing transaction order across chains, shared sequencing reduces the window for MEV extraction and creates a more efficient market. It turns fragmented liquidity into a shared pool, allowing users to interact with multiple rollups as if they were one cohesive network. This structural change is the foundation for the next generation of scalable, composable blockchain applications.

For a deeper technical breakdown of how shared sequencers function, see Cube Exchange’s explanation.

How shared sequencers order transactions

When rollups operate in isolation, their sequencers work in silos. Alice pays Bob on Rollup A, while Dave pays Eve on Rollup B. These transactions never interact, creating fragmented liquidity and missed opportunities for cross-rollup composability. Worse, isolated sequencers allow MEV bots to front-run users within a single chain without the friction of competing against other ecosystems.

A shared sequencer solves this by acting as a common ordering layer. Instead of each rollup having its own sequencer, multiple rollups connect to a single network that processes transactions together. This mimics a shared highway where traffic from different cities is managed by one central traffic control system, ensuring fair and efficient flow.

1

Transaction Submission

Users submit transactions to their respective rollup contracts. Instead of going to a private sequencer, these transactions are broadcast to the shared sequencer network. The network receives the raw transaction data, including the target rollup and the payload, effectively pooling liquidity from all connected chains.

2

Cross-Rollup Ordering

The shared sequencer orders transactions across all connected rollups in a single, global sequence. This is the critical step for atomic execution. If Rollup A needs to send tokens to Rollup B, the sequencer places the "send" transaction and the corresponding "receive" transaction adjacent to each other in the global order, ensuring they are processed together.

3

Batching and Compression

Once ordered, the sequencer batches these transactions into compressed blocks. By grouping data from multiple rollups, the sequencer reduces the overall data footprint. This compression is vital for keeping L1 submission costs low, as Ethereum calldata or blob space is expensive. The batch includes metadata identifying which transactions belong to which rollup.

4

L1 Submission and Execution

The compressed batch is submitted to the Ethereum mainnet. Rollup nodes then unpack the batch, executing the transactions in the global order. Because the order was determined by the shared sequencer, Rollup A and Rollup B can verify that the cross-rollup interactions happened atomically, completing the cycle without intermediate bridges or trust assumptions.

Previous

1234

Next

This mechanism shifts the trust model from individual sequencer operators to a shared network. As noted in discussions on ethresear.ch, this approach reduces the reliance on any single entity for ordering, while simultaneously enabling new forms of cross-chain liquidity that were previously impossible in isolated environments.

Fixing cross-rollup MEV and fragmentation

Cross-rollup MEV represents the most persistent friction in multi-chain ecosystems. When rollups operate with isolated sequencers, they create fragmented liquidity silos. This fragmentation allows MEV bots to extract value by exploiting the time lag and price discrepancies between chains. An arbitrageur can buy an asset on Rollup A and sell it on Rollup B, capturing the spread before the wider market adjusts. This process drains value from users and protocols, turning cross-chain activity into a zero-sum game for extractors.

Shared sequencing addresses this by placing multiple rollups under a single ordering layer. Instead of competing for block space in isolated domains, transactions from different chains are batched together in a unified sequence. This atomic ordering makes cross-rollup arbitrage significantly harder to execute profitably. Bots can no longer rely on the latency between separate sequencers to front-run trades. The shared sequencer effectively flattens the playing field, ensuring that price discovery happens simultaneously across all connected chains.

The result is a more efficient market where value extraction is minimized. By synchronizing transaction order, shared sequencing reduces the "MEV tax" that users currently pay when bridging assets. It transforms cross-rollup interactions from a fragmented, exploitable landscape into a cohesive, atomic execution environment. This approach aligns with the broader goal of trustless interoperability, where composability is built into the protocol layer rather than patched together with fragile bridges.

Enabling synchronous atomic execution

The current cross-rollup experience is fragmented. When you bridge assets or interact with protocols spanning multiple Layer 2s, you are essentially navigating disconnected islands. Each rollup maintains its own sequencer, ordering transactions in isolation. This fragmentation creates a dangerous gap: by the time a transaction is confirmed on one chain, the state on another may have shifted. This latency is where value leaks. Bots and MEV extractors exploit these disjointed states, front-running or sandwiching trades across chains before you can complete your swap.

Shared sequencing solves this by providing a common ordering layer. Instead of three different sequencers processing your requests at different speeds and in different orders, a shared sequencer batches transactions from multiple rollups into a single, unified stream. This allows for synchronous atomic execution. The system can now guarantee that if a trade on Rollup A fails, the corresponding update on Rollup B never happens. It turns cross-rollup interactions into a single, indivisible action.

This approach fundamentally changes how composability works. Previously, cross-rollup logic required complex, multi-step bridging with high failure rates. With synchronous execution, protocols can write logic that assumes a consistent global state across rollups. It eliminates the need for users to manually manage intermediate states or worry about partial execution failures. The shared sequencer ensures that the "all-or-nothing" guarantee holds true, making cross-rollup applications feel as seamless as native single-chain experiences.

The benefits extend beyond just user experience. By aligning the ordering of transactions across rollups, shared sequencing reduces the opportunity for cross-chain MEV. When transactions are processed in a coordinated block rather than isolated chains, the windows for arbitrage and front-running shrink significantly. This creates a fairer environment for users and developers alike, as discussed in recent ethresear.ch discussions on shared sequencing architectures.

Checklist for cross-rollup integration

Before adopting a shared sequencer, treat the infrastructure as a new trust boundary. Fragmented liquidity and hidden MEV risks disappear only when the ordering layer behaves like a single, synchronized state machine. Use this checklist to verify that your integration holds up under stress.

• Verify data availability guarantees. Ensure the sequencer commits to on-chain data proofs. Without this, you risk losing transaction history if the sequencing operator goes offline.
• Check sequencer decentralization. Avoid single-point failures. Look for networks where multiple nodes participate in ordering to prevent censorship or arbitrary reordering.
• Test synchronous atomicity. Confirm that transactions across different rollups execute in the same block window. This is the only way to guarantee that a swap on Rollup A completes exactly when a deposit on Rollup B is recorded.
• Assess MEV protection. Shared sequencing concentrates ordering power. Implement fair sequencing mechanisms or bundle protections to prevent front-running between distinct chains.

These checks align with findings from ethresear.ch regarding synchronous atomic execution. They also reflect the operational standards outlined by Cube Exchange for shared sequencing infrastructure.

FAQs on shared sequencers

What is a blockchain sequencer?

An L2 sequencer is a node or network of nodes responsible for receiving, ordering, and batching layer 2 transactions before submitting them to the layer 1 blockchain. It is a major component for scaling blockchain networks and reducing user fees by processing transactions off-chain first. Without a sequencer, users would face high gas costs and slow confirmation times on the base layer.

What role does a sequencer play in a rollup?

Sequencers are responsible for ordering rollup transactions and creating rollup transaction blocks. They are tightly coupled with the rollup's design, and every rollup has its sequencer, resulting in rollups becoming a closed ecosystem. This isolation is what causes fragmented liquidity and prevents atomic cross-chain operations.

What is a shared sequencer?

A shared sequencer is a transaction-ordering layer used by multiple rollups at once. Its purpose is to replace isolated sequencing domains with a common one, so rollups can get faster coordination, better foundations for cross-rollup composability, and less dependence on a single operator per chain. This allows different chains to agree on transaction order without needing separate bridges for every interaction.

What is an example of a cross-chain protocol?

Let's say Alice wants to exchange some Bitcoin for Ethereum. However, Alice's Bitcoin is on the Bitcoin blockchain, and she wants to receive Ethereum on the Ethereum blockchain. To do this, Alice can use a cross-chain protocol to facilitate the transaction. Shared sequencers aim to make this process more atomic and less reliant on trusted bridges by allowing the rollups to coordinate directly.

What is the name for a sequencer that handles transaction ordering for multiple chains at once?

The correct term is a shared sequencer. It handles transaction ordering for multiple chains at once to prevent fragmented liquidity. The options "local, private, single" describe traditional, isolated rollup sequencers that operate independently. A shared sequencer breaks down these silos by providing a common ordering layer.

Quick checklist