BUILD / GUIDE

Networks

Arc and Robinhood Chain: one consumer interface, two ways to bind drand.

One interface

Consumers use the same D20VRFConsumer base and the same calls on every network: quoteFee, quoteFeeAt, requestRandomness, requestMappedRandomness, getMappedResult, refundRequest and retryCallback. The networks differ in how a request gets its drand input, in the fee token and in finality.

Arc Mainnet, chain 5042, live: epochs plus drand, fees in USDC.
Arc Testnet, chain 5042002, development: epochs plus drand, fees in USDC.
Robinhood Chain, chain 4663, live: round-bound drand, fees in ETH.
Robinhood Chain Testnet, chain 46630, development: round-bound drand, fees in ETH.

Deployed contracts

Arc: epochs plus drand

Each 200-block epoch commits one drand evmnet round, published only for paid demand and verified onchain by the registry. The VRF input then binds a block after publication, whose hash was unknown when the round was committed. Fees are paid in native USDC. The x402 agent API and the MCP server open their requests on Arc, and the Explorer indexes Arc requests and epochs.

Architecture Source inputs

Robinhood Chain: round-bound drand

There are no epochs. Each request is bound to a future drand round when it is made, so nobody can know or choose the result in advance. The contract verifies the drand signature and the VRF proof on chain, and anyone can replay a result from public data. A request binds the first drand evmnet round scheduled at least 3 seconds after its block's timestamp (RoundAssigned). The keeper fulfils it with that round's 64-byte BLS signature and the VRF proof; the coordinator verifies a round's signature once and caches its randomness, sha256 of the signature, for every request bound to the round.

Architecture Trust

Robinhood Chain: fees and settlement

The fee is paid in ETH: max(0.000025 ETH, 2 × base fee × (405,000 + callback gas)). pricing() and keeperFeeBps() return the live values, which the owner can change for future requests. Callback gas is 30,000 to 1,000,000. An accepted proof earns the keeper 80% of the escrowed fee and the DAO the rest, also when the callback fails; retryCallback redelivers the same word. A typical delivery takes 5–8 seconds. If a request is not fulfilled within 60 seconds, its fee can be refunded to the request's refund address. As with any randomness service, design applications so that a party cannot cancel a request and retry for a better outcome.

Service rules

Robinhood Chain: finality

Results are confirmed by the sequencer within seconds. Settlement on Ethereum follows in about 15–20 minutes.

Explorer and agents

The Explorer indexes Arc requests and epochs; a Robinhood request is looked up by ID and read from the chain, then replayed in the browser. The x402 agent API and the MCP server run on Arc only and charge USDC. @d20dao/vrf-sdk 0.6.0 or newer replays Robinhood requests, and so does the Explorer.

Explorer For agents

Work with your agents

Copy a task-specific prompt with the protocol references and integration rules.

Plain text Agent guide

View prompt

Help me choose the D20DAO network for my application: Arc or Robinhood Chain, mainnet or testnet. Compare fee token, how a request gets its drand input, finality and explorer coverage, then set up the consumer for the chosen network.

Read these public references first; do not guess signatures, addresses or limits:
- This guide: https://d20dao.org/docs/networks (full text of every guide: https://d20dao.org/llms-full.txt, agent guide: https://d20dao.org/agents.md)
- SDK README and AGENTS.md: https://github.com/d20dao/d20-sdk (also inside the installed package). It lists the randomness options, callback gas bounds, how to wait for results, compiler setup and gas needs for refunds and retries.
- Protocol source (contracts and replay library): https://github.com/d20dao/d20-sdk/tree/main/protocol, pinned to commit 98e537fb249dd0d3365b8d78e6040a9323a65a88 by PROTOCOL-PROVENANCE.json
- Deployment manifests: https://d20dao.org/deployments/arc-mainnet.json, https://d20dao.org/deployments/arc-testnet.json, https://d20dao.org/deployments/robinhood-mainnet.json, https://d20dao.org/deployments/robinhood-testnet.json
- Integration skills and templates: https://github.com/d20dao/skills (d20-consumer: methods.md, RandomnessConsumer.sol, mappings.mjs)
- Explorer for checking requests: https://d20dao.org/explorer (arc.d20dao.org for Arc Mainnet, arc-testnet.d20dao.org for Arc Testnet; Robinhood requests are looked up by ID)
- Agent API, for agents and services without a contract: https://d20dao.org/docs/agents (0.05 USDC per call over x402)
If a link is unavailable, use the installed package's README, AGENTS.md, ABIs and protocol sources.

Networks: Arc Mainnet chain 5042 (live, USDC; RPC https://rpc.mainnet.arc.io; explorer https://explorer.arc.io); Arc Testnet chain 5042002 (build and test here first, USDC; RPC https://rpc.testnet.arc.io; explorer https://testnet.arcscan.app); Robinhood Chain chain 4663 (live, ETH; RPC https://rpc.mainnet.chain.robinhood.com; explorer https://robinhoodchain.blockscout.com); Robinhood Chain Testnet chain 46630 (build and test here first, ETH; RPC https://rpc.testnet.chain.robinhood.com; explorer https://explorer.testnet.chain.robinhood.com). Native USDC on Arc and ETH on Robinhood Chain have 18 decimals. The consumer interface is the same on both; Arc serves requests through epochs, Robinhood Chain binds each request to a future drand round. Compile with Solidity 0.8.28 and EVM version cancun, importing contracts from the installed @d20dao/vrf-sdk package. Take the coordinator proxy address from the manifest of the network you target and check that its implementation matches the manifest. Any consumer contract can request; there is no allowlist, and EOAs cannot request.

Requests and fees: use the D20VRFRequests helpers from the SDK for every randomness option (raw word, dice, custom dice, coin flip, ranges, choose one or many, shuffle). Never hardcode the fee. In a contract, quote with quoteFee(callbackGasLimit) inside the requesting transaction. Off chain, quote with quoteFeeAt(callbackGasLimit, latest block baseFeePerGas) plus a buffer, or the SDK's quoteRequestFee with an ethers v6 provider, because eth_call reports a base fee of 0. Choose one payment pattern deliberately: collect a buffered quote from the user, pay the exact fee from the contract and return the change; or forward msg.value and accept that the excess becomes refund credit of the refund address.

Results: store the delivered word or mapped result in your consumer when the authenticated callback arrives, keyed by request ID, and have the application read that state. Off chain, wait for the coordinator's fulfillment events or poll getRequest (getRoundRequest on Robinhood Chain); the SDK documents the fields and mapped-result readers. A browser app must bundle the ESM package. Delivery usually takes a few seconds; measured Arc Testnet completion times, including under burst load, are at https://d20dao.org/benchmarks (observations of the testnet keepers, not an SLA). On Robinhood Chain a typical delivery takes 5–8 seconds. An unserved request can be refunded strictly after its 60-second deadline at the refund ratio fixed when it was requested. Give refund and callback-retry transactions explicit gas limits as documented.

Keep callbacks small and authenticated through D20VRFConsumer, and never request randomness from inside a callback. An accepted proof with a failed callback is paid service: retry the same stored result, never reroll. Optional _onRefund(requestId) means the refund recipient was paid or credited, not that the consumer received funds, and notification retries must not pay twice. Keep application assets and settlement separate from RNG fees.

For verification, keep the original epoch packet, request and target context and accepted proof evidence. Mathematical replay alone does not prove chain inclusion; check receipts and the implementation history too.

Implement only the requested changes. Do not ask for keeper, VRF, deployer or bot secrets, and do not send funded or mainnet transactions without my explicit authorization. Compile, run lifecycle tests on a local chain or a testnet, then report changed files, results, anything unverified, and any documentation that was unclear or missing.