Run an Atmos endpoint
A wallet that only takes an RPC URL, such as MetaMask, can still use Atmos. `atmos-host` is an open-source server that gives the wallet an ordinary URL and sends every call on through Nym, checked against a light client. Sepolia only, for now.
Who sees what
| Where the host runs | The host’s operator sees | RPC providers see | Who the wallet trusts |
|---|---|---|---|
| Your own machine | nothing beyond you | your queries, not your IP | your own host, which checks the proofs |
| Someone else’s server | your IP and your queries | your queries, not your IP | that operator: the wallet can’t check proofs itself |
Run it yourself to keep anon-rpc’s guarantees. A host run by someone else still keeps your IP from the providers, and any operator can be swapped for another, but that operator could answer falsely.
Run it
You need a trusted Sepolia beacon block root as the starting point. Take a recent finalized root from more than one source and check they agree. The light-client source does not serve every root: if GET / reports bootstrap not served for checkpoint, start again with another recent finalized root.
The worker can run in one of two places, set by ATMOS_RUNTIME:
| Runtime | Where the worker runs | Image | Status |
|---|---|---|---|
node (default) | the Node harness, in a V8 isolate with no browser | Node base image | verified on Sepolia: a 5-minute wallet-style session answered 73 of 73 calls, 69 of them verified |
chromium | anon-rpc’s browser harness, in headless Chromium | about 3.8 GB | verified on Sepolia |
With Docker, from the repository root:
# Node runtime (default)
docker build -f host/Dockerfile.node -t atmos-host .
docker run -p 127.0.0.1:8545:8545 -e ATMOS_CHECKPOINT=0x… atmos-host
# Chromium runtime
docker build -f host/Dockerfile -t atmos-host:chromium .
docker run -p 127.0.0.1:8545:8545 -e ATMOS_RUNTIME=chromium -e ATMOS_CHECKPOINT=0x… atmos-host:chromium From source, with Node 24 or later:
cd harness && npm install && npm run build && cd .. # Node runtime
cd host
npm install
npx playwright install chromium # Chromium runtime only
npm run build
ATMOS_CHECKPOINT=0x… npm start # or ATMOS_RUNTIME=chromium … The host is yours alone by default. It answers only at 127.0.0.1 or localhost, and only to wallet extensions and clients that send no browser origin, so websites you visit can’t use it or tell that it is running. List extra browser origins in ATMOS_ORIGINS (comma-separated). An open host for others sets ATMOS_PUBLIC=1, which accepts any host name and origin. Request bodies are capped at 4 MiB.
The host waits for a working route before it answers, which takes from about 15 seconds to two minutes. GET / reports the runtime, whether it is ready, and counts answers by kind.
Set ATMOS_SHAPE=1 to send every outgoing call on the constant-rate schedule. Every provider gets a fixed number of calls on a fixed clock from the moment the host starts, with dummy calls filling the empty places, so the count and size of the requests that leave stop showing when the wallet is active.
What it changes, measured on Sepolia: an observer of the host’s outgoing traffic tried to tell 12-second windows of wallet activity from idle ones, using the best threshold chosen with hindsight. 50 % is chance; each figure was compared with 2,000 shuffles of the idle and busy labels.
| Requests per window | Bytes per window | Head (beacon) checks | |
|---|---|---|---|
| Shaping off | 98.6 % right | 98.6 % right | 51.4 % (chance) |
| Shaping on | 52.1 % (chance) | 60.4 % (chance) | 50.0 % (chance) |
In shaped mode every request body is also padded to 2 KB, so each one enters the mixnet at the same size; the observer’s accuracy on bytes in the tunnel was 56.9 %, again chance.
These figures cover requests only. Replies are not padded: they come from the provider at their own size, and through Nym a larger reply becomes more return packets at the entry gateway. A proof or an eth_call result can differ in size from a dummy’s reply, so an observer of incoming traffic may still tell busy windows from idle ones. That has not been measured yet.
What it costs:
- Latency: about one slot per call, at most 4 s for reads and 8 s for proofs.
- Constant load: about 3 calls a second in total, sent to the providers around the clock whether or not anyone uses the wallet. That load is why shaping is off by default on free providers.
- What it doesn’t hide: the size of the providers’ replies, which the exit can still see.
Point a wallet at it
Add http://127.0.0.1:8545/11155111 as an RPC endpoint for Sepolia (chain ID 11155111). The path selects the chain; other paths return an error.
What gets checked
| Calls | How |
|---|---|
eth_chainId, net_version | answered locally |
eth_getBalance, eth_getTransactionCount, eth_getCode, eth_getStorageAt | proven with eth_getProof against the verified head |
eth_blockNumber, eth_getBlockByNumber / ByHash without transactions | the header hashes to a block hash the light client trusts (within 64 blocks of the head) |
eth_call | executed locally on proven state; a revert comes back as a revert |
eth_getTransactionReceipt | the block’s receipts rebuild its receipts root |
eth_estimateGas | the call is proven to succeed; the gas figure itself is the provider’s |
eth_gasPrice, eth_maxPriorityFeePerGas | base fee from a verified header; the tip is the provider’s, capped at 2 gwei |
eth_sendRawTransaction | sent on; the returned hash must equal the transaction’s hash |
| anything else | passed through unchecked, and counted |
A check that fails returns an error. It never falls back to an unchecked answer.
Costs
- A verified read takes about 1–2 seconds;
eth_call3–8 seconds. - The first receipt from a block takes 20–40 seconds, because the whole block’s receipts come through the mixnet. Later receipts from the same block are immediate.
- Each host allows 20 calls in flight per client address and batches of up to 20.