Token at launch · Robinhood Chain CA not live yet Buy on Pons Chart
Chaff Open the app

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:

your appbalanceOf(you) CHAFF relaycrowd = HMAC(key, you)shuffle + random idskeep 1 answer RH Chain nodesees 16 walletsanswers all 16 1 read 1 answer 16 reads, 1 batch16 answers

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:

  1. 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.
  2. 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.
  3. 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

WhatMethodsHandling
Wallet readseth_getBalance, eth_getTransactionCount, eth_getCode, eth_call to balanceOf(a), allowance(a, s), nonces(a)Hidden in a crowd
Public readseth_chainId, eth_blockNumber, eth_getBlockBy*, eth_getTransactionByHash, eth_getTransactionReceipt, gas, other eth_callPassed through
Everything elseeth_sendRawTransaction, eth_estimateGas, eth_getLogs, signingRefused 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
ToolArgumentsReturns
private_balancesaddress, key?, k?ETH, USDG, WETH and 12 stock tokens with USD values, the crowd, reads sent, whether the wallet is in the pool
private_readmethod, params, key?Any allowed JSON-RPC read; wallet reads hidden, others passed
pool_statusnonePool 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

RouteWhat
GET /api/poolCurrent decoy snapshot: epoch, size, fromBlock, toBlock, addrs
GET /api/statusPool size and the relay's counters
POST /rpc, /rpc/<key>JSON-RPC relay
POST /mcpMCP 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/.