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. Your IP stays with the entry node, the fee is paid from a shielded note, and per-hop random delays spread the timing between your request and its arrival in the mempool.

Open source. Deployed on Arbitrum Sepolia. Full paper here.

Nox builds the anonymity network and the transaction relay as one system: the exit that decrypts a request is the exit that submits it, and the relay fee is paid from shielded notes. Random per-hop delays and node cover traffic run today; default-on client cover is the next milestone.

Each hop adds an independent random delay, and timing resistance grows with traffic volume.


How a private transaction works

Packets flow through three hops: entry, mix and exit. Each node strips a layer of encryption and delays randomly before forwarding.

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 fresh random interval, so departure order does not follow arrival order. Nodes also generate cover traffic: loop packets and drop packets on a Poisson schedule that give real traffic a crowd to hide in. 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, with every packet delivered. With a 100 ms mean delay per hop (an evaluation setting; the testnet runs 40 ms), expected end-to-end latency sits around 300 ms. Ethereum's block time is 12 seconds. Plenty of room.

Full benchmark data here.


Running a node

Nodes register on-chain with a stake, which publishes their public key and service URL. Every participant derives the same topology from the on-chain registry; strict per-layer roles are the next milestone.

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 the same wallet UX 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 toward mainnet. If you want to try querying through the mixnet, the Nox Explorer lets you fetch balances and submit private transactions right now.


Links