Why shared sequencing matters
Isolated rollups create fragmented liquidity. When each Layer 2 operates its own sequencer independently, transactions are ordered in silos. This fragmentation allows arbitrageurs to exploit non-atomic price discrepancies between chains, extracting value that should remain within the protocol or benefit users. This phenomenon, known as cross-rollup MEV, undermines the atomicity required for fair cross-chain execution.
Cross-rollup sequencing solves this by introducing a shared order. Instead of processing transactions in isolation, a shared sequencer (like Espresso) or a coordinated L1-based model groups transactions from multiple rollups into a single, deterministic sequence. This ensures that related transactions—such as a swap on one rollup and its settlement on another—are processed atomically. Without this shared order, cross-chain trades are exposed to front-running and sandwich attacks that exploit the delay between L2 confirmations.
The architecture shift is fundamental. In traditional models, the sequencer is a single operator deciding local order. In shared sequencing, the order is determined by a protocol-level mechanism that respects cross-rollup dependencies. This prevents the "first-seen" advantage that arbitrageurs currently leverage, ensuring that the final state of a cross-chain transaction is both predictable and fair.
Choose your sequencing architecture
Atomic cross-rollup transactions require a single source of truth for transaction ordering. Without shared sequencing, users face a fragmented experience where assets must bridge across separate chains, introducing latency and potential points of failure. You have two primary architectural paths: centralized shared sequencers and decentralized L1-based sequencing.
Centralized Shared Sequencers
Centralized shared sequencers, such as Espresso Systems, act as a dedicated middleware layer. They accept transactions from multiple rollups, order them in a single stream, and distribute that order to the respective chains. This approach is akin to a central traffic controller managing intersections across different cities, ensuring that cross-chain trades happen simultaneously without the need for complex atomic swaps.
The benefit here is speed and simplicity. Developers can integrate a shared sequencer API and immediately gain cross-rollup atomicity. However, this introduces a trust assumption. Users must trust that the sequencer operator will not reorder transactions for MEV (Maximal Extractable Value) or censor specific users. While many shared sequencers employ cryptographic proofs to ensure fairness, the operational control remains with a single entity or a small consortium.
L1-Based Decentralized Sequencing
L1-based sequencing, often referred to as "based rollups," pushes the sequencing responsibility back to the Ethereum Layer 1 block producers. In this model, the L1 proposer includes rollup blocks directly within the L1 block, effectively sequencing them alongside L1 transactions. This eliminates the need for a separate shared sequencer infrastructure.
This approach offers maximum decentralization and security, as it relies on the economic security of Ethereum itself. It removes the trust assumption associated with third-party sequencers. However, it introduces complexity. Rollup builders must coordinate with L1 searchers and builders to ensure their blocks are included in the L1 block, which can lead to higher latency and potential exclusion if L1 congestion is severe.
Comparison of Architectures
| Feature | Centralized Shared Sequencer | L1-Based Sequencing |
|---|---|---|
| Trust Model | Trust in sequencer operator | Trust in Ethereum L1 validators |
| Latency | Low (dedicated infrastructure) | Higher (dependent on L1 block times) |
| Complexity | Low (API integration) | High (L1 builder coordination) |
| Decentralization | Moderate | High |
| MEV Protection | Depends on operator fairness | Native to L1 block building |
Implementation Checklist
-
Evaluate trust assumptions: Is your user base comfortable with a centralized sequencer?
-
Assess latency requirements: Does your application need sub-second cross-rollup finality?
-
Review developer resources: Does the chosen sequencer provide robust SDKs and documentation?
-
Plan for fallbacks: What happens if the shared sequencer goes offline or censors transactions?
-
Test atomicity: Verify that your cross-rollup transactions revert correctly if one leg fails.
Design the atomic transaction flow
To execute an atomic transaction across multiple rollups, the system must replace isolated ordering with a shared sequence. Instead of each rollup deciding independently which transactions to include, a centralized or distributed sequencer accepts transactions from all involved chains and sorts them into a single, linear timeline. This shared order is the foundation of atomicity; it ensures that dependent actions are processed in the exact order intended, preventing race conditions or partial execution states.
The workflow begins when a user signs a transaction payload that references multiple rollup contracts. Rather than submitting this payload to individual rollup sequencers, the user sends it to the shared sequencing layer. This layer validates the signature and groups the transaction with others, creating a unified block of ordered operations. By centralizing the ordering phase, the system guarantees that if one part of the transaction fails, the entire batch can be rejected before any state changes occur on the destination rollups.
Once the shared sequencer finalizes the order, it broadcasts the ordered batch to each participating rollup. Each rollup then executes the transactions in the agreed-upon sequence. Because the order was already determined and agreed upon by the shared layer, each rollup can process its portion of the transaction without worrying about conflicting inputs from other chains. This decouples ordering from execution, allowing rollups to maintain their own state machines while still participating in atomic cross-chain operations.
Finally, the transactions are posted to the underlying Layer 1 for finality. The Layer 1 acts as the ultimate source of truth, verifying that the shared sequencer’s output matches the committed data. If a dispute arises or a sequencer behaves maliciously, the Layer 1 can resolve the conflict using the pre-agreed order. This L1 finality ensures that the atomic transaction is irreversible and secure, completing the flow from user intent to cross-rollup execution.
The user creates a transaction that interacts with contracts on two or more rollups. They sign this payload with their private key and submit it to the shared sequencer network. The payload includes metadata identifying the target rollups and the specific state transitions required for atomicity.
The shared sequencer receives the transaction and places it in a global order alongside other pending operations. This step is critical: the sequencer ensures that the transaction’s position relative to other cross-rollup actions is deterministic. If the transaction depends on a prior state change on another rollup, the sequencer verifies that dependency before finalizing the order.
The ordered batch is distributed to each involved rollup. Each rollup executes its portion of the transaction using the shared order as a constraint. Because the order is fixed, rollups can process their state changes in parallel or sequentially without risk of conflict. If any execution fails, the entire batch is marked invalid, preserving atomicity.
The rollups post their execution proofs or state roots to the Layer 1 blockchain. The Layer 1 verifies that the shared sequencer’s output was correct and that the atomic transaction was fully executed. Once confirmed on L1, the transaction is irreversible, and the new state is visible across all participating rollups.
Handle fee markets and ordering
Standard EIP-1559 fee markets often fail in cross-rollup contexts. Consider dynamic fee sharing or priority gas auctions.
Cross-rollup atomicity requires a unified view of value flow. When transactions span multiple rollups, the fee market must reflect this shared state. Without coordination, users face unpredictable costs and potential front-running.
Dynamic Fee Sharing
Espresso Systems addresses this by decoupling sequencing from execution. The sequencer orders transactions across rollups, ensuring fair placement. Fees are calculated based on the total network congestion, not just a single chain's load. This prevents users from gaming the system by shifting activity to a less congested rollup.
L1-Based Ordering
Alternatively, Layer 1-based models use the base layer as the ultimate arbiter. Transactions are submitted to the L1 mempool, where they are ordered by priority. This provides a single source of truth for ordering. However, it introduces latency and higher costs. The trade-off is between speed and absolute fairness.
Both approaches aim to prevent front-running. The key is ensuring that the fee mechanism incentivizes honest ordering. If the fee market is misaligned, attackers can manipulate the sequence to extract value.
Verify execution on Layer 1
Finalizing cross-rollup transactions requires posting the agreed-upon state to a shared Layer 1 settlement layer. This step transforms a temporary sequence into an immutable, atomic commitment. Without this L1 anchor, the cross-rollup state remains fragile and vulnerable to reorgs or sequencer censorship.
In ZK-based models, this involves submitting zero-knowledge proofs that verify the validity of the off-chain state transitions. For Optimistic models, it means posting transaction data (calldata or blobs) to allow for a challenge period. In both cases, the L1 contract acts as the single source of truth, ensuring that the ordering established by the shared sequencer cannot be altered retroactively.
Espresso’s architecture leverages this by having rollups commit to Espresso’s ordered state root on L1. This creates a "shared order" guarantee: if two rollups agree on the order, L1 ensures that order is preserved and final. This approach decouples execution from settlement, allowing each rollup to optimize for speed while relying on L1 for security and atomicity.
Common questions about rollups
Before diving into cross-rollup sequencing, it helps to clarify the foundational components of the ecosystem. This section addresses basic questions about rollup types, sequencer roles, and Layer-2 definitions to ensure we are all speaking the same language.
Helpful gear
Use these product recommendations as a starting point, then choose the size, material, and price point that fit how you actually use the gear.
As an Amazon Associate, we may earn from qualifying purchases.
No comments yet. Be the first to share your thoughts!