Reference
Chaff docs
CHAFF is a JSON-RPC relay for Robinhood Chain (chain id 4663). Any read that names a wallet goes to the node as k reads of the same shape, one per wallet of a crowd: yours plus k-1 real wallets that have moved tokens on the chain. The node answers all of them. Only your side knows which answer it wanted.
How it works
One balance read, server mode, k = 16:
In client mode the box in the middle moves into your app: src/client.js builds the crowd with your key, and the relay only checks the methods and forwards the batch. Then the relay sees 16 wallets as well.
Crowd rules
A crowd only helps if repeated reads don't leak. Three rules, each enforced in src/chaff.js and covered by tests:
- One wallet, one crowd. Every read about wallet R (ETH, USDG, every stock token, its nonce) uses the same k-1 decoys. Otherwise R would be the only address present in both the USDG crowd and the NVDA crowd.
- Sticky. The crowd is the k-1 pool wallets with the highest
HMAC-SHA256(key, R || D)(rendezvous hashing). Same key, same crowd, so stacking a month of node logs narrows nothing. When the pool grows, most of a crowd stays put. - Keyed by you. Without the key nobody can recompute crowd(R), so a node can't test "whose crowd would look like this one".
Also: the batch order is shuffled with a CSPRNG, every element gets a fresh random id, and the from, gas and value fields of hidden eth_calls are dropped, since from would name you anyway. A unit test checks that the real read lands in every position of the batch about equally often.
Decoy pool
Decoys are real externally owned wallets (no contracts) seen in Transfer logs of USDG, WETH, the 12 stock tokens and any token traded on Pons. The relay scans the newest blocks every 4 minutes and random windows of the last 7 days every 45 seconds, checks each address with eth_getCode, and keeps up to 8,000. A snapshot of up to 4,096, sorted by address, is served at /api/pool. Members of the last snapshot stay while they are still active, so crowds barely change between snapshots.
Why this matters: a decoy that never moved tokens would look fake next to a wallet that trades. Pool wallets all look like people who use the chain.
RPC endpoint
POST https://chaffrpc.xyz/rpc/<key> # key = 16 to 64 bytes of hex, made once and kept POST https://chaffrpc.xyz/rpc # no key: a fresh crowd per request (weaker, see limits) ?k=16 # crowd size 4 to 32
Single requests and batches (up to 40) are accepted. Answers keep your ids and your order. The response header x-chaff-crowd says how many wallets the node saw.
curl -s https://chaffrpc.xyz/rpc/$KEY -H 'content-type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{"to":"0x5fc5360d0400a0fd4f2af552add042d716f1d168","data":"0x70a08231000000000000000000000000<wallet>"},"latest"]}'
Make a key: node -e "console.log(crypto.randomBytes(32).toString('hex'))" or the button on the home page.
Methods
| What | Methods | Handling |
|---|---|---|
| Wallet reads | eth_getBalance, eth_getTransactionCount, eth_getCode, eth_call to balanceOf(a), allowance(a, s), nonces(a) | Hidden in a crowd |
| Public reads | eth_chainId, eth_blockNumber, eth_getBlockBy*, eth_getTransactionByHash, eth_getTransactionReceipt, gas, other eth_call | Passed through |
| Everything else | eth_sendRawTransaction, eth_estimateGas, eth_getLogs, signing | Refused with a reason |
MCP tools
Streamable HTTP, stateless, at https://chaffrpc.xyz/mcp. Read-only.
claude mcp add --transport http chaff https://chaffrpc.xyz/mcp
| Tool | Arguments | Returns |
|---|---|---|
private_balances | address, key?, k? | ETH, USDG, WETH and 12 stock tokens with USD values, the crowd, reads sent, whether the wallet is in the pool |
private_read | method, params, key? | Any allowed JSON-RPC read; wallet reads hidden, others passed |
pool_status | none | Pool size, block range, relay counters |
Give your agent one secret key per user and have it pass the same key on every call. Prices in private_balances come from Chainlink feeds on Robinhood Chain (stocks) and the Uniswap v3 quoter (ETH in USDG).
Client mode
Three small ES modules with no dependencies: chaff.js, client.js, sha256.js (plus assets.js for the token list). They run in the browser and in Node 18+.
import { createChaff, newKey } from "https://chaffrpc.xyz/src/client.js";
const chaff = createChaff({ endpoint: "https://chaffrpc.xyz", key: MY_KEY, k: 16 });
const rows = await chaff.balances(me); // ETH, USDG, WETH, 12 stock tokens
const bal = await chaff.eip1193.request({ method: "eth_getBalance", params: [me, "latest"] });
// viem
const client = createPublicClient({ transport: custom(chaff.eip1193) });
The client fetches the pool snapshot, builds the crowd locally, sends the batch with x-chaff-client: 1, and keeps only its answers. The relay checks every element against the method list and forwards the batch unchanged.
HTTP API
| Route | What |
|---|---|
GET /api/pool | Current decoy snapshot: epoch, size, fromBlock, toBlock, addrs |
GET /api/status | Pool size and the relay's counters |
POST /rpc, /rpc/<key> | JSON-RPC relay |
POST /mcp | MCP endpoint |
Rate limit: 120 wallet reads a minute per IP on /rpc (a crowd counts once), 60 MCP calls, 120 API calls.
Limits
- No key, weaker crowd. Without a key each request gets a fresh crowd, and a node that sees two reads of the same wallet can intersect them. Always use a key for repeat reads.
- Quiet wallets. A wallet that has not moved tokens recently is not in the pool, and a node with its own index could notice it is the odd one out.
- Server mode trusts the relay. It builds the crowd, so it knows the wallet. It writes nothing down, but client mode removes the need to trust that.
- The relay picks the pool. In client mode a dishonest relay could serve a tiny or crafted pool. The client refuses pools smaller than 4k, and the snapshot is public, so anyone can compare it with the chain.
- Your IP. The node sees the relay's IP. The relay sees yours. Use Tor or a VPN if that matters.
- Timing. A read right before a transaction can be linked to it by time. Transactions are public.
- Unrecognised eth_calls pass unchanged. If you put your address in their calldata, the node sees it.
- Live beta. Not audited.
Self-host
git clone <repo> chaff && cd chaff npm test # unit tests, no network node serve.mjs 7104 # no npm packages needed
Node 20+. The server resolves the official RPC over DNS-over-HTTPS and falls back to the publicnode mirror for reads. Data (pool, settings, counters) lives in data/.