Fairness & Transparency

We believe in 100% transparency. Here is how our system works.

Provably Fair

Every outcome is generated using a cryptographically secure random number generator that you can verify.

Known Odds

We display the exact probability for every item in every box. No hidden variables.

Secure Audits

The verification math is public, deterministic, and can be reproduced independently using any standard crypto tools.

How to verify

You don’t need to “trust us”. You can verify the randomness yourself. There are two checks: (1) the server seed was committed before the roll, and (2) the roll number was computed correctly.

1) Check the commitment (most important)
  1. Before opening, copy Server Seed Hash from the “Provably Fair” modal.
  2. Open the box and wait until it fully reveals.
  3. After reveal, copy the Server Seed.
  4. Hash it with SHA-256 and confirm it equals the Server Seed Hash you saved.
If the hash matches, the server couldn’t “swap seeds” after seeing your result.
2) Check the roll number (optional)
  1. Copy Client Seed and Nonce from the modal.
  2. Use the verifier below (or run the code snippet in the “Advanced” section).
  3. Compare the computed roll to the “Roll Outcome” shown in the modal.
This proves the shown roll outcome comes from the exact same inputs.
What each value means
  • Server Seed: secret key (revealed after the roll).
  • Server Seed Hash: public fingerprint of the next server seed (shown before the roll).
  • Client Seed: value you control (you can change it before rolling).
  • Nonce: a counter that changes every roll so each roll is unique.
  • Roll Outcome: the computed result (0–100) used to select the winning item.
Important note

The Server Seed Hash is shown before the roll, but the Server Seed is not. Hashes are one-way, so seeing the hash does not reveal the secret seed.

Verify Box Open

Paste the Server Seed, Client Seed, and Nonce from the box “Provably Fair” modal. This will calculate the exact roll outcome (0–100) so you can compare it to what the game showed.

Verify Battle Result

Auto: 0

Advanced (for power users)

If you don’t want to use our website verifier, you can reproduce everything yourself using standard cryptography tools.

Box algorithm details (exact steps)
Box roll algorithm (what we verify):
1) message = clientSeed + ":" + nonce
2) hmacHex = HMAC_SHA256(key=serverSeed, message=message)  // hex string
3) subHash = first 8 hex chars of hmacHex (32 bits)
4) decimal = parseInt(subHash, 16)
5) roll = (decimal / 2^32) * 100   // gives [0, 100)
Copy/paste Node.js verifier (box opens)

Run locally with Node.js (recommended), or in any online Node runner. Replace the 3 values.

const crypto = require("crypto");

const serverSeed = "PASTE_SERVER_SEED";
const clientSeed = "PASTE_CLIENT_SEED";
const nonce = Number("PASTE_NONCE"); // e.g. 12

// 1) Verify commitment (optional but recommended)
const serverSeedHash = crypto.createHash("sha256").update(serverSeed).digest("hex");
console.log("sha256(serverSeed):", serverSeedHash);

// 2) Verify roll outcome
const message = `${clientSeed}:${nonce}`;
const hmac = crypto.createHmac("sha256", serverSeed).update(message).digest("hex");
const subHash = hmac.slice(0, 8);
const decimal = parseInt(subHash, 16);
const roll = (decimal / 4294967296) * 100;

console.log({ message, hmac, subHash, decimal, roll });
Battle verifier note (RNG v2)

Battles use a versioned message that includes battle context (battleId, roundIndex, seatIndex) in addition to seeds and nonce. This prevents reusing the same seeds across different battles to get the same output.

Tip: you can use the “Verify Battle Result” tool above, or replicate the same logic with HMAC-SHA256 using the v2 message format.

Item Rarity Tiers

Common
50-80%
Rare
15-30%
Ultra-Rare
1-5%
Legendary
< 1%

How Randomization Works

When you create a battle, our server generates a random Server Seed. We immediately show you the hash of this seed so you know we cannot change it later.

Each player has their own Client Seed (or one is randomly generated). This ensures that players have influence over the outcome, making it impossible for the server to pre-determine a loss.

For battles, we use a versioned message that includes the battleId, roundIndex, and seatIndex, plus a deterministic nonce. This roll determines which item you get from the box.