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
22 December 2024, 03:46 PM
(hashed) 8f6130c001fa58fd5b99df4acae7747467791e67d91fb5282c175f3918c689be
89169c728620ac888d69955e8b50456ee43fd8ad077415b9491db60c5211fb9a
558747 - 558928
21 December 2024, 03:46 PM
b2278f3c7f69f464e3bafa0bafa4625295fb7cfa002a92d718ae2cd6e1dcc928
e1139af8f18de83586ae96fdfc288e0b2f8470635a00a493e85f4b42f34495b2
555971 - 558746
20 December 2024, 03:46 PM
8c7e0e348bc9af78ef3fcfcdb86006bdbd8ee5b73d979bffa6796c8a816e3390
ff8fa0ea959661509eaffa8a868b5abbe941aac2c92b428b2ff39ac997f1a3c2
553196 - 555970
19 December 2024, 03:45 PM
8f636424258747537b47e57c8f7ffafb53b9d971bacff7af659590c2c8c39460
fc8d6fc73c0f0d2911e822e3a756376854a80464edf005cf0e7d3ff07202d0d6
550421 - 553195
18 December 2024, 03:45 PM
5ab621be9e10c3bb23bf2e0b72c219c7383ebefd027b14a80c815e7cda823a89
ce2b035fb4efd3839b27ef8a2235bfd37604c49153b6535ae1312b23328047b7
547646 - 550420
17 December 2024, 03:45 PM
4d7bec326c5922ef40dc9047871782bb0f54fa186b60ddf5b8216ff989e422da
4b2862ac3327f4cc4898df281463532d69312e36c7cda309555800c818a495bd
544870 - 547645
16 December 2024, 03:44 PM
aa42648ddca5f9ec81584ec60d569d88a361768573e852c9a0d32589245fcfe8
b3f1229fb96c57055c47ccba96d96effd5c82cbd2804eba2fe0e79a4145940c4
542095 - 544869
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
22 December 2024, 03:56 PM
(hashed) 3a2651e6c1c38a8a9ef5d2f29f9c94c36356e0b603b02b7430674b6f7b003190
9c1dcf545a6834ef40ffbf35812c036424a3085529a2b0166ac146ff0aa00996
651446 - 651632
21 December 2024, 03:56 PM
dc78f271780514c6683fda793e966e1d11575cad0ec6ae2f0b1849b55c3bc83d
c3810ad079a85f1dd3700524fcb4f6644d08e6463f819006b98f4543de7d0c78
648242 - 651445
20 December 2024, 03:55 PM
c1aed02ef238d6662547f5a34e44658cbe7ecfbf7457aaecf0f52063ee541c2f
b58bdebae9e1fc33d43b8ea003f2ec61f9845603a632aea325571b3700dad998
645061 - 648241
19 December 2024, 03:55 PM
1d937f609a750700ea6db9134ecb5fa2d28c3d2c25c054a8966b6bcf3771ee64
955f8388335be8badb1692eb733459757ba9a978d5542b829de756d8194fc915
641815 - 645060
18 December 2024, 03:55 PM
aa7cd8f1c7225eb95ff2b6dc9d25b78dc90eea52f729a6e56e9ff959e4648ff7
03639da5e6adc41297b4fc3ff82c73c4f6d0cee2b8cf9547bd053d455e7663d1
638532 - 641814
17 December 2024, 03:55 PM
24f5c6f48aa7c17033e4cd5cb150b965374194d04c94f11e20c3a9536c78114b
d63a7ebaa0efb73ffc910d66a9f75c23f05cc26a5982cd15471d9b4c71121958
635268 - 638531
16 December 2024, 03:55 PM
935a91b43dac15f29f72429e23197534541896c8e8ee965cf4be6df48b209e5b
784318db9a9fe6a96816b96d97304278a24f8103f540d342f39e619a3528406c
632005 - 635267
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