Dice Protocol

Real-time Randomness Layer
for Onchain Applications

Real-time randomness for onchain applications

Sub-second, verifiable randomness infrastructure built for games, AI agents, DeFi and autonomous applications.
Live onRobinhood Chain & Arbitrum One. Base next.

Looking for RNG for Robinhood Chain? Live oracle, fee, and integration path.

0.000025
ETH
Exact fee
~1-3
seconds
Reveal time
4663
chain id
Robinhood Chain
42161
chain id
Arbitrum One
x402
$0.05 USDG live
Agentic payments

Features

Built for developers who need real randomness.

Unbiased

Two-party commit-reveal: user randomness combined with provider's hash chain reveal. Designed so neither party can unilaterally bias the outcome when commitments hold and the provider seed stays private.

Verifiable

Every reveal is checked onchain via Keccak256. Anyone can independently verify the randomness was computed correctly.

Developer-first

TypeScript SDK, Solidity interfaces, and a simple callback pattern. Integrate in under 50 lines of code.

Agent-friendly

x402 live: agents pay fixed $0.05 USDG on Robinhood via Primer, then receive verifiable randomness. Direct on-chain requestV2 (exact ETH fee) still available.

How it works

Three steps. About 1-3 seconds typical. If reveal never comes, refund after ~60-90s.

01

Request

Your contract calls requestV2() with a user-generated random value and pays the exact 0.000025 ETH fee. If unrevealed after ~60-90s, requester can refundRequest.

02

Reveal

The Tyche keeper detects the request event and submits the next hash chain value as a reveal in ~1-3 seconds typically.

03

Callback

The contract verifies the reveal, combines it with the user's value and the provider's preimage, then calls your entropyCallback() with the final random number.

Quick Start

Integrate in 30 lines.

MyGame.sol
import { IEntropyConsumer } from "@diceprotocol/sdk/solidity/IEntropyConsumer.sol";
import { IEntropy } from "@diceprotocol/sdk/solidity/IEntropy.sol";

contract MyGame is IEntropyConsumer {
    IEntropy public immutable dice;
    address public provider = 0x8741...F2b6;

    constructor(address _dice) {
        dice = IEntropy(_dice);
    }

    function roll() external payable {
        bytes32 userRandom = keccak256(
            abi.encodePacked(msg.sender, block.timestamp)
        );
        dice.requestV2{value: msg.value}(
            provider, userRandom, 200000
        );
    }

    function entropyCallback(
        uint64 seq, address, bytes32 random
    ) internal override {
        uint256 result = uint256(random) % 6 + 1;
    }

    function getEntropy() internal view override returns (address) {
        return address(dice);
    }
}

Start building with
onchain randomness.

No sign-up. No API key. Just call the contract and get random numbers.