TL;DR

Fragmentation across Ethereum rollups(L2s) has come at a cost — gas, time, security, and network effect among others. Data shows that the majority of value is concentrated across ~10 rollups, with users bridging billions monthly to move across ecosystems, incurring extra delays and fees for basic cross-chain actions. Optimistic exits take ~7 days; ZK exits still take hours. Meanwhile, siloed ecosystems, fragmented liquidity and user bases all contribute to lost network effects. 

The answer? Make rollups Compose.

The state of rollups and the bridging cash cow

Rollups currently carry the bulk of Ethereum activity. On L2BEAT’s Scaling Summary, the top networks by Total Value Secured (TVS) include Arbitrum One (~$17.87B), Base (~$14.20B), OP Mainnet (~$3.05B), Linea (~$1.48B), Starknet (~$709.72M), zkSync Era (~$522.01M), and Scroll (~$217.79M). These top rollups concentrate the majority of value and usage, yet remain largely siloed. The walled gardens of yesteryear have become the walled forests of today. L2BEAT

Top L2s by TVS (Arbitrum, Base, OP Mainnet, Linea, zkSync Era, Starknet, Scroll, etc.). (L2BEAT)

To get assets from L2↔L2, the ecosystem has developed bridges. Users and dApps together spend enormous amounts of capital each month to route around this fragmentation. On DefiLlama Bridges, the last 30 days show ~$34B bridged across protocols (essentially the TVS of the top 2 rollups in Ethereum combined), underscoring just how often value must hop between domains to reach liquidity, incentives, or app-specific opportunities. Because of this, bridges are ‘killing it’ by tapping into a multi-billion-dollar need.

DefiLlama ~$34B in the last 30 days—stacked by major bridges. (DeFi Llama)

Portal/Wormhole, Hyperliquid Bridge on Arbitrum, Stargate v2, CCIP/Transporter, Connext, Gnosis, Avalanche Bridge, cBridge, Axelar Satellite, Hop: those protocols account for a large share of the $34B+ monthly flows. Volume composition shifts month-to-month—typically clustering around:

• Yield & incentive programs: Points, rewards, fee rebates concentrated on specific L2s.

• App exclusivity: DEXs, CEXs, lending markets, restaking/staked-point ecosystems available only on X or Y rollup.

• Asset rails: Purpose-built pathways for a specific token to move across chains as the same native asset, not a wrapped IOU—for example, Circle’s CCTP

• Latency & fee routing: traders' path to the cheapest/fastest venue for the next action.

Capital isn’t “choosing” fragmentation—it’s paying billions to work around it. The $34B+/month in bridge flows is a symptom of missing synchronous composability; users shuttle value to where they need to act, because they can’t compose across rollups in one atomic step today. 

The multivariate cost of fragmentation

1. The $$ Cost of Bridging

Cross-rollup transactions typically incur extra L1 gas for prove/finalize on exits (or a relayer fee that covers that L1 gas), so they’re materially pricier than single-chain calls. That means gas (often paid multiple times for L2→L1→L2 moves) and third-party fees on “fast” bridges make cross-rollup actions expensive. Guides comparing options show that official bridges can cost anywhere from a few dollars to tens of dollars in gas, while liquidity bridges advertise sub-$1 fills under ideal conditions (each with its own fees and trust assumptions). 

Even when using “easy mode” relays (to avoid the 7-day optimistic challenge period), an extra relaying fee is added. Superbridge, for example, pegs it to an L1 tx budget (e.g., 400k gas @ 40 gwei). Those costs roll up to the user. 

Cross-rollup operations routinely add extra transactions and fees compared to same-chain actions.

2. Time: Asynchronous withdrawals

Same-slot withdrawals don’t exist on today’s L2s. On Ethereum L1, synchronous composability is the norm; state changes and withdrawals finalize together in one block. On L2s, they don’t: exits are asynchronous, forcing bridge-then-wait flows. In other words, without same-slot withdrawals, L2s can’t deliver the one-click, all-in-one flow users expect. The result: a UX that fractures the user experience. 

• Optimistic rollups (Arbitrum, OP Mainnet, etc.): ~7-day challenge period for withdrawals to L1 via the official bridges. It’s fundamental to the security model. (Arbitrum Support)

• ZK rollups (zkSync, Linea, Starknet): Proofs let you exit in hours once verified on L1, but still not instant. zkSync documents a 3-hour minimum, often +1–2 hours for batching. (ZKsync Docs)

Practically, multi-rollup strategies (borrow on A, swap on B, repay on A) stretch over hours to days. Users either accept the delay or turn to “fast” bridges as volatility and wait times potentially impact the final result of a transaction.

3. UX: From L1 One-Click to L2 Multi-Step 

On Ethereum L1, multi-dApp flows are one-click and atomic: a single transaction can lend on Aave, swap on Uniswap, and repay or rebalance elsewhere—all within the same block, all-or-nothing. That’s the “money-legos” experience: one signature, one receipt, seamless state transitions across protocols.

On today’s L2s, the same flow splinters. Protocols are deployed on different rollups, cross-rollup calls aren’t synchronous, and users are pushed into manual handoffs—move funds, re-approve tokens, keep gas on multiple L2s, repeat. Steps that are instant and atomic on L1 become separate, non-atomic transactions stretched over minutes to days, with failure points in the middle (and no simple rollback). The result: strategies like cross-margining, flash loans, or deep DEX aggregation across rollups don’t feel like “one action” and can lead to opportunity costs. 

4. Innovation, Complexity & Network Effects

For developers: every additional L2 deployment turns one product into N products. You’re cloning deployments, re-running audits, wiring different wallets/oracles/indexers, maintaining separate liquidity, analytics, and support. At the end of the day, teams ship less, take fewer risks, and burn more runway and operational overhead defending parity across chains instead of innovating.

For users: “the same dApp” across L2s isn’t the same. They juggle token versions, approvals, gas on each L2, and inconsistent liquidity/fees. Ported apps often have uneven depth and slightly different configs; what was one click on L1 becomes a chain of errands. Power users keep balances on multiple L2s—capital that could be productive is stranded for contingency.

For Ethereum: fragmentation converts a single, compounding marketplace into many sub-markets. Liquidity, attention, and developer effort get diluted, weakening the positive feedback loop that made L1 “money-legos” so powerful. Instead of each new dApp being instantly composable with the whole ecosystem, it’s composable with a slice, resulting in a narrower surface area for integrations, fewer emergent behaviors, and slower innovation. In aggregate, this is a drag on the pace of innovation and the perceived superiority of Ethereum as the foundation of the digital economy.

5. Liquidity Fragmentation

When the same markets are cloned across rollups, liquidity doesn’t add up—it splits. Instead of one deep pool for ETH/USDC, you get five medium pools on five L2s, each with thinner depth, wider spreads, and more volatile pricing. Market makers must fragment inventory, capital efficiency drops (idle buffers everywhere), and arbitrage becomes a constant tax: you’re paying to rebalance imbalances that wouldn’t exist if order flow met a single pool. Lending suffers too: duplicated reserves mean lower utilization on each chain, so borrowers see tighter caps or higher rates while lenders earn less than a unified pool would allow. In short, replicated liquidity erodes depth, raises slippage, and dilutes yield—the opposite of the L1 “money-legos” flywheel.

Understanding how assets move between Ethereum and rollups is critical because not all bridges offer the same security guarantees. This distinction matters: different versions of the “same” token (like USDC vs. USDC.e) can carry very different risk profiles. For users and developers, this adds complexity and uncertainty to cross-rollup liquidity.

In practice, that means the same ticker can carry very different assumptions: e.g., native USDC on an L2 (often via Circle’s CCTP burn/mint rail) avoids wrapped-token risk, while USDC.e is a bridged IOU with extra bridge risk; and some L2s have large shares of funds that arrived through non-canonical bridges, which L2BEAT flags as additional trust to evaluate. For fragmentation, this is pivotal: token versions, trust models, and exit guarantees diverge across L2s—compounding liquidity splits and UX confusion even when symbols look identical. 

The Solution: A Unified, Synchronous Cross-Rollup Model

Compose introduces a validator-secured Shared Publisher (SP) that coordinates cross-rollup bundles and finalizes them on Ethereum atomically—all-or-nothing—in the same L1 settlement window. No wrapped assets. No bespoke third-party trust. No user-driven multi-step dance.

Concretely, this model addresses each pain point:

• Cost: Cross-rollup actions are batched and proof-aggregated, amortizing L1 footprint across many messages (like how rollups amortize L2 tx costs). Users avoid the extra finalize trips and duplicate L1 calls typical of today’s bridges.

• Time: Synchronous execution means strategies finalize together—no “wait a week, then click finalize.”

• UX: One-click multi-rollup actions replicate the L1 composability paradigm. Think “swap on B with collateral on A” as one action, not a multi-day odyssey.

• Security: Secured by Ethereum validators and validity proofs rather than ad-hoc committees or multisigs. The aim is to remove the weakest links that made bridges the top attack vector.

• Network effects: Developers deploy once and reach users/liquidity across rollups. Liquidity concentrates, markets deepen, and DeFi regains the money-lego flywheel.

• Liquidity: No more liquidity duplication across chains and users also dont need to have liquidity on different chains just to do some simple multi-chain transaction.

Rollups keep their sequencers and sovereignty; the SP coordinates and publishes bundles to L1—so cross-rollup actions succeed or revert together.

Ready to help make Ethereum feel like one chain again? Visit Compose to learn how validator-secured synchronous composability removes delays, cuts costs, and restores the L1-grade UX across L2s.