Verifiable randomness,
delivered in seconds

A multi-provider commit-reveal randomness oracle on Robinhood Chain. Flat fee per request, callback to your contract in 1–3 seconds, every reveal verified by keccak256 on-chain — and refundable if it ever isn't. Speaks the Pyth Entropy V2 ABI, so an existing consumer integrates by changing one address.

Integrate in 30 lines Read the trust model

Status

deploying

Requests served

—

Fee per request

—

Typical latency

1–3 s

How it works

Neither the provider nor the requester can choose the outcome. Both are locked in before either sees anything.

Provider pre-commits

The provider registers the head of a hash chain on-chain before your request exists. Every future reveal is already fixed — it just isn't public yet.

You add entropy

Your request carries your own 32-byte contribution. The final word is keccak256(reveal, yours, provider, seq, you) — the provider can't grind it, and neither can you. No blockhash is mixed in: on an Orbit L3 that refers to the parent chain and isn't sound entropy.

Verified delivery

The reveal is checked on-chain by walking keccak256 back to the commitment, then delivered to your entropyCallback. Unrevealed? Anyone can trigger your refund.

Ways in

Four, depending on what you're building.

Solidity consumer

Inherit IDicedConsumer, override entropyCallback, call requestV2. About 30 lines — see the snippet below.

Already on Pyth Entropy

Change one address. requestV2, getFeeV2, getProviderInfoV2, getRequestV2, refundRequest and the callback selector all match Pyth's ABI.

Agents, over HTTP

No wallet, no gas, no Solidity. Sign one stablecoin payment and POST for a word — the response carries the sequence number and reveal transaction so it stays auditable.

Run a provider

Registration is permissionless. Commit a hash chain, set your own fee, keep your own fees. Consumers choose whom to request from, so no single operator can stall the oracle.

Test before you pay

The same oracle runs on Robinhood Chain testnet (chain 46630) with its own keeper, so you can integrate end-to-end without spending real ETH. Grab test funds from the faucet, point at the testnet address in the docs, and ship when it works.

Integration snippet

Pyth-Entropy-shaped interface: existing consumers port by changing one address. Full docs and TypeScript SDK in the integration guide.

contract CoinFlip is IDicedConsumer {
    IDicedEntropy public immutable entropy;

    function flip(bytes32 userRandom) external payable returns (uint64 seq) {
        seq = entropy.request{value: msg.value}(userRandom, 0); // exact fee
    }

    function entropyCallback(uint64 seq, address, bytes32 randomNumber) internal override {
        bool heads = uint256(randomNumber) & 1 == 0;
        // ... your logic
    }
}

Fees

Pay with	Fee	Status
ETH (native)	—	live at launch
WETH	—	live at launch
DICED	—	coming soon

Fees are escrowed per request and only earned by the operator after a successful reveal. Unrevealed requests refund in full — permissionlessly.

Honest about trust

Single-provider commit-reveal has one residual assumption: the provider can't change an outcome, but it could withhold one (your recourse: an automatic refund). We document exactly what is and isn't guaranteed — no hand-waving.

The full trust model →

Verifiable randomness,delivered in seconds