The need to Compose

Ethereum L1 made DeFi explode because it has deep liquidity and contracts are composable synchronously and atomically within the same block. However, with the need to scale L1 throughput, rollups inadvertently split users, liquidity, and state across many rollup ecosystems. Cross-rollup UX became asynchronous, multi-step, slow, and often non-atomic - pushing activity and value capture toward bridges and siloed sequencers. 

Compose is the connective tissue that brings the L1 feel back to the rollup era.

The properties mentioned above are essential for UX and developer features, making the Ethereum L1 what is it today.

What is Compose?

Compose is built on a based Shared Publisher architecture that coordinates multi-chain transactions, aggregates ZK proofs, and publishes a superblock to Ethereum via L1 validators. Multi-rollup actions execute together or not at all, restoring the one-click UX users and devs know and love on the L1.

What is synchronous composability?

Same-block feel across rollups: no partial fills, no bridge purgatory, and if any leg fails, all legs revert. It’s the L1 “money-legos” experience on L2s.

The vision: One Ethereum from L1 to L2

Compose aims to connect every corner of Ethereum so that transactions feel like one network - instant, atomic UX across domains - while aligning value with Ethereum’s validator set. Users get one-click flows, dApps don’t need to be redeployed across the rollup ecosystem, rollups grow without giving up sequencer autonomy, and validators participate in a new, credibly neutral interop role.

Why synchronous composability is hard (and why it’s worth it)

Each rollup differs in finality, sources of data availability (DA), sequencing, and contract layouts. To date, there hasn’t been a universal coordinator to align execution safely and instantly across domains. Async “lock/mint” flows risk supply inflation if one leg reverts after another leg has minted; intent/LP bridges are fast but non-atomic, trusted, and liquidity-limited. 

Compose fixes this by making cross-rollup execution all-or-nothing, without third-party liquidity.

The Compose tech stack

The Shared Deposit Bridge

Composability starts with liquidity. The current ERC representations used on rollups are not meant to be composable, a major hurdle for interoperability. Most solutions are based on liquidity, meaning someone needs to provide it e.g. for bridging where liquidity lives on multiple rollups in order to facilitate transactions. This is great for fast UX, but very limited to the different tokens used and liquidity depth. 

This means there is a gap for a solution that is liquidity independent. The shared bridge addresses this programmatically by creating an entry point to different rollups where the goal is to have a composable liquidity layer that can stretch across multiple rollups without affecting liquidity depth. The shared deposit bridge acts as a superhighway so assets can move freely between rollups without the need for providing liquidity, or the need for resolvers. 

Think about the experience on Ethereum L1, the assets can just move between accounts because of it’s programmatic nature.

The Shared Publisher

The Shared Publisher (SP) is a validator-powered coordination layer that:

1. orchestrates cross-rollup bundles via 2PC simulation,

2. verifies them with ZK proof aggregation,

3. publishes a single aggregated superblock to Ethereum via L1 validators.

The major difference between Compose and other interoperability solutions is that rollups keep control of sequencing and fee markets. The economies of scale are important here - if there are many rollups aggregating transactions into one proof they can more frequently post and settle, potentially cutting down the withdrawal times to less than 1 hour. 

A new revenue stream for validators and rollups
All interactions carry a fee - which is collected by SSV validators in ETH on top of staking rewards. Part of the reward goes to sequencers themselves, meaning revenue for validators and rollup sequencers help with economic stability. 

Step-by-step cross-chain transaction 

1. Mailbox: inbox/outbox primitives
   Every rollup gets a MailBox with an inbox and outbox. When a transaction spans multiple rollups, each sequencer simulates its local part, records cross-chain calls as mailbox writes, and pre-populates the counterpart’s inbox. This ensures both sides will read exactly what the other side wrote at execution.

2. Two-Phase Commit (2PC)
   After the simulation, each sequencer votes. If all legs are valid, commit; if any leg fails, abort and revert. This provides atomic execution (the gold standard) rather than mere co-inclusion.

3. ZK proofs and proof aggregation
   The SP uses ZK proofs to attest that every leg executed correctly. Multiple rollup blocks and bundles are aggregated, reducing marginal cost as volume scales; one aggregated proof is posted with the superblock to Ethereum.

4. Separating sequencing from publishing
   Sequencers stay sovereign (own mempools, ordering, fee markets). Publishing of cross-rollup bundles is handled by the SP and finalized by L1 validators—that’s the “based” part.

5. Account Abstraction (ERC-4337) on top
   With AA wallets, front-ends can package a multi-rollup workflow as a single UserOperation—e.g., swap on Rollup A + lend on Rollup B—one signature, one UX flow, fully atomic underneath.

Think of the mailbox calls as cross-chain call/return, and 2PC+ZK as the safety net that guarantees reads match writes (or everything reverts).

What this means in practice

L1-grade UX for the L2 ecosystem

One-click actions, same-block feel, no wrapped assets, and no stranded funds. 

For users asking, “which rollup should i use?” this question fades away;
for dApps, deploy once, compose everywhere;
for rollups, UX improves, and withdrawals can become near instant…

Predictable fees

All legs are simulated and fixed before commitment; gas is predictable across chains. As more multi-chain transactions occur, aggregation amortizes costs across the bundle, making cross-chain affordable at scale.

New use cases unlocked

• Cross-rollup flash loans & swaps

• Cross-chain calls

• Omni-chain transactions

• Unified NFT markets

All of this is finally possible without custom bridges, wrappers, or trust in third-party liquidity.

What this means for SSV

By enabling frictionless cross-rollup composability, cross-chain transactions will become more prevalent (as we can see by the multi-billion bridging industry that currently fills this gap). More txs will generate more fees to validators running the shared publisher and ultimately some of those fees will go back to the SSV DAO (design and implementation is still up to SSV DAO approvals and vote). Ultimately, by extending what validators can do Compose increases rewards for them by solving the L2 fragmentation problem, a win-win for the greater Ethereum ecosystem.

How Compose compares to other interoperability solutions

• Async message passing: can take minutes/hours and risks half-done states. Compose ensures atomic execution, not just inclusion.

  

• Intents: fast, but rely on third-party liquidity and settle asynchronously; not atomic. Compose executes all-or-nothing in the same flow and doesn’t need external LPs.

  

Plotting the difference

What’s in it for integrated rollups?
Compose will bootstrap synchronous composability for the largest to the smallest rollups today on Ethereum. Any rollup joining Compose can tap into liquidity, users, and dApps on any rollup in Ethereum today, it’s unlike any other solution around and essentially solves the bootstrap problem. 

When a rollup integrates Compose it exposes its users to the blue ocean of dApps and users on the biggest L2s from day 1. It’s a 2 way street though - opening up your rollup up in this sense exposes your ecosystem to the blue ocean of L2s - driving adoption and the best UX from the get go. Enabling this connectivity is essentially levels the playing field for rollups that aren’t currently capturing the lion’s share of activity in Ethereum by tapping into their success and network effect, leading a new renaissance for the rollup industry by moving from economic islands to the a truly interconnected Ethereum.

Will Compose become permissionless? 

Permissionless validator participation is part of the roadmap. Initially only SSV validators will be able to opt in but as Compose evolves any validators from any staking service will be able to tap-in to increase validator rewards for their users. 

Who’s building Compose?

SSV DAO, and the core contributor (SSV Labs) behind Ethereum’s leading DVT infrastructure (SSV Network) is building Compose as a based application (bApp), extending validators’ role from L1 attesters to L2 composers.

A first glance at Compose

The official Alpha 0 devnet is on the horizon! Stay tuned to the Compose website and X where the team will soon showcase how users can deposit and perform a cross rollup swap via a user friendly UI with one click.

Not convinced? 

Does Compose force shared sequencing?
No. Sequencer sovereignty is a core principle; Compose coordinates and publishes, but doesn’t take over ordering. Infact by integrating Compose and supporting cross-rollup transactions rollup sequencers gain a new revenue stream.

Is this “another L1”?
No. It’s a coordination/publishing layer that strengthens Ethereum’s rollup-centric roadmap.

What about bridges, DEXs, dApps—do they need changes?
Compose operates beneath dApps. It doesn’t force rewrites; it makes cross-rollup interaction instant and atomic with a simple integration.

Why use Zero Knowledge (ZK)?
ZK delivers fast, succinct settlement and aggregates multiple rollup proofs into one, which amortizes costs as volume increases.

Composing a new vision for Ethereum rollups

Builders, rollups, and Eth power users!
If you’re building dApps or rollups, get in touch, subscribe to the newsletter for updates and follow @ComposeNetwork to join devnets and co-design pilots. DMs are always open, let’s make Ethereum feel like one chain again.

External reading (context & ecosystem)

• Research on composability and based rollups (Eth Fabric)

• Landscape of trustless interoperability (1kx)

• Taiko on based sequencing and pre-confirmations