Logo2.0

Provably Fair

What does it mean?

A provably fair algorithm solves the trust issue between players and operators by providing a transparent way to verify round results.

Provably Fair implies that the results are generated before the betting phase and that they can't be altered by the server operator for their benefit.

The verification process is also transparent and available for everyone to evaluate.

Algorithm

The Wheel has 54 possible outcomes. Outcome 0 will always be Gold, while the other outcomes (1 to 53) are assigned to the other colors on the wheel.

Every day, a string of random letters and numbers is generated that will be used to generate all outcomes for that day. We refer to this as the Seed or Secret.

Usually, each seed is used for 24 hours; it's hidden for as long as it's being used. Instead, we display the BLAKE2b hash of the seed below.
It's important to note that since we are generating the Seed at the beginning of the day, this means that all results are pre-determined and we are not able to alter the round results during the day. Therefore, you have the absolute guarantee that the rounds you play in are truly random and not influenced by external factors.

Since the BLAKE2b hash function is deterministic (meaning it will always output the same result for the same input) we can cryptographically prove the statement we're making above.

Adding to the seed, each round has a unique Round Number or Nonce. That number is added to the end of the seed every round. The resulting string, in the format of {seed}:{nonce} will determine the round's outcome.

Wheel

Round ID
Date / Time
Seed
Hash

Verification Example

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

 import hashlib
 
 # Replace these with the unhashed seed of the day and the round's number
 secret = "Replace this with the UNHASHED seed of the day"
 nonce = 6800 #Replace this with the round's number
  
 def calculate_game_outcome(secret, nonce):
     # Combine the secret and nonce into a single string
     full_seed_string = f"{secret}:{nonce}"
  
     # Create a BLAKE2b hash of the combined string
     full_seed = hashlib.blake2b(full_seed_string.encode(), digest_size=32).digest()
  
     # Convert the hash to a hex string and take the first 8 characters
     seed = full_seed.hex()[:8]
  
     # Convert the hex value to an integer and calculate the remainder
     return int(seed, 16) % 54
  
 CHOICES = {
     50: [0],
     25: [3, 39],
     5: [1, 9, 11, 19, 21, 33, 35, 43, 45, 53],
     3: [5, 7, 13, 15, 17, 23, 25, 27, 29, 31, 37, 41, 47, 49, 51],
     2: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52]
 }
  
 def get_multiplier_by_random(random):
     for multiplier, numbers in CHOICES.items():
         if random in numbers:
             return multiplier
  
 for i in range (nonce, nonce - 10, -1):
     # Print the outcome
     random = calculate_game_outcome(secret, i)
     multiplier = get_multiplier_by_random(random)
     print(f"{random} is the outcome (x{multiplier}) of round #{i}")