<h3>What is Provable Fairness?</h3><p>Provable fairness is a key principle in online gaming that ensures game 
                         results are generated in a truly random manner and remain immune to any manipulation by the game operator or 
                         other external parties. It assures that all players have equal chances of winning, making each game outcome 
                         entirely unpredictable and free from bias.</p><h3>Achieving Provable Fairness</h3><p>To ensure every wager is 
                         verifiably fair, our platform leverages a mix of key components:</p><ol><li><strong>Server-Side Seed: 
                          </strong>A random value generated by our system that serves as a critical input to the random number 
                          generator.</li><li><strong>Client-Side Seed:</strong> A unique value created by the player, allowing 
                          them to influence the outcome and thereby adding an extra layer of fairness.</li><li><strong>Cryptographic 
                          Nonce:</strong> A distinct number that secures each game's unpredictability, effectively preventing any 
                          manipulation of the results.</li></ol><p>Collectively, these elements serve as inputs to the random number 
                          generator, producing a game outcome in a manner that is both transparent and verifiable.</p><h3>Verifying 
                          Fairness</h3><p>Players can verify the fairness of every game via our verification page. This transparency 
                          is key, as it enables them to inspect both the server-side and client-side seeds along with the cryptographic 
                          nonce.</p>

Overview

<h3>Implementation of Provable Fairness at Sorte Seis</h3><p>At Sorte Seis, we’ve adopted an innovative method 
                         for implementing provable fairness on our online gaming platform. Understanding that traditional approaches 
                         can be complex and potentially daunting for new players, we’ve refined our process to make it more accessible 
                         and transparent.&nbsp;</p><h3>Traditional Server Seed Generation</h3><p>Typically, online casinos produce an 
                         unhashed server seed represented as a 64-character hexadecimal string. While this approach is secure, it results 
                         in a seed that appears as a complex series of characters, making it challenging for players to decipher and 
                         verify.</p><h3>Example of a Traditional Server 
                         Seed</h3><pre>g9IiwibWFjIjoiNDljMGEwYzgwOGM0MjYxMjUzOWQxNzE3OGFjZTI4YmE2NmVmNDkwZjg4ZjY2MDZjNDk3MDA0MDc0MmU2NjVjMSIsInRhZyI6IiJ9</pre><h3>
                         Sorte Seis's pioneering method for generating server seeds.</h3><p>To improve both accessibility and clarity, we've 
                         implemented a 12-word mnemonic seed phrase system for our server seed. This method simplifies the server 
                         seed's appearance, making it more intuitive and familiar—especially for users accustomed to cryptocurrency 
                         wallet formats.</p><h3>Example of Sorte Seis's Server Seed</h3><pre><strong>fringe father crew abandon lift jar blast awesome knife labor tape common&nbsp;</strong></pre>
                         <h3>Generating the 12-Word Mnemonic 
                         Phrase</h3><p>Our server seed generation process starts by constructing a 12-word mnemonic phrase. Initially, 
                         we encode entropy in increments of 32 bits, then derive a checksum from the SHA256 hash of this entropy. The 
                         combined entropy and checksum bits are subsequently used to form the mnemonic phrase.</p><h3>Entropy and Checksum Calculation</h3><pre>
CS = ENT / 32
MS = (ENT + CS) / 11

|  ENT  | CS | ENT+CS |  MS  |
+-------+----+--------+------+
|  128  |  4 |   132  |  12  |
|  160  |  5 |   165  |  15  |
|  192  |  6 |   198  |  18  |
|  224  |  7 |   231  |  21  |
|  256  |  8 |   264  |  24  |
                          </pre><h3>JS Fairness Model for Float and Integer Generation</h3><pre>
const byteGenerator = async function* (

    cursor = 0,

    clientSeed: string | null = null,

    serverSeed: string | null = null,

    nonce: number | null = null

  ) {

    // Setup cursor variables

    let currentRound = Math.floor(cursor / 32);

    let currentRoundCursor = cursor;

    currentRoundCursor -= currentRound * 32;



    // Generate outputs until cursor requirement is fulfilled

    while (true) {

      // HMAC function used to output provided inputs into bytes

      const hmac = createHmac(

        'SHA-256',

        clientSeed + ':' + nonce + ':' + currentRound,

        serverSeed

      );

      const buffer = new Uint8Array(str2ab(hmac));

      // Update cursor for next iteration of loop

      while (currentRoundCursor &lt; 32) {

        // The yield keyword is used in a Generator function, similar to JavaScript's function* syntax

        yield buffer[currentRoundCursor];

        currentRoundCursor++;

      }

      currentRoundCursor = 0;

      currentRound++;

    }

  };

  const createHmac = (algorithm: string, text: string, key: string | null) =&gt; {


    // eslint-disable-next-line new-cap

    const shaObj = new jsSHA(algorithm, 'TEXT');

    shaObj.setHMACKey(key, 'TEXT');

    shaObj.update(text);

    return shaObj.getHMAC('BYTES');

  };

const generateIntegers = async ({

    cursor = 0,

    count = 1,

    target = 100,

    clientSeed,

    serverSeed,

    nonce = 0,

    floats = [],

  }: IntegerProps) =&gt; {

    // Step 1: Generate a series of floats

    floats =

      floats.length &gt; 0

        ? floats

        : await generateFloats({

          cursor,

          count,

          clientSeed,

          serverSeed,

          nonce,

        });

    // Step 2: Positions

    const positions = Array.from({ length: target }, (_, i) =&gt; i + 1);



    // Step 3: Get hits

    const hits = floats.map((float, index) =&gt; {

      return positions.splice(Math.floor(float * (target - index)), 1)[0];

    });

    return hits;

  };

const generateFloats = async ({

    cursor = 0,

    count = 1,

    range = [0, 1],

    clientSeed,

    serverSeed,

    nonce = 0,

    intOnly = false,

    checkScaledResult = true,

  }: Props) =&gt; {

    // Random number generator function

    const rng = byteGenerator(cursor, clientSeed, serverSeed, nonce);

    // Declare bytes as empty array

    const bytes = [];



    // Populate bytes array with sets of 4 from RNG output

    while (bytes.length &lt; count * 4) {

      const item = await rng.next();

      bytes.push(item?.value);

    }

    // Return bytes as floats

    const floats: number[] = [];

    const byteChunks = chunkArray(bytes, 4);

    for (const bytesChunk of byteChunks) {

      let result = 0;

      for (let i = 0; i &lt; bytesChunk.length; i++) {

        const divider = Math.pow(256, i + 1);

        const partialResult = bytesChunk[i] / divider;

        result += partialResult;

      }

      if (checkScaledResult) {

        // Scale the result to the desired range

        const scaledResult = result * (range[1] - range[0]) + range[0];

        let validResult = intOnly ? Math.floor(scaledResult) : scaledResult;

        while (floats.includes(validResult)) {

          validResult++;

          if (validResult &gt; range[1]) {

            validResult = range[0];

          }

        }

        floats.push(validResult);

      } else {

        floats.push(result);

      }

    }



    return floats;

  };
                                </pre>
                                <h3>Generate Binary Seed from Mnemonic Function</h3><p>Within our system, we convert both the client 
                                and server binary seeds into floats. This operation is essential for producing the binary seeds that 
                                confirm the fairness of our algorithms. By ensuring the mnemonic seed is accurately transformed into a 
                                binary format, we uphold the integrity and transparency of our processes.</p><p>Additionally, this function 
                                allows us to verify that the disclosed mnemonic seed aligns with the binary server seed, clearly demonstrating that 
                                our systems and algorithms operate fairly. Generating a binary seed from the mnemonic provides a reliable method to 
                                ensure the overall integrity and fairness of our procedures.</p><pre>
import CryptoJS from 'crypto-js';

export const generateBinarySeed = (mnemonic: string): string =&gt; {
  const salt = 'mnemonic';
  const iterationCount = 2048;
  const derivedKeyLength = 64;

  const seed = CryptoJS.PBKDF2(mnemonic, salt, {
    iterations: iterationCount,
    keySize: derivedKeyLength / 4, // Key size is specified in words, so divide by 4
    hasher: CryptoJS.algo.SHA512,
  });

  const binarySeed = CryptoJS.enc.Hex.parse(seed.toString());
  const hexStr = binarySeed.toString(CryptoJS.enc.Hex);
  const bin2hex = (s: string) =&gt; {
    let i;
    let l;
    let o = '';
    let n;
    s += '';
    for (i = 0, l = s.length; i &lt; l; i++) {
      n = s.charCodeAt(i).toString(16);
      o += n.length &lt; 2 ? '0' + n : n;
    }
    return o;
  };
  const binStr = bin2hex(hexStr);
  const shortBinStr = binStr.slice(0, 64);
  return shortBinStr;
};
                                    </pre><h3>Converting the Mnemonic Phrase to a Binary Seed</h3><p>To derive the binary seed from 
                                    the mnemonic phrase, we employ the PBKDF2 algorithm using HMAC-SHA512. In this process, the 
                                    mnemonic phrase acts as the password, while the salt is the literal string 'mnemonic.'</p><h3>
                                    Final Conversion to a 64-Character Hex String</h3><p>We then refine the 128-character string, 
                                    converting it into the conventional 64-character hexadecimal format typically used for generating 
                                    results.&nbsp;</p><h3>Rotating Your Seed Pair</h3><p>Whenever a player updates their client seed, 
                                    our system concurrently rotates the server seed. This rotation of the seed pair guarantees that 
                                    both seeds remain synchronized and are refreshed for every game, thereby reinforcing the integrity 
                                    of our random number generation process.</p><h3>Nonce</h3><p>The nonce, which increases with every 
                                    bet, operates in unison with the client and server seeds to produce a unique outcome for each game. 
                                    This process guarantees both the fairness and the unpredictability of every wager.</p>
                                    <h3>Conclusion</h3><p>This innovative method for generating server seeds not only simplifies the 
                                    process of result verification but also makes it more accessible to users. By preserving high 
                                    entropy and robust cryptographic security—similar to the techniques used in cryptocurrency 
                                    wallets—it ensures the integrity of our games while reinforcing player confidence in the 
                                    fairness and transparency of our gaming platform.</p>

What is Provable Fairness?

Achieving Provable Fairness

Verifying Fairness