Skip to content
Randoo
$0.01…per request

Drop-in Ronin VRF for games.

A drop-in Ronin VRF coordinator at half the native fee. Same requestRandomSeed call, verified on-chain before your callback.

Try the playgroundRead the quickstart
Dice.sol
// your game contract; compiles against Randoo as-is
contract Dice is RandooConsumerRonin {
    // one coordinator address, mainnet + Saigon
    address constant RANDOO =
        0xC66eB2e7EE91145875000Ad46B55600000000001;
    constructor() RandooConsumerRonin(RANDOO) {}

    function roll() external payable returns (bytes32 h) {
        // pay the on-chain quote; unused gas is refunded
        h = _requestRandomness(
            msg.value, 250_000,
            20e9 + block.basefee * 2,
            msg.sender
        );
    }

    function _fulfillRandomSeed(
        bytes32 h, uint256 seed
    ) internal override {
        _settle(h, seed); // verifiable seed lands here
    }
}

Live on Ronin mainnet

Latest seed
Requests fulfilled
p50 fulfil, last 200
Success rate
Fee per request

What is Ronin VRF?

Ronin VRF is the on-chain verifiable random function used by Ronin games. A contract calls requestRandomSeed on a coordinator and receives a proven random seed in rawFulfillRandomSeed. Native Ronin VRF is the Sky Mavis coordinator; Randoo is a separate drop-in coordinator with the same IRoninVRFCoordinatorForConsumers interface at half the $0.01 service fee.

Randoo is a drop-in VRF coordinator for the Ronin blockchain. Game contracts call requestRandomSeed, pay extra RON with the request, and receive a verifiable random seed on-chain in about two seconds. It implements the same IRoninVRFCoordinatorForConsumers interface as native Ronin VRF at half the $0.01 service fee, with no subscription.

Native coordinator reference: Ronin VRF docs.

Ask
requestRandomSeed with RON. Same call as native Ronin VRF.
Prove
Oracle posts a VRF proof. The coordinator verifies it on-chain before the callback.
Settle
rawFulfillRandomSeed runs with the seed. Unused gas is refunded.

Four steps to a verified seed

Add verifiable randomness to a Ronin game contract with the native VRFConsumer interface and the Randoo coordinator.

  1. 1

    Inherit RandooConsumerRonin

    Inherit RandooConsumerRonin (shipped with the sample). Your contract already compiles against Randoo if it compiles against native Ronin VRF.

  2. 2

    Point at the Randoo coordinator

    Pass 0xC66eB2e7EE91145875000Ad46B55600000000001 into the consumer constructor instead of the native proxy. Same CREATE3 address on Ronin mainnet and Saigon.

  3. 3

    Quote and request

    Call estimateRequestRandomFee, then requestRandomSeed with msg.value at least that quote and a non-zero refund address.

  4. 4

    Fulfill on-chain

    The oracle proves the seed. Your rawFulfillRandomSeed (or _fulfillRandomSeed) runs with the verified seed. Unused RON is refunded.

Read the quickstart

Migration is one argument.

Randoo implements the Ronin VRF coordinator interface. Deploy your consumer against the Randoo coordinator instead of the native proxy. Nothing else changes.

Dice.sol · diff
  import {VRFConsumer} from "@ronin-chain/ronin-random-beacon/contracts/consumer/VRFConsumer.sol";
   
  // your game contract
  contract Dice is VRFConsumer {
-    constructor() VRFConsumer(0x16a62a921e7fec5bf867ff5c805b662db757b778) {}
+    constructor() VRFConsumer(0xC66eB2e7EE91145875000Ad46B55600000000001) {}
   
      function roll() external payable {
          _requestRandomness(
              msg.value,
              250_000,
              20e9 + block.basefee * 2,
              msg.sender
          );
      }
   
      function _fulfillRandomSeed(
          bytes32 reqHash, uint256 seed
      ) internal override { _settle(seed); }
  }

Same requestRandomSeed, same rawFulfillRandomSeed, same fee quoting. Your consumers compile against Randoo unchanged.

Migrate from Ronin VRF

Same request. Half the service fee.

Native Ronin VRF (Sky Mavis) charges $0.01 plus gas. Randoo is a separate coordinator with the same consumer interface. Games opt in by changing one constructor argument.

Native Ronin VRF

$0.01

service fee per request

Randoo

−50%

$0.005

service fee per request · live on-chain quote

Consumer interface

Native Ronin VRF
requestRandomSeed, estimateRequestRandomFee, rawFulfillRandomSeed
Randoo
Same IRoninVRFCoordinatorForConsumers interface

Service fee

Native Ronin VRF
$0.01 in RON per request
Randoo
Half the native service fee, quoted on-chain

Billing

Native Ronin VRF
Pay per request, unused gas refunded
Randoo
Pay per request, unused gas refunded, no subscription

Proof

Native Ronin VRF
On-chain VRF verification before callback
Randoo
Chainlink-format VRF.sol verifier, seed bound to the request

Migration

Native Ronin VRF
Default Sky Mavis coordinator proxy
Randoo
One constructor argument: the coordinator address

What does half the fee save your game?

Native Ronin VRF bills a $0.01 service fee per request. Randoo bills $0.005, quoted live from the coordinator. Drag to match your request volume.

5,000
10010k100k

Service fee only. Fulfillment gas is billed the same way by both coordinators, and unused gas is refunded.

Saved every month

$25.00

≈ 455 RON

That is $0.005 back per request, or 50% of the native service fee.

On-chain randomness for Ronin games

If the outcome has to be random and the player has to be able to check it, request a seed. Typical uses: loot boxes, dice, NFT reveals, raffles.

Loot boxes and drops

Roll item rarity on-chain so players can verify the drop. The seed is proven before your callback assigns the item.

require(seed % odds == 0) // legendary

Dice, cards, and matches

Settle a roll, shuffle, or critical hit with a seed the loser can check on the explorer, not a number the server picked.

require(seed % 6 + 1 == 4) // rolled a four

NFT mint order and reveals

Assign token IDs or reveal metadata from a VRF seed so mint order cannot be ground after the request is in flight.

uint256 tokenURI = uris[seed % uris.length]

Raffles and lucky draws

Pick a winner from a snapshot of entries. The request is bound to a blockhash; the proof is checked on-chain.

address winner = entrants[seed % entrants.length]

Handled for you.

Gas spikes, nonce races, stuck fulfill transactions, callback reverts. The oracle absorbs them; your consumer only sees a seed or a refund.

Pickup in milliseconds

Confirmation is one block. The oracle picks the request up within milliseconds of that block and starts proving.

Verified proofs

The coordinator checks the VRF proof on-chain before it calls you back. A bad proof never reaches your consumer.

Fast callbacks

Confirmation is one Ronin block. The live mainnet p50 is in the strip under the headline, measured from real fulfils.

Gas bumps, not pages

A stuck fulfill transaction is resubmitted at 1.25× gas, up to three times, still billed at your declared price.

How fulfillment works

Half the native service fee.
No subscription.

Native Ronin VRF charges $0.01 plus gas per request. Randoo bills … in RON (…) plus estimated fulfillment gas. The price is quoted on-chain before you send.

Full pricing
Pay per requeston-chain quote
/ request in RON

Plus estimated fulfilment gas; overpayment is refunded.

  • One flat fee per request
  • Drop-in for Ronin VRF consumers: change one address
  • On-chain quote before every send
  • Verified on-chain before your callback

Questions people ask about Ronin VRF

What is Ronin VRF?

Ronin VRF is the on-chain verifiable random function used by Ronin games. A contract calls requestRandomSeed on a coordinator and receives a proven random seed in rawFulfillRandomSeed. Native Ronin VRF is the Sky Mavis coordinator; Randoo is a separate drop-in coordinator with the same IRoninVRFCoordinatorForConsumers interface at half the $0.01 service fee.

What is Randoo?

Randoo is a drop-in VRF coordinator for Ronin. Game contracts call requestRandomSeed on the Randoo coordinator, pay extra RON with the request, and receive a verifiable random seed on-chain in about two seconds. It uses the same consumer interface as native Ronin VRF at half the service fee.

What is the Ronin VRF coordinator address?

Native Ronin VRF (Sky Mavis) is at 0x16a62a921e7fec5bf867ff5c805b662db757b778 on mainnet and 0xa60c1e07fa030e4b49eb54950adb298ab94dd312 on Saigon. Randoo's coordinator is 0xC66eB2e7EE91145875000Ad46B55600000000001 on both chains. Point a new or migrated consumer at the Randoo address to use Randoo.

What is a verifiable random function (VRF)?

A verifiable random function produces a random output plus a proof that the output was computed from a secret key and a public input. On-chain VRF lets a game contract trust a random seed without trusting the oracle that delivered it. The coordinator checks the proof before calling the consumer back.

What is a VRF coordinator?

A VRF coordinator is the on-chain contract that accepts randomness requests, holds the prepaid fee, and later calls the consumer with a verifiable random seed. On Ronin, consumers talk to a coordinator through requestRandomSeed, estimateRequestRandomFee, and rawFulfillRandomSeed.

How does Ronin VRF work?

A game contract sends RON with requestRandomSeed. An oracle waits for confirmations, produces a VRF proof bound to that request, and the coordinator verifies the proof on-chain before calling rawFulfillRandomSeed on the consumer. Unused gas is refunded to the refund address.

How do I get a random number in a Ronin smart contract?

Inherit Ronin's VRFConsumer, deploy it with a coordinator address, quote estimateRequestRandomFee, and call requestRandomSeed with enough msg.value. The seed arrives in rawFulfillRandomSeed. Point the constructor at Randoo instead of the native coordinator to use Randoo.

How much does Ronin VRF cost?

Native Ronin VRF charges a $0.01 service fee in RON plus fulfillment gas. Randoo bills half that service fee, quoted on-chain, plus estimated fulfillment gas. There is no subscription. Overpayment is refunded after the callback.

How do I migrate from native Ronin VRF to Randoo?

Change the coordinator address in your consumer constructor to 0xC66eB2e7EE91145875000Ad46B55600000000001. That CREATE3 address is the same on Ronin mainnet and Saigon. Keep requestRandomSeed, estimateRequestRandomFee, and rawFulfillRandomSeed. No other consumer code has to change. Rehearse on Saigon before mainnet.

Is Randoo compatible with requestRandomSeed?

Yes. Randoo implements IRoninVRFCoordinatorForConsumers: requestRandomSeed, estimateRequestRandomFee, and rawFulfillRandomSeed. Same consumer interface, not a semantic clone: seed derivation, events, and deploy shape differ from the native proxy.

Does Randoo require a Chainlink VRF subscription?

No. Randoo v1 is pay-per-request on Ronin. You send the fee with the request. There is no subscription ID, no LINK token, and no need to fund a Chainlink billing account.

How long does on-chain randomness take on Ronin?

Randoo targets about two seconds p50 from request to callback under normal conditions. Pickup is milliseconds after confirmation; the oracle then proves and fulfills. Live p50 and success rate are published on the homepage.

Is Randoo the same as native Sky Mavis VRF?

No. Native Ronin VRF is the Sky Mavis coordinator at a well-known proxy. Randoo is a separate coordinator with the same consumer interface, a lower service fee, and its own oracle set. Games opt in by pointing at Randoo's address.

Ship randomness for half the fee.

Point your consumer at Randoo and request your first seed. Then race the native coordinator head to head in the playground.

Try the playground Read the quickstart