atmos

atmos

Anonymous Ethereum RPC that is fast enough to leave on.

Run it on your machine

curl -fsSL https://atmos.xavio.dev/install.sh | sh

Then add this to MetaMask as a Sepolia network

http://127.0.0.1:8545/11155111

Needs Node 24 or newer. Install guide

Hiding the IP is the first step, not the last

anon-rpc lets a wallet send its RPC calls through an anonymity network from inside a sandboxed, hash-pinned worker. Atmos is a client layer on top of it. It makes that path fast and reliable enough to leave on by default, and then works on what a provider can still see.

What anon-rpc does

A wallet creates an AnonRpcWorker from a specifier contract address. The harness reads the worker’s hash from the chain, fetches the bundle, checks its hash and runs it in a sandbox with a small capability API. The wallet gets back an anonymous fetch. Nym, Nox and Tor each ship a worker. The provider sees an exit’s IP address instead of the user’s.

What a provider still sees

Removing the IP is one of five things an RPC user needs:

PropertyBehind stock anon-rpc
P1ContentThe provider sees every address and every call. An address is an identity.
P2LinkageCalls on one session link together, and sessions can be re-linked by their timing.
P3IntegrityNothing checks the answers. Both the provider and the exit could lie.
P4AvailabilityA provider can refuse anonymised traffic, and some do.
P5WritesA signed transaction names its sender, whatever the IP.

On top of that, the anonymous path is slow in ways a wallet notices: parallel reads queue behind fresh connections, the first call to each provider costs seconds, and a worker can report ready on a route that is already dead.

What Atmos adds, in three stages

One read, end to end. The request crosses your machine, then the mixnet, and the reply comes back on its own route:

A request leaves the wallet through the local host, the SDK and the sandboxed Nym worker, then crosses the entry gateway, three mix layers and the exit to the RPC provider. The reply comes back on its own route. A standby route stays warm.Nym mixnetWalletLocal host127.0.0.1:8545Atmos SDKroutes, batches, checksNym workeranon-rpc's sandboxEntryMix 1Mix 2Mix 3ExitIPRRPC providerstandby route, warm · routes rotate about every 10 minutes
request reply, on its own reply path · only the Nym directory and the entry gateway see your IP; the provider sees the exit

v1: the harness layer (built)

v1 wraps the stock browser harness. It needs no change to any network’s worker.

  1. Route selection from public data. Atmos picks the entry gateway and the exit uniformly from the Nym directory’s top performance band, and checks that the entry answers. Choosing uniformly from public data uses nothing about the client.
  2. A probe before trust. A worker counts as usable only once a real call gets through. ready alone does not prove the route works.
  3. A standby route. A second worker boots on a different exit. If a call stalls, traffic moves to the standby, and a new standby boots behind it.
  4. Batch, don’t fan out. Calls issued together to one provider go out as a single JSON-RPC batch, one request in flight per provider. Each provider’s batch limit is respected.
  5. Careful writes. A transaction in flight is never sent twice, and is never raced or retried on another route.

v2: verified and shaped

  • Proof-checked reads (built). A light client follows the sync committee’s signatures to a trusted head. Balances, nonces, code and storage are checked with eth_getProof against that head’s state root. eth_call runs locally on proven state, and receipts are checked against the block’s receipts root. A lying exit or provider can cause a failure, never a wrong answer.
  • Constant-rate traffic (built, opt-in). Off by default. Padded batches leave on a fixed schedule with a random phase per session. In our model, that brings timing re-linkage down to chance, and measured on outgoing requests an observer was at chance too. Replies are not padded, so incoming traffic is not covered.
  • Provider splitting (not yet). Each address read from one provider, on its own session, so no single provider sees the whole set.

How a read is proven before your code sees it:

Sync-committee signatures give a verified head; its state root checks the provider's proof; only then does the answer reach your code. A wrong proof ends in a failure, never a wrong answer.Sync committeesigned by 512 validatorsVerified headlight clientState rootin that headerProof checkedeth_getProofAnswerto your codeRPC provider sends the valueand its Merkle proofeth_call runs in alocal EVM on proven statea proof that does not match:a failure, never a wrong answer

What the constant-rate schedule changes for someone watching the traffic:

Without shaping, requests leave in bursts when the wallet is busy. With shaping they leave on a fixed clock, one per slot, with dummies filling the empty slots, so an observer sees the same steady stream either way.Not shapedbursts show when you are busyShapedone per slot, dummies in the gapswhat an observer sees on the shaped lane: one packet a slot
a call you made a dummy · covers outgoing requests; replies are not padded

Access-list updates (built, experimental). Every block’s EIP-7928 access list is the same for every client, so fetching it names nobody. Atmos checks each list against the block header and applies it to the accounts it already holds, so reading one of them again sends nothing. It works only while it keeps pace with the chain; when it falls behind, reads fall back to proofs.

Every block's access list is fetched, the same list for every client, and checked against the block header. It updates the accounts already held, so reading one of them again answers locally and sends nothing.Each new blockthe same list for everyone, checked against the headerAccounts you holda repeat read is answeredhere: no request names itexperimental: only while it keepspace; behind, reads fall back to proofs

v3: the transport (planned)

A modified build of the Nym client’s network stack: a warm pool of connections per provider, safe retries for idempotent reads, and HTTP/2. This needs a fork, which is why it comes last.

What it costs

Every stage trades something. Batching and failover cost nothing in privacy terms. Proofs make each read 150–250 times larger, which matters on a mixnet: about 70 ms per KB of reply in our measurements. Constant-rate traffic adds about one slot of waiting to every call. The benchmarks measure what each stage actually buys.