Provably Fair by BC.Game - nucleare/DeepSearch_HashGames GitHub Wiki

The Non-Techie Explanation

To put it simply, provably fair is the term used to describe games that have a verifiably random game result. What this means is, after you complete your game, round or session, you can use a third party verifier to make sure the casino did not manipulate any of the game’s results.

You Must Do Your Part!

Just because a casino is using provably fair random number generation (RNG), doesn’t mean that they can’t or won’t cheat you. The reason provably fair works is because you, the player, are given the ability to participate in the RNG. You do this by choosing your own client seed. Always choose your own client seed. Otherwise, the casino will use a preset seed pair which completely voids any provable fairness of the coming game results. Think of choosing your own client seed like cutting a deck of cards. The reason you would cut a deck of cards is to be sure the dealer didn’t have the cards arranged in a certain order that would benefit him. The same goes for choosing your client seed.

How To Change Your Seed At Bc.Game

BC.Game uses provably fair RNG on its entire selection of games. But, like any other provably fair site, you have to change your client seed. BC.Game has made this a very simple 2 step process for you. Here’s how…. With Pictures!

Step 1. Open the Seed Settings by clicking the seed icon towards the bottom of the game screen.

Step 2. Manually enter a new client seed and then click confirm.

That’s it! You can now be sure that all your future bets will be random. However, just placing your trust in an onsite settings menu is not good enough. The only way to make sure provably fair casinos are in fact fair and stay that way, is to check up on them from time to time using third party verifiers.

If you’d like to know how to verify the fairness of your bets, be sure to check out the next post titled, “How To Verify Fairness.”

Crash by BC.Game

Fairness

Is The Game Fair?

We are a fair and impartial prediction and guessing platform. Our goal is to eliminate all unfair factors and make players feel comfortable and have fun.

We have generated a total of 10 million hashes (the generation chain is verifiable), and each hash corresponds to a curve crash multiplier.

We release these 10 million numbers in reverse order, each corresponding to one turn of the game (i.e. we have 10 million turns in total).

In other words, the crash number of each turn already exists and is not calculated after the game starts. Players can therefore place their bet without concern.

Will The Game Be Manipulated By The Platform?GitHub Verify

The integrity check value is key to verifying whether there is any official manipulation; The test algorithm is provided as follows.

Example: 6b5124897c3c48d0e46cc9249f08c7e560792459f1bad1171224643b5d2be231

Take a random value in the 2^52 range, namely 16^13, i.e. a 13-bit hexadecimal number (because the hash value is hexadecimal, 2^52 === 16^13)6b5124897c3c4 (0x6b5124897c3c4 equals 1887939992208324 in the decimal system).
Distribute the random value to 01, by dividing it by the maximum value of 13 fs, namely 0x6b5124897c3c4/0x10000000000000. Given the discrete random nature of the hash value, we then can think that any hash value can be transformed into a random number of 01, 1887939992208324/4503599627370496 = 0.419206889692064.
Make the house edge 1%. Further to calculate 99/(1-X), where X is the random value calculated at Step 2. When X is 0, the result is 99; when X is 1, the result is positive infinite; when X is 0.01, the result is 100; when X is less than 0.01, the result is less than 100. Conclusion: The overall random number distribution is 99 to positive infinite; and when the random number distribution is 0~0.01, the result is less than 100.

99/(1-0.419206889692064) = 170.45656748150867

All values less than 100 will be set to 100. In other words, there is a probability of 1% that 100 will appear. Round off the number and divide it by 100 to get the final result. 170/100 = 1.70

Conclusion: The hash value used in the game is inverse ordered. Therefore, with the SHA256 algorithm, a previous hash used in the game can be calculated from its subsequent hash. Since there is one-to-one correspondence between the key and the value of hash, we can draw the conclusion that if a hash can be used to calculate the hash that precedes it, then this hash should have been already generated when the preceding prize is announced. Similarly, the entire hash chain is generated at the very beginning and cannot be changed once generated. Otherwise, it cannot pass verification by SHA256, and as far as the payout is concerned, this is nothing more than a probability game in which crash is a given. The official organizer cannot manipulate any game set. Therefore, CRASH is more transparent than other gambling methods. This is the cornerstone on which our game is built.

Simple calculation:

When the 13-bit hash value is 8000000000000 = 1.98, 0xb000000000 = 3.168, 0xc000000000 = 3.96, that is, the first digit is greater than 8((16-8)/16≈0.5), the result is approximately 2x; when the first digit is greater than b((16-11)/16≈0.3), the result is approximately 3x; and when the first digit is greater than c((16-12)/16≈0.25), the result is approximately 4x, and the same rule applies to the rest.

When the 13-bit hash value is f000000000000 = 15.84, ff00000000000 = 253.44, fff000000

Mines by BC.Games

How Are the Results Calculated? To get the results, we calculate the hash value of the combination with HMAC_SHA256. This gives us a 64-character hexadecimal string: hash = HMAC_SHA256 (clientSeed:nonce, serverSeed).

const crypto = require("crypto");

function getResult(hash) {
  const allNums = [
    7, 2, 19, 25, 1, 13, 5, 24, 14, 6, 15, 9, 22, 16, 3, 17, 18, 20, 8, 21, 4,
    12, 10, 23, 11,
  ];
  let seed = hash;
  let finalNums = createNums(allNums, seed);
  seed = crypto.createHash("SHA256").update(seed).digest("hex");
  finalNums = createNums(finalNums, seed);
  return finalNums.map((m) => m.num.num);
}

function createNums(allNums, hash) {
  let nums = [];
  let h = crypto.createHash("SHA256").update(hash).digest("hex");
  allNums.forEach((c) => {
    nums.push({ num: c, hash: h });
    h = h.substring(1) + h.charAt(0);
  });
  nums.sort(function (o1, o2) {
    if (o1.hash < o2.hash) {
      return -1;
    } else if (o1.hash === o2.hash) {
      return 0;
    } else {
      return 1;
    }
  });
  return nums;
}

function main (serverSeed, clientSeed, nonce) {
  let resultArr = [clientSeed, nonce];
  let hmacSha256Result = crypto.createHmac("sha256", serverSeed).update(resultArr.join(":")).digest("hex")
  let resultList = getResult(hmacSha256Result);
  console.log(resultList);
}

// main("server seed", "client seed", "nonce");

Limbo By BC.Games

How are results calculated? To get the results.

Hex string: hash = HMAC_SHA256(clientSeed:nonce, serverSeed) Example: 6b5124897c3c48d0e46cc9249f08c7e560792459f1bad1171224643b5d2be231

Take a random value in the 2^52 range, namely 16^13, i.e. a 13-bit hexadecimal number (because the hash value is hexadecimal, 2^52 === 16^13)6b5124897c3c4 (6b5124897c3c4 equals 1887939992208324 in the decimal system).
Distribute the random value to 01, by dividing it by the maximum value of 13 fs, namely 6b5124897c3c4/fffffffffffff. Given the discrete random nature of the hash value, we then can think that any hash value can be transformed into a random number of 01 (fffffffffffff is equal to 45035996270496 in the decimal system) 1887939992208324/4503599627370496 = 0.419206889692064.
Make the house edge 1%. Further to calculate 99/(1-X), where X is the random value calculated at Step 2. When X is 0, the result is 99; when X is 1, the result is positive infinite; when X is 0.01, the result is 100; when X is less than 0.01, the result is less than 100.

99/(1-0.419206889692064) = 170.45656748150867

All values less than 100 will be set to 100. In other words, there is a probability of 1% that 100 will appear. Round off the number and divide it by 100 to get the final result.

170/100 = 1.70

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

Did you really need to know this? Probably not. It’s there for those who expect transparency and precision in a provably fair game of chance.

We put our “cards on the table.”

Good luck!

Limbo Verifier

Dice By BC.Game

How are results calculated? To get the results.

First we calculate the hash value of the combination with HMAC_SHA256. This gives us a 64-character hexadecimal string: hash = HMAC_SHA256 (clientSeed:nonce, serverSeed).
Finally, we take 8 characters of the hash and convert it to an int32 value. Then we divide the converted value by 0x100000000, multiply it by 10001 and divide it by 100 so that the resulting number conforms to the constraints of the dice range.

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

Did you really need to know this? Probably not. It’s there for those who expect transparency and precision in a provably fair game of chance.

We put our "cards on the table."

Good luck!

Dice Game Verifier

Hash Dice by BC.Game

Is HashDice 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 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 (16 ^ 5 - 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

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

function getRoll (serverSeed, clientSeed, nonce) {
  var hash = hmac_sha512(clientSeed:nonce, serverSeed);
  var index = 0;
  do {
    var lucky = parseInt(hash.substr(index, 5), 16);
    index += 5;
  } while (lucky >= 1000000);
  return lucky % 100000;
}

Please also check our online betverify.

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

Plinko by BC.Game

Fairness Verification

Solving the Trust Issue with Online Gambling

The underlying concept of provable fairness is that players have the ability to prove and verify that their results are fair and unmanipulated. This is 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)

Plinko Verifier

Ultimate Dice by BC.Game

How are results calculated?

To get the results.

First we calculate the hash value of the combination with HMAC_SHA256. This gives us a 64-character hexadecimal string: hash = HMAC_SHA256 (clientSeed:nonce, serverSeed).
Finally, we take 8 characters of the hash and convert it to an int32 value. Then we divide the converted value by 0x100000000, multiply it by 10000 so that the resulting number conforms to the constraints of the dice range.

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

Did you really need to know this? Probably not. It’s there for those who expect transparency and precision in a provably fair game of chance.

We put our "cards on the table."

Good luck! Ultimate Dice Verify