Rush Game


What does it mean?

All game results for the next 6 million rounds have been predetermined. Before each round, we reveal a hash of the result, making it impossible for us to change the result after the fact.

We have actually chained all results, making it impossible for us to even change future results. And before generating the chain of results, we revealed the first hash, published this to , and mixed in a future Bitcoin blockhash we could not have known. This makes all results provably fair.


Global Seed

November 14 2023 9:01 PMx0.027073f429be10dd4beab70ff9dc548946333b031b8bdff1fe5855440ee0cd343bb9
November 14 2023 1:19 PMx0.02705fcbad076b85cfd9d6ce8923280374cc2092b2ecdc7f5543bca3dbaf05ca8e96
November 14 2023 1:19 PMx0.0270d4088eca1cf0fce7161d4dd85eaa288b89f799b4b43510b7272d8884feda7d94
November 14 2023 1:19 PMx0.0270da60384ee47d3720f7325fea986472f058120cafb8461e914c9c04bdbe0754b4
November 14 2023 1:19 PMx0.02707e07d43fb743f97d9796428c401fed7729800b2ee730e7be0b3ae573ba04814b
November 14 2023 1:18 PMx0.02709ae75594415a83f69575d9ac347ae43bb7b091d44bd59f0e4b4df9194f9d2bc8


Before the first round of the game began, we created a chain of hashes. Each hash is a 256 bit value. The chain begins with a randomly chosen 256 bit value and every subsequent value is calculated using the

Using a cryptographic hash function ensures that one can easily calculate any value in the chain using the previous value, but one can not easily calculate values in the reverse direction. The last value in the precalculated hash chain is what we publically published and used for the first round of the game. The second round of the game used the second to last hash value, the third round used the third to last hash value, etc. By traversing the chain in this manner, one can verify that the outcome of all past game rounds were consistent with the precalculated chain, but the outcome of future rounds remains unpredictable to users.

In order to eliminate the possibility that we intentionally generated the chain using an initial value that biased the games results in our favor, each value in the chain is appended to the global seed and the resulting value is hashed again using BLAKE2b to create the final value that will determine the outcome of each game round. This global seed is set to the hash of the Bitcoin block that we announced prior to its mining. The inclusion of the global seed ensures that the outcome of the games was unknowable to us when the hash value of the first game was published.


Anyone can verify that the outcomes of all prior game rounds were generated using the provably fair algorithm with the following python code:

import math
import pyblake2

# The global seed is the hash of the Bitcoin block published by Rollbit
global_seed = bytes.fromhex("00000000000000000004ab6468e03c35500b5f59b8ef58ef9873f67ffbf12bcd")

# In this example, we'll start with the 369,862nd game round and work backwards.
round = 369862

# The round_hash is initially set to the value published for the 369,862nd round.
round_hash = bytes.fromhex("344893385fa113a48edafe61cc0e52a11fba9c1cd2dc4a92f7e919be87945ec5")

# Iterate backwards through the rounds
for i in range(round, round - 10, -1):
    # For every round, we append the global_seed to the round_hash to get a final hash value.
    round_final_hash = pyblake2.blake2b(round_hash + global_seed, digest_size=32).digest()

    # We then convert that hex value to a floating point number 'x',
    # which is uniformly distributed in the unit interval
    x = float(int.from_bytes(round_final_hash[:8], byteorder='little', signed=False)) / float(2**64 - 1)

    # The round's outcome is calculated by applying the house's 5% edge,
    # rounding to 0.01 precision, and restricting the outcome range to [1.0, 1000000.0)
    outcome = min(1e6, max(1.0, math.floor(100.0*(1.0-0.05)/x) / 100.0))

    print("Round: ", i)
    print("Round Hash: ", round_hash.hex())
    print("Round Outcome: ", outcome)

    # For the next round, we calculate the next value in the chain of hashes.
    round_hash = pyblake2.blake2b(round_hash, digest_size=32).digest()