Danous360

Live Rain

0 minutes ago

0.00

It's about to Rain!

Complete the captcha to join the rain!

English

Română

Français

Pусский

German

Select a game from the list below to learn about how we ensure that the results are always random and never tampered with.

Danous360 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));

Server Seed

Useds

Created At

No data found

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);