Disclaimer: The following blog is a proposal from the Account Abstraction team. Content may not imply consensus views, and the EF is a broad organization that includes a healthy diversity of opinion across Protocol and beyond that together strengthen Ethereum.

Since the early days of Ethereum, the promise has always been bold: a global, permissionless, censorship-resistant computing platform. Today, that promise is more alive than ever. Ethereum has scaled through rollups, where blockspace is abundant and transactions are cheap. The challenge now is not just throughput, but seamless user experience across that multichain horizon.

What if all the L2s felt like a single, unified Ethereum?

No bridges to think about, no chain names to recognize, no fragmented balances or assets.

That’s the vision of the Ethereum Interop Layer (EIL): making Ethereum feel like one chain again — while preserving the trust-minimized, decentralized foundations we all care about.

EIL makes Ethereum’s rollups feel like a single, unified chain by enabling users to sign once for a cross-chain transaction without adding new trust assumptions. Built on ERC-4337 account abstraction and the principles of the Trustless Manifesto, users themselves initiate and settle cross-L2 actions directly from their wallets, not through relayers or solvers. EIL preserves Ethereum’s core guarantees of self-custody, censorship resistance, disintermediation, and verifiable onchain execution. This new account-based interoperability layer unifies Ethereum’s fragmented L2 ecosystem under Ethereum’s own security model.

The problem: fragmentation at scale

L2 chains have brought dramatic gains in throughput and cost-efficiency. Yet they’ve introduced a new kind of complexity for users and wallets:

• Which chain is my token on?
• How do I move tokens from Arbitrum → Base → Scroll → Linea?
• Do I need to trust a third-party bridge or relayer?
• Does my wallet or dapp need to manually integrate every new chain?

From a user’s perspective, the result is less Ethereum and more multiple separate Ethereums. You’re managing chains, not simply transacting. That creates friction, cognitive overhead, and often exposure to additional trust assumptions — bridges, relayers, solvers — along with increased censorship risk.

The vision: many L2s, one Ethereum

Imagine this instead:

You open your wallet, choose an asset and an address, and hit Send.

Your wallet figures out which chain it’s on and how to deliver the asset — behind the scenes.

You mint an NFT, move tokens, trade assets — and it doesn’t matter which rollup you or the counterparty are on, or where the dapp is deployed.

New networks join the ecosystem, and your wallet just works with them — no custom integrations, no reliance on off-chain operators.

That’s EIL. It’s about wallet-centric multichain UX: the wallet becomes your universal window into the Ethereum ecosystem, and the network feels like one seamless experience rather than a patchwork of islands.

In a sense, EIL is to Ethereum what HTTP was to the early Internet.

Before HTTP, users could connect to individual servers — but not seamlessly combine them in one flow.

HTTP unified the experience, letting browsers traverse servers effortlessly.

EIL aims to do the same for Ethereum’s rollups: bringing Ethereum into its “web era”, where wallets act like browsers and users navigate freely across L2s without friction.

What it takes: trust assumptions, preserved

Unity of UX is compelling — but only if it doesn’t compromise Ethereum’s core values:

• Self-custody: users hold their assets and initiate transactions themselves.
• Censorship-resistance: no intermediary can block or delay your transaction.
• Privacy: you don’t have to reveal your IP address or intentions to a relayer or solver.
• Verifiability: any logic that matters can be checked onchain or in open-source wallet code.

EIL was designed according to the trustless manifesto. It moves the logic onchain and into the user’s wallet, removing dependence on intermediaries and opaque server logic. Users transact directly on all chains; trustless liquidity providers supply funds but never interact directly with users, nor see their transactions.

Instead of “I trust a bridge operator to move my funds,” you get “my wallet and contract do it — under verifiable rules.”

The trust boundary remains minimal.

Ethereum is about disintermediation — interop should be as well

Ethereum’s great innovation is replacing intermediaries with verifiable code.

Crypto once depended on centralized exchanges (CEXs) until Ethereum made decentralized exchanges (DEXs) possible — no need to trust a custodian, no counterparty risk, just a verified smart contract. DeFi changed the world by offering an intermediary-free alternative to TradFi.

Cross-L2 interop still resembles a CEX model, with bridge operators, relayers, solvers, and opaque off-chain infrastructure.

Transacting across L2s should be as trustless as using a DEX.

EIL moves the logic onchain and into the user’s wallet, removing dependence on intermediaries and opaque server logic. Users transact directly on all chains; trustless liquidity providers supply funds but never interact directly with users, nor see their transactions.

From the user’s view: how it feels

• Cross-chain transfer — Alice has USDC on Arbitrum, Bob is on Base.
  In one click, her wallet executes a transfer to Bob’s Base address. From Alice’s point of view: “Send USDC to Bob” — she doesn’t care which network it happens on.

• Cross-chain mint — Alice holds ETH on Arbitrum and Scroll. She wants to mint an NFT on Linea.
  Her wallet automatically consolidates balances and handles inter-chain gas and asset movement transparently. One click, one signature.

• Cross-chain swap — Alice finds better liquidity for her token on an Optimism DEX.
  She swaps from Arbitrum, her wallet handles the path, and she ends up back on Arbitrum with her new token — no bridging, no manual steps.

For the user it’s: “Send, mint, swap — I just do what I want.”
Behind the scenes it’s: “Wallet + onchain protocol transact across chains — no new trust requirements.”

Why this matters for the ecosystem

When interoperability becomes a wallet-level capability instead of an app-by-app integration, the entire ecosystem advances:

• Wallets and dapps become multichain-native by default.
• New rollups are automatically compatible, accelerating adoption.
• Developers can focus on building great experiences, not wiring up cross-chain plumbing.
• Users reclaim the simplicity of Ethereum: one wallet, one signature, many chains — one experience.
• Most importantly, Ethereum’s trust-minimized model remains intact without new intermediaries.

This brings us closer to the original promise: a world computer that is global, open, seamless and trustless.

The bottom line

Ethereum has already scaled. What’s lagged is the feeling of unity.

The Ethereum Interop Layer is the next step toward that unity — where your wallet is your portal, and every rollup feels like Ethereum’s native extension rather than a separate silo.

We invite wallet teams, dapp builders, network designers, and the broader ecosystem to join this journey.
Together, we can make Ethereum not just scalable — but seamlessly singular.

Let’s make Ethereum feel like one chain again.