Como o provably fair funciona na Roulette

Veja como jogar Roulette na Cloudbet, e como verificar se cada giro é provably fair.

Como jogar Roulette

Roulette é um jogo clássico de cassino em que você aposta em onde uma bolinha giratória vai parar em uma roda numerada. Você faz uma ou mais apostas na mesa de números, então a roda gira e a bolinha é lançada. Assim que ela se assenta em um bolso numerado, esse é o número vencedor — todas as apostas que o cobrem pagam, e todo o resto perde.

Fazendo apostas

Você pode apostar no resultado de algumas formas diferentes, e é livre para combinar várias apostas na mesma rodada. Apostas internas (em números específicos) pagam mais, mas são mais difíceis de acertar; apostas externas (em grupos mais amplos) pagam menos, mas acertam com mais frequência:

1. Pleno / Número Único (35:1): aposta em um número exato (0–36, ou 00 na Roulette Americana).
2. Cavalo (17:1): dois números adjacentes.
3. Rua (11:1): três números em sequência.
4. Esquina (8:1): quatro números que se encontram em uma esquina.
5. Primeira Quatro / Top Line (8:1 Europeia / 6:1 Americana): cobre 0 (e 00 na Americana), 1, 2, 3.
6. Seis Números (5:1): duas fileiras adjacentes, seis números.
7. Coluna (2:1): uma das três colunas verticais.
8. Dúzias (2:1): 1–12, 13–24, ou 25–36.
9. Vermelho/Preto, Ímpar/Par, Alto/Baixo (1:1 cada).

Roulette Europeia vs. Americana

A Cloudbet oferece as duas versões. A Roulette Europeia tem um único zero (37 resultados possíveis, RTP de 97,30%); a Roulette Americana adiciona um segundo bolso "00" (38 resultados possíveis, RTP de 97%), o que aumenta ligeiramente a vantagem da casa. A versão que você está jogando deve ser exibida claramente antes de você fazer uma aposta. Ambas incluem um modo Autoplay para giros contínuos com valores de ficha e número de giros predefinidos.

Assim que suas apostas são feitas e a rodada é resolvida, quaisquer apostas vencedoras são pagas automaticamente de acordo com suas odds, e a mesa é reiniciada para a próxima rodada.

Esta página cobre como a Roulette transforma uma sequência de números aleatórios provably fair em um número vencedor. Para saber como essa sequência aleatória é gerada em primeiro lugar — seed do servidor, seed do cliente, nonce, hashing, SHAKE256 — veja o guia de provably fair da Cloudbet.

Transformando números aleatórios em um resultado de Roulette

Para a Roulette, o sistema provably fair precisa provar que o número vencedor é escolhido por aleatoriedade verificável, e não escolhido depois do fato.

O processo é simples: na Roulette Europeia, um número inteiro entre 0 e 36 é amostrado da sequência de números aleatórios — esse é o número vencedor. Na Roulette Americana, o número amostrado pode variar de 0 a 37, com "37" mapeado para o duplo zero, "00"; resultados de 0 a 36 são usados como estão.

Como o número vencedor é selecionado

Os bytes aleatórios gerados pelo SHAKE256 (veja nossa página de provably fair) são divididos em números inteiros sem sinal de 4 bytes, variando de 0 a 2³²−1. O número vencedor da Roulette é escolhido entre 37 resultados possíveis (Europeia) ou 38 (Americana) — então, nas etapas abaixo, P é 37 ou 38.

Para escolher um número vencedor de forma justa entre esses P resultados, aplicamos a amostragem por rejeição (veja Como Funciona o Provably Fair), e então calculamos o número resultante módulo P — o resto se torna o número vencedor (na Roulette Americana, "37" é exibido como "00").

Uma vez gerado, o número vencedor é salvo e ocultado no lado do servidor — ele não pode ser alterado ou adulterado sem detecção depois que a rodada começa. Assim que você faz sua aposta, ela é comparada com esse número pré-determinado para resolver a rodada.

Verifique seus próprios resultados de Roulette

Escrevemos um pequeno programa em Node.js fiel à implementação de Roulette na Cloudbet (tanto Europeia quanto Americana). Insira sua Seed do Servidor, Seed do Cliente e Nonce para reproduzir seu resultado. (Lembrete: para revelar a Seed do Servidor de uma rodada na Cloudbet, você precisa já ter rotacionado para um novo par de seeds.)

Dependências:

npm install js-sha3

O código:

// If you are running this yourself, then you can input your own data here
// You can then compare:
// 1) Cloudbet's provided Commitment to the Commitment outputted here. This proves that the Server Seed was not altered during gameplay.
// 2) Cloudbet's provided game outcome to the game outcome outputted here. This proves that your game's outcome was determined solely by the pre-game seeds and was not altered afterwards.
const Version = Object.freeze({ AMERICAN: "american", EUROPEAN: "european" }); // Here the possible versions are listed
let myServerSeed      = 'your_server_seed'; // ✍️YOUR_INPUT✍️: Enter your (unhashed) Server Seed here
let myClientSeed      = 'your_client_seed'; // ✍️YOUR_INPUT✍️: Enter your Client Seed here
let myNonce           = 1;                  // ✍️YOUR_INPUT✍️: Enter your Nonce here
let myRouletteVersion = Version.AMERICAN;   // ✍️YOUR_INPUT✍️: Enter your roulette version (either Version.AMERICAN or Version.EUROPEAN)
const usingCustomData = false;              // Change this to true if you are using your own data

// Load libraries
const crypto = require('crypto');
const { sha3_256, shake256 } = require('js-sha3');

// Step 1: Generate a Server Seed and Commitment
// And generate a Client Seed - either by player input or by the player's browser
function generateServerSeed() {
  let seed = crypto.randomBytes(32).toString('hex');
  if (usingCustomData) { seed = myServerSeed; }
  const commitment = sha3_256(seed);
  return { 'serverSeed': seed, 'commitment': commitment };
}
function getClientSeed() {
  let seed = crypto.randomBytes(32).toString('hex');
  if (usingCustomData) { seed = myClientSeed; }
  return seed;
}

// Step 2: Create a Round Signature with SHA3 using a Server Seed, Client Seed and Nonce
function createRoundSignature(serverSeed, clientSeed, nonce) {
  return sha3_256(`${serverSeed}:${clientSeed}:${nonce}`);
}

// Step 3: Create a SHAKE256 stream generator from a Round Signature.
// To simplify this example program, this function doesn't create a stream, but instead a sequence of custom length.
function* createRandomNumberSequence(numbersToGenerate, roundSignature) {
  const numOfBytes = 4 * numbersToGenerate;           // 4 bytes (32 bits) per random number we generate
  const byteStream = shake256.create(8 * numOfBytes); // shake takes bits as input
  byteStream.update(roundSignature);                  // Use the Round Signature to seed the generator
  const buf = Buffer.from(byteStream.digest());       // The Buffer class lets us package every 4 bytes into one 32-bit integer
  for (let i = 0; i < numbersToGenerate; i++) {
    yield buf.readUInt32BE(i * 4);                    // Read buf in 4-byte steps
  }
  throw new Error("No more numbers in the random number sequence! Fix: make 'numbersToGenerate' larger.");
}

// Step 4: Draw from the random number sequence to calculate the game result
function getGameResult(rouletteVersion, rng) {
  let numOfOutcomes = 0;
  if (rouletteVersion === Version.EUROPEAN) {
    numOfOutcomes = 37;
  } else if (rouletteVersion === Version.AMERICAN) {
    numOfOutcomes = 38;
  }

  let result = String(sample(numOfOutcomes, rng))

  // Convert the result '37' to '00'
  if (result === '37') {
    result = '00';
  }
  return result;
}
// Sample a number from P number of outcomes using Rejection Sampling
function sample(P, rng) {
  const maxAcceptable = Math.floor(0x100000000 / P) * P;

  // Rejection sampling
  let rand;
  do {
    rand = rng.next().value;
  } while (rand >= maxAcceptable);

  // Modulo operation
  const sampled_number = rand % P;

  return sampled_number;
}

// Example usage
(function main() {
  let nonce = 1;
  let rouletteVersion = Version.AMERICAN;
  if (usingCustomData) { nonce = myNonce; rouletteVersion = myRouletteVersion; }

  const { serverSeed, commitment } = generateServerSeed();
  const clientSeed = getClientSeed();

  const roundSignature = createRoundSignature(serverSeed, clientSeed, nonce);
  const numbersToGenerate = 1 * 2; // We need 1 random number, but there is an improbable case we'll need two
  const rng = createRandomNumberSequence(numbersToGenerate, roundSignature);

  const value = getGameResult(rouletteVersion, rng);

  console.log('📝 Commitment (shown before the game):', commitment);
  console.log('🔒 Server Seed (revealed after the game):', serverSeed);
  console.log('🎲 Client Seed:', clientSeed);
  console.log('🔢 Nonce:', nonce);
  console.log(`🎯 Winning Number (in the ${rouletteVersion} version):`, value);
})();

Mais explicações dos jogos provably fair:

1. Provably fair Mines
2. Provably fair Pump
3. Provably fair Plinko
4. Provably fair Dice
5. Provably fair Dice: Golden Ticket
6. Provably fair Limbo
7. Provably fair Keno