Skip to content
Randoo

Ronin VRF coordinator

On-chainrandomnessfor Ronin games.

Randoo is a drop-in VRF coordinator. One payable requestRandomSeed returns a seed the coordinator verifies on-chain before your callback, at half the native service fee.

Run a requestRead the quickstart
Dice.sol · Ronin VRF consumerdrop-in ABI
// your game contract. Already compiles against Randoo
contract Dice is VRFConsumer {
  function roll() external payable {
    uint256 fee = RANDOO.estimateRequestRandomFee();
    // send the on-chain quote; unused gas is refunded
    RANDOO.requestRandomSeed{value: fee}(
        payable(msg.sender), "refund address"
    );
  }

  function rawFulfillRandomSeed(
      uint256 requestId, uint256 seed
  ) internal override { _settle(requestId, seed); }
}
p50 fulfill
—
Success rate
—
Requests fulfilled
—

What is Randoo?

A VRF coordinator Ronin games can drop in

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 ABI as native Ronin VRF at half the $0.01 service fee, with no subscription.

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.

How it works

Four steps to a verified seed

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

  1. 01

    Inherit VRFConsumer

    Use VRFConsumer from the Ronin random beacon. Your contract already compiles against Randoo if it compiles against native Ronin VRF.

  2. 02

    Point at the Randoo coordinator

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

  3. 03

    Quote and request

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

  4. 04

    Fulfill on-chain

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

Full quickstart

Migration is one argument.

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

Dice.sol · diffronin mainnet
  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.

Versus native 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 ABI. Games opt in by changing one constructor argument.

Consumer ABI

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

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 VRF is for

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.

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.

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.

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.

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

About two seconds p50 from request to callback. Live p50 and success rate are at the top of this page.

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

Pricing

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

+ estimated fulfillment gas · overpayment refunded

  • One flat fee per request
  • Drop-in for the Sky Mavis coordinator ABI
  • On-chain quote before every send
  • ~2s p50 end-to-end latency

Answers

Questions people ask about Ronin VRF

Short answers. The structured data on this page uses the same wording, so what an answer engine quotes is what you read here.

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 ABI as native Ronin VRF at half the service fee.

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. It is an ABI drop-in, not a semantic clone: seed derivation 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 ABI, a lower service fee, and its own oracle set. Games opt in by pointing at Randoo's address.

Roll your first request.

Race the native coordinator head to head and see whose seed lands first.

Try the playground Browse the docs