🔐 Fair Play System: Multiplayer Hash Chain Generation

Overview

To ensure transparency and provable fairness we have generated a chain of 10 million SHA256 hashes for each multiplayer game, starting with a server secret that has been repeatedly fed the output of SHA256 back into itself 10 million times

The SHA256 of the final hash for Platform is: eeb4d340bfaed702601b9a08faba2f8088c4810c3e3a883293accaf25053b883

The SHA256 of the final hash for Crash is: c46f0705f6ba4df891ce44accda8f89f5a6fa8b987eb7c7b445280cf6cabfbc6

The SHA256 of the final hash for Battle is: 63cb1eb64ec4eb4de02f6bad85e42365d08f37497a1b7e907bd0b9183f27e1b3

By publicising it here we are preventing any ability to pick an alternate SHA256 chain. Now the game server is playing through this chain of hashes in reverse order, using these values to calculate the game results provably fair.

How It Works

1. Secret Initial Hash: Each multiplayer game type has its own private initial hash (known only to the server), forming the root of a unique hash chain.

2. Hash Chain Generation: From the initial secret hash, we generate a chain of 10,000,000 hashes by applying SHA256 repeatedly.

  func HashSeed(seed string) string {
      hash := sha256.Sum256([]byte(seed))
      return hex.EncodeToString(hash[:])
  }

  func CalculateHashChain(firstHash string) []string {
    hashes := make([]string, 10_000_000)
    for i := int64(0); i <= 10_000_000; i++ {
      firstHash = HashSeed(firstHash)
      hashes[i] = firstHash
    }
    return hashes
  }

3. Reverse Consumption: We reveal the final hash in the chain to the public. Each game round consumes the hashes in reverse order: Round 1 uses hash[10_000_000] Round 2 uses hash[9_999_999] and so on…

4. This design makes it impossible to forge future hashes, while allowing anyone to verify all previous hashes.

🔒 Security & Fairness Benefits

Unpredictability: Future game outcomes cannot be known or influenced, even by the server.

Verifiability: Players can verify the integrity of any previous round using only the publicly revealed final hash.

Game Isolation: Each game type has its own chain, preventing cross-game manipulation.

Fair Play for Single-Player Games

To ensure provable fairness in single-player games, our platform uses a system based on three main components to generate the result seed:

1. Client Seed: This is a user-controlled seed. It is automatically generated when a user registers, but the user can change it at any time. Changing the client seed initiates the generation of a new server seed.

2. Server Seed: This is generated by the server using internal parameters that are not disclosed to the user. It is uniquely bound to the current client seed. For each client seed, there is a corresponding server seed. When the user changes the client seed, the previous server seed is revealed for verification purposes.

3. Nonce: A unique number that is based on the timestamp of the bet (in milliseconds). It ensures that even repeated actions produce different outcomes.

Game Seed Generation

These three values are combined and hashed using HMAC-SHA256 to generate the final game seed, which is then used to determine the result of the game.

  func GenerateUserGameSeed(userSeed string, userServerSeed string, nonce int64) (string, error) {
    data := fmt.Sprintf("%s:%s:%d", userServerSeed, userSeed, nonce)
    mac := hmac.New(sha256.New, []byte(data))
    gameSeed := hex.EncodeToString(mac.Sum(nil))
    return gameSeed, nil
  }

Verification

The server provides the hashed version of the current server seed before any bet is made.

After the user changes their client seed, the previously used server seed is revealed.

This allows users to verify that all results generated with the previous server seed were consistent and fair.

🎲 Dice Game – Result Calculation

In the Dice game, a user selects from 1 to 5 numbers (out of 6 possible sides). A single dice roll is simulated using the generated game seed. If the rolled number matches one of the user's selections, the user wins.

  func rollDice(seed string, selectedNumbers []int64) (int64, bool, error) {
    if len(selectedNumbers) < 1 || len(selectedNumbers) > 5 {
      return 0, false, fmt.Errorf("incorrect number of selected numbers: %d", len(selectedNumbers))
    }

    bigSeed, ok := new(big.Int).SetString(seed, 16)
    if !ok {
      return 0, false, fmt.Errorf("failed to convert seed to big.Int")
    }

    // Simulate dice roll: number from 1 to 6
    dice := new(big.Int).Mod(bigSeed, big.NewInt(6))
    diceFace := dice.Int64() + 1

    for _, num := range selectedNumbers {
      if num == diceFace {
        return diceFace, true, nil
      }
    }

    return diceFace, false, nil
  }

💣 Mines Game – Mine Placement Logic

In the Mines game, the objective is to uncover as many tiles as possible without hitting a mine. The placement of mines is derived deterministically using a cryptographically secure game seed. This ensures fairness and transparency, allowing the user to verify that the game board was not manipulated.

Inputs:

seed: a 64-character hex string derived from the combination of ClientSeed, ServerSeed, and Nonce using HMAC-SHA256.

numberOfMines: the number of mines to place on the board.

maxCells: total number of cells on the board (e.g., 25 for a 5x5 grid).

Go Code

func generateMines(seedHex string, numberOfMines int) ([]int64, error) {
	if numberOfMines > 25 {
		return nil, fmt.Errorf("invalid number of mines: %d", numberOfMines)
	}

	var mines []int64
	used := make(map[int]bool)
	i := 0

	for len(mines) < numberOfMines {
		mac := hmac.New(sha256.New, []byte(seedHex))
		mac.Write([]byte(fmt.Sprintf("mine-%d", i)))
		sum := mac.Sum(nil)

		val := binary.BigEndian.Uint32(sum)
		pos := int(val%25) + 1

		if !used[pos] {
			used[pos] = true
			mines = append(mines, int64(pos))
		}
		i++
	}

	return mines, nil
}

Example

If numberOfMines = 3 and maxCells = 25, the function will deterministically return 3 unique cell indices (from 1 to 25) where mines are placed.

🕹 Platforms — Game Logic

In the Platforms game, the result of each round is determined by a public, verifiable hash that is part of a previously published hash chain.

📌 Platform Drop Logic

Each round uses a hash from the chain to determine the "last platform" — the platform that will disappear at the end of the game.

    func generateLastPlatform(hash string) (int64, error) {
      h, err := hex.DecodeString(hash)
      if err != nil {
        return 0, err
      }

      number := binary.BigEndian.Uint64(h[:8])

      rng := rand.New(rand.NewSource(int64(number)))
      randomNumber := rng.Intn(25) + 1 // Platforms are numbered 1 through 25

      return int64(randomNumber), nil
    }

🎯 Platform Drop in Real Time

During gameplay, players stand on different platforms. The platform that drops is randomly selected from the available platforms, ensuring it is never the same as the previously dropped one.

🚀 Rocket — Game Logic

In Rocket, each round result (crash multiplier) is determined using a public hash from the pre-generated hash chain (unique per game). The outcome is calculated using a deterministic function that converts the hash into a multiplier.

  func generateMultiplier(hash string) (float64, error) {
    const N = 40

    bigH, ok := new(big.Int).SetString(hash, 16)
    if !ok {
      return 0, fmt.Errorf("failed to convert seed to big.Int")
    }

    mod := new(big.Int).Mod(bigH, big.NewInt(N))
    if mod.Cmp(big.NewInt(0)) == 0 {
      return 1, nil
    }

    if len(hash) < 13 {
      return 0, fmt.Errorf("hash too short")
    }
    h13Str := hash[:13]
    bigH13, ok := new(big.Int).SetString(h13Str, 16)
    if !ok {
      return 0, fmt.Errorf("failed to convert first 13 hex digits to big.Int")
    }

    // Compute 100 * (2^52 - h) / (2^52 - h)
    e := new(big.Int).Lsh(big.NewInt(1), 52) // 2^52
    hundred := big.NewInt(100)
    hundredE := new(big.Int).Mul(hundred, e)
    numerator := new(big.Int).Sub(hundredE, bigH13)
    denom := new(big.Int).Sub(e, bigH13)

    numFloat := new(big.Float).SetInt(numerator)
    denomFloat := new(big.Float).SetInt(denom)
    ratio, _ := new(big.Float).Quo(numFloat, denomFloat).Float64()

    floored := math.Floor(ratio)
    result := floored / 100.0

    return result, nil
  }

Every player receives the hash before the round, and can independently verify that the result matches the published formula, ensuring full transparency and provable fairness.

🎲 Battle — Weighted Roulette Fairness

In Battle, one player is selected as a winner based on the proportional size of their bet to the total pool. This means larger bets result in higher chances of winning.

We use a deterministic and provably fair selection mechanism:

1. A public game hash is used to generate a pseudo-random number in the range [0.0, 1.0).

2. Each player is assigned a segment of the range proportional to their bet (e.g. a 20% bet covers 20% of the range).

3. The random number determines the winning segment, and thus the winner.

  func pickWinner(hash string, chances []float64) (int, error) {
    if len(chances) == 0 {
      return -1, fmt.Errorf("zero participants")
    }

    total := 0.0
    for _, chance := range chances {
      if chance < 0 {
        return -1, fmt.Errorf("chance cannot be negative")
      }
      total += chance
    }

    if total < 99.99 || total > 100.01 {
      return -1, fmt.Errorf("sum of chances must be 100%%, got: %.2f%%", total)
    }

    randomValue, err := deterministicFloatFromHash(hash)
    if err != nil {
      return -1, fmt.Errorf("random generation failed: %w", err)
    }

    cumulative := 0.0
    for i, chance := range chances {
      cumulative += chance / 100.0
      if randomValue < cumulative {
        return i, nil
      }
    }

    return -1, fmt.Errorf("failed to pick winner")
  }

  func deterministicFloatFromHash(hash string) (float64, error) {
    bytes, err := hex.DecodeString(hash)
    if err != nil {
      return 0, err
    }
    if len(bytes) < 8 {
      return 0, fmt.Errorf("hash too short")
    }
    num := binary.BigEndian.Uint64(bytes[:8])
    return float64(num) / float64(math.MaxUint64), nil
  }