Privacy protocols on EVM blockchains have gotten good at hiding what a transaction does. Shielded pools, ZK proofs, encrypted notes. The cryptography works.
What these systems don't cover is the act of submitting it. Your IP goes to the RPC provider. The timing of your transaction hitting the mempool correlates with your network activity. The relay fee narrows who could have sent it. You can encrypt everything inside a transaction and still be fully identifiable from everything around it.
Two layers of off-chain privacy
Interacting with a blockchain privately requires hiding two separate things:
| Layer | What leaks | What hides it |
|---|---|---|
| Network layer | Your IP, request timing, submission patterns | Mixnets |
| Query layer | What data you're requesting | PIR, ORAM, TEE |
Both matter. Network privacy without query privacy means the provider knows what you asked for, just not who you are. Query privacy without network privacy means the provider can't see what you want, but they know your identity.
Nox solves the network layer.
Nox is a Sphinx mix network co-designed with an anonymous transaction relay layer for EVM blockchains. Encrypted packets pass through three mix nodes, each stripping a layer and holding for a random interval. The exit node submits your transaction on-chain. The gas fee is paid through a zero-knowledge proof from a shielded note. No IP logged, no on-chain payment linking back to you, no timing correlation in the mempool.
Open source. Deployed on Arbitrum Sepolia. Full paper here.
Why not just use Tor + a relayer?
Some projects try to fix metadata leakage by composing existing tools. Route through Tor or Nym, hand off to an independent relayer, hope the seam between systems doesn't leak.
It does. Packet timing at the exit of the anonymity layer matches transaction appearance in the mempool. Two independent privacy systems will always have a boundary, and that boundary is a correlation point. The Ethereum Foundation has explored this path from the Tor side, but Tor only covers IP privacy. Query content, timing patterns, and transaction submission are still exposed.
Tor is an onion router, not a mixnet. It forwards packets immediately to keep latency low. That preserves timing patterns. DeepCorr achieves 96% deanonymization accuracy with 900 packets. RECTor works even under noise. In 2024, German police confirmed this in practice: self-operated relays, timing surveillance, court-ordered ISP records. KAX17 showed a single operator can compromise enough relays for broad correlation.
Nox adds what Tor deliberately omits: per-hop random delay, Poisson mixing, and cover traffic. No timing signal left to correlate.
Nox builds both layers as one system. The node that decrypts your packet is the node that submits your transaction. No boundary, no seam.
| Factor | Tor | Nym | VPN | Nox |
|---|---|---|---|---|
| IP hidden from RPC | Partial | Yes | Partial | Yes |
| Timing decorrelation | No | Yes | No | Yes |
| Gas fingerprint resistance | No | No | No | Yes |
| Sender timing decorrelated from mempool | No | No | No | Yes |
| Sender/receiver unlinkability | No | Yes | No | Yes |
| Anonymous responses (SURB) | No | Yes | No | Yes |
| Native TX execution | No | No | No | Yes |
Tor and VPN are marked partial for IP hiding because exit node IPs are publicly listed and frequently blocked by RPC providers.
How a private transaction works
Your client generates a ZK proof that you can cover the relay fee, without revealing who you are. That proof is bound to the exact operation: specific contract, specific calldata, specific fee. Single-use. Can't be redirected, replayed, or reused.
The client wraps everything into an encrypted packet and sends it to a random entry node. Three hops later, the exit node has the plaintext transaction and the proof. It checks that the fee covers gas, submits both atomically, and collects the payment from a reward pool.
The exit node earns revenue. It never learns who paid.
Reads are private too
This part gets less attention, but it matters just as much.
A balance check, a contract call, a log query. All of these go through your RPC provider today, and the provider sees your IP, the addresses you're querying, how often you check. With Nox, the same query routes through the mix network. The provider sees the exit node. Never you.
Reads don't modify state, so no gas payment is needed. No on-chain trace at all. You can monitor wallets, check DeFi positions, scan for transfers, and nobody can correlate those queries back to you.
Getting replies back anonymously
Sending a request anonymously is one thing. Getting a response back without revealing who asked? Harder.
Before sending a request, your client builds single-use reply envelopes with a return path encrypted at every hop. The exit node puts its response in the envelope and sends it back through the network. Three hops later, you have the answer. The exit node never learned where it went.
For large responses, we split data across multiple envelopes with error correction baked in. The client can reconstruct the original even when packets get lost. At 10% packet loss, delivery goes from 31% to 98%. We chose upfront redundancy over retransmission because retransmission patterns are themselves a timing side channel.
Fast enough for DeFi
Every node delays every packet by a random interval, so output timing is independent of input. Nodes also generate cover traffic: loop packets and drop packets that keep baseline volume constant. Quiet periods don't reveal when real activity happens. All packets are 32 KB and structurally identical, whether they carry a swap, a health check, or noise.
In benchmarks: 58.6 microseconds per hop, 372 packets per second across ten nodes, zero loss. At production delay settings, expected end-to-end latency sits around 300 ms. Ethereum's block time is 12 seconds. Plenty of room.
Running a node
Nodes register on-chain with a stake, which publishes their public key and service URL. Layer assignment is deterministic from the address, so every participant computes the same topology without coordination.
Exit nodes earn fees by relaying transactions. The economics: simulate before submitting, check the proof's payment against gas cost, submit if profitable, skip if not. Only state-changing operations require payment. Reads and cover traffic are free, because more traffic means a larger anonymity set for everyone.
If you want to run a node: setup guide here. Questions or issues? Open a GitHub issue.
Building on Nox
Nox can route through the mixnet:
- Any HTTPS request
- EVM transactions
- Smart contract calls
- RPC queries
- ZK proof submissions
The SDK supports all of these with drop-in integration. No UX change for your users.
We've integrated Noir proofs into the mixnet. You can submit on-chain verification requests through Nox and pay for gas anonymously using our ZK payment circuit. The prover's identity never touches the chain. The gas-payment circuit itself is written in Noir and is modular, so alternative payment schemes can plug in without changing the routing layer.
Documentation and SDK reference.
What's next
Nox solves the network layer. The other half is the query layer. We're building Raven, a private information retrieval service that hides what data you're requesting from the server. Combined with Nox, both who you are and what you're asking for are hidden. More on that soon.
In parallel, we're taking the mixnet to production. If you want to try querying through the mixnet, the Nox Explorer lets you fetch balances and submit private transactions right now.