Provably Fair Gaming

What is Provably Fair?

All our games are built on a provably fair foundation, ensuring complete transparency and verifiability of every game outcome. This system allows players to independently verify that game results are fair and have not been manipulated.

How It Works

The Foundation

Every game starts with a pre-generated game hash that is displayed before the game begins. This hash serves as proof that the outcome was predetermined and cannot be changed after you see it. The hash is based on a randomly generated seed.

Blockchain Integration

Once a game starts, we select a non-mined EOS blockchain block. The block number is made public immediately, ensuring full transparency before it is mined. When the block is mined, we retrieve its transaction hash (transaction ID).

Outcome Generation

The transaction ID is combined with the pre-generated game hash and any additional game-specific data. This combined string is then hashed using SHA-512. From the resulting hash, we extract the first 16 characters and convert them into an integer, which determines the game outcome.

Single-player Games

For single-player games, we also provide the seed on the end of the game which is what the game hash was generated from. This allows players to verify the game hash itself.

Interactive Game Demonstrations

Test our provably fair algorithms with real examples. Each tab below contains the algorithm explanation, code implementation, and an interactive form where you can input your own values to see how the outcomes are calculated.

PvP Flip

Coinflip

Pengu Pump

Scratch Cards

PvP Flip

Proportional betting system where the side with higher bet amounts has a higher chance of winning.

Game Hash

Transaction ID

Game ID

EOS Block

Amount solpengu

Amount snowfox

PvP Flip history

pvpFlip

Loading history…


// All of these parameters is required. AMOUNT_X is amount of total wager of each side. Since percentage is based on total wager on each side.
// These variables can be found either in your game history or from the end result provided on the end of the game.
// You can also grab fresh sample data from the Provable Fair page.

const GAME_HASH = "";
const TRANSACTION_ID = "";
const GAME_ID = "";
const AMOUNT_SOLPENGU = 0.1;
const AMOUNT_SNOWFOX = 0.1;

async function getCoinFlipSide(gameHash, transactionId, gameId, amountSolpengu, amountSnowfox) {
  const combinedInput = `${gameHash}${transactionId}${gameId}`;
  const finalHash = await hash(combinedInput);
  
  const hashString = typeof finalHash === 'string' ? finalHash : Array.from(finalHash, byte => byte.toString(16).padStart(2, '0')).join('');
  const hashSubstring = hashString.substring(0, Math.min(16, hashString.length));

  console.log("Hash pre-computed: %s", hashSubstring);

  const hashValue = BigInt("0x" + hashSubstring);
  const mod = BigInt(10000000);

  console.log("Hashed value: %s, bet on solpengu: %s SOL, bet on snowfox: %s SOL.", hashValue, amountSolpengu, amountSnowfox);

  const ticketsSolpengu = BigInt(Math.round(amountSolpengu * Number(mod)));
  const ticketsSnowfox = BigInt(Math.round(amountSnowfox * Number(mod)));

  const totalBetAmount = ticketsSolpengu + ticketsSnowfox;

  if (totalBetAmount <= 0n) {
    return 'UNKNOWN';
  }
  
  const randomValue = hashValue % totalBetAmount;
  const wonSide = randomValue < ticketsSolpengu ? "SOLPENGU" : "SNOWFOX";

  console.log("Ticket: #%s, won side: %s", randomValue, wonSide);

  return wonSide;
}

async function hash(input) {
  const encoder = new TextEncoder();
  const data = encoder.encode(input);
  const hashBuffer = await crypto.subtle.digest('SHA-512', data);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
}

getCoinFlipSide(GAME_HASH, TRANSACTION_ID, GAME_ID, AMOUNT_SOLPENGU, AMOUNT_SNOWFOX);

Loading…

Verification

You can verify any game result by:

Collecting the inputs: Note the game hash (shown before the game), transaction ID (from the EOS blockchain), and game ID
Running the algorithm: Use the appropriate algorithm code for your game type
Comparing results: The calculated outcome should match the actual game result

All algorithms use standard cryptographic functions (SHA-512) and are deterministic, meaning the same inputs will always produce the same outputs.

Transparency Guarantee

Our provably fair system ensures:

Pre-commitment: Game hashes are generated and shown before games begin
Blockchain dependency: Outcomes depend on unpredictable blockchain data
Open algorithms: All calculation methods are publicly available
Independent verification: Anyone can verify results using the provided data

This system guarantees that neither the house nor players can manipulate game outcomes, creating a truly fair gaming environment.