Proximity,
not privilege.
Everyone trading Robinhood Chain reads it through the operator’s public RPC, which serves a transaction once it has been executed and indexed. We read the sequencer feed at the source, which carries the signed transaction before any of that happens. The difference is a measurable number of milliseconds, and it is the entire product.
Measured continuously from an ordinary machine over the public internet, that gap runs 680ms at the median. We sell closeness to the chain and freshness of data. We do not sell queue position, because on this chain nobody can.
What the feed is doing right now
Read from this node’s own counters at request time. Every percentile below carries the number of samples it was computed from, because a p99 over eleven samples is not a p99.
| Window | samples | min | p50 | p90 | p99 | max | mean |
|---|---|---|---|---|---|---|---|
| feed lead over public RPC | 1,024 | 148ms | 680ms | 1.04s | 4.18s | 9.29s | 779ms |
| interval between feed frames | 4,096 | 0µs | 126ms | 129ms | 179ms | 695ms | 100ms |
What the speed layer actually is
No part of this list moves a transaction ahead of another. Each item is either data you get earlier, a read that answers faster, or a submission path with fewer hops in it.
- 01
Turbo feed relay
One process holds a single upstream connection to wss://feed.mainnet.chain.robinhood.com, decodes every frame once, and fans the decoded messages out to every subscriber. One socket up, many down — opening a connection per customer would multiply our own latency by the customer count and turn us into a load generator against the chain we exist to watch.
Our target for added latency between the frame arriving on our socket and leaving for yours is under one millisecond. That is a design target, not a published measurement: the number we publish is the end-to-end lead over the public RPC above, because it is the only one you can check from outside.
The public tier is delayed by two seconds deliberately. A real-time feed given away for free removes the revenue that pays for the watchtower, and the watchtower is the part of this that nobody else is doing. A two-second-old feed is still strictly better than polling an RPC if you are not racing.
- 02
Turbo RPC
The same node that re-derives state roots for the watchtower serves reads. Head state is kept hot in memory because the feed has already told us what changed before the block is queryable anywhere else, so a read against head does not wait on a cold trie walk.
Rate limits rise with tier and are listed in the table below. Archive reads — historical state at arbitrary height — are enabled on Turbo and above, because they are expensive to hold and the storage cost is real.
eth_simulateV1, eth_sendRawTransactionConditional and eth_sendRawTransactionSync are live on this chain and proxied. eth_subscribe, debug_* and trace_* are not available upstream, so we do not offer them and no tier unlocks them.
- 03
Bundle submission relay
There is no builder on this chain, so a Flashbots-style bundle cannot exist here. What can exist: atomicity, by collapsing N actions into one transaction against your own executor contract, and conditionality, by attaching state preconditions the sequencer checks at admission and drops on for zero gas.
Position is the third thing bundles are normally bought for, and it is the one we cannot sell. It is decided by arrival time and nothing else. How the relay works, in full →
- 04
Launch radar and simulate
Every transaction lifted from the feed is inspected for the calldata signature of a pool creation, a liquidity add or a large router swap, before it has executed anywhere. A feed signal is pre-execution intent — somebody is calling createPair — and it is labelled as intent until the confirming log arrives from our own node.
Simulation runs against the head state we already hold, which is fresher than the public RPC will serve, and it remains a forecast rather than a guarantee. The radar, its selectors and its live feed →
The public feed delay is 2,000 ms, applied in one place in the codebase — the hub that fans the feed out — so there is exactly one function that decides who gets data when.
The truth is free. The latency is not.
Attestations, daily roots, the assertion ledger and chain status need no key and never will. These tiers price throughput and freshness on the speed layer, and that revenue is what keeps the node running.
| Tier | $VERD stake | per month | feed delay | rpc / s | feed subs | simulate / min | bundles / min | archive | radar | cross-connect |
|---|---|---|---|---|---|---|---|---|---|---|
| Public | none | free | 2,000 ms | 5 | 1 | no access | no access | no | no | no |
| Pro | 250,000 | $400 | real time | 100 | 5 | 600 | 60 | no | yes | no |
| Turbo | 2,000,000 | $2,500 | real time | 1,000 | 25 | 6,000 | 600 | yes | yes | no |
| Colocated | contract | contract | real time | 10,000 | 200 | 60,000 | 6,000 | yes | yes | contract |
- Public
Delayed feed and the full attestation history. Free, forever, no key required.
- Pro
Real-time feed, launch radar, simulate against head state, and the bundle relay.
- Turbo
Everything in Pro plus archive reads, unthrottled burst submission, and priority egress.
- Colocated
Cross-connect in the sequencer datacentre. Latency SLA, dedicated capacity, contract terms.
The sequencer orders strictly first-come, first-served. Nothing above changes that.
There is one sequencer, no public mempool and no builder. eth_maxPriorityFeePerGas returns 0x0 — measured on mainnet, not assumed — so there is no fee auction to win and no bid that reorders anything. Timeboost is not enabled. Whoever’s bytes reach the sequencer first is sequenced first, and the only lever anyone has is arrival time.
So we reduce your arrival time, and we sell the identical service to the person on the other side of your trade. That is a race, not an entitlement, and it is worth saying in the same typeface as the pricing.
- Ordering priority or queue position.
- Front-running capability.
- Protection from a faster participant.
- Any guaranteed position inside a block.
- Guaranteed inclusion of any transaction.
- Data earlier than the public RPC serves it, by a published margin.
- Reads answered from head state we already hold.
- Conditional submission that fails for free instead of failing expensively.
- Atomic execution inside one transaction, guaranteed by the EVM.
- Signed ingress receipts, and the documented option to bypass us entirely.
The complete list of what we cannot do, with the measurement behind each one →
How the feed lead is measured
The number at the top of this page is the one figure a customer buys and cannot independently verify before buying. Here is exactly how it is produced, including the ways it is wrong.
- 01 sample
One transaction in every 400 that crosses the feed is picked for measurement. Its arrival timestamp was stamped on the socket before any parsing ran, so the clock starts on the network and not on our decoder.
- 02 poll
We call eth_getTransactionByHash against the operator’s public RPC for that hash, every 25 ms, until it returns a result. At most three samples are in flight at once and each gives up after 8 seconds.
- 03 record
The gap between the feed timestamp and the first successful poll is pushed into a rolling window of the last 1,024 samples. Every percentile on this page is computed from that window, and the sample count is printed beside it.
- 04 why sampling
Measuring every transaction would put a request per transaction on the endpoint we are comparing ourselves against, degrade it, and inflate our own number. The measurement must not distort the thing being measured, so it runs thin on purpose.
- 05 known bias
The recorded gap is an over-estimate by up to one poll interval, and it includes the RPC round-trip from our machine. It is measured from an ordinary, non-colocated host over the public internet. It says how much earlier we saw a transaction than the public RPC would serve it to us — not how close we are to the sequencer itself, which we cannot observe.
The raw window is served at /v1/feed/stats without a key. If you would rather not take our word for the median, connect to the same public feed, run the same comparison against the same public RPC, and check us.