Quote from: cryptogeniusdice on Today at 01:33:52 PM

Quote from: dvdx1995 on Today at 09:10:25 AM

Quote from: cryptogeniusdice on Today at 04:44:15 AM

Quote from: dvdx1995 on September 28, 2023, 11:47:50 PM

Hello there.

I was watching your topic about the accusation of stake.. but im not sure where do you find the evidence they cheater.

Iterations for mine bets which you provided differes as it depends if mines are opened one by one or automatically (multiple field at once)

I have prepared some php code which you can use to verify outcome of the mine games with tool that stake provide.
You can use some online php compilers example https://www.w3schools.com/php/phptryit.asp?filename=tryphp_compiler

Code:

<?php
    // Example usage:
    $cursor = 0; // please do not update this value
    //we need 24 results for mines to generate as we have 24 possible mines
    $count = 24;

    $hashedServerSeed = 'def3a5cbd25b59adf1d26cfca8efa8e349240c6f5a7a9754a7bc3614a68a5283';
    $clientSeed = 'Vl-f-FEmK7';
    $serverSeed = 'd67cb6c65af339a914a82fbdc652fe13bd022da2c753bf445751a73a3eb4c6d9';
    $nonce = 1;

    function verifyIfServerSeedIsTrue(string $hashedServerSeed, string $serverSeed): bool
    {
        //lets verify if my unhashedServerSeed is actually sha256 hashedServerSeed
        return hash('sha256', $serverSeed) === $hashedServerSeed;
    }

    echo "lets verify if my unhashedServerSeed is actually sha256 hashedServerSeed , Result: => ";
    var_dump(verifyIfServerSeedIsTrue($hashedServerSeed, $serverSeed));

    $hmac_sha256 = [];
    function byteGenerator(string $serverSeed, string $clientSeed, int $nonce, int $cursor): \Generator
    {
        // Setup cursor variables
        $currentRound = floor($cursor / 32);
        $currentRoundCursor = $cursor - ($currentRound * 32);

        // Generate outputs until cursor requirement is fulfilled
        while (true) {
            // Calculate the HMAC
            // Initialize the HMAC context
            $msg = $clientSeed . ":" . $nonce . ":" . $currentRound;
            $hmac = hash_hmac('sha256', $msg, $serverSeed, true);


            $hmacBytes = str_split($hmac);
            // Update cursor for the next iteration of the loop
            while ($currentRoundCursor < 32) {
                yield ord($hmacBytes[$currentRoundCursor]); // Yield the number
                $currentRoundCursor +=  1;
            }
            $currentRoundCursor = 0;
            $currentRound += 1;
        }
    }

    // Convert the hash output from the rng byteGenerator to floats
    function generateFloats (string $serverSeed, string $clientSeed, int $nonce, int $cursor, int $count): array
    {
        // Random number generator function
        $rng = byteGenerator($serverSeed, $clientSeed, $nonce, $cursor);

        // Declare bytes as empty array
        $bytes = [];

        // Populate bytes array with sets of 4 from RNG output
        while (count($bytes) < $count * 4) {
            $bytes[] = $rng->current();
            $rng->next();
        }

        // Chunk the array into sets of 4
        $byteChunks = array_chunk($bytes, 4);
        // Map and reduce each chunk to calculate floats
        $result = array_map(function ($byteChunk) {
            $partialResult = 0.0;
            foreach ($byteChunk as $i => $value) {
                $partialResult += $value / pow(256, $i + 1);
            }
            return $partialResult;
        }, $byteChunks);
        return $result;
    };

    function fisherYatesShuffle(array $array): array
    {
        $result = [];
        $cells = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24];
        for ($i=0; $i< count($array); $i++) {
            $result[$i] = $cells[$array[$i]];
            array_splice($cells, $array[$i], 1);
        }
        return $result;
    }

    $results = generateFloats($serverSeed, $clientSeed, $nonce, $cursor, $count);
    $int_array = [];

    foreach ($results as $result) {
        $r = ($result * ($count+1));
        $int_array[] = (int) $r;
        $count -= 1;
    }

    $mines_positions = fisherYatesShuffle($int_array);

    echo "<br><b>Mines postions</b></br>";
    echo "Game Nonce:" . $nonce;

    foreach ($mines_positions as $key => $value) {
        echo "</br>" . $key . " = " . $value;
    };
?>

For the exaple my outcome is the same as in stake web page.

Quote

lets verify if my unhashedServerSeed is actually sha256 hashedServerSeed , Result: => bool(true)
Mines postions
Game Nonce:1
0 = 5
1 = 7
2 = 14
3 = 15
4 = 13
5 = 11
6 = 18
7 = 8
8 = 12
9 = 2
10 = 16
11 = 23
12 = 6
13 = 1
14 = 0
15 = 21
16 = 20
17 = 19
18 = 17
19 = 22
20 = 9
21 = 10
22 = 3
23 = 24

its not about the calculation for mines there is no paranthesis of code is giving to find the solution.

How it is not about the calculation...

Result where mines are placed is generated at the beggining once you change seed on stake (for infinite nonce)

no matter if game nonce is 10 or 100 000 000 , places for mines are known. as stake knowns your seed and server seed (unhashed) so they can know that before.

IT does not matter HOW MANY MINES YOU PLAY as the PLACES WHERE MINES ARE PLACED ARE KNOWN BEFORE GAME EVEN START.

WHAT IS IMPORTANT IS that once server seed is unhashed and you can know it .. you can verify the results for each of the round you played via the tool they provide or if you don't trust their tools you can write your own ... example is my php code .. which gave you exactly the results of mines fo each game for the provided serverseed , clientseed .

Only think which you basically care is IF MINES ARE ON THE SAME POSITION AS THEY SHOULD BE

Lets say you played 1 000 games on mines from nonce 1 to 1001

You have recorded every of the game and can see in which places mines were placed .. now lets rotate your seed at nonce 1002 and verify each bet with their tool/my code.

You can compare if the mine places which you had playing while hash was still not revealed are the same after you know unhashed serverseed.

under point 3 , if you compare the iteration of the mines you will come to know how different are these as registered in the back end.

if you had ever played mines you know the game ends when you pick a bomb, so for a game of 2 mines how can i pick up more than 11 bombs in the second iteration.

is there ny logic Huh

?

Regarding to the different itarations registered in archive files.

As i already told you it depends if you open fields ONE BY ONE or VIA AUTOMATIC BET (WHEN YOU CHOOSE WHICH FIELDS TO OPEN)

BUT EVEN IF YOU OPEN IT ONE BY ONE , it does not matter of the
If its shown one way or another as the MOST IMPORTANT IS THE MINE PLACES NOT THE FIELDS WHICH YOU HAVE IN THE LOG.

Example
Compare this as a log from mines opened ONE BY ONE (MANUALLY CLICKING).

Quote

"state": {
   "mines": [
   13,
   17,
   5
   ],
   "minesCount": 3,
   "rounds": [
   {
   "field": 0,
   "payoutMultiplier": 1.125
   },
   {
   "field": 6,
   "payoutMultiplier": 1.2857142857142856
   },
   {
   "field": 12,
   "payoutMultiplier": 1.4785714285714282
   },
   {
   "field": 18,
   "payoutMultiplier": 1.7120300751879696
   },
   {
   "field": 24,
   "payoutMultiplier": 1.9973684210526312
   },
   {
   "field": 21,
   "payoutMultiplier": 2.3498452012383897
   },
   {
   "field": 17,
   "payoutMultiplier": 0
   }
   ]
   }

WITH THE LOG OF MINES OPENED BY PRE SELECTED FIELDS

Quote

"state": {
   "mines": [
   0,
   24,
   9
   ],
   "minesCount": 3,
   "rounds": [
   {
   "field": 0,
   "payoutMultiplier": 0
   },
   {
   "field": 6,
   "payoutMultiplier": 0
   },
   {
   "field": 12,
   "payoutMultiplier": 0
   },
   {
   "field": 18,
   "payoutMultiplier": 0
   },
   {
   "field": 24,
   "payoutMultiplier": 0
   },
   {
   "field": 21,
   "payoutMultiplier": 0
   },
   {
   "field": 17,
   "payoutMultiplier": 0
   },
   {
   "field": 10,
   "payoutMultiplier": 0
   },
   {
   "field": 16,
   "payoutMultiplier": 0
   },
   {
   "field": 8,
   "payoutMultiplier": 0
   },
   {
   "field": 2,
   "payoutMultiplier": 0
   },
   {
   "field": 14,
   "payoutMultiplier": 0
   },
   {
   "field": 4,
   "payoutMultiplier": 0
   },
   {
   "field": 20,
   "payoutMultiplier": 0
   }
   ]
   }

As you can see the logs show me that i "clicked" fields 0,6,12 etc.. BUT YOU CAN SEE THAT I ALREADY FAILED ON THE with the 1st one as mines positions are 0,24,9

This means if i play with 1 mine at that particular game, the mine would be at field 0
if i will play with 2 mines it would be 1st mine at field 0 , 2nd mine at field 24,
if i will play with 3 mines it would be 1st mine at field 0, 2nd mine at field 24 , 3rd mine at field 9
and so on (positions and the order of mines you can verify via the tool that STAKE or I have provided to you, i"ve shared the URL where you can just copy and past the code already. (https://www.w3schools.com/php/phptryit.asp?filename=tryphp_compiler)).

SO TO VERIFY IF THE GAMES WAS CORRECT WE ONLY NEED TO KNOW MINES POSITIONS AND THE POSITIONS WHICH WE OPENED/CLICKED AND IT SHOULD BE ORDERED BY THE FIELD ID WHICH WAS CLICKED OR SELECTED 1st,2nd,3rd etc..

I'm a bit concerns based on your replays/analysis that you are not even sure how the game of mines works and how it generates the outcome for each game.
You have found some different iteration for 2 games, which AS I ALREADY EXPLAINED, DOES NOT MATTER. IF ORDER OF MINES AND ORDER OF FIELDS OPENED ARE EQUAL TO YOUR ACTUALL RECORDED GAMEPLAY IT MEANS THERE IS NOTHING RIGGED/MANIPULATED as you suggesting.