Provably Fair

CRASH, the flagship game on the CRYPTOROCKET platform, ensures fairness through a cryptographically secure and transparent system powered by Redstone's Oracle. This section explains how the game achieves provable fairness in simple terms, so players can trust the integrity of every round.

How CRASH Works

In CRASH, players bet on a multiplier that increases over time until the game "crashes" at a specific multiplier. The goal is to cash out before the crash to win based on the multiplier at the time of cashing out. The crash point is determined by a cryptographic algorithm, ensuring it is unpredictable and fair.

Why CRASH is Provably Fair

The fairness of CRASH relies on two key components: Redstone's Oracle and a transparent cryptographic algorithm. Here's how it works:

1. Seeding with Redstone's Oracle Each game round starts with a unique "seed" provided by Redstone's Oracle, a decentralized data provider that ensures the seed is unpredictable and tamper-proof. This seed, combined with a provably fair "salt" (a random string), is used to generate the game's outcome. The use of the oracle guarantees that neither players nor the platform can manipulate or predict the seed in advance.

2. Cryptographic Hash Generation The game uses the HMAC-SHA256 algorithm to create a game hash from the seed and salt. This hash determines the crash point. The process is deterministic, meaning anyone with the game hash and salt can verify the result, but it's impossible to predict the outcome before the game starts.

3. Crash Point Calculation The crash point is calculated using the following algorithm:

   def get_result(game_hash):
       hm = hmac.new(str.encode(game_hash), b'', hashlib.sha256)
       hm.update(salt.encode("utf-8"))
       h = hm.hexdigest()
       if (int(h, 16) % 33 == 0):
           return 1
       h = int(h[:13], 16)
       e = 2**52
       return (((100 * e - h) / (e-h)) // 1) / 100.0

   • Approximately 3% of the time (specifically, if the hash modulo 33 equals 0), the game crashes immediately at a multiplier of 1x.

   • For the remaining ~97% of games, the hash is used to compute a multiplier using the formula: multiplier = floor((100 * 2^52 - h) / (2^52 - h)) / 100, where h is a 52-bit integer derived from the first 13 characters of the hash. This ensures a minimum multiplier of 1x and a smooth distribution of crash points.

   • The result is a multiplier (e.g., 1.45x, 3.20x) that determines when the game crashes.

4. Hash Chaining for Transparency Each game's hash is used to generate the next game's hash using the following algorithm:

   def get_prev_game(hash_code):
       m = hashlib.sha256()
       m.update(hash_code.encode("utf-8"))
       return m.hexdigest()

   This creates a chain of hashes that players can trace backward. The hash chain is publicly accessible, allowing anyone to audit the fairness of past games.

Why This is Fair

• Unpredictability: The use of Redstone's Oracle ensures the initial seed is non-deterministic and cannot be manipulated by the platform or players.

• Verifiability: The cryptographic process is open and deterministic, using standard algorithms (HMAC-SHA256 and SHA256) trusted across major platforms.

• Transparency: The hash chain allows auditing of the entire history of game results, confirming that outcomes are consistent and unaltered.

• No Platform Control: The cryptographic process ensures the platform cannot influence or predict crash points, as the results are determined by the oracle's seed and the algorithm.

By combining Redstone's Oracle with a battle-tested cryptographic algorithm, CRASH guarantees a fair, transparent, and exciting gaming experience. Players can enjoy the thrill of the game with confidence that every crash point is provably fair.