The Compose universal bridge is a shared, canonical bridge that pools liquidity in LockBoxes on an asset’s “home” chain and represents it everywhere else as a standard ComposeableERC20 (CET), making tokens move between Ethereum rollups and L1 through a single, consistent interface. This turns today’s fragmented, bridge-specific wrappers into one unified liquidity layer, so rollups, DeFi protocols, and power users get simpler UX, safer collateral, and truly composable cross-rollup strategies.

The problem with assets on rollups

Most of the value on Ethereum now sits on a small cluster of major L2s, while users pay tens of billions of dollars a month just to move between them, paying extra gas, taking on bridge risk, and managing a zoo of wrapped assets and URLs along the way.

On L1, value moves as you expect: one token, one chain, one state machine. On L2s, the same asset might exist as:

• Native ERC-20 on Ethereum.

• A canonical version on one rollup.

• Different wrappers on multiple rollups, each with different bridge contracts and trust assumptions.

Compose’s universal bridge is designed to collapse all of that into a single, consistent model:
a shared bridge and token standard that lets rollups move assets between each other and Ethereum while keeping liquidity canonical and UX simple.

Think of the universal bridge as the asset side of Compose’s architecture. The universal bridge handles tokens and liquidity; the Shared Publisher handles execution and synchronous composability.

Rollup liquidity is fragmented

Before we dive into the universal bridge, it’s worth recapping why the status quo is so painful for rollups and DeFi power users.

• Bridges are the value-added tax on fragmentation. Users routinely bridge L2 → L2 or use “fast” bridges that introduce LP risk and additional fees. Monthly bridged volume is in the tens of billions, essentially a recurring tax on cross-rollup activity.

• Exits are asynchronous. Optimistic rollups can have multi-day exit windows on canonical bridges; ZK rollups shrink that to hours, but we’re still far from “same-slot” withdrawals. Multi-rollup strategies span many transactions and involve long delays.

• Each bridge invents its own wrapped asset. Message-passing bridges lock tokens on chain A, mint representations on chain B, and rely on validators/relayers. Liquidity bridges rely on LPs, solvency, and settlement games. Neither is designed as a universal standard for rollup assets.

• Developers inherit the mess. Every new chain integration means another token list, another bridge, another UX surface area where users can get confused or stuck.

From a network-effect perspective, this is tragic. Instead of a single unified liquidity layer, Ethereum’s rollup era ended up with dozens of fragmented layers. Compose’s job is to stitch that back together, and the universal bridge is how you do it at the asset level.

Introducing the Compose Universal Bridge

At a high level, the universal bridge implements three big ideas:

1. Every asset has a canonical home.

   Within the universal bridge, each supported asset is assigned a canonical chain where its real collateral lives.

• Some assets are canonical on Ethereum L1 (e.g., ETH, major ERC-20s).

• Others are canonical on a particular L2 (L2-native tokens).

• Each asset has at least one canonical chain (often L1 for majors, sometimes an L2 for rollup-native tokens).

2. On non-canonical chains, assets are always represented as a standard token: ComposeableERC20 (CET).
   CET is the universal token format on destination chains — ERC-20 compatible, enriched with cross-chain metadata (ERC-7802), and mint/burn-gated by the bridge.

3. Liquidity is pooled in shared LockBoxes on canonical chains.
   For assets canonical to Ethereum, the universal bridge uses LockBox contracts (e.g., ERC20LockBox implemented as an ERC-4626 tokenized vault) to pool liquidity into a single vault that can be accessed via any rollup.

From a user’s perspective, you don’t directly see any of this complexity. You just move tokens from Rollup A to Rollup B using a consistent interface and see a single representation of your asset on each chain.

From a protocol’s perspective, the universal bridge gives you a unified liquidity layer that plugs straight into Compose’s synchronous composability stack: mailbox messaging, two-phase commit (2PC), and ZK-proved settlement.

Integrating the universal bridge into rollups and dApps

From a rollup or dApp developer’s perspective, the universal bridge is a set of well-defined contracts and standards you plug into your existing stack.

For rollup teams, integration looks roughly like this:

• Deploy the canonical LockBoxes (for L1 assets) or register canonical L2-native assets.

• Deploy the bridge contracts that talk to the Mailbox and mint/burn CET on your chain.

• Wire your sequencer / node stack into the Mailbox interface so messages are written before blocks execute and read when bridge calls are processed.

• Expose one standard bridge entrypoint for wallets and apps (no per-asset/per-bridge routing logic).

For dApp developers, it’s even simpler:

• Treat CET as a standard ERC-20 in your contracts.

• Use the cross-chain metadata (ERC-7802) if you need to know an asset’s canonical chain or address.

• Let the universal bridge handle mint/burn + settlement (you don’t need to write custom bridge adapters per rollup).

Why it matters

For rollups & devs:
The universal bridge turns fragmented liquidity into canonical liquidity by consolidating each asset into a single vault on its home chain instead of scattering it across multiple bridge-specific pools. That means one vault per asset rather than one per bridge per rollup, which simplifies accounting, reduces surface area for bugs, and makes it easier to reason about solvency and flows. 

On the UX side, any wallet or frontend that integrates the universal bridge instantly supports every rollup plugged into it, so ecosystems don’t have to convince wallets and dashboards to add bespoke paths for their chain. Operationally, integrations also get easier: rollups expose a consistent messaging and bridge interface, rather than spinning up a new custom bridge and token format every time they onboard a new asset or partner chain.

For DeFi Power Users:
This translates into a much cleaner mental model and risk profile. Each asset has a single representation per chain, expressed as CET with metadata that clearly anchors it back to its canonical chain and contract, instead of similarly named wrappers with unclear provenance. 

Because custody is held in canonical LockBoxes and movements are governed by validity proofs rather than ad-hoc relayer committees or opaque bridge multisigs, users don’t have to gamble on which bridge is “safest” for a particular route. And since CET behaves exactly like a standard ERC-20 at the contract level, aggregators, DEXs, lending markets, and other protocols can treat it as first-class collateral, unlocking better composability and more sophisticated cross-rollup strategies without specialised handling.

Universal bridge vs other solutions

Most alternatives fall into a few buckets:

The universal bridge is different because:

• It standardizes assets (CET) across chains rather than creating a new wrapper for each bridge.

• Compose works regardless of specialised routes or the amount of capital (high or low).

• It anchors custody in canonical chains and vaults rather than in each bridge instance.

• It inherits atomicity and replay protection from Compose’s Shared Publisher protocol instead of reinventing safety for each token or path.

Security & trust assumptions 

The universal bridge is designed so that bridge safety isn’t a separate trust island; it inherits the same guarantees as the rest of the Compose stack.

• Custody anchored in canonical chains.

  • L1-native assets live in LockBoxes (ETHLockBox / ERC20LockBox) under normal Ethereum execution and consensus.

  • L2-native assets live on their canonical rollup under that rollup’s security model.

• Mint/burn is strictly gated.

  • Only the universal bridge contracts can mint or burn CET on non-canonical chains.

  • CET supply is always tied back to locked collateral in the canonical LockBox or the native token contract.

• Message integrity via Mailbox + proofs.

  • Bridge operations are encoded as Mailbox messages and must appear consistently in all participating chains’ inbox/outbox sets.

  • The Shared Publisher aggregates ZK proofs over these sets; mismatches can be detected and rolled back at the protocol level.

• No extra validator committee.

  • There is no separate “bridge multisig” to trust.

  • Safety depends on Ethereum L1, the security of the participating rollups, and the validity of the proofs, not on ad-hoc relayers or an off-chain bridge operator.

For rollup teams, the key point is that the universal bridge doesn’t ask you to bolt on a separate trust model just to move assets. It reuses the same correctness and settlement machinery you already rely on, but customized for synchronous composability.

Example use case 

Start catering to DeFi power users who want to run cross-rollup strategies:

• You hold USDC on Arbitrum (canonical L2 for some part of your strategy).

• A new perp platform on a smaller rollup (R1) has the best funding and depth for a trade you want to take.

• You want to size up quickly, then move back, without juggling multiple bridges and dashboards.

With the universal bridge + Shared Publisher:

1. Your wallet (or dApp) crafts a single flow:

   • Lock USDC in the L1 LockBox (canonical chain).

   • Mint CET-USDC on R1 via universal bridge messages.

   • Open a perp position on R1, using CET-USDC as margin.

2. Underneath, the universal bridge handles the liquidity path, while the Shared Publisher coordinates the multi-rollup bundle atomically — lock, mint, and trade either all succeed together or fail together.

3. When you’re done, you reverse the flow: close, burn CET-USDC on R1, withdraw from the LockBox back to your preferred rollup.

You never see half a dozen wrapped tokens, nor do you worry about a specific bridge’s solvency. You just see “USDC” on each chain, backed by canonical collateral and standardized contracts.

What this unlocks for the Ethereum ecosystem

Zooming out, the universal bridge and Shared Publisher gradually turn Ethereum rollups from walled gardens into open forests. Rollups plug into a shared asset standard, benefit from every new integration, and gain a new stream of interop fees. DeFi protocols can design products as if they were running on a single, large L2 rather than a patchwork of chains, and Ethereum validators capture more value through settlements that are directly tied to real cross-rollup activity. The more assets and rollups that adopt CET and LockBoxes as their default asset model, the stronger the network effects become and the harder it is for any isolated ecosystem to compete with Ethereum’s unified liquidity surface.

Where to go next

If you want to go deeper into the architecture behind the universal bridge and how it ties into synchronous composability:

• Read the Compose Universal Bridge minipaper for full CET, LockBox, and mailbox specs.

• Explore “A Beginner’s Guide to Compose” for a broader overview of the Shared Publisher and synchronous composability UX.

• Check out “The True Cost of Rollup Fragmentation” to see the economic case for unifying liquidity across L2s.

Developers! Prepare for the public testnet by exploring the documentation.