Raven is a framework for fetching state from a server without revealing which record you asked for.
The server answers a question it cannot read.
Your query is encrypted before it leaves the device. The server computes over the whole database without ever learning which record you wanted. One server, so there is no non-collusion assumption to depend on.
No gigabytes to sync, no hints to keep current.
The client is hintless and compiles to WebAssembly. A browser or a phone asks for the one record it needs, instead of downloading the entire dataset just to stay private.
Answers within seconds of the chain head.
A small live sidecar absorbs new blocks in milliseconds while a heavy main engine serves the snapshot. Reads stay current without rebuilding the world on every update.
The database is a matrix. Your encrypted query is indistinguishable from noise. The server multiplies it across every row and returns a single encrypted column that only your device can open. What it sees is a query for an opaque index, and nothing more.
Before a wallet can build a proof, it reads its Merkle path and membership status from a server that holds the tree, and that read alone reveals which leaf is yours. Raven serves the read blind: the client fetches the path it needs while the operator learns nothing about which leaf was requested, and the proof is assembled locally. Shielded-pool reads and inclusion proofs share one PIR shape, a blind fetch of sibling nodes by index over an append-only tree, so the same engine serves a Privacy Pools or Railgun path and a Semaphore or World ID membership proof.
A balance or storage lookup hands your RPC provider the exact address and slot you care about, along with your IP, timing, and device fingerprint, enough to profile and deanonymize you. With hundreds of millions of active accounts, holding the state trie locally is infeasible on consumer hardware, so the read goes through a third party by necessity. Raven answers the same point reads without ever learning the target, by address or by row.
Stealth-address standards let a sender pay you at a fresh one-time address by publishing an ephemeral public key to an on-chain announcement set, which every recipient must scan to find payments meant for them. Scanning that public set through a server reveals which announcements you checked, the exact link the standard is designed to break. Raven lets a wallet scan the set blind, so the server learns neither which announcements you read nor which ones were yours.
Wallets and dapps increasingly check an address against a public list, sanctions sets, scam and address-poisoning blocklists, or an allowlist, but asking a server "is this flagged?" reveals exactly which address you are about to touch. Encoding the list as a compact approximate-membership filter answers the membership question without disclosing the queried key. Small lists are downloaded and checked entirely offline; when a list is too large to ship, the same filter is queried blind.
The main engine serves a stable snapshot with fast sublinear queries. The sidecar holds only what changed since that snapshot and rebuilds every block. The client queries both and keeps the fresher answer.
When the sidecar fills it folds into the main on a parallel copy, which swaps in atomically. No downtime, no stale window, no torn reads.
Follows the sharded PIR design for Ethereum state. Read the research →
A PIR server only ever sees a flat array of fixed-width rows and a request for row N. The mapping layer is the function from an application lookup to that row index, and Raven makes it pluggable. Pick a family to see the tradeoff:
Cuckoo hashing & PBC: SealPIR, eprint 2017/1142. Binary fuse filter: ChalametPIR, eprint 2024/092.
The query is encrypted before it leaves your device. The server computes the answer it is not allowed to read.
Verified against the on-chain root, fresh to within seconds of the chain head. Same proofs, same chain, blind reads.
