Fixing Cross-Chain Interop: From Confirmations to Composability with CIRC
This is an Espresso Research post describing our design for CIRC (Coordinated Inter-Rollup Communication), a messaging protocol with the capability to support asynchronous and synchronous composability.
Our multi-chain future will rely on seamless communication between L2s. With an eye on that goal, we created the Espresso Network, which provides fast, reliable, credibly neutral confirmations of a chain’s rapidly changing state. Mainnet went live in November.
But Espresso’s confirmation layer is just the foundation. Part of Espresso’s mandate is to explore the interop and composability design space, leveraging Espresso confirmations to design the protocols and standards that will make Ethereum composable again.
This post describes our design of a fast, versatile message-passing protocol built atop the Espresso Network that we believe has the potential to make cross-chain interactions faster, more secure, and more flexible than ever before. We call it CIRC (Coordinated Inter-Rollup Communication).
The Problem: Current Limitations
Whether synchronous or (really fast) asynchronous composability between Ethereum’s L2s is the goal, today’s interop solutions fall short. Most fall somewhere between these two polar-opposite paths:
The Slow, Secure Route
- L2s pass messages via the Ethereum L1
- Slow because requires waiting for L1 finality (~15 minutes)
- Could be even slower depending on a chain’s L1 posting frequency (some L2s wait several hours or even days before publishing their blocks to the L1)
- Secure because it’s backed by Ethereum’s $80+ billion in economic stake
- High costs due to L1 gas fees
The Fast, Trust-Dependent Route
- Chains pass messages directly, but must trust each others’ centralized sequencers
- Less secure since a malicious or hacked sequencer could provide data that conflicts with what it publishes to the L1 for settlement
- Creates interdependencies that introduces cascading reorg risk
- Not scalable due to compounding risk
Between these two options, there are intermediate solutions, such as LayerZero and Hyperlane, which use committees of “validators” to facilitate message passing between chains.
While these protocols have gained adoption, their impact is limited because they integrate with individual apps rather than L2s directly. This prevents fundamental improvements like faster bridging of canonical tokens — they can only handle wrapped versions.
To improve on the current options, we need a system that enables chains to communicate directly with each other both quickly and securely without placing additional trust in centralized parties.
What’s CIRC?
CIRC is a versatile messaging protocol we’ve designed that would be able to work with any rollup tech stack or virtual machine. It would be built atop Espresso’s confirmation layer and be versatile enough to improve all forms of interop: make intent-based bridging more efficient, speed up bridging of canonical tokens, and even enable synchronous composability between chains.
Some benefits we predict include:
- Enable developers to build fast cross-chain applications that can access users across multiple chains through a single integration
- Allow users to move assets, including canonical tokens and NFTs, and data between chains with minimal friction and low latency
- Help solvers operate more efficiently and reduce capital requirements by minimizing locked liquidity across chains
Whether you’re building DeFi applications, NFT marketplaces, or cross-chain games, a protocol like CIRC would provide the infrastructure you need.
The Power of Espresso Confirmations
Modularity in blockchain infrastructure allows each component to be optimized for specific functions.
While Ethereum excels at security and decentralization, it sacrifices speed to achieve these properties, making it a poor choice to handle communication between L2s. That’s where the Espresso Network comes in.
Espresso’s confirmation layer complements Ethereum’s strengths while providing the speed needed for cross-chain communication. It’s secured by HotShot, our custom-designed Byzantine-fault tolerant (BFT) consensus protocol, which maintains its integrity as long as two-thirds of nodes are honest. The network launched on mainnet in November with a permissioned set of nodes, but will soon transition to permissionless proof-of-stake, fortifying the network further via economic security.
Anyone can use Espresso confirmations to determine a chain’s state within seconds and be confident—provided they trust Espresso’s BFT network with its two-thirds honest validator threshold—that it’d match the state they could eventually derive had they waited 15 minutes for L1 finality.
When chains integrate with Espresso, they continue to sequence their own blocks, but send them to the Espresso Network for confirmation before being published to the settlement layer. Espresso confirms blocks in under 10 seconds, a period of time that will shorten as we optimize the protocol. These confirmed blocks become immutable, as chains can only settle blocks that match those confirmed by Espresso, effectively preventing sequencer equivocation and protecting against reorgs.
This no-equivocation guarantee is achieved with a small modification to the chain’s settlement contract. (For Orbit L3s like RARI Chain, which recently integrated with Espresso, this feature is enforced by a TEE rather than modifying the settlement contract.)
Espresso confirmations alone can be powerful for improving interop. For example, intent-based solvers could use them to fulfill orders securely in seconds rather than choose between waiting 15+ minutes for finality or risky fast execution, as well as rebalance across chains more frequently.
But in this scenario, the solver is handling communication offchain, and while the user is happy to get their order filled quickly, nothing the solver is doing is enforced by the chain. For that, we need a messaging protocol built atop Espresso that allows chains to communicate directly. Add that to the mix and solvers can do more than just fulfill orders more efficiently; they can also rebalance across chains more frequently (because for that, they’d need to go through a native bridge).
CIRC is one such design for a message-passing protocol, which ensures cross-chain messages can be verified and processed quickly while maintaining strong security guarantees. Though protocols like LayerZero and Hyperlane could also fulfill those requirements by leveraging Espresso confirmations.
CIRC: A Simple Protocol with Powerful Cross-Chain Results
Just as the internet relies on protocols like TCP and HTTP for communication, blockchain networks need standardized ways to interact if we want to enable cross-chain communication at speeds that could support synchronous composability.
Existing standards are hobbled by being too specific or not versatile enough to support synchronous message passing. We returned to first principles when we designed CIRC. We wanted it to be generic enough to work with any rollup tech stack or VM, but versatile enough to support all forms of interop, from intent-based bridging to cross-chain synchronous composability.
CIRC’s Components
At its core, CIRC’s design comprises two key components:
Standardized Message Format
- Unified mailbox system with inboxes and outboxes
- Chain-agnostic message structure
- Support for both asynchronous and synchronous messaging
Coordination Mechanism
- Manages message passing between chains
- Allows any party to relay messages between chains with valid proofs
- Supports various coordination systems, including shared sequencers
- Chains can use existing escape hatches for guaranteed message delivery
CIRC’s Key Features
- VM Agnostic: CIRC does not impose any format on the messages’ content and can be enabled via smart contracts without a chain needing to modify its underlying VM.
- Parallel Execution: Different chains can process and verify their state changes independently
- Independent Settlement: CIRC is designed to enable interop between chains even if they don’t share the same settlement layer
- Cryptographic Security: Security relies on cryptographic or TEE proofs rather than relying on economic security (e.g., slashing) for safety
- Flexible Trust Levels: CIRC is versatile enough to enable chains to choose their preferred trust level:
— Chains with high mutual trust (like those sharing a sequencer) can achieve near-instant message passing.
— Chains preferring minimal trust assumptions, CIRC’s design uses trusted execution environments (TEEs) to verify messages before delivery, significantly reducing risks from invalid messages or chain reorganizations - Failsafe: CIRC is safe, even if two high-trust chains end up being malicious. That’s because even in high-trust environments everything is still enforced by Espresso + TEEs. The worst that could happen is that the two chains would have a very short reorg (around 10 seconds, covering the time since the previous Espresso confirmation).
From Theory to Practice: Accelerating Native Token Bridges
Let’s walk through an example that demonstrates how CIRC works in both low-trust and high-trust scenarios.
Low-Trust Scenario
Imagine a user wants to bridge native ARB from one Arbitrum Orbit L3 to another Arbitrum Orbit L3. In this scenario, the chains don’t trust each other.
Today, that user would be waiting an entire week before they could claim their funds on the destination chain (15 minutes for L1 finality plus 7-day fraud window). If the source chain has enabled fast withdrawals, a feature of Arbitrum’s Nitro stack, then the user could skip the 7-day fraud window, but would still need to wait at least the 15 minutes for L1 finality while the tokens are routed through Arbitrum One before being minted on the destination chain.
If that same user was bridging ARB between two Arbitrum Orbit chains plugged into the Espresso Network + CIRC, they’d have possession of freshly minted ARB tokens (not routed through Arbitrum One) on the destination chain in less than 20 seconds.
Here’s how that’s possible (diagram below):
- User submits transaction to the source chain (let’s call it L3a, and the destination chain L3b)
- L3a’s sequencer includes that transaction, which burns the user’s tokens on L3a, in a batch and sends it to the Espresso Network
- Espresso confirms that batch in <10 seconds and returns it to L3a’s validator, which is contained inside a TEE (part of CIRC’s design)
- The validator generates a TEE proof of the block and makes it available for anyone to fetch
- A relayer grabs the proof, verifies it, notices the user’s bridging transaction
- The relayer sends a transaction to mint tokens to L3b’s inbox contract (part of CIRC’s design)
- L3b’s sequencer includes that transaction in the next batch it sends to Espresso
- L3b’s TEE-encased validator receives confirmation of that batch in <10 seconds
- Sequencers for both chains eventually send their Espresso-confirmed blocks to Arbitrum One for settlement.
This whole process would take <20 seconds.
High-Trust Scenario
In a scenario where L3a and L3b trust each other, the only thing that would change is that their respective sequencers, while still publishing batches to Espresso, wouldn’t actually need to wait for blocks to be confirmed or TEE proofs to be generated (i.e., they trust each other’s sequencer to give the right state). However, even in this high-trust scenario, chains would still be safe. A malicious or hacked sequencer could still send bad information to the other chain, but the worst that would happen is that the discrepancy would be caught by Espresso and the two chains would have to reorg, but only back to the last valid Espresso-confirmed block, which would be only 10 or so seconds in the past.
Options for Synchronous Composability
While the above example drastically speeds up the canonical bridging of a native token, the two chains (L3a and L3b) are not synchronously composed.
But CIRC’s design does envision how to enable synchronous composability between chains. It requires chains to assume some additional trust assumptions, mainly use of a shared sequencer. While this might not be the right option for all L2s and L3s, it could be deployed within clusters of L2s that share other trust assumptions, such as OP Stack or Elastic chains.
Unlocking Other Use Cases
Once chains can communicate quickly and reliably (even synchronously), there’s no end to the new cross-chain applications and user experiences developers could enable by building upon Espresso and a protocol like CIRC.
Some examples include:
- Synchronously composable DeFi protocols
- Cross-chain NFT experiences
- Multi-chain lending markets
Building on Espresso: Protocol-Agnostic Foundation
While we’re excited about CIRC’s potential, Espresso’s confirmation layer is designed to support any well-designed message-passing protocol. In fact, there’s a potential future where we don’t ship CIRC.
Existing protocols like LayerZero or Hyperlane could leverage Espresso confirmations to achieve similar benefits. The key is chain-level integration with Espresso’s confirmation layer — once that foundation is in place, chains and apps (such as those already using LayerZero or Hyperlane) can implement whatever message-passing standard best suits their needs.
This flexibility is intentional. Our goal isn’t to force a single solution but to provide the foundational infrastructure that enables better cross-chain communication, regardless of the specific protocol used.
Composability is Coming
The combination of Espresso’s confirmation layer and protocols like CIRC will create a foundation for true cross-chain composability.
As more chains integrate with Espresso, we move closer to realizing the vision of a seamlessly interconnected blockchain ecosystem, where assets and information flow freely while maintaining the security and independence of individual networks.
To learn more about Espresso and how your chain can leverage the Espresso Network for fast, reliable confirmations that unlock future interop potential, check out our docs.
About Espresso Systems
Espresso Systems builds the infrastructure and incentive mechanisms to ensure that all chains can work together as one. The Espresso Network provides chains with fast, reliable confirmations of their own state, as well as the states of other chains. Its versatility also means chains can use the Network for decentralized sequencing and data availability. Espresso Research explores the design space of cross-chain composability, defines the role of the Espresso Network within it, and collaborates with design partners to develop and test innovative proposals. Founded in 2022, the company has raised $60 million from partners including a16z Crypto, Greylock Partners, and Electric Capital.
Website | Docs | GitHub | Medium | HackMD | X | LinkedIn | Warpcast | Discord | Research Forum
