🔬 How Our Crash Game Calculator Works

FantasyMarket uses a provably fair system that generates each game's crash point using cryptographic hashing. This document explains exactly how the algorithm works so you can independently verify that every outcome is fair and transparent.

Every crash point is determined before you place your bet, using:

  • Server Seed: A randomly generated value known only to FantasyMarket
  • Client Seed: A value you control that changes with each round
  • Round Number: A sequential counter that increments each game

No changes can be made after the round begins. The outcome is completely predetermined using mathematics, not random luck.

⚙️ The Algorithm: Step by Step

1
Generate the Server Seed
FantasyMarket creates a random server seed using cryptographically secure random generation. This value is kept secret until after you place your bet.
Server Seed = Random 256-bit hexadecimal string
Example: a7f3e1b8c2d9f4a5e6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e
2
Hash the Server Seed (SHA-256)
The server seed is hashed using SHA-256, a cryptographic algorithm. This hash is shown to you before the round starts. You can verify it matches the unhashed seed after the game.
Server Seed Hash = SHA-256(Server Seed)
Example: 5e7f3a9b1c2d4e6f8a0b3c5d7e9f1a2b4c6d8e0f2a4c6e8f0a1b3c5d7e9f1a
3
Combine the Seeds and Round Number
After the round completes, the server seed is combined with your client seed and the round number. These three values are concatenated together (joined as a single string).
Combined String = Server Seed + Client Seed + Round Number
Example: a7f3e1b8c2d9f4a5...my_seed_value...42
4
Hash the Combined String
The combined string is hashed again using SHA-256. This produces a unique value that represents this exact game round.
Combined Hash = SHA-256(Combined String)
Example: 7f8e9d0c1b2a3f4e5d6c7b8a9f0e1d2c3b4a5f6e7d8c9b0a1f2e3d4c5b6a
5
Extract Hex Characters
We take the first 13 characters from the combined hash (which are hexadecimal digits: 0-9, a-f).
Hex Substring = Combined Hash[0:13]
Example: 7f8e9d0c1b2a3
6
Convert Hex to Decimal
The hexadecimal substring is converted to its decimal equivalent (base 16 to base 10).
Decimal Value = parseInt(Hex Substring, 16)
Example: 7f8e9d0c1b2a3 (hex) = 562949953290915 (decimal)
7
Apply Modulo 1000
We divide the decimal value by 1000 and take the remainder. This gives us a value between 0 and 999.
Modulo Result = Decimal Value % 1000
Example: 562949953290915 % 1000 = 915
8
Divide by 100 (Scale to Multiplier)
The result is divided by 100 to convert it to a crash point between 1.00x and 9.99x.
Crash Point = (Modulo Result / 100)
Example: 915 / 100 = 9.15x
9
Apply Minimum and Maximum Bounds
We ensure the crash point is at least 1.00x and at most 10.00x. This prevents impossible values.
Final Crash Point = max(1.00, min(Crash Point, 10.00))
Example: max(1.00, min(9.15, 10.00)) = 9.15x

📐 Complete Formula

The complete calculation can be expressed as:

// Pseudocode function calculateCrashPoint(serverSeed, clientSeed, roundNumber) { combined = serverSeed + clientSeed + roundNumber.toString() hash = SHA256(combined) hexSubstring = hash.substring(0, 13) decimalValue = parseInt(hexSubstring, 16) modulo = decimalValue % 1000 crashPoint = modulo / 100 return max(1.00, min(crashPoint, 10.00)) }

📋 Real Example Walkthrough

Let's trace through a complete example to see how a crash point is calculated:

Example Round #42

Component Value
Server Seed a1b2c3d4e5f6...
Client Seed my_custom_seed
Round Number 42

Step-by-step calculation:

1. Server Seed Hash = SHA-256(a1b2c3d4e5f6...) = 7f8e9d0c1b2a3f4e5d6c7b8a9f0e1d2c...
2. Combined = "a1b2c3d4e5f6..." + "my_custom_seed" + "42"
3. Combined Hash = SHA-256(combined) = 3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d...
4. Hex Substring = "3a4b5c6d7e8f9"
5. Decimal = 245716305621369 (converted from hex)
6. Modulo = 245716305621369 % 1000 = 369
7. Crash Point = 369 / 100 = 3.69x
8. Final = max(1.00, min(3.69, 10.00)) = 3.69x

Result: The rocket will crash at exactly 3.69x in this round.

✅ How to Verify a Round

After each game completes, you can verify that the crash point was calculated fairly:

  1. Get all the seeds: The server seed is revealed after the round completes
  2. Run the calculation: Use this formula with the revealed server seed, your client seed, and the round number
  3. Compare results: Your calculated crash point should match the actual crash point to the hundredth of a percent
  4. Verify the hash: Hash the server seed alone and compare it to the hash shown before the bet—they must match
🔒 Key Insight: If the server seed hash matches before the bet, and your calculations produce the same crash point, the game was definitely fair. FantasyMarket could not have changed the outcome.

You can manually verify any previous round using the Verify button in the Provably Fair section of the game.

🎯 Why This Design Matters

Transparency

Every component (server seed, client seed, round number) is shown to you. Nothing is hidden. You can verify the math yourself using any SHA-256 calculator.

Fairness

The outcome is determined before you place your bet (by the server seed hash). FantasyMarket cannot change the outcome after you bet.

Responsibility

You control the client seed, so you have influence over the randomness. You can even set a custom seed if you wish.

Mathematical Certainty

SHA-256 is a one-way cryptographic function. The outcome cannot be reversed or manipulated. The same inputs will always produce the same output.

🛠️ Verification Tools

Using FantasyMarket's Verification Tool

The easiest way to verify a round is to:

  1. Complete a game round
  2. Click the "Verify" button in the Provably Fair section
  3. The tool will automatically calculate and compare results

Manual Verification (Advanced)

If you want to verify manually, you'll need:

  • A SHA-256 calculator (online or local tool)
  • The revealed server seed, client seed, and round number
  • The original crash point for comparison

Recommended SHA-256 Tools

  • Online: Search "SHA-256 online calculator" in your browser
  • Terminal: Use echo -n "your_string" | sha256sum (Linux/Mac)
  • Python: Use the hashlib library

🤝 Our Transparency Pledge

FantasyMarket is committed to provably fair gaming:

  • ✅ Every outcome is mathematically predetermined
  • ✅ All inputs are transparent and verifiable
  • ✅ The algorithm is explained in detail (this document)
  • ✅ You can verify any round independently
  • ✅ No changes can be made after bets are placed

If you ever have doubts about fairness, you can always verify the math yourself. That's the whole point of provably fair gaming.

← Back to Game Home →