Fairness Verification of Results

Verify the authenticity of any roulette result. Our system guarantees 100% transparency of the gameplay.

Verify Result How it works
No Verification
Verification Result
Computed Hash:
How verification works

Before each round, the system generates a random number and a cryptographic salt, then calculates the SHA-256 hash.

The hash is published before the round starts, and the number and salt are revealed after its completion.

You can easily verify whether the published hash matches the open data:

SHA-256(number:salt)
Verification example:
  1. Number: 5: 5
  2. Salt: a1b2c3d4e5f6: a1b2c3d4e5f6
  3. Hash: e37f...0840: e37f...0840

To verify, compute the SHA-256 hash of the string 5:a1b2c3d4e5f6 and compare it with the original hash. If they match, the result is fair.

How the fair game system works
Hash Generation

Before the round starts, the system generates a random number from 0 to 36 and a unique cryptographic salt. Then the SHA-256 hash of the string "number:salt" is calculated.

Hash Publication

The hash is published before players start placing bets. This guarantees that the result is predetermined and cannot be changed after bets are placed.

Result Reveal

After the round ends, the system reveals the used number and salt. Anyone can verify whether the previously published hash matches this data.

Example of independent verification (in Go): 
package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

func main() {
    number := 5                   // Number that came up
    salt := "a1b2c3d4e5f6"        // Salt from bot message
    originalHash := "e37f...0840" // Hash from round start

    // Format string and calculate hash
    data := fmt.Sprintf("%d:%s", number, salt)
    hasher := sha256.New()
    hasher.Write([]byte(data))
    computedHash := hex.EncodeToString(hasher.Sum(nil))

    // Verify match
    if computedHash == originalHash {
        fmt.Println("Result is valid!")
    } else {
        fmt.Println("Result does not match hash!")
    }
}

Thanks to the pre-hashing system, the result of each round is determined in advance and cannot be changed after betting starts. The hash is published before the round starts, and after completion, you can verify its correspondence with the open data.

The SHA-256 cryptographic algorithm mathematically guarantees that it is impossible to find another number and salt combination that would produce the same hash.

Salt is a random string of characters added to the number before calculating the hash. It is needed so that one cannot prepare in advance a table of correspondences of all possible numbers (from 0 to 36) to their hashes.

Without salt, a malicious actor could simply look in such a table and find out which number will come up. Salt adds unpredictability and guarantees the uniqueness of the hash for each round, even if identical numbers are drawn.

You can use any of the following tools:

  • The built-in verification form on this page
  • Online SHA-256 calculators (e.g., Online SHA-256)
  • Command line on Linux/Mac: echo -n "5:a1b2c3d4e5f6" | sha256sum
  • Any programming language with a library for computing SHA-256 hashes

Don't forget to use the number:salt format without spaces and other characters.