Anatomy of Cross-Rollup MEV: Why Shared Sequencers Don't Solve Atomic Arbitrage

Maximal Extractable Value (MEV) — the profit that can be extracted by reordering, inserting, or censoring transactions within a block — has reshaped the economic landscape of blockchain networks. On Ethereum L1 alone, MEV extraction has generated billions in cumulative value since the merge. But as activity migrates to Layer 2 rollups, a new and largely unsolved problem has emerged: cross-rollup MEV.

The premise is simple. Price discrepancies exist between identical assets on different L2s — ETH on Arbitrum vs. ETH on Optimism, USDC on Base vs. USDC on zkSync. Arbitrage across these venues is the most natural form of MEV. But unlike L1 arbitrage, where a searcher can atomically execute both legs of a trade within a single block, cross-rollup arbitrage faces fundamental coordination challenges that no current architecture fully solves.

The Economics of Cross-Domain MEV

To understand why this matters, consider the scale. Research from Extropy Academy shows that 35.67% of L2 arbitrages require third-party bridges, creating massive inefficiency. The total addressable MEV across L2 rollups is estimated at $500M+ annually and growing as L2 TVL increases. For searcher teams, protocol designers, and sequencer operators, this is the next frontier.

Cross-domain MEV takes several forms, each with different complexity and execution requirements:

• Cross-rollup arbitrage: Exploiting price differences for the same asset across L2s (e.g., buy ETH on Arbitrum, sell on Optimism)
• Cross-rollup liquidations: Liquidating undercollateralized positions on one L2 using capital from another
• Cross-rollup sandwich attacks: Front-running and back-running a large swap that spans multiple L2 bridge transactions
• Backrunning bridge flows: Arbitraging the price impact of large bridge transfers as they arrive on the destination chain

The Shared Sequencer Promise

Shared sequencers — proposed by projects like Astria, Espresso, and Radius — offer an elegant narrative. Instead of each rollup running its own sequencer, multiple rollups share a single sequencing layer. This shared layer can see transactions across all participating rollups simultaneously and, theoretically, order them in a way that enables atomic cross-rollup execution.

The pitch is compelling: if a single entity orders transactions across Arbitrum and Optimism, it should be able to guarantee that either both legs of a cross-rollup arbitrage execute or neither does. Atomic composability across rollups — the holy grail of modular blockchain architecture.

The problem is that ordering transactions across rollups and executing them atomically across rollups are fundamentally different problems. Shared sequencers solve the first but cannot, by themselves, solve the second.

Why Atomic Cross-Rollup Execution Is Impossible (Without Tradeoffs)

To understand the limitation, we need to decompose what 'atomic execution' actually requires. On a single chain, atomicity means that all operations within a transaction either succeed together or fail together, and the result is included in a single block. This works because a single execution environment processes the entire transaction.

Cross-rollup transactions involve two separate execution environments. Even if a shared sequencer orders the transactions for inclusion in the same relative position on both rollups, the execution on each rollup happens independently. Several problems emerge:

The State Divergence Problem

Between the time the shared sequencer orders a cross-rollup bundle and the time each rollup executes its portion, the state on each rollup may change due to other transactions. The shared sequencer commits to an ordering, but it cannot commit to an execution outcome because it doesn't control the execution environments.

Concretely: the sequencer orders 'buy 100 ETH on Arbitrum at price X' and 'sell 100 ETH on Optimism at price Y' as an atomic pair. But between ordering and execution, another transaction on Arbitrum moves the price. The Arbitrum leg now executes at a different price than expected — or reverts entirely. The Optimism leg may still execute, leaving the searcher with an incomplete position.

The Finality Asymmetry Problem

Different rollups have different finality characteristics. Optimistic rollups have a 7-day challenge window. ZK rollups need time to generate and verify proofs. Even within the same rollup family, block times and confirmation requirements differ. A shared sequencer that sequences across rollups with different finality properties cannot guarantee that both legs reach finality simultaneously.

This creates a window where one leg is confirmed and the other isn't — the exact opposite of atomicity. A sophisticated attacker could exploit this asymmetry to extract value from the sequencer or the searcher.

The Game-Theoretic Breakdown

Recent academic research has demonstrated something counterintuitive: in certain market conditions, atomic cross-rollup execution actually decreases arbitrage profit compared to non-atomic execution. The reason is that atomicity constrains the searcher's strategy space. Without atomicity, a searcher can execute each leg independently, adapting to price movements in real-time. With forced atomicity, the searcher is locked into a fixed strategy at ordering time.

This creates a paradox: the mechanism designed to enable cross-rollup MEV can actually make it less profitable in the exact scenarios where it's needed most — volatile markets with rapid price movements.

A Concrete Example: Uniswap v4 on Arbitrum vs. Curve on Optimism

Let's walk through a specific cross-rollup arbitrage to illustrate the challenges. Suppose ETH is trading at $3,000 on a Uniswap v4 pool on Arbitrum and $3,015 on a Curve pool on Optimism — a 0.5% price discrepancy.

• Step 1: The searcher detects the price discrepancy by monitoring both mempools
• Step 2: The searcher constructs a bundle: buy 10 ETH on Arbitrum ($30,000) + sell 10 ETH on Optimism ($30,150) = $150 gross profit
• Step 3: The searcher submits the bundle to the shared sequencer for atomic ordering
• Step 4: The shared sequencer includes both transactions in the next batch for each rollup
• Step 5: Arbitrum's execution environment processes the buy — but the Uniswap v4 pool's tick has moved due to a preceding transaction. The buy price is now $3,005 instead of $3,000
• Step 6: Optimism's execution environment processes the sell at $3,015 as expected
• Step 7: Net profit is now $100 instead of $150 — or, if the Arbitrum price moved further, the trade may be unprofitable

In this scenario, the shared sequencer provided ordering guarantees but couldn't prevent the state change on Arbitrum that reduced profitability. The 'atomic' guarantee was illusory — the transactions were ordered together but didn't execute against the expected state.

What Actually Works: Intent-Based Architectures

The more promising approach to cross-rollup MEV doesn't try to force atomicity across separate execution environments. Instead, it embraces the separation and uses intent-based architectures with solver competition.

In an intent-based system, a user or searcher expresses an intent ('I want to buy 10 ETH on the cheapest available venue across all L2s') rather than constructing specific transactions. Solvers compete to fill this intent by executing transactions on the user's behalf across whatever chains offer the best price.

EIP-7683: Cross-Chain Intent Standard

EIP-7683 proposes a standard interface for cross-chain intents. It defines how intents are expressed, how solvers discover and bid on intents, and how settlement happens. The key innovation is that solvers take on the execution risk — they front the capital on the destination chain and are reimbursed on the source chain, absorbing the finality asymmetry problem.

• Users express intents, not transactions — they specify desired outcomes, not execution paths
• Solvers compete on price, creating a market for cross-chain execution quality
• Solvers manage inventory across chains, absorbing latency and finality risks
• Settlement happens asynchronously — the user gets their desired outcome quickly while settlement completes in the background
• The solver network naturally routes to the most efficient path, adapting to real-time conditions

Solver Networks in Practice

Protocols like Across, UniswapX, and CoW Protocol have implemented solver networks that demonstrate the viability of this approach. Across, for example, uses a network of relayers who front capital on the destination chain, providing near-instant cross-chain transfers while managing finality risk off-chain.

The economics work because solvers are specialized — they maintain capital on multiple chains, have sophisticated pricing models for cross-chain execution risk, and compete with each other to offer the best prices. This competition produces better outcomes for users than any shared sequencer could guarantee.

Proposer-Builder Separation and Cross-Domain MEV

The evolution of Proposer-Builder Separation (PBS) on Ethereum L1 offers lessons for the L2 MEV landscape. EIP-7732 (ePBS) will enshrine the builder-proposer separation in the protocol itself, eliminating the trusted relay dependency of the current MEV-Boost architecture.

For cross-rollup MEV, the key insight from PBS is the separation of concerns: the entity that orders transactions (sequencer/proposer) doesn't need to be the entity that constructs optimal bundles (builder/solver). Shared sequencers might find their most valuable role not as cross-rollup atomicity providers but as cross-rollup ordering layers that feed intent-based solver networks.

The Future: Pragmatic Cross-Rollup Composability

The future of cross-rollup MEV isn't atomic execution — it's pragmatic composability built on intent-based architectures, solver competition, and asynchronous settlement. This isn't as elegant as the shared sequencer narrative, but it's what actually works given the physical constraints of distributed systems.

• Shared sequencers will provide ordering guarantees and soft pre-confirmations, but not atomic execution
• Intent-based architectures will handle the last mile of cross-rollup execution
• Solver networks will become the primary infrastructure for cross-chain MEV extraction
• The distinction between L2s will blur as chain abstraction layers hide the underlying complexity from users
• MEV redistribution mechanisms (like MEV-Share) will evolve to work across rollup boundaries

The organizations building for cross-rollup MEV should invest in solver infrastructure, cross-chain inventory management, and intent-based protocol integrations — not in waiting for shared sequencers to deliver atomic execution they structurally cannot provide.