The Randomness Layer

Verifiable entropy for Robinhood Chain

A commit-reveal oracle delivering verifiable randomness onchain. Every output is deterministic and publicly verifiable onchain.

Built on Robinhood Chain

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

Use cases

Randomness where trust matters.

Gaming

Provably fair dice rolls, card shuffles, loot boxes, and matchmaking. Players can audit the randomness source onchain.

NFT mints

Fair trait reveals and randomized drops. No one — not the team, not the minter — can influence the outcome after commitments are locked.

Governance

Random sortition, jury selection, and raffle-based participation. Trustless selection that anyone can verify.

DeFi

Randomized vault strategies, verifiable airdrops, and lottery pools. Onchain entropy without offchain trust assumptions.

Security model

Commit-reveal by design.

No front-running

The user commits a random value before the provider reveals. The provider cannot change the reveal after seeing the request, and the user cannot change their commitment after seeing the reveal.

Refund safety

If a reveal is not submitted within the timeout window, the requester can call refundRequest to recover the fee. The oracle contract enforces this window onchain.

Hash-chain reveals

Each reveal is the next value in a deterministic hash chain. The contract verifies the chain link against the provider's published history.

Open source

Contracts, SDK, and documentation are public. Anyone can verify the logic, run the keeper, or integrate directly.

Quick Start

Integrate in 30 lines.

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

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

    constructor(address _axion) {
        axion = IEntropy(_axion);
    }

    function roll() external payable {
        bytes32 userRandom = keccak256(
            abi.encodePacked(msg.sender, block.timestamp)
        );
        axion.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(axion);
    }
}
Read the full integration guide →