Shared Sequencers & Cross-Domain MEV

You spent five lessons learning that cross-chain arbitrage is hard because the two legs don’t settle in one transaction. Buy ETH on chain A at $2000, sell on chain B at $2020, and somewhere between those two clicks you are exposed: holding inventory, waiting on finality, trusting a bridge, praying nothing depegs. The 1% gap is the carrot; the exposure window is the stick.

This capstone asks the question the whole course has been circling: can we buy atomicity back? And while we’re answering it — where does all that ordering power, all that MEV, actually go when you smear a market across many chains? Spoiler: it doesn’t evaporate. It moves to a new throne. Let’s find the throne.

MEV doesn’t die, it relocates

Think of MEV like water pressure in a building. You can’t make the pressure go away by adding more pipes — you just move where it pushes hardest. Split one chain into ten rollups and the maximal extractable value (the profit a party can earn purely by choosing what transactions to include and in what order) doesn’t drain out the bottom. It pools in new joints.

The classic single-chain plays you already know still happen inside each chain:

• Sandwich — wedge a victim’s swap between your buy and sell.
• Backrun — land a transaction immediately after a known one (a big trade, an oracle update) to harvest the move it causes.
• PBS / MEV-Boost — proposer-builder separation, where searchers build ordered bundles, builders assemble blocks, and a relay runs a sealed-bid auction so the proposer collects the value without choosing the order.

But a multi-chain world mints a brand-new species on top of those.

Cross-domain MEV is the value extractable by controlling or coordinating transaction ordering across two or more chains or rollups at once. Two flagship examples: (1) capturing a cross-chain arbitrage by ordering both legs favorably — your buy on chain A and your sell on chain B each land exactly where you want them; (2) backrunning a bridge deposit — you see a large deposit confirm on the source chain and race to act on the destination chain before the price there reacts.

The hero diagram below is the single-chain MEV supply chain you met earlier — searcher, builder, relay, proposer — re-cast as a cross-domain pipeline. The punchline is the same structural fact: whoever holds the right to order wins, and in a multi-chain world that right can span domains.

When it matters

Cross-domain MEV is the dominant lens the moment a strategy touches more than one chain. If your arb, liquidation, or backrun depends on what happens on a second domain, you are no longer competing only against local searchers — you’re competing against whoever can best coordinate ordering across both. That party sets the floor on what edge is left for you.

Sequencers: the rollup’s order-maker

Picture a single train dispatcher at one station, holding the only clipboard that says which train leaves and in what order. Every passenger (transaction) has to go through that one person. Fast and tidy — and also a perfect spot to play favorites.

A sequencer is the component of a rollup that receives transactions, decides their order, and posts the resulting batches down to L1 (Ethereum) for data availability and settlement. Most rollups in production today run a single centralized sequencer operated by the rollup team itself. One clipboard, one dispatcher.

That operator has a structural advantage. Because it sees the incoming transaction flow and chooses the order, it can — in principle — front-run (insert its own transaction ahead of yours), censor (delay or drop transactions it dislikes), or simply harvest ordering MEV that no one else can touch. It’s a latency-and-ordering monopoly.

In practice that power is mitigated, not removed, by three things:

• Reputation — the team’s business depends on not visibly abusing users.
• Forced-inclusion / escape hatches — mechanisms that let you submit a transaction directly to L1 if the sequencer censors you, so it can’t censor you forever.
• Decentralization roadmaps — public commitments to hand sequencing to a permissionless set over time.

When it matters

If you’re arbing into or out of a rollup, the sequencer is the gatekeeper of your fill. Its latency edge means it can, in principle, see your inbound arb and react first; its censorship power means your escape-hatch fallback may be too slow to save a time-sensitive trade. Knowing whether a chain runs one operator’s clipboard — and how fast its forced-inclusion path is — is part of pricing the leg.

Shared sequencers

Now imagine the dispatcher upgrades: instead of one clipboard per station, one dispatcher coordinates the timetables of many stations at once. If a passenger needs to catch a connecting train at a second station, the dispatcher can guarantee both trains wait for each other — or neither leaves. That’s a shared sequencer.

A shared sequencer is a sequencing layer that orders transactions for many rollups together (designs like Espresso and Astria pursue this). Because one party builds the ordering for several chains in the same beat, it can offer the prize this whole course has been chasing: atomic cross-rollup inclusion. It can bundle a transaction on rollup X and a transaction on rollup Y so that they land together or not at all — restoring atomicity across rollups and enabling genuinely atomic cross-rollup arbitrage. Buy on X, sell on Y, both in one indivisible commitment. No exposure window between the legs.

That’s the upside, and it’s enormous: it directly dissolves the Lesson 1 problem for any pair of chains that share the sequencer.

The cost is equally enormous, and it’s the theme of this lesson made literal:

• A new cross-domain MEV throne. Concentrating ordering power over many chains in one place creates the single most powerful seat for cross-domain MEV that exists. The shared sequencer is the entity best positioned to coordinate ordering across domains — exactly the value we defined earlier.
• Trust and censorship, scaled up. A centralized sequencer can censor one chain; a shared one can censor — or extract from — all the chains it serves. The forced-inclusion and decentralization questions don’t go away; they get multiplied.
• It only helps shared chains. A shared sequencer restores atomicity only between rollups that actually use it. Two arbitrary independent L1s — say Bitcoin and an unrelated chain — share no sequencer, so this buys them nothing. Atomicity here is a club good, not a universal one.

When it matters

Shared sequencers reshape the strategy map for any rollup ecosystem that adopts them. If your two legs both live inside a shared-sequencer set, atomic cross-rollup arb is on the table and the edge collapses toward whoever wins the sequencer’s auction. If even one leg is outside, the classic carry-trade risks reassert themselves — so the first question for any cross-rollup strategy is simply: do both chains share a sequencer?

Approximating atomicity without a shared sequencer

No shared sequencer between your two chains? Then you can’t get true atomicity — but you can rent something that feels like it by paying a specialist to eat the risk in the middle. Three families do this, and the trick to understanding each is to ask one question: who bears the residual inventory/finality/tail risk?

1. Bonded relayers / fast-fill (e.g. Across). A relayer fronts the user’s funds on the destination chain instantly out of its own inventory, then reclaims the slow canonical bridge transfer afterward. To keep it honest, the relayer posts a bond — collateral that gets slashed (confiscated) if it misbehaves. The user gets near-atomic UX (funds on B in seconds); the relayer eats the latency and finality risk of the slow leg.

• Approximation gap: it works only if the bond is large enough to deter cheating, and only if relayers actually show up to fill. No relayer, no fast fill — you fall back to the slow bridge.

2. Escrow / HTLC atomic swaps. A hashed timelock contract (HTLC) locks funds on both chains behind the same secret hash, with a timeout. Either both claims happen (the secret is revealed, both sides unlock) or both refund after the timeout. This is genuinely atomic-ish: the cryptography guarantees you can’t be left half-filled.

• Approximation gap: it’s slow (you wait out timelocks), it locks capital on both sides while pending, and it’s exposed to griefing and the free-option problem — the party who reveals the secret last can choose to walk away if the price moved against them, having tied up the counterparty’s capital for free. That optionality has real value, and the counterparty pays for it.

3. Intent-based systems (UniswapX, CoW Protocol, Across-as-intents). The user signs a desired outcome, not a sequence of transactions: “I want at least X of token Y on chain B in exchange for my token on chain A.” Competing solvers (specialized fillers) then bid to satisfy that intent, taking on the cross-chain execution and all its risk themselves. The user gets an atomic-feeling, guaranteed outcome — they either get their X of Y or the intent isn’t filled — while the solver bears the residual inventory, finality, and tail risk.

• Approximation gap: trust shifts to solvers and the competition between them. If solvers collude or centralize, the user’s effective price worsens; and the same underlying bridge risk the solver uses to move funds is still sitting there — just on the solver’s books instead of yours.

Here’s the trade-off space side by side. Notice nothing scores well on every axis — that’s the whole point.

When it matters

These three are the actual toolkit you’ll use in production, because most real cross-chain pairs don’t share a sequencer. Picking among them is a risk-routing decision: fast-fill and intents give your users speed by selling the in-between risk to a relayer/solver (you pay a spread); HTLCs give you cryptographic safety at the cost of speed and capital. The right choice depends on which axis — latency, capital, or trust — your strategy can least afford to spend.

The frontier: buying back atomicity

Step back and look at the whole arc. One thread runs through every lesson in this course, and it’s the loss of a single primitive: atomicity — the property, free on any one chain, that a buy and a sell either both execute or neither does, inside one transaction.

Lesson 1 took that away the moment the two legs lived on different chains. And everything since has been the bill for that loss:

• You must hold inventory between the legs.
• You sit inside an exposure window where price can move against you.
• You inherit bridge trust and tail risk — depegs, finality reversals, validator-set compromise.

Seen that way, this entire final lesson is one idea wearing four costumes. Shared sequencers, bonded relayers, HTLC escrows, intent+solver systems — they are all the industry trying to buy atomicity back. And each pays for it with a different currency:

When it matters

This is the lens to carry out of the course. Any cross-chain product you evaluate — a bridge, an intent app, a new rollup’s sequencer design — answer two questions: how much atomicity does it actually restore, and for whom? and what is it paying with — trust, capital, latency, or centralization? The answers tell you where the residual risk sits, who’s getting paid to bear it, and whether there’s still an edge left for you.

Recap