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.
selfie-games.online 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
10 September 2024, 01:22 AM
(hashed) bd39158414b83c575e8225a9233e1afd333dea7eb019b0ae1d136b992b57b0c9
469925ca62db8b6598833b7c99d6ddb92c86a9f71ed73ac02656e66e72740595
1798995 - 1800384
09 September 2024, 01:22 AM
9ee5239b8a162122e03d6c339c605b4bedb8145c2237e0d54f84c6a2b6541efd
677520a51fc791730a2f502afb6bf911305912cf82a266bf85cdcce7e3a38e94
1796215 - 1798994
08 September 2024, 01:22 AM
05b034add8d7cb19dc78b3b9ffad08e8105459bc7338b11fc637f3733f752614
401af3118db3bc3de47f662559e78b197d50b7a2b2143a787d79e339c92564fd
1793435 - 1796214
07 September 2024, 01:21 AM
4dfcd8bb2629066b0b8ba3b32290f46e9a9d321b682ff638d81ca5ceded3eb39
d4f9d2d3c30fb237c7597dfca34fe1a58d4b2ef59ad869c0eda2366eac21728c
1790654 - 1793434
06 September 2024, 01:21 AM
64b79313138b58c55a60a04743f8f7e8665dba20fdb45ad7464ecfaa3a92cf63
fc9d6db8e46e71b187f4c616fd79158b70f775f890c2e28e5423e307bb54fc29
1787873 - 1790653
05 September 2024, 01:21 AM
1eace6c0d916605cc6becdc7b13d672f39b27b55799d2fae31505ea38727f3aa
792db9114494a40770a86cabe8d393c25d2a47cd2a3ec40ec1a975ac07351ddf
1785092 - 1787872
04 September 2024, 01:20 AM
621e1d2c19783bd1ac3ec8c5b00740e1f6077822365bc0a0e51eb39b82d469d7
b5d007ded555c7d8508a7dbdd16940dc4ba0737c144f45fdb508b0d89b704920
1782312 - 1785091
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
10 September 2024, 01:34 AM
(hashed) 6678bbe3ac1df86bdd4fe6ea64692ea7551e8fdafddd811b81ef94f376958e2b
f0aa118e5f35a139172e5fe73c5fdcd770f31d076e529ae647e1b6befe0db393
2090852 - 2092449
09 September 2024, 01:34 AM
1bf905b039c30d4694c118cfe22586bef26de2f0d9e6b0297a427cb2c966d7ce
a240c52f551d464334eceedde7d5454bca8d16af35d23b8a5877087d606621d8
2087602 - 2090851
08 September 2024, 01:34 AM
1b8a54679e23d42847ec99eed4f31ad4f600a2824500e3c7b28e95db7b839ce4
60e14df8e0751292ff44f550478b3771b11169954b9eb250e35d90d6c4ca0afc
2084335 - 2087601
07 September 2024, 01:33 AM
cd1875189894c16000b4c965ecd3d9379386226801195ef02be1c669fd90d7b2
a9c3bd69a61d80c825eab2a7053b4dac8e990e7783e8870f17be97ba2ccc177e
2081059 - 2084334
06 September 2024, 01:32 AM
95da25098faa69356c4e429d319f111573edbeea97c3374d0c43b693b60f6d1e
586af073c40703fcbee3abb7d711f60bc1906b33e35de563396849cffc3e0c3f
2077832 - 2081058
05 September 2024, 01:32 AM
f283894066fc50378d29b61c35bf4dea602f2fc32217333fcd740246c538f2b9
a6c6622a5aafe2f1c6ea4dba6a451cb512198685bc51bfd56c812cf984f9ca5a
2074595 - 2077831
04 September 2024, 01:32 AM
9dfeab018d9d6c5a4df9d5b2df2f5e724c6952da0544935e7fbf448e0e8b0a24
f4cc528c1698ded6c1f1f74c56dcce08077c35c8dba2b6aaba06700497895958
2071333 - 2074594
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