Thunder Limbo is LIVE and Provably Fair – Test it yourself

It’s no secret that Thunder Dice, and Thunder Limbo, along with other chance games, are casino games. We also know that randomness plays a huge role in all casino games. But… How can you, as a Player, be sure that any given casino game is actually random? Is there anything which proves that a game’s randomness is rigged to increase casino margin? Usually, there is no way to check it and Players should believe in game providers’ guarantees. Sometimes third parties’ certificates can increase given game credibility. But is there anything a player can do to check by themselves? Yes and it’s called the Provably Fair algorithm.

Provably Fair Gaming

So how do Provably Fair algorithms work?

The result of each played game is defined by a random number, generated using the Provably Fair algorithm. Two main ingredients are used to generate this number are:

• Game Seed: a String value, which is generated by the server before the game, coded (hashed) using the HMAC algorithm and then shared with the Player.
• Player Seed: a String value, which is generated for the Player and can be changed by the Player before the game starts.

Details of the algorithm, which transforms Seeds to a random number define the game results. This number is hared with Users (described below).

Once the game is finished, the Player can request for a Seed rotation which also reveals the not-hashed Game Seed.
Using this data, the Player can check:

• If Server Seed shared by system is the same one which has been known in advance in hashed format;
• If the random number generated by the Seed was actually used to define the game’s outcome.

Thunder Dice uses a Provably Fair algorithm to make the game fully transparent and give Players the chance to validate it.

Seeds and other components

All parameters which are used by the algorithm to generate the random byte stream are initially generated by the system when the Player opens the game. These parameters are:

• Player’s Seed:
  a String value which is known and can be changed by the Player.
  Exception is the first wager, which will be placed using auto-generated seed due to technical limitations.
• Server’s Seed:
  a String value generated by the Server and then shared with the User as a Hash code.
  To generate a Hash from this Seed we use SHA-256 algorithm (input in HEX format)
• Nonce:
  This is counter generated by the system and automatically increased by 1 for each next coin (wager) played. The first played Wager for a given Seed’s pair equals 1.
  It is needed to differentiate results given by Wagers, as a pair of Seeds is rotated on Player’s demand.
• Round:
  A Parameter, which is used for each Wager, having 3 values: 0, 1, 2.
  It is needed, as for each Wager we need to generate 3 different Strings (each generated using same pair of Seeds, same Nonce and different Round value)

How to test that Thunder Dice or Thunder Limbo are Provably Fair

All these parameters can be checked for each Wager in the Provably Fair expandable menu, which can be accessed in the following way:

1. Open “My Bets” -> “Games” -> Thunder Dice Wager or Thunder Limbo Wager -> Share Wager:

2. Expand Provably Fair menu:

3. In the menu User is able to find Hash prepared from Server Seed, Client Seed, and Nonce.
   To rotate seeds you can use the “Rotate your seed pair” feature:

4. Here, not only the currently used pair of seeds are displayed, but also the User is already informed about the next Server Seed (of course in Hashed form) and can Edit client seed.

5. After given pair of Seeds is rotated, the not-hashed Server Seed from previous pair is revealed to Player:

In the result, players have access to all parameters, which allows them to check if a given Wager was actually randomly generated. In the next paragraph there is an explanation on how a random number is generated from these parameters.

Generation of Random Number

The game draws a random number between 0 and 1 (but never exactly 0; it’s always a tiny bit more than 0). To generate a random number, Thunder Limbo uses HMACSHA256 algorithm, which generates a byte stream with length of 32 bytes. To be more precise, following algorithm is used:

Byte Stream(length equal to 32) = hmacsha256key, message where:
Key = server_seed Message = client_seed:nonce:round

RNG Code: Thunder Limbo & Thunder Dice

double FirstByteDenominator = 256.0;
double SecondByteDenominator = 256.0 * 256.0;
double ThirdByteDenominator = 256.0 * 256.0 * 256.0;
double FourthByteDenominator = 256.0 * 256.0 * 256.0 * 256.0;

void Fill(byte[] serverSeed, string? clientSeed, long nonce, double[] result)
{
    var hmac = new HMACSHA256(Encoding.ASCII.GetBytes(Convert.ToHexString(serverSeed)));
    var messageTemplate = $”{clientSeed}:{nonce}:”;
    var rngData = new byte[32];

    var neededRounds = (int)Math.Ceiling(result.Length / 8M);

    var idx = 0;
    for (var round = 0; round < neededRounds; ++round)
    {
        var message = messageTemplate + round;
        var encodedMessage = Encoding.ASCII.GetBytes(message);
        var bytesWritten = hmac.ComputeHash(encodedMessage, rngData)

        for (var offset = 0; offset < 32; offset += 4)
        {
            var value = rngData[offset] / FirstByteDenominator +
                        rngData[offset + 1] / SecondByteDenominator +
                        rngData[offset + 2] / ThirdByteDenominator +
                        rngData[offset + 3] / FourthByteDenominator;
            result[idx] = value;

            ++idx;

            if (idx == result.Length)
                break;
        }
    }
}

Dice Round Result Calculation

In our version of dice, we cover a possible roll spread of 00.00 to 100.00, which has a range of 10,001 possible outcomes.
The game event translation is done by multiplying the generated number by the number of possible outcomes and then dividing by 100 so that the Round result fits the constraints of our stated dice range.
Round Result = Random number * number of outcomes / 100

Example Calculation

Suppose the random number drawn is 0.25:
Round Result = 0.2555 * 10001 / 100
So, the round result is 25.00.

Limbo Round Multiplier Calculation

The game uses the following formula to determine the round multiplier:
Multiplier = RTP / Random Number
RTP stands for “Return to Player” and for Thunderpick games, it is 0.98 (or 98%).
Random Number is the value drawn in the previous step (a random number between 0 and 1, but never exactly 0).
If the result is less than 1, it’s set to 1 (so the minimum possible multiplier is 1).
Round Multiplier = max(multiplier, 1);

Example Calculation

Suppose the random number drawn is 0.25:
Round Multiplier = 0.98 / 0.25 = 3.92
So, the round multiplier is 3.92x. If your target multiplier is more than or equal to the round multiplier, you win.

Check it yourself!

Now that you have all the information to check our  Thunder Dice is Provably Fair. Try it for yourself after your next game!