Chat
0/2203
Live Drop

Provably Fair

Is Roulette fair game?

  • We are a fair and transparent betting platform, aiming to eliminate all unfair factors and let players have fun, provides HashDice with provable and verified system that allows each game fair in encrypted way.
  • In order to allow players to verify their bets, a pair of Server Seed and Client Seed is used to calculate a roll number.
  • Knowing Server Seed, Client Seed and Nonce it's possible to calculate bet result. To prevent a player from result prediction, Server Seed is hidden, and a SHA-256 hash of the seed is shown instead. After next randomization, previous Server Seed is revealed and a player is able to verify the bet. Also, players can make sure that Server Seed wasn't changed by comparing their hashes before and after randomization.

How it works

In order to allow players to verify their bets, a pair of Server Seed and Client Seed is used to calculate a roll number.

  • Public Seed - a concatenation of 6 pairs of random numbers, 00 to 39, generated daily at 00:00 UTC
  • Server Seed a SHA - 256 hash of 16 cryptographically secure random bytes, generated at the same time as the public seed
  • Round ID - the round's unique identifier, which increments by 1 each roun

We publish a SHA-256 hashed version of the server seed for the current day so you can ensure it never changes. At the end of the day, we publish the unlashed server seed for you to verify rollswith.


function calculateHash(clientSeed, nonce, serverSeed) {
  const crypto = require('crypto');

  // Step 1: Calculate HMAC-SHA256 hash
  const hmac = crypto
    .createHmac('sha256', serverSeed)
    .update(`${clientSeed}:${nonce}`)
    .digest('hex');

  // Step 2: Take the first 15 characters
  const first15Chars = hmac.substring(0, 15);

  // Step 3: Convert to decimal
  const decimalValue = BigInt(`0x${first15Chars}`);

  // Step 4: Perform modulus 47
  const remainder = decimalValue % 47n;

  // Step 5: Take 14 characters starting from the index (assume starting index = remainder)
  const startIndex = Number(remainder);
  const next14Chars = hmac.substring(startIndex, startIndex + 14);

  // Step 6: Convert to decimal
  const nextDecimalValue = BigInt(`0x${next14Chars}`);

  // Step 7: Divide by 8, multiply by 2^-53, multiply by 10000
  const result =
    (Number(nextDecimalValue) / 8) *
    Math.pow(2, -53) *
    10000;

  // Step 8: Take the integer part
  return Math.floor(result);
}


const clientSeed = "2wzp443ewBZXa1yT";
const nonce = 0;
const serverSeed = "8SuBhXE3F2TFfAorCyE4qozN0pWUqF5p1hW5NFVJzWocs19pXUzkxTOT";

const result = calculateHash(clientSeed, nonce, serverSeed);
console.log(result); // 110.82

Validate Round result

Date User Public Seed Rolls
2024-05-1063329f6b91076e63d2196123d3189... 63329f6b91076e63d2196123d31899628688 - 9630672
2024-05-1063329f6b91076e63d2196123d3189...
63329f6b91076e63d2196123d3189
9628688 - 9630672
2024-05-1063329f6b91076e63d2196123d3189...
63329f6b91076e63d2196123d3189
9628688 - 9630672

Is Open Case a fair game?

  • We are a fair and transparent betting platform, aiming to eliminate all unfair factors and let players have fun, provides HashDice with provable and verified system that allows each game fair in encrypted way.
  • In order to allow players to verify their bets, a pair of Server Seed and Client Seed is used to calculate a roll number.
  • Knowing Server Seed, Client Seed and Nonce it's possible to calculate bet result. To prevent a player from result prediction, Server Seed is hidden, and a SHA-256 hash of the seed is shown instead. After next randomization, previous Server Seed is revealed and a player is able to verify the bet. Also, players can make sure that Server Seed wasn't changed by comparing their hashes before and after randomization.

How it works

The result for each case opening is generated by the following logic.

  • 1- The server seed is a cryptographically secure pseudo-randomly generated string
  • 2- The nonce is a number that is incremented every time the server seed is used
  • 3- The client seed is a user-defined (or random by default) string. You can change this to be whatever you want from the info tab
  • 4- The pre-result is calculated based on server seed, client seed, nonce and case number.
  • 5-Then we pick a result between 1 and qty, where the qty is the total number of tickets (determined by the chosen case).
  • 6- Every item in the case has its own number range, which is used to pick the winning item based on the result. 

function calculateHash(clientSeed, nonce, serverSeed) {
  const crypto = require('crypto');

  // Step 1: Calculate HMAC-SHA256 hash
  const hmac = crypto
    .createHmac('sha256', serverSeed)
    .update(`${clientSeed}:${nonce}`)
    .digest('hex');

  // Step 2: Take the first 15 characters
  const first15Chars = hmac.substring(0, 15);

  // Step 3: Convert to decimal
  const decimalValue = BigInt(`0x${first15Chars}`);

  // Step 4: Perform modulus 47
  const remainder = decimalValue % 47n;

  // Step 5: Take 14 characters starting from the index (assume starting index = remainder)
  const startIndex = Number(remainder);
  const next14Chars = hmac.substring(startIndex, startIndex + 14);

  // Step 6: Convert to decimal
  const nextDecimalValue = BigInt(`0x${next14Chars}`);

  // Step 7: Divide by 8, multiply by 2^-53, multiply by 10000
  const result =
    (Number(nextDecimalValue) / 8) *
    Math.pow(2, -53) *
    10000;

  // Step 8: Take the integer part
  return Math.floor(result);
}


const clientSeed = "2wzp443ewBZXa1yT";
const nonce = 0;
const serverSeed = "8SuBhXE3F2TFfAorCyE4qozN0pWUqF5p1hW5NFVJzWocs19pXUzkxTOT";

const result = calculateHash(clientSeed, nonce, serverSeed);
console.log(result); // 110.82

How are results calculated?

First, combine the server seed, client seed and the nonce to get the SHA512 hash
  • We use the combination to compute the HMAC_SHA512 hash. This gives us a 128-character hex string: hash = HMAC_SHA512 (client Seed: nonce, server Seed)
  • Then we take the first 5 characters of the 128 character hex string and convert them to a decimal number from 0 to 1,048,575 (16 ^ 5-1). If it is less than 1 million, it is used as the random number. If it is more than 1 million, we use the next five characters from the same 128 character hex string. We are able to repeat the process up to 25 times.
  • In very rare cases ((48,576 / 1,000,000) ^ 25) When converting to decimal, none of the 25 trials are below 1 million, we use the remaining 3 characters and convert them to your random number.
We hope that having all this information at your disposal will reassure you that Open Case is an entirely honest and transparent game. Win with us, enjoy yourself, and does not hesitate to contact support if you have any questions.

Is Case Battle a fair game?

  • CaseBattles uses a provably fair system in which the public seed is not known until after a battle game has started. The result for each round is generated using the SHA-256 hash of 4 separate inputs

How it works

The result for each case opening is generated by the following logic.

  • 1- The "server seed" is a securely random value generated when a battle is created. The SHA-256 hash of the server seed is immediately shown to all players after the battle creation. Players can verify the server seed revealed following the battle result matches this SHA-256 hash.
  • 2- The "public seed" is the ID of an EOS block, chosen to be generated after the final challenger joins a battle.
  • 3- Once the last player joins, our system selects an EOS blockchain block number that will be produced in the near future. The ID of this block serves as the public seed. This ensures that neither the players nor our system can predict the data that will determine the items that are pulled from each case in the battle rounds until all players have committed their bets.
  • 4- Round Number
  • 5- Player Position - (1 to 4), depending on the battle mode.
  • Please note that the order of the players shown on the table is the same as in the battle page when you joined the battle, and that indicates the player position for the seed.
  • In the event of a tie, the system initiates an additional Tiebreaker round.
  • The Tiebreaker round's result is calculated using the SHA-256 hash of 3 distinct inputs:
  • 1-The "server seed"
  • 2- The "public seed"
  • 3- Last Round Number + 1
  • And the number of tickets is determined by how many people are participating on the tiebreaker.
  • Your position on the tiebreaker is in ascending order. As an example, if 3 people are in a tiebreaker, the assigned ticket goes from left to right. This means that if players in position 2 and 3 are in a tiebreaker, the ticket number 1 is assigned to player 2 and the ticket number 2 is assigned to player 3.
  • In case of a team battle tie, the CT side is always ticket 1 and T side is always ticket number 2.

function calculateHash(clientSeed, nonce, serverSeed) {
  const crypto = require('crypto');

  // Step 1: Calculate HMAC-SHA256 hash
  const hmac = crypto
    .createHmac('sha256', serverSeed)
    .update(`${clientSeed}:${nonce}`)
    .digest('hex');

  // Step 2: Take the first 15 characters
  const first15Chars = hmac.substring(0, 15);

  // Step 3: Convert to decimal
  const decimalValue = BigInt(`0x${first15Chars}`);

  // Step 4: Perform modulus 47
  const remainder = decimalValue % 47n;

  // Step 5: Take 14 characters starting from the index (assume starting index = remainder)
  const startIndex = Number(remainder);
  const next14Chars = hmac.substring(startIndex, startIndex + 14);

  // Step 6: Convert to decimal
  const nextDecimalValue = BigInt(`0x${next14Chars}`);

  // Step 7: Divide by 8, multiply by 2^-53, multiply by 10000
  const result =
    (Number(nextDecimalValue) / 8) *
    Math.pow(2, -53) *
    10000;

  // Step 8: Take the integer part
  return Math.floor(result);
}


const clientSeed = "2wzp443ewBZXa1yT";
const nonce = 0;
const serverSeed = "8SuBhXE3F2TFfAorCyE4qozN0pWUqF5p1hW5NFVJzWocs19pXUzkxTOT";

const result = calculateHash(clientSeed, nonce, serverSeed);
console.log(result); // 110.82

Is Upgrader a fair game?

  • We are a fair and transparent betting platform, aiming to eliminate all unfair factors and let players have fun, provides HashDice with provable and verified system that allows each game fair in encrypted way.
  • In order to allow players to verify their bets, a pair of Server Seed and Client Seed is used to calculate a roll number.
  • Knowing Server Seed, Client Seed and Nonce it's possible to calculate bet result. To prevent a player from result prediction, Server Seed is hidden, and a SHA-256 hash of the seed is shown instead. After next randomization, previous Server Seed is revealed and a player is able to verify the bet. Also, players can make sure that Server Seed wasn't changed by comparing their hashes before and after randomization.

How it works

How is the data calculated?

To generate a roll number between 0 and 99,999:

  • First we calculate the hash value of the combination with HMAC_SHA512. This gives us a 64-character hexadecimal string: hash = HMAC_SHA512 (clientSeed:nonce, serverSeed)
  • We then take the first 5 characters of that hash and convert them to a decimal number ranging from 0 to 1,048,575 (165-1). If it is less than 1 million, we divide it by 100,000 and use it as your roll outcome. Otherwise, we repeat using the next five characters. We are able to repeat the process up to 25 times.
  • In the very rare case ((48,576/1,000,000)^25) that none of the 25 trials are lower than 1 million when converted to decimal, we use the remaining 3 characters and convert them to your roll number. Code Example 25 times.

The following code example can be used to verify a bet:


function calculateHash(clientSeed, nonce, serverSeed) {
  const crypto = require('crypto');

  // Step 1: Calculate HMAC-SHA256 hash
  const hmac = crypto
    .createHmac('sha256', serverSeed)
    .update(`${clientSeed}:${nonce}`)
    .digest('hex');

  // Step 2: Take the first 15 characters
  const first15Chars = hmac.substring(0, 15);

  // Step 3: Convert to decimal
  const decimalValue = BigInt(`0x${first15Chars}`);

  // Step 4: Perform modulus 47
  const remainder = decimalValue % 47n;

  // Step 5: Take 14 characters starting from the index (assume starting index = remainder)
  const startIndex = Number(remainder);
  const next14Chars = hmac.substring(startIndex, startIndex + 14);

  // Step 6: Convert to decimal
  const nextDecimalValue = BigInt(`0x${next14Chars}`);

  // Step 7: Divide by 8, multiply by 2^-53, multiply by 10000
  const result =
    (Number(nextDecimalValue) / 8) *
    Math.pow(2, -53) *
    10000;

  // Step 8: Take the integer part
  return Math.floor(result);
}


const clientSeed = "2wzp443ewBZXa1yT";
const nonce = 0;
const serverSeed = "8SuBhXE3F2TFfAorCyE4qozN0pWUqF5p1hW5NFVJzWocs19pXUzkxTOT";

const result = calculateHash(clientSeed, nonce, serverSeed);
console.log(result); // 110.82

Is Plinko a fair game?

  • We are a fair and transparent betting platform, aiming to eliminate all unfair factors and let players have fun, provides HashDice with provable and verified system that allows each game fair in encrypted way.
  • In order to allow players to verify their bets, a pair of Server Seed and Client Seed is used to calculate a roll number.
  • Knowing Server Seed, Client Seed and Nonce it's possible to calculate bet result. To prevent a player from result prediction, Server Seed is hidden, and a SHA-256 hash of the seed is shown instead. After next randomization, previous Server Seed is revealed and a player is able to verify the bet. Also, players can make sure that Server Seed wasn't changed by comparing their hashes before and after randomization.

How it works

  • Solving the Trust Issue with Online Gambling
  • underlying concept of provable fairness is that players have the ability to prove and verify that their results are fair and unmanipulated. This is The achieved through the use of a commitment scheme, along with cryptographic hashing.
  • The commitment scheme is used to ensure that the player has an influence on all results generated. Cryptographic hashing is used to ensure that the casino also remains honest to this commitment scheme. Both concepts combined creates a trust-less environment when gambling online
  • This is simplified in the following representation:
  • First, hash HMAC_SHA512(clientSeed:nonce, serverSeed)
  • Finally, we divide the hash into 16 groups in groups of 8 characters, each group will be converted to a number in the range (0, 1). If it is less than 0.5, the ball will fall to the left, otherwise it will fall to the right.

Note: A new seed must be set to verify the previous data (the server seed is encrypted)


function calculateHash(clientSeed, nonce, serverSeed) {
  const crypto = require('crypto');

  // Step 1: Calculate HMAC-SHA256 hash
  const hmac = crypto
    .createHmac('sha256', serverSeed)
    .update(`${clientSeed}:${nonce}`)
    .digest('hex');

  // Step 2: Take the first 15 characters
  const first15Chars = hmac.substring(0, 15);

  // Step 3: Convert to decimal
  const decimalValue = BigInt(`0x${first15Chars}`);

  // Step 4: Perform modulus 47
  const remainder = decimalValue % 47n;

  // Step 5: Take 14 characters starting from the index (assume starting index = remainder)
  const startIndex = Number(remainder);
  const next14Chars = hmac.substring(startIndex, startIndex + 14);

  // Step 6: Convert to decimal
  const nextDecimalValue = BigInt(`0x${next14Chars}`);

  // Step 7: Divide by 8, multiply by 2^-53, multiply by 10000
  const result =
    (Number(nextDecimalValue) / 8) *
    Math.pow(2, -53) *
    10000;

  // Step 8: Take the integer part
  return Math.floor(result);
}


const clientSeed = "2wzp443ewBZXa1yT";
const nonce = 0;
const serverSeed = "8SuBhXE3F2TFfAorCyE4qozN0pWUqF5p1hW5NFVJzWocs19pXUzkxTOT";

const result = calculateHash(clientSeed, nonce, serverSeed);
console.log(result); // 110.82

Is Dice a fair game?

  • We are a fair and transparent betting platform, aiming to eliminate all unfair factors and let players have fun, provides HashDice with provable and verified system that allows each game fair in encrypted way.
  • In order to allow players to verify their bets, a pair of Server Seed and Client Seed is used to calculate a roll number.
  • Knowing Server Seed, Client Seed and Nonce it's possible to calculate bet result. To prevent a player from result prediction, Server Seed is hidden, and a SHA-256 hash of the seed is shown instead. After next randomization, previous Server Seed is revealed and a player is able to verify the bet. Also, players can make sure that Server Seed wasn't changed by comparing their hashes before and after randomization.

How it works

How is the data calculated?

To generate a roll number between 0 and 99,999:

  • First we calculate the hash value of the combination with HMAC_SHA512. This gives us a 64-character hexadecimal string: hash = HMAC_SHA512 (clientSeed:nonce, serverSeed)
  • We then take the first 5 characters of that hash and convert them to a decimal number ranging from 0 to 1,048,575 (165-1). If it is less than 1 million, we divide it by 100,000 and use it as your roll outcome. Otherwise, we repeat using the next five characters. We are able to repeat the process up to 25 times.
  • In the very rare case ((48,576/1,000,000)^25) that none of the 25 trials are lower than 1 million when converted to decimal, we use the remaining 3 characters and convert them to your roll number. Code Example 25 times.

The following code example can be used to verify a bet:


function calculateHash(clientSeed, nonce, serverSeed) {
  const crypto = require('crypto');

  // Step 1: Calculate HMAC-SHA256 hash
  const hmac = crypto
    .createHmac('sha256', serverSeed)
    .update(`${clientSeed}:${nonce}`)
    .digest('hex');

  // Step 2: Take the first 15 characters
  const first15Chars = hmac.substring(0, 15);

  // Step 3: Convert to decimal
  const decimalValue = BigInt(`0x${first15Chars}`);

  // Step 4: Perform modulus 47
  const remainder = decimalValue % 47n;

  // Step 5: Take 14 characters starting from the index (assume starting index = remainder)
  const startIndex = Number(remainder);
  const next14Chars = hmac.substring(startIndex, startIndex + 14);

  // Step 6: Convert to decimal
  const nextDecimalValue = BigInt(`0x${next14Chars}`);

  // Step 7: Divide by 8, multiply by 2^-53, multiply by 10000
  const result =
    (Number(nextDecimalValue) / 8) *
    Math.pow(2, -53) *
    10000;

  // Step 8: Take the integer part
  return Math.floor(result);
}


const clientSeed = "2wzp443ewBZXa1yT";
const nonce = 0;
const serverSeed = "8SuBhXE3F2TFfAorCyE4qozN0pWUqF5p1hW5NFVJzWocs19pXUzkxTOT";

const result = calculateHash(clientSeed, nonce, serverSeed);
console.log(result); // 110.82

Is Dice a fair game?

  • We are a fair and transparent betting platform, aiming to eliminate all unfair factors and let players have fun, provides HashDice with provable and verified system that allows each game fair in encrypted way.
  • In order to allow players to verify their bets, a pair of Server Seed and Client Seed is used to calculate a roll number.
  • Knowing Server Seed, Client Seed and Nonce it's possible to calculate bet result. To prevent a player from result prediction, Server Seed is hidden, and a SHA-256 hash of the seed is shown instead. After next randomization, previous Server Seed is revealed and a player is able to verify the bet. Also, players can make sure that Server Seed wasn't changed by comparing their hashes before and after randomization.

How it works

How is the data calculated?

To generate a roll number between 0 and 99,999:

  • First we calculate the hash value of the combination with HMAC_SHA512. This gives us a 64-character hexadecimal string: hash = HMAC_SHA512 (clientSeed:nonce, serverSeed)
  • We then take the first 5 characters of that hash and convert them to a decimal number ranging from 0 to 1,048,575 (165-1). If it is less than 1 million, we divide it by 100,000 and use it as your roll outcome. Otherwise, we repeat using the next five characters. We are able to repeat the process up to 25 times.
  • In the very rare case ((48,576/1,000,000)^25) that none of the 25 trials are lower than 1 million when converted to decimal, we use the remaining 3 characters and convert them to your roll number. Code Example 25 times.

The following code example can be used to verify a bet:


function calculateHash(clientSeed, nonce, serverSeed) {
  const crypto = require('crypto');

  // Step 1: Calculate HMAC-SHA256 hash
  const hmac = crypto
    .createHmac('sha256', serverSeed)
    .update(`${clientSeed}:${nonce}`)
    .digest('hex');

  // Step 2: Take the first 15 characters
  const first15Chars = hmac.substring(0, 15);

  // Step 3: Convert to decimal
  const decimalValue = BigInt(`0x${first15Chars}`);

  // Step 4: Perform modulus 47
  const remainder = decimalValue % 47n;

  // Step 5: Take 14 characters starting from the index (assume starting index = remainder)
  const startIndex = Number(remainder);
  const next14Chars = hmac.substring(startIndex, startIndex + 14);

  // Step 6: Convert to decimal
  const nextDecimalValue = BigInt(`0x${next14Chars}`);

  // Step 7: Divide by 8, multiply by 2^-53, multiply by 10000
  const result =
    (Number(nextDecimalValue) / 8) *
    Math.pow(2, -53) *
    10000;

  // Step 8: Take the integer part
  return Math.floor(result);
}


const clientSeed = "2wzp443ewBZXa1yT";
const nonce = 0;
const serverSeed = "8SuBhXE3F2TFfAorCyE4qozN0pWUqF5p1hW5NFVJzWocs19pXUzkxTOT";

const result = calculateHash(clientSeed, nonce, serverSeed);
console.log(result); // 110.82