How to run a Robinhood Chain node.

Full or archive. By the arrowrpc.com team, an independent community RPC provider, not affiliated with Robinhood. Everything below comes from running our own nodes in production, with real measurements.

Robinhood Chain is an Arbitrum Orbit L2 (chain ID 4663) settling to Ethereum, launched publicly on July 3, 2026. Running your own node gets you an unmetered local RPC, trustless access to chain state, and independence from providers' quotas.

TL;DR

• Sync a full archive node from genesis in ~13 hours on decent hardware, if you use the path state scheme (--execution.caching.state-scheme=path). The default hash scheme is 18x slower and 3x larger on disk. This is the single most important flag in this guide.
• Budget ~12 GB/day of disk growth at current chain activity (either node type; archive on the path scheme is barely bigger than a full node).
• Don't panic when the first hour of syncing looks stuck. See Sync expectations.

Hardware

Network-attached storage (cloud volumes) will throttle your sync badly. The official docs warn about this and we confirm it. Single-core speed matters more than core count: block execution is largely single-threaded.

Prerequisites

1. Ethereum L1 endpoints. You need an execution RPC and a beacon (consensus) endpoint for blob data. Pitfalls we hit so you don't have to:

• Alchemy: works, but a from-genesis sync will burn a serious chunk of a free tier's monthly quota. Watch your dashboard.
• PublicNode: free tier rejects the historical eth_getLogs the node needs at initialization ("Archive requests require a personal token"). Doesn't work for bootstrapping.
• dRPC: worked for us for both execution and beacon, including the historical queries.

2. Chain config files. Grab robinhood-chain-info.json and robinhood-genesis.json from the official run-a-node docs.

3. Docker (or extract the nitro binary from the image and run it under systemd; it's the same binary either way, and Offchain Labs only distributes official builds as Docker images).

The flags that matter

--execution.caching.state-scheme=path    # THE flag. 18x faster sync, 3x smaller DB
--execution.caching.archive              # only if you want archive (historical state)
--chain.id=4663
--chain.info-files=/config/robinhood-chain-info.json
--init.genesis-json-file=/config/robinhood-genesis.json
--parent-chain.connection.url=<YOUR_L1_RPC>
--parent-chain.blob-client.beacon-url=<YOUR_L1_BEACON>
--node.feed.input.url=wss://feed.mainnet.chain.robinhood.com   # wss://, not https://
--execution.forwarding-target=https://rpc.mainnet.chain.robinhood.com
--node.staker.enable=false

If you'll serve RPC to anything other than localhost, add:

--http.addr=0.0.0.0 --http.port=8547 --http.api=net,web3,eth,arb,debug
--http.vhosts=*                          # or your hostname; default rejects non-localhost Host headers
--http.corsdomain=*                      # if browsers will call you
--ws.addr=0.0.0.0 --ws.port=8548 --ws.api=net,web3,eth --ws.origins=*

Quick start (Docker, full node)

mkdir -p ~/rh/config ~/rh/data   # put the two config JSONs in ~/rh/config

docker run -d --name rhnode --restart unless-stopped \
  -v ~/rh/data:/home/nitro/.arbitrum \
  -v ~/rh/config:/home/nitro/config \
  -p 8547:8547 -p 8548:8548 \
  offchainlabs/nitro-node:v3.11.2-3599aca \
  --chain.id=4663 \
  --chain.info-files=/home/nitro/config/robinhood-chain-info.json \
  --init.genesis-json-file=/home/nitro/config/robinhood-genesis.json \
  --execution.caching.state-scheme=path \
  --parent-chain.connection.url=<YOUR_L1_RPC> \
  --parent-chain.blob-client.beacon-url=<YOUR_L1_BEACON> \
  --node.feed.input.url=wss://feed.mainnet.chain.robinhood.com \
  --execution.forwarding-target=https://rpc.mainnet.chain.robinhood.com \
  --node.staker.enable=false \
  --http.addr=0.0.0.0 --http.port=8547 --http.api=net,web3,eth

For an archive node add --execution.caching.archive. Mount data on your NVMe; the container writes as the nitro user, so the volume must land at /home/nitro/.arbitrum.

Optional performance env (measured ~5% on block execution): -e GOGC=400 -e GOMEMLIMIT=<half your RAM>GiB.

Sync expectations

This is where most people think something is broken. It isn't:

• First ~10 minutes: the node grinds through the chain's private pre-launch period (April 30 to July 3, 2026), which is nearly empty. Block numbers barely move while L1 timestamps fly by. You may see ~11 blocks/s and log lines like Reading message result remotely. This phase does not predict your sync time.
• Then it takes off: through the dense post-launch history we sustained ~200 blocks/s (archive, path scheme). Total from genesis to tip: 12 h 38 m on the recommended hardware above.
• At tip the node follows the sequencer feed, with the head typically ahead of the public RPC by a few blocks.

With the default hash scheme instead of path, the same sync measured ~11 blocks/s sustained: roughly two months. Use the path scheme.

Disk math

Measured at ~8M transactions/day of chain activity (mid-July 2026):

• Archive node (path scheme): 92 GB for the full chain to block 9.7M, growing 11–12 GB/day
• Hash-scheme archive (don't): 70–86 kB per block, ~330 GB before we killed it, still not at tip
• Chain data alone (bodies/receipts, irreducible for any node type): ~14 kB/block average

Plan disk for a year, not a month, and remember growth scales with chain activity. Recheck the numbers after launch-hype settles.

Snapshots: skip the sync entirely

Nitro supports initializing from a snapshot: --init.url=<SNAPSHOT_URL> on first start. Robinhood doesn't publish official snapshots yet; we publish periodic pruned snapshots at arrowrpc.com so you can be at tip in roughly the time it takes to download and extract.

Gotchas we hit

• eth_config 400 errors in logs against some L1 providers: benign. The node polls an optional endpoint and falls back to static config.
• Blob retention: beacon nodes prune blobs after ~18 days, but a genesis sync needs blobs from April 30, 2026. Use a beacon endpoint that serves historical blobs (dRPC worked for us), or start from a snapshot and sidestep the whole problem.
• invalid host specified when calling your node through a domain: that's --http.vhosts (default localhost). IPs pass, hostnames need the flag.
• 429s from your L1 provider mid-sync: add retry flags (--parent-chain.connection.retries=15 --parent-chain.connection.retry-delay=200ms) and watch your quota.
• Early-sync rate extrapolation: whatever blocks/s you measure in the first 15 minutes, it's wrong (see above). Measure after the node reaches July 2026 history.

Verifying your node

# at tip?
curl -s -X POST http://localhost:8547 -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
# compare with the public tip at https://rpc.mainnet.chain.robinhood.com

# archive actually serving history? (answer must equal the block you ask at, not the head)
curl -s -X POST http://localhost:8547 -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{"to":"0x0000000000000000000000000000000000000064","data":"0xa3b1b31d"},"0x1e8480"]}'

That second probe calls ArbSys.arbBlockNumber() at block 2,000,000. An archive node returns 0x1e8480; a node silently serving head state returns the current block. Test with a value that must vary by height, not a constant.