The Compose Alpha 0 devnet introduces Ethereum's first atomic cross-rollup swap. Move assets from Rollup A to B, swap on a DEX, and return to A in one click, eliminating bridges, waits, and network switches.

A DeFi power user’s dream

If you’ve spent the last few years juggling bridges, wrapped assets, network switching, and dozens of L2s to chase DeFi opportunities, this one’s for you.

Compose Alpha 0 devnet just unlocked a fully atomic A → B → A cross-rollup swap:

Assets leave rollup A, move to rollup B, swap on a DEX, and return to rollup A — all in one flow. No external liquidity providers. No bridge UI or network switching. Just pure synchronous, composable interop powered by Compose.

It’s Ethereum’s first atomic cross-rollup swap — and it’s the first real taste of what rollups look like when they actually compose with each other.

Exploring the first Compose DeFi use case

On the Alpha 0 devnet, Compose connects two stock rollups built with OP Succinct stack to generate validity proofs for transactions, eliminating disputes entirely.

On top of that, we wired in our core architecture so that a user can:

1. Deposit USDC to rollup A using the universal deposit bridge.

2. Move assets to Rollup B, to swap on a DEX (e.g., into ETH).

3. Send the ETH back to Rollup A.

4. Settle instantly on ETH L1 using aggregated ZK proofs.

From the user’s point of view, this is a one-click cross-rollup swap:

• One UX flow through fully programmatic cross-chain contract calls.

• Instant atomic execution.

• No waiting for bridges, network switching, or liquidity providers.

• ZK-proved from end-to-end.

• If any leg fails, everything reverts.

Underneath, Compose coordinates multiple per-chain transactions in lockstep and only commits them if all legs succeed.

The stack behind the swap

1. A based Shared Publisher

   • Compose’s Shared Publisher (SP) runs on Ethereum validators (initially via SSV). Sequencers on each rollup keep local control, but they publish cross-rollup bundles through the SP, which aggregates them into a single “superblock” and posts it to Ethereum.
     
     

2. Fully programmatic cross-chain contract calls

   • Apps don’t talk to bridges; they talk to a Mailbox contract that abstracts cross-rollup messages: write on one rollup, read on another, all coordinated by the SP.
     
     

3. Instant, atomic execution using Two-Phase Commit

   • Sequencers simulate each leg locally.

   • They exchange Mailbox messages.

   • Each chain votes yes/no in a two-phase commit (2PC) protocol.

   • If any chain votes “no”, the entire bundle aborts.

   • If all vote “yes”, the Shared Publisher finalizes the bundle and posts it to Ethereum in a single settlement step, restoring L1-style atomicity across rollups.
     
     

4. ZK-proved end-to-end

   • Each rollup produces validity proofs for its local blocks.

   • Compose aggregates these proofs and publishes a single proof in the form of a superblock, amortizing cost as usage scales and anchoring everything to Ethereum security.

Why DeFi Users Should Care

Bridges are a tax on cross-rollup interactions

Today, if you want to do a cross-L2 trade, you usually:

• Bridge from Rollup A to B, swap, and bridge back again.

• Wait (hours to days) depending on challenge windows.

• Network switching and the need for liquidity across multiple chains to pay for gas, if LPs even provide liquidity for those tokens.

That simple flow runs through bridges that have become toll booths between Ethereum’s rollup ecosystems:

• ~$30B in bridge volume every month flows through cross-chain bridges.

• Only a handful of general-purpose rollups (Arbitrum, Base, OP Mainnet, etc.) dominate TVS, meaning most liquidity is essentially locked in a few silos.

• Cross-chain bridges have consistently been among DeFi’s biggest security risks, accounting for the majority of funds lost in recent years.

Comparing Compose to intents

Today, two philosophies try to reconnect it all from opposite ends of the stack: Compose’s synchronous composability, which extends Ethereum’s atomic execution model across rollups, and intents, which rely on off-chain solvers to deliver user-specified outcomes.

Execution Model

Compose executes cross-rollup flows at the protocol level. Messages move through Mailboxes on each rollup, and the Shared Publisher simulates the full bundle before committing, so every chain either advances together or reverts together. 

Intents invert this: users describe the outcome they want, off-chain solvers simulate possible routes and front the liquidity, then later settle on-chain once bridges and messages clear. 

With Compose, atomicity is enforced by consensus and shared state; with intents, it is enforced by solver economics.

Latency

With Compose, latency is essentially determined by rollup block time. When a cross-rollup bundle is included, all legs finalize atomically, so there are no intermediate states and no separate settlement phase. 

Intents are asynchronous by design: a user broadcasts an intent, solvers wait for on-chain events and sufficient confirmations, then execute and reconcile after. The UX can feel fast if solvers front results, but total completion time depends on bridge delays, network conditions, and solvers rather than a single, deterministic commit.

Expressiveness

Compose is as expressive as the EVM itself, just stretched across domains. Developers can compose arbitrary read and write operations across many rollups—arbitrage, swaps, liquidations, NFT moves—in one atomic transaction, and reason about it like an Ethereum dApp on the L1. 

Intents are outcome-driven and shift complexity to solvers: each new pattern (for example, a multi-rollup swap) requires new solver logic, capital, and risk management. In theory, intents can express anything; in practice, they tend to focus on simpler, well-bounded tasks where success is easy to define up front.

Use cases

Compose is built for use cases that must be synchronous and stateful across chains:

• Cross-rollup swaps and no-LP bridging (like the A → B → A swap in Alpha 0).

• Arbitrage and flashloans spanning multiple rollups.

• Singleton dApps – one protocol instance coordinating users on many rollups.

These are flows where temporary partial states are unacceptable and real-time visibility across domains is crucial.

Why this is good for Ethereum, not just Compose and its users

Synchronous cross-rollup execution is the way to:

• Reconnect fragmented liquidity and users across rollups. Use any token, on any dApp, on any chain.

• Tie rollup economics back to ETH validators, by routing interop fees through the Shared Publisher rather than to third-party bridges.

• Let smaller rollups plug in and become instantly reachable from larger ecosystems, rather than bootstrapping in isolation.

What’s next for Compose?

Cross-rollup swaps are just the beginning. 

With Compose, the only constraint is the builders’ imagination. If you can describe the flow -> “borrow here, route there, settle back over there”, you can build it. From multi-rollup arbitrage to things we don’t even have jargon for yet, Compose is the connective tissue. We’re shipping the rails; the weird, powerful, interop-native DeFi apps on top are up to you.