All articles

colibri.stateless now verifies EEZ rollups

colibri.stateless 3.1 adds experimental support for Ethereum Economic Zone rollups: verify RollupX data on the device, anchored in Ethereum consensus, without trusting the RPC provider.

Simon Jentzsch

A glowing cube hangs above a chain of smaller blocks, with a wireframe hummingbird beside the line that connects them

The latest colibri.stateless release (3.1) adds experimental support for rollups of the Ethereum Economic Zone (EEZ). Your wallet or dApp can now verify data from an EEZ rollup on the device, anchored in Ethereum's own consensus, without trusting the RPC provider that served it. The first supported chain is RollupX (chain ID 696991), the EEZ development network that settles to Ethereum mainnet.

Why EEZ matters

EEZ is designed to make cross-chain transactions atomic: one transaction can execute across Ethereum and a rollup, and either everything happens or nothing does. Today's rollups mostly live in separate silos. Moving value between them means bridges, waiting times and fragmented liquidity, and that fragmentation is exactly the problem EEZ targets (BlockEden).

With synchronous composability, a contract on an EEZ rollup can call a contract on L1 inside the same transaction and act on the result. In practice, liquidity that lives on one chain becomes usable from another. A swap on a rollup can, for example, tap an AMM pool on mainnet atomically, without first bridging funds or trusting an intermediary.

EEZ is developed by Gnosis and ZisK with funding from the Ethereum Foundation (crypto.news). At Devcon 8 in Mumbai, the team presented live demos of atomic cross-chain execution, among them a CoW Swap order on RollupX that was filled with liquidity from Ethereum mainnet (crypto.news).

The most visible commitment comes from Gnosis Chain itself. In August 2026, GnosisDAO approved GIP-153: Gnosis Chain will retire its own validator set and become an EEZ rollup that settles to Ethereum (Cointelegraph). According to Gnosis, the switch is planned via a hard fork in spring 2027. Contracts, balances, addresses, the chain ID and xDAI as gas token stay the same, so nothing needs to be redeployed (ChainCatcher). Gnosis Chain would then be the first general-purpose zone in EEZ.

For colibri.stateless this matters directly: we already verify Gnosis Chain today through its own consensus. Once Gnosis Chain settles to Ethereum, the EEZ path described below is how its data will be verified.

How colibri.stateless verifies an EEZ rollup

colibri.stateless is a stateless light client: it verifies RPC responses directly on the device, without syncing any chain data. Until now it supported L1 chains such as Ethereum mainnet, Gnosis Chain and Sepolia, as well as OP Stack rollups like Base and Optimism. This release extends verification to EEZ rollups.

An EEZ rollup settles to Ethereum through the EEZ manager contract (a proxy) on L1. For every rollup, this contract stores the hash of the latest committed L2 block. That single value is the bridge colibri.stateless needs, and the verification follows from it in three steps:

  1. Prove the L1 head. As before, colibri.stateless verifies the current Ethereum block header using the BLS signature of the sync committee.
  2. Prove the latest committed L2 block hash. A storage proof against the verified L1 state root yields the L2 block hash stored for the rollup in the EEZ manager contract. With it, the L2 block header committed on L1 is verified, including its state root.
  3. Prove the target block. If the requested block is older than the committed one, colibri.stateless uses EIP-2935. This system contract keeps the hashes of the last 8191 blocks in the L2 state, so a second storage proof against the committed block's state root yields the hash of the target block. If the requested block is the committed block itself, this step is skipped.

From the verified target header, colibri.stateless proves the actual response as usual: account and storage proofs for eth_getBalance or eth_call, transaction and receipt proofs for transactions and logs.

Technically, this is built on nested execution-layer proofs: an EL_PROOF can carry another EL_PROOF for the next chain level (definition in the code). The same verifier logic that proves an account on mainnet therefore proves the L2 block hash, and then the state of the rollup.

What you still trust

colibri.stateless removes the RPC provider from the trust model. It does not remove the rollup's settlement from it. What the client proves is that the response belongs to an L2 block whose hash Ethereum's sync committee has attested as stored in the EEZ manager contract. That this block is the result of a correct state transition is guaranteed by the proof system EEZ uses for settlement, and the contract itself is an upgradeable proxy.

This is the same model as for any rollup: the verifier is exactly as strong as the chain of commitments it checks. Our job is to make sure no unverified link is added on the way to your device.

Current limits and next steps

In this first phase, colibri.stateless can verify requests for the latest committed L2 block and its 8191 predecessors. As a consequence, latest (as well as safe and finalized) means the latest block whose hash has been committed on L1, not the newest block the sequencer has produced.

How old that block is depends on the activity on the rollup:

  • No activity: the rollup commits roughly every 4 hours. The committed block can then be hours old, but since no transactions happened in between, the rollup state is unchanged. Note that eth_call is executed in the context of that block, so results that depend on block.timestamp reflect the time of the committed block.
  • Pure L2 transactions: the commitment follows within about 15 minutes at most.
  • Cross-chain transactions: the block hash is committed on L1 right away, so the result is verifiable within the next Ethereum blocks.

For wallet developers this has a practical consequence: a freshly sent L2 transaction only becomes verifiable once its block is committed. Until then, its receipt cannot be proven yet, and the nonce returned for latest does not include it, so wallets should track pending nonces locally.

The next milestones close these gaps step by step:

  • Recent blocks. We will verify blocks that are not yet committed on L1. The goal is to reuse the same proof system that EEZ already uses for settlement, and to verify its attestations off-chain instead of waiting for the L1 commitment.
  • Historical blocks. Blocks older than the 8191-block window will be proven through the L2ExecutionPerformed event of the EEZ manager contract. Each such event marks an older committed L2 block hash, and together with cached EIP-2935 data it gives colibri.stateless an anchor for any historical target block.
  • Cross-chain simulation. Finally, we will verify the simulation of cross-chain transactions, so a wallet can check what an atomic L1/L2 transaction will do before it is signed.

Try it on RollupX

EEZ support in colibri.stateless is experimental, and so is EEZ itself. But you can already try it on RollupX, the EEZ development network on Ethereum mainnet. colibri.stateless acts as your RPC provider: every response is verified on your device, from the L1 sync committee down to the RollupX block.

From the command line:

colibri-verifier -c rollupx eth_getBlockByNumber latest false

Or in JavaScript, using colibri.stateless as the EIP-1193 provider for ethers (v6):

npm install @corpus-core/colibri-stateless@^3.1.1 ethers
import { BrowserProvider } from "ethers";
import Colibri from "@corpus-core/colibri-stateless";

async function main() {
  // Initialize the client with the default configuration and RPCs
  const client = new Colibri({ chainId: "rollupx" });

  // Use the Colibri client as the EIP-1193 provider for ethers (v6)
  const provider = new BrowserProvider(client);

  // Fetch the latest committed block using the ethers provider
  const block = await provider.getBlock("latest");
  console.log("Block fetched via ethers:", block);
}

main().catch(console.error);

We would love to hear your feedback in the colibri-stateless repository.

Sources

Try Colibri — Ethereum stateless client

Verify blockchain data locally with cryptographic proofs. No trusted RPC required.