All articles

Devcon 8

Mumbai · 3–6 November 2026

WatchSessionSlides

Conference Talks · Part 1 of 1

The Wallet Is the New Trust Boundary

Ethereum is trustless. The wallet is not. A recap of the corpus.core talk at Devcon 8: verify reads, execute locally, and explain intent at the edge.

Steffen Kux

Title slide of the Devcon 8 talk The Wallet Is the New Trust Boundary, Verifying Ethereum at the Edge, by Steffen Kux of corpus.core

Target audience: Intermediate · 5 min read

TL;DR

  • The protocol can be trustless while the wallet still believes every RPC answer.
  • Balances, calls, logs and simulations are reads. Each one tells a provider what you hold or what you are about to do.
  • A stateless client in the wallet verifies those answers, then runs eth_call and simulation locally.
  • A valid transaction is not the same as the one you meant. Proofs establish what is true. A small local model explains what it means.

1. Trustless Protocol, Trusted Wallet

The Trustless Manifesto says anyone can join, verify and act without permission and without fear. Self-sovereignty, verifiability, censorship resistance, the walkaway test, accessibility and transparent incentives are the bar. Remove any of them and a protocol starts to behave like a platform.

Ethereum meets that bar. The wallet does not. It asks an RPC provider for balances, storage, eth_call, logs, the nonce, the gas estimate and a simulation, and it signs on what comes back. The manifesto already names the default: hosted RPCs. Every one of those answers is believed, not verified.

The line sits between the protocol and the edge. Consensus, execution and state roots are verifiable by anyone. The RPC provider, the indexer and the simulation API sit in between, and the wallet sits on the wrong side of that line.

2. Every Read Is a Confession

The same boundary leaks intent before a transaction exists.

The wallet asksThe provider learns
Balances of your addressesWhat you hold, and that the addresses belong together
Positions and allowancesYour protocols and counterparties
Pool and route queriesWhat you are about to trade, and when
A simulation of a pending transactionYour full intent, before it exists on-chain

No transaction is required. The provider sees every query, and the pattern says more than any single fact. Read privacy belongs with verification, in the client, which is the subject of Ethereum read privacy.

3. Verify What You Read

The fix is not a nicer RPC provider. It is a stateless client in the wallet. Colibri takes data and proofs from any endpoint and checks them on the device: execution proofs for accounts, storage, code and receipts against the state root, and consensus proofs that the block is canonical, down to a ZK sync proof of about 350 bytes. The endpoint becomes transport. It can lie, and the proof fails.

From that verified state the wallet stops asking what a call will do. eth_call and an unsigned transaction run in a local EVM, on the slots the call actually touches. The result is return values, transfers, approvals and state changes, including delegatecalls.

4. Valid Is Not What You Meant

Verified data is not yet a verified decision. A swap of 1 ETH for USDC can arrive with an unlimited USDT approval and 0.05 ETH sent to an address you did not choose. All of that can be valid. It is not what you meant. Bybit had valid signatures and a lying display. The question at the edge is not only "is this valid?" but "is this what I meant?"

Proofs and the EVM answer the first question. They are reproducible. A small domain model answers the second: it explains the effects and flags the ones that do not match the intent. It has to run in the wallet. A cloud model would be another trust boundary. That split is what the transaction security agent is for, and the Don't Sign Blind article covers the local model in more detail.

The training path stays on verified facts. Real transactions, Colibri proofs, a local simulation, source matched through Sourcify, and only the code path that actually ran. A frontier model can teach once, offline. The small model explains every transaction after that.

5. CROPS at the Edge

The standard the talk uses: Ethereum must remain censorship resistant, open source, private and secure. A wallet with a stateless client is how that reaches the user.

  • Censorship resistance. Any RPC is replaceable, because none of them has to be trusted.
  • Open source. Colibri is verification you can audit and run yourself.
  • Privacy. Read privacy is a protocol capability. PAP is the optional layer on the same client, not a separate app feature.
  • Security. Verify the read, the execution and the intent before you sign.

Infrastructure becomes transport. Colibri moves the trust boundary to the place where the user decides.

Watch the talk

Slides

Download the slides (PDF)

Try Colibri — Ethereum stateless client

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