Provably Fair

Random Number Generation

For each verifiable game, a client seed, a server seed, a nonce and a cursor are used as the input parameters for the random number generation function. This function utilises the cryptographic hash function HMAC_SHA256 to generate bytes which are then used as the foundation for how we generate provably fair random outcomes on our platform.

      // Random number generation based on following inputs: serverSeed, clientSeed, nonce and cursor
function byteGenerator({ serverSeed, clientSeed, nonce, cursor }) {
  // Setup curser variables
  let currentRound = Math.floor(cursor / 32);
  let currentRoundCursor = cursor;
  currentRoundCursor -= currentRound * 32;

  // Generate outputs until cursor requirement fullfilled
  while (true) {
    // HMAC function used to output provided inputs into bytes
    const hmac = createHmac('sha256', serverSeed);
    const buffer = hmac.digest();

    // Update curser for next iteration of loop
    while (currentRoundCursor < 32) {
      yield Number(buffer[currentRoundCursor]);
      currentRoundCursor += 1;
    currentRoundCursor = 0;
    currentRound += 1;

Server Seed

The server seed is generated by our system as a random 64-character hex string. You are then provided with an encrypted hash of that generated server seed before you play any games. The reason we provide you with the encrypted form of the server seed is to ensure that the un-hashed server seed cannot be changed by the casino operator, and that the customer cannot calculate the results beforehand.

To reveal the server seed from its hashed version, the seed must be rotated by the customer, which triggers the replacement with a newly generated one.

From this point you are able to verify that the hashed server seed matches that of the un-hashed server seed. This process can be verified via our un-hashed server seed function found in the menu above.

Client Seed

The client seed belongs to the customer.

All customers are free to edit and change their client seed regularly to create a new chain of random upcoming outcomes.

You can do this via the fairness modal.


The nonce is simply a number that increments as every new game is played.

The implementation of nonce, ensures we remain committed to your client seed and server seed pair, whilst generating new results for each game played.

Cursor (Incremental Number)

We use 4 bytes of data to generate a single game result, and because SHA256 is limited to 32 bytes, we utilise this implementation of a cursor to give us the ability to create more game events without having to modify our provable fair algorithm.

The cursor is only iterated over when the game being played requires the generation of more than 8 (32 bytes / 4 bytes) possible outcomes. For example: when we need to use more than 8 cards in a game of blackjack.

The cursor starts as 0 and gets increased by 1 every time the 32 bytes are returned by the HMAC_SHA256 function. If we don’t require more than 8 random numbers to be generated for the game events, then the curser does not increment as there is no need to generate any additional possible game outcomes.

Games with more than 1 incremental number:

  • Hilo (Unlimited to cover required amount of cards)
  • Keno (2 increments for every game due to 10 possible outcomes)
  • Mines (3 increments per game for 24 possible bomb locations)
  • Plinko (2 increments per game to cover possible 16 decisions)
  • Blackjack (Unlimited to cover required amount of cards)
  • Video Poker (7 increments to generate 52 possible cards in a full deck)
  • Diamond Poker (2 increments to cover 10 diamonds: 5 per customer/dealer)
  • Slots (The incremental number is only utilised for bonus rounds)

Games with only 1 incremental number (represented as default value 0):

  • Dice
  • Limbo
  • Wheel
  • Baccarat
  • Roulette
  • Diamonds