Skins: 0
Coins: 0.00
0 Online
Provably Fair
Select a game from the list below to learn about how we ensure that the results are always random and never tampered with.
bitcoking.com uses provably fair method, that doesn't allow us to manipulate the outcome once the game is started, below you can see how the outputs are caluclated.
You can execute the code straight from your browser with tools such as this NodeJS tester. Simply replace all parameters with the ones in the round you want to check.
Info
This is a passphrase or a randomly generated string that is determined by the player or their browser. This can be edited and changed regularly by yourself.
Client Seed
This field is required
To reveal the hashed server seed, the seed must be rotated by the player, which triggers the replacement with a newly generated seed. From this point you are able to verify any bets made with the previous server seed to verify both the legitimacy of the server seed with the encrypted hash that was provided.
You can validate hashed server seed using this script. The hashed server seed is a SHA-256 hash of the seed so after you unhash it, you can check that it matches with the hashed version.
Server Seed Hashed
This field is required
You can validate hashed server seed using this script. The hashed server seed is a SHA-256 hash of the seed so after you unhash it, you can check that it matches with the hashed version.
var sha256 = require('sha256');
var seed = 'f0c82c85ba6ef5cbba7406db81ee5451a1a795120e335116dc637d34a105e6e6';
function fair_getHash256(seed){
return sha256(seed);
}
console.log('Hashed: ' + fair_getHash256(seed));
Id
Server Seed
Useds
Created At
No data found
Roulette Game
Each section of the roll is assigned a number - and there are 15 potential numbers to land on. The resulting number from each spin is determined by a combination of three individual elements, which are fed into an algorithm:
Client seed is SHA-256 hash generated daily from random 32 bytes. We show it to you the moment it's generated.
Server seed is SHA-256 hash generated daily from random 32 bytes. We show you the encrypted version while it's in use.
The nonce is based on numbers that is the round id. The first round ever played would have an nonce of 1. This number increases by 1 for each new round. The nonce's job in generating outcomes is to ensure that, even when the same public seed and server seed combination are used, the outcome generated in the next game would still be different, since the seed combination is paired with a unique nonce, the nonce for each game is always different, since the round id would have increased by one for every new game played.
Since each roll, or outcome, is generated using cryptographically-secure randomness, the probability of a particular outcome will never change - even if you play 100,000,000 times. There’s no pattern or method used to determine which number will hit next - it’s sheer randomness.
Today's server seed is currently in-use, therefore it is a secret and only the encrypted seed (hash) is visible to you. You can not verify today's results until the day is over and the (unhashed) server seed has been revealed.
var crypto = require('crypto');
var roll_server_seed = 'aed859a82f458f3111fb8dd813001a65a9d88fce5004a37a3648a4f3c745e9df';
var roll_public_seed = '3e2a4be2d0eb744ea4b07b2773f881f035f84f5fcb1880ceb25929ad7563df34';
var roll_nonce = 0;
function fair_getCombinedSeed(server_seed, public_seed, nonce) {
return [server_seed, public_seed, nonce].join('-');
}
function fair_generateSaltHash(seed) {
return crypto.createHmac('sha256', seed).digest('hex');
}
function fair_getRoll(salt, max) {
return Math.abs(parseInt(salt.substr(0, 12), 16)) % max;
}
var generated_seed = fair_getCombinedSeed(roll_server_seed, roll_public_seed, roll_nonce);
var generated_salt = fair_generateSaltHash(generated_seed);
var generated_roll = fair_getRoll(generated_salt, 15);
console.log('Roll: ' + generated_roll);
Date
Server Seed
Public Seed
Games
01 April 2025, 04:14 PM
(hashed) 522627bb9a3756ecb9d261322ecc5349f52182eaf48568c8b82f13627726db52
9c48306f7f30d10a3f18d6210920bb0e008ca77a03631e21619d59ca5b715530
836259 - 837521
31 March 2025, 04:14 PM
02cd919be1dc09df5aab9e1a12000a7349eb2dfee9d379a1e87746a7c85613d0
079b1dc67c0153aa54265bd51b535d27fdc57ff485792154ce95dce1ea127307
833484 - 836258
30 March 2025, 04:13 PM
17e5cbe02795f8d50e9e003a45a5b38a8567f908c13cec97d9d26b36e2418965
7ab1ea2b4af1aa754f0c8672c3b0b43749c3e4442f1f98593c5069b850bf54a8
830709 - 833483
29 March 2025, 04:13 PM
6b89cb62293181c54df391bd8977ba03d02d137fd82b0033a41567458d6743d6
d632cb7bf8359de73b2368608cb965a357e8f6d9f5ea9fed39f2e1c4d903c82e
827933 - 830708
28 March 2025, 04:13 PM
0bd8c7ba574aae972ffbdfa5c16507a3657af143c85471bf400cb594492290a9
de9084974c74635184822de503718e43032204610941575313a482621f776d0b
825157 - 827932
27 March 2025, 04:12 PM
dbf22f600e3d21bec610196abc99e3f0d5bd3d2a85f325d90c88aaecb8d7d52c
c0452603c6a68dc30fcc2b717f56de438b4eee135c761231e562802967dfd477
822382 - 825156
26 March 2025, 04:12 PM
9231a0cfa5d3d928198b5e1985e2f52868bc56ea14b5959bbf01a8a2955fccc8
d11bd44a57a9ce48372920cae677cc5f745c23c9b851786be9463ad387255e6f
819607 - 822381
Crash Game
Each section of the roll is assigned a number - greater than or equal to 1.00 to land on. The resulting number from each crash is determined by a combination of three individual elements, which are fed into an algorithm:
Client seed is SHA-256 hash generated daily from random 32 bytes. We show it to you the moment it's generated.
Server seed is SHA-256 hash generated daily from random 32 bytes. We show you the encrypted version while it's in use.
The nonce is based on numbers that is the round id. The first round ever played would have an nonce of 1. This number increases by 1 for each new round. The nonce's job in generating outcomes is to ensure that, even when the same public seed and server seed combination are used, the outcome generated in the next game would still be different, since the seed combination is paired with a unique nonce, the nonce for each game is always different, since the round id would have increased by one for every new game played.
Since each roll, or outcome, is generated using cryptographically-secure randomness, the probability of a particular outcome will never change - even if you play 100,000,000 times. There’s no pattern or method used to determine which number will hit next - it’s sheer randomness.
Today's server seed is currently in-use, therefore it is a secret and only the encrypted seed (hash) is visible to you. You can not verify today's results until the day is over and the (unhashed) server seed has been revealed.
var crypto = require('crypto');
var roll_server_seed = 'e581f85cab4f8f4ee22afc82b8299c4bd7f132049c9212b32e989b798246ac31';
var roll_public_seed = '1b233defb3b6acc3ead30a62ded768e8db9950bb922db728f44dcf9fb464d21e';
var roll_nonce = 0;
function fair_getCombinedSeed(server_seed, public_seed, nonce) {
return [server_seed, public_seed, nonce].join('-');
}
function fair_generateSaltHash(seed) {
return crypto.createHmac('sha256', seed).digest('hex');
}
function fair_getRollCrash(salt){
var INSTANT_CRASH_PERCENTAGE = 5.00;
// Use the most significant 52-bit from the salt to calculate the crash point
var h = parseInt(salt.slice(0, 52 / 4), 16);
var e = Math.pow(2, 52);
var result = (100 * e - h) / (e - h);
// INSTANT_CRASH_PERCENTAGE of 5.00 will result in modifier of 0.95 = 5.00% house edge with a lowest crashpoint of 1.00x
var houseEdgeModifier = 1 - INSTANT_CRASH_PERCENTAGE / 100;
var endResult = Math.max(100, result * houseEdgeModifier);
return Math.floor(endResult);
}
var generated_seed = fair_getCombinedSeed(roll_server_seed, roll_public_seed, roll_nonce);
var generated_salt = fair_generateSaltHash(generated_seed);
var generated_roll = (fair_getRollCrash(generated_salt) / 100).toFixed(2);
console.log('Roll: ' + generated_roll);
Date
Server Seed
Public Seed
Games
01 April 2025, 04:28 PM
(hashed) eb317c0719df6e3b56f119e2a6a336de876c7c44edaf3b1d7104c142f5df16b0
a3759a7c7e303585f15472ba80e68ad43f6e22928029efce1b84cc7181140af1
974703 - 976120
31 March 2025, 04:28 PM
0abb857d3ae48bfebf5c39ae03a57c1cc6f2e5cc70d3adc245c5ed97e9c3e10f
505a555d19f71dddfd5f56548674d9efb5f8dd740c9ab8465f9fc944814d65ac
971512 - 974702
30 March 2025, 04:28 PM
549b147b6282be62cc1bb0b7669c9c8ccbea973afc045c3b69c1c38c1513d235
053bec2d3ec9718fbc6349de36d1aea7c01ac7940da26ae304e071eea0c1305d
968295 - 971511
29 March 2025, 04:27 PM
42422133373de696a7716a631f8c59aab1337e05b984043dc370a5fe48fd070f
efb7c355a9b43f428baf400cc8b745320e5014e5840141df64de7e3c9d2c904e
965045 - 968294
28 March 2025, 04:27 PM
9917aaa1524445a041005dabe09401edd37041718218f056a23d3a8e4594cb33
a277a4a04fa558b8333503647fc40bc06268fbbced675902e25514dea7a6279e
961784 - 965044
27 March 2025, 04:26 PM
d667d7a278744aa107974dda9c2d60219c2802eec48653e31974a5449de616be
a7ff872d503044dfb76f8c141c1db31ca5d1c77cb243dc455d2068ef74fc9223
958508 - 961783
26 March 2025, 04:25 PM
966a5c960056948e9391d8b007473650a70f83e14af92b29f4845f1da07c606c
52ff333d20e2dc7bcbea4bdf03377eb72f9133917882b602272f1692910be9c7
955317 - 958507
Jackpot Game
Jackpot uses a provably fair system in which the public seed is not known until after a jackpot game has started. The result for each round is generated using the SHA-256 hash of 3 separate inputs:
The server seed is a securely random value, generated when a round is created. The SHA-256 hash of the server seed is displayed to all players immediately after a round is created. Players can check that the private seed revealed after the jackpot result is made known matches this SHA-256 hash.
The public seed is the ID of an EOS block, which is to be generated after the countdown is finished. When the countdown is finished, our system chooses a block number on the EOS blockchain that will be generated in the near future. The ID of this block is what will be used as the public seed. This way, neither the players nor our system know what data will be used to generate the jackpot result until after both players have committed their bets.
The nonce is based on numbers that is the round id.
var crypto = require('crypto');
var roll_server_seed = 'cc0fa67554c2e9fc0f6a4a833353080a6f0e7dd2e8a911efb8f6f05c75a93063';
var roll_client_seed = '0d3ec17f8e156a06656107778fbb83211d96c8686bcaa6f0a957baf18ca21b5f';
var roll_nonce = 5;
function fair_getCombinedSeed(server_seed, public_seed, nonce) {
return [server_seed, public_seed, nonce].join('-');
}
function fair_generateSaltHash(seed) {
return crypto.createHmac('sha256', seed).digest('hex');
}
function fair_getRoll(salt, max) {
return Math.abs(parseInt(salt.substr(0, 12), 16)) % max;
}
var generated_seed = fair_getCombinedSeed(roll_server_seed, roll_client_seed, roll_nonce);
var generated_salt = fair_generateSaltHash(generated_seed);
var generated_roll = fair_getRoll(generated_salt, Math.pow(10, 8)) / Math.pow(10, 8);
console.log('Roll: ' + generated_roll);
Id
Server Seed
Public Seed
Block id
Roll
Created At
No data found
Coinflip Game
Coinflip uses a provably fair system in which the public seed is not known until after a coinflip game has started. The result for each round is generated using the SHA-256 hash of 3 separate inputs:
The server seed is a securely random value, generated when a round is created. The SHA-256 hash of the server seed is displayed to all players immediately after a round is created. Players can check that the private seed revealed after the coinflip result is made known matches this SHA-256 hash.
The public seed is the ID of an EOS block, which is to be generated after the countdown is finished. When the countdown is finished, our system chooses a block number on the EOS blockchain that will be generated in the near future. The ID of this block is what will be used as the public seed. This way, neither the players nor our system know what data will be used to generate the coinflip result until after both players have committed their bets.
The nonce is based on numbers that is the round id.
var crypto = require('crypto');
var roll_server_seed = '30dfbd2887ff70583787976bc3105fc992942f91985c7acd96cc5a2ff4de6e45';
var roll_public_seed = '0d3a2d2c14fa35d5cec6c3940b05040e62ba57182661174dc48a35e6dab46e7d';
var roll_nonce = 1;
function fair_getCombinedSeed(server_seed, public_seed, nonce) {
return [server_seed, public_seed, nonce].join('-');
}
function fair_generateSaltHash(seed) {
return crypto.createHmac('sha256', seed).digest('hex');
}
function fair_getRoll(salt, max) {
return Math.abs(parseInt(salt.substr(0, 12), 16)) % max;
}
var generated_seed = fair_getCombinedSeed(roll_server_seed, roll_public_seed, roll_nonce);
var generated_salt = fair_generateSaltHash(generated_seed);
var generated_roll = fair_getRoll(generated_salt, Math.pow(10, 8)) / Math.pow(10, 8);
var generated_side = (generated_roll < 0.5) ? 1 : 2;
console.log('Roll: ' + generated_roll + ' | Side: ' + generated_side);
Id
Server Seed
Public Seed
Block id
Roll
Created At
No data found
Dice Game
In the Provably Fair tab, you can change the client seed and regenerate the server seed.
Server seed is SHA-256 hash generated from random 32 bytes. You can regenerate server seed in any time. You cannot see the original server seed, yet you will be able to check that it was unmodified later after regenerating the server seed.
Client seed is generated first time for user, same way like server seed. As the client seed affects every roll result, changing it to any seed of your choice at any time means you can ensure that it's impossible for us to manipulate the result.
However, the SHA-256 function we use to generate the roll is deterministic, if the client seed is combined with the same server seed, it will generate exactly the same roll result every time. This could be used to abuse the system, so we use something called a 'nonce' which prevents this from being abusable. Each roll done using the same server seed & client seed pair will also be paired with a different nonce, which is simply a number starting at 0 and incremented by 1 for each roll done.
The nonce is based on numbers that we can't manipulate (they naturally increment by 1 after each roll).
SHA-256 returns the hash value for the salt hash combination in a hex-encoded form. We then take the first 8 characters from this hash and convert this hex string to a number.
We apply a modulus of 10000 to converted number, giving us a number in the range of 0-9999. Finally, division by 100 produces a decimal number in the range 0-99.99.
Each roll can be verified using this formula as soon as you have revealed your server seed for the previous rolls. The published unhashed server seeds can be checked by simply applying the SHA-256 function to it, this will produce the previously published hashed version of the server seed, which was made visible to you before any roll using it was ever made. Each user can check the integrity of every roll made using this information.
var crypto = require('crypto');
var roll_server_seed = '2c3eea4603280f3cadfb0046b248e7b756930b0b6886997ac73f96d478c823f3';
var roll_client_seed = '0b3eeb63c10796f00e3faff36207b369';
var roll_nonce = 0;
function fair_getCombinedSeed(server_seed, public_seed, nonce) {
return [server_seed, public_seed, nonce].join('-');
}
function fair_generateSaltHash(seed) {
return crypto.createHmac('sha256', seed).digest('hex');
}
function fair_getRoll(salt, max) {
return Math.abs(parseInt(salt.substr(0, 12), 16)) % max;
}
var generated_seed = fair_getCombinedSeed(roll_server_seed, roll_client_seed, roll_nonce);
var generated_salt = fair_generateSaltHash(generated_seed);
var generated_roll = (fair_getRoll(generated_salt, 10000) / 100) % 100;
console.log('Roll: ' + generated_roll);
Id
Server Seed
Client Seed
Nonce
Roll
No data found
Unbox Game
In the Provably Fair tab, you can change the client seed and regenerate the server seed.
Server seed is SHA-256 hash generated from random 32 bytes. You can regenerate server seed in any time. You cannot see the original server seed, yet you will be able to check that it was unmodified later after regenerating the server seed.
Client seed is generated first time for user, same way like server seed. As the client seed affects every roll result, changing it to any seed of your choice at any time means you can ensure that it's impossible for us to manipulate the result.
However, the SHA-256 function we use to generate the roll is deterministic, if the client seed is combined with the same server seed, it will generate exactly the same roll result every time. This could be used to abuse the system, so we use something called a 'nonce' which prevents this from being abusable. Each roll done using the same server seed & client seed pair will also be paired with a different nonce, which is simply a number starting at 0 and incremented by 1 for each roll done.
The nonce is based on numbers that we can't manipulate (they naturally increment by 1 after each roll).
The total tickets is based on sum of tickets from crates.
SHA-256 returns the hash value for the salt hash combination in a hex-encoded form. We then take the first 8 characters from this hash and convert this hex string to a number.
We apply a modulus of 'total_tickets' to converted number, giving us a number in the range of 0-'total_tickets'. Finally, incrementing by 1 produces a integer number in the range 1-'total_tickets' + 1.
Each roll can be verified using this formula as soon as you have revealed your server seed for the previous rolls. The published unhashed server seeds can be checked by simply applying the SHA-256 function to it, this will produce the previously published hashed version of the server seed, which was made visible to you before any roll using it was ever made. Each user can check the integrity of every roll made using this information.
var crypto = require('crypto');
var roll_server_seed = '2c3eea4603280f3cadfb0046b248e7b756930b0b6886997ac73f96d478c823f3';
var roll_client_seed = '0b3eeb63c10796f00e3faff36207b369';
var roll_nonce = 12;
var roll_total_tickets = 10000;
function fair_getCombinedSeed(server_seed, public_seed, nonce) {
return [server_seed, public_seed, nonce].join('-');
}
function fair_generateSaltHash(seed) {
return crypto.createHmac('sha256', seed).digest('hex');
}
function fair_getRoll(salt, max) {
return Math.abs(parseInt(salt.substr(0, 12), 16)) % max;
}
var generated_seed = fair_getCombinedSeed(roll_server_seed, roll_client_seed, roll_nonce);
var generated_salt = fair_generateSaltHash(generated_seed);
var generated_roll = fair_getRoll(generated_salt, roll_total_tickets) + 1;
console.log('Roll: ' + generated_roll);
Id
Server Seed
Client Seed
Nonce
Tickets
Roll
No data found
Case Battle Game
Casae Battle uses a provably fair system in which the public seed is not known until after a battle game has started. The result for each battle is generated using the SHA-256 hash of 3 separate inputs:
The server seed is a securely random value, generated when a round is created. The SHA-256 hash of the server seed is displayed to all players immediately after a round is created. Players can check that the private seed revealed after the coinflip result is made known matches this SHA-256 hash.
The public seed is the ID of an EOS block, which is to be generated after the countdown is finished. When the countdown is finished, our system chooses a block number on the EOS blockchain that will be generated in the near future. The ID of this block is what will be used as the public seed. This way, neither the players nor our system know what data will be used to generate the coinflip result until after both players have committed their bets.
The nonce is based on numbers that is the round id.
The rounds is based on numbers that is the number of cases the battle have.
The players is based on numbers that is the number of players the battle have.
The output is a matrix. Each row represents the round and the column represents the player position. Each value is based on numbers that is the case roll.
var crypto = require('crypto');
var roll_server_seed = '48dc637aedd2d53c1dbf4d0cb8c48e3be1a243a6fb9e6738cd528cef1db1159e';
var roll_public_seed = '11db6dc55673ab3d610ee1b96593a08ed5029231f4a0fa1e8d54e1b4abd34c5f';
var roll_nonce = 3;
var roll_rounds = 4;
var roll_players = 2;
function fair_getCombinedSeed(server_seed, public_seed, nonce) {
return [server_seed, public_seed, nonce].join('-');
}
function fair_generateSaltHash(seed) {
return crypto.createHmac('sha256', seed).digest('hex');
}
function fair_getRoll(salt, max) {
return Math.abs(parseInt(salt.substr(0, 12), 16)) % max;
}
function fair_getRollCaseBattle(salt, rounds, players) {
var array = [];
for(var i = 0; i < rounds; i++) {
array.push([]);
for(var j = 0; j < players; j++) {
var salt_position = fair_generateSaltHash(salt + '-' + i + '-' + j);
var roll = fair_getRoll(salt_position, Math.pow(10, 8)) / Math.pow(10, 8);
array[i].push(roll);
}
}
return array;
}
var generated_seed = fair_getCombinedSeed(roll_server_seed, roll_public_seed, roll_nonce);
var generated_salt = fair_generateSaltHash(generated_seed);
var generated_roll = fair_getRollCaseBattle(generated_salt, roll_rounds, roll_players);
console.log('Roll: ' + JSON.stringify(generated_roll));
Id
Server Seed
Public Seed
Block id
Roll
Created At
No data found
Minesweeper Game
In the Provably Fair tab, you can change the client seed and regenerate the server seed.
Server seed is SHA-256 hash generated from random 32 bytes. You can regenerate server seed in any time. You cannot see the original server seed, yet you will be able to check that it was unmodified later after regenerating the server seed.
Client seed is generated first time for user, same way like server seed. As the client seed affects every roll result, changing it to any seed of your choice at any time means you can ensure that it's impossible for us to manipulate the result.
However, the SHA-256 function we use to generate the roll is deterministic, if the client seed is combined with the same server seed, it will generate exactly the same roll result every time. This could be used to abuse the system, so we use something called a 'nonce' which prevents this from being abusable. Each roll done using the same server seed & client seed pair will also be paired with a different nonce, which is simply a number starting at 0 and incremented by 1 for each roll done.
The nonce is based on numbers that we can't manipulate (they naturally increment by 1 after each roll).
SHA-256 returns the hash value for the salt hash combination in a hex-encoded form. We then take the first 8 characters from this hash and convert this hex string to a number.
A mine game is generated with 24 separate salts. Each salt is generated by using the index of tile from board and the main salt who is generated using the server seed, client seed and the nonce. Each output is multiplied by the number of possible unique tiles still remaining on the board. This is done by subtracting the number of tiles remaining by 1 for each iteration game result generated using the corresponding output provided. The location of the mine is plotted using a grid position from left to right, top to bottom.
The fisher-yates shuffle implementation is utilised to prevent duplicate possible hits being generated. Between 1 and 24 game results are used, based on the settings chosen.
Each roll can be verified using this formula as soon as you have revealed your server seed for the previous rolls. The published unhashed server seeds can be checked by simply applying the SHA-256 function to it, this will produce the previously published hashed version of the server seed, which was made visible to you before any roll using it was ever made. Each user can check the integrity of every roll made using this information.
var crypto = require('crypto');
var roll_server_seed = '2c3eea4603280f3cadfb0046b248e7b756930b0b6886997ac73f96d478c823f3';
var roll_client_seed = '0b3eeb63c10796f00e3faff36207b369';
var roll_nonce = 43;
function fair_getCombinedSeed(server_seed, public_seed, nonce) {
return [server_seed, public_seed, nonce].join('-');
}
function fair_generateSaltHash(seed) {
return crypto.createHmac('sha256', seed).digest('hex');
}
function fair_getRoll(salt, max) {
return Math.abs(parseInt(salt.substr(0, 12), 16)) % max;
}
function fair_getShuffle(salt, max) {
//Set shuffle inexes
var array = [];
for(var i = 0; i < max; i++) array.push(i);
//Fisher-yates shuffle implementation
var k = 0;
for(var i = array.length - 1; i > 0; i--, k++) {
var salt_possition = fair_generateSaltHash(salt + '-' + k);
var roll = fair_getRoll(salt_possition, Math.pow(10, 8)) / Math.pow(10, 8);
var j = Math.floor(roll * (i + 1));
[array[i], array[j]] = [array[j], array[i]];
}
return array;
}
var generated_seed = fair_getCombinedSeed(roll_server_seed, roll_client_seed, roll_nonce);
var generated_salt = fair_generateSaltHash(generated_seed);
var generated_array = fair_getShuffle(generated_salt, 25);
var generated_roll = '';
generated_array.forEach(function(item){
if(item < 10) generated_roll += '0' + item;
else generated_roll += item;
});
console.log('Roll: ' + generated_roll);
Id
Server Seed
Client Seed
Nonce
Roll
No data found
Tower Game
In the Provably Fair tab, you can change the client seed and regenerate the server seed.
Server seed is SHA-256 hash generated from random 32 bytes. You can regenerate server seed in any time. You cannot see the original server seed, yet you will be able to check that it was unmodified later after regenerating the server seed.
Client seed is generated first time for user, same way like server seed. As the client seed affects every roll result, changing it to any seed of your choice at any time means you can ensure that it's impossible for us to manipulate the result.
However, the SHA-256 function we use to generate the roll is deterministic, if the client seed is combined with the same server seed, it will generate exactly the same roll result every time. This could be used to abuse the system, so we use something called a 'nonce' which prevents this from being abusable. Each roll done using the same server seed & client seed pair will also be paired with a different nonce, which is simply a number starting at 0 and incremented by 1 for each roll done.
The nonce is based on numbers that we can't manipulate (they naturally increment by 1 after each roll).
SHA-256 returns the hash value for the salt hash combination in a hex-encoded form. We then take the first 8 characters from this hash and convert this hex string to a number.
A tower game is generated with 10 separate salts. Each salt is generated by using the index of stage from board and the main salt who is generated using the server seed, client seed and the nonce. We apply for each output a modulus of 3 to this number, giving us a number in the range of 0-2, which represent the index of tile for a wrong move. The location of the tile is plotted using a grid position from bottom to top, left to right.
Each roll can be verified using this formula as soon as you have revealed your server seed for the previous rolls. The published unhashed server seeds can be checked by simply applying the SHA-256 function to it, this will produce the previously published hashed version of the server seed, which was made visible to you before any roll using it was ever made. Each user can check the integrity of every roll made using this information.
var crypto = require('crypto');
var roll_server_seed = '2c3eea4603280f3cadfb0046b248e7b756930b0b6886997ac73f96d478c823f3';
var roll_client_seed = '0b3eeb63c10796f00e3faff36207b369';
var roll_nonce = 45;
function fair_getCombinedSeed(server_seed, public_seed, nonce) {
return [server_seed, public_seed, nonce].join('-');
}
function fair_generateSaltHash(seed) {
return crypto.createHmac('sha256', seed).digest('hex');
}
function fair_getRoll(salt, max) {
return Math.abs(parseInt(salt.substr(0, 12), 16)) % max;
}
function fair_getRollTower(salt) {
var array = [];
//Get tower roll by stage
for(var i = 0; i < 10; i++){
var salt_possition = fair_generateSaltHash(salt + '-' + i);
var roll = fair_getRoll(salt_possition, 3);
array.push(roll);
}
return array;
}
var generated_seed = fair_getCombinedSeed(roll_server_seed, roll_client_seed, roll_nonce);
var generated_salt = fair_generateSaltHash(generated_seed);
var generated_array = fair_getRollTower(generated_salt);
var generated_roll = generated_array.join('');
console.log('Roll: ' + generated_roll);
Id
Server Seed
Client Seed
Nonce
Roll
No data found
Plinko Game
In the Provably Fair tab, you can change the client seed and regenerate the server seed.
Server seed is SHA-256 hash generated from random 32 bytes. You can regenerate server seed in any time. You cannot see the original server seed, yet you will be able to check that it was unmodified later after regenerating the server seed.
Client seed is generated first time for user, same way like server seed. As the client seed affects every roll result, changing it to any seed of your choice at any time means you can ensure that it's impossible for us to manipulate the result.
However, the SHA-256 function we use to generate the roll is deterministic, if the client seed is combined with the same server seed, it will generate exactly the same roll result every time. This could be used to abuse the system, so we use something called a 'nonce' which prevents this from being abusable. Each roll done using the same server seed & client seed pair will also be paired with a different nonce, which is simply a number starting at 0 and incremented by 1 for each roll done.
The nonce is based on numbers that we can't manipulate (they naturally increment by 1 after each roll).
SHA-256 returns the hash value for the salt hash combination in a hex-encoded form. We then take the first 8 characters from this hash and convert this hex string to a number.
A plinko game is generated with 14 separate salts. Each salt is generated by using the index of stage from board and the main salt who is generated using the server seed, client seed and the nonce. We apply for each output a modulus of 2 to this number, giving us a number in the range of 0-1, which represent the next move of ball (left = 0 or right = 1).
Each roll can be verified using this formula as soon as you have revealed your server seed for the previous rolls. The published unhashed server seeds can be checked by simply applying the SHA-256 function to it, this will produce the previously published hashed version of the server seed, which was made visible to you before any roll using it was ever made. Each user can check the integrity of every roll made using this information.
var crypto = require('crypto');
var roll_server_seed = '2c3eea4603280f3cadfb0046b248e7b756930b0b6886997ac73f96d478c823f3';
var roll_client_seed = '0b3eeb63c10796f00e3faff36207b369';
var roll_nonce = 59;
function fair_getCombinedSeed(server_seed, public_seed, nonce) {
return [server_seed, public_seed, nonce].join('-');
}
function fair_generateSaltHash(seed) {
return crypto.createHmac('sha256', seed).digest('hex');
}
function fair_getRoll(salt, max) {
return Math.abs(parseInt(salt.substr(0, 12), 16)) % max;
}
function fair_getRollPlinko(salt) {
var array = [];
//Get plinko roll by stage
for(var i = 0; i < 14; i++){
var salt_possition = fair_generateSaltHash(salt + '-' + i);
var roll = fair_getRoll(salt_possition, 2);
array.push(roll);
}
return array;
}
var generated_seed = fair_getCombinedSeed(roll_server_seed, roll_client_seed, roll_nonce);
var generated_salt = fair_generateSaltHash(generated_seed);
var generated_array = fair_getRollPlinko(generated_salt);
var generated_roll = generated_array.join('');
console.log('Roll: ' + generated_roll);
Id
Server Seed
Client Seed
Nonce
Roll
No data found