Verifiable Unified Binary Trie
A modified Ethereum execution client that stores state in a binary trie and proves — inside a zkVM — that its execution matches mainnet, block by block.
The Problem
Ethereum's Merkle Patricia Trie (MPT) was designed for a pre-ZK world. Its hexary branching (16 children per node) means every state proof carries 15 sibling hashes per level — about 4,800 bytes per leaf across ~10 levels. Its nested "trie-of-tries" architecture forces double proof paths for storage access. And its RLP encoding and Keccak hashing are notoriously expensive inside zk circuits.
For PIR servers, this is especially painful: attaching Merkle proofs to database entries creates a ~150x storage blowup under MPT. A binary trie cuts this to ~40x (1,280 bytes per leaf) — and reduces per-level PIR query overhead from ~48x to ~9x. Light clients benefit similarly from the smaller, zk-friendlier proofs.
EIP-7864 proposes moving Ethereum to a binary trie, but the transition is complex and years away. The benefits of binary tries are available today, however — thanks to increasingly affordable zkVMs.
The Approach
The goal is to run a modified Ethereum execution layer (EL) client whose state representation is a binary trie conforming to EIP-7864, instead of the canonical MPT. This client syncs to the Ethereum blockchain block by block, applying the same transactions as mainnet — but writing state updates into the binary trie.
The execution of this modified client happens inside a zkVM. For each block, the zkVM produces a proof that establishes two things:
- Correct state transition — the binary trie was updated correctly according to the block's transactions.
- Block identity — the block that was applied is precisely the same block that was applied on mainnet.
To establish block identity, the zkVM proof takes as input a proof of the corresponding mainnet transition — a proof that the canonical MPT-based client executed the same block correctly. Such proofs are produced by existing L1 provers (see ethproofs.org for a list). The mainnet prover may run alongside the UBT node or be a remote service.
These proofs chain recursively: each block's proof verifies the previous block's proof, forming a proof chain back to genesis. Verifying the latest proof transitively attests that the UBT state is equivalent to mainnet state across the entire chain.
Why It Matters
- Light clients get compact, zk-verifiable state proofs over a binary structure — faster to verify and smaller to transmit than MPT proofs.
- PIR servers can serve provable state, letting clients verify that the data returned by a PIR query is authentic without trusting the server.
- Future-proofing — when Ethereum eventually adopts a binary trie (per EIP-7864), this work provides a tested implementation and a direct migration path.
- Bonus: Contributing to L1 security — EIP-7864 is very close to the metal, so the more its implementation is used and tested the more assurance that bugs and issues are surfaced early, before it is included in the L1 protocol.