Como o provably fair funciona no Dice: Golden Ticket
Veja como jogar Dice: Golden Ticket na Cloudbet, e como verificar se cada lançamento e sorteio do Golden Ticket é provably fair.
Como jogar Dice: Golden Ticket
Dice: Golden Ticket (DGT) funciona como o clássico Dice da Cloudbet, com uma camada extra: um alvo bônus oculto que pode pagar um multiplicador bônus além da sua vitória normal.
Jogo base: escolha Roll Over (2,00–99,99) ou Roll Under (0,01–98,00), depois faça sua aposta. Se o dado cair do seu lado do alvo, você ganha o pagamento implícito pelo seu alvo (um alvo mais apertado = multiplicador maior).
O bônus Golden Ticket: a cada rodada, um segundo valor oculto — o Golden Ticket — também é definido no tabuleiro, com seu próprio multiplicador bônus entre 3x e 200x. Se o seu lançamento de dado cair dentro de ±1,75 da posição do Golden Ticket, você ganha o pagamento bônus com esse multiplicador, instantânea e automaticamente — sem aposta extra necessária, e ele se soma à sua vitória normal.
Você não mira diretamente no Golden Ticket — não é algo que você possa direcionar ou influenciar, ele simplesmente está sempre em algum lugar do tabuleiro a cada rodada, e cair perto dele é um bônus além da sua jogada normal.
Cloudbet Originals Dice: Golden Ticket
O DGT Original da Cloudbet tem RTP de 99%, multiplicador máximo de dado de x6.730, e prêmio máximo de $1.000.000.
Dice: Golden Ticket (DGT) usa a mesma base provably fair de todos os Cloudbet Originals — veja Como Funciona o Provably Fair para a mecânica geral (Seed do Servidor, Seed do Cliente, Nonce, SHAKE256, amostragem por rejeição). A amostragem do valor do dado também funciona da mesma forma que no Dice simples — o DGT soma o valor e o multiplicador do Golden Ticket por cima. Abaixo está como essa sequência se transforma especificamente no seu resultado no DGT.
Transformando números aleatórios em um resultado de jogo
O DGT precisa provar que dois valores são determinados por aleatoriedade verificável: o valor do dado e o valor do Golden Ticket.
O processo é simples: primeiro, um número inteiro entre 0 e 10000 (inclusive) é amostrado para ser o valor final do dado. Depois, outro número inteiro entre 175 e 9825 (inclusive) é amostrado para ser o valor final do Golden Ticket. Ambos os números são divididos por 100 para que cada um tenha duas casas decimais — variando de 0 a 100 (dado) e 1,75 a 98,25 (Golden Ticket).
O intervalo do Golden Ticket é mantido deliberadamente em 1,75–98,25, e não 0–100, para que, onde quer que ele caia, sempre exista uma "zona dourada" completa de 3,5 de largura ao seu redor onde o valor do dado pode cair e ganhar o bônus. Se o intervalo fosse até as bordas (0 ou 100), um Golden Ticket que caísse perto de uma borda teria uma zona dourada menor — e piores chances — do que um que caísse no meio.
O DGT também tem um recurso único: o multiplicador do Golden Ticket é, ele mesmo, gerado por um processo provably fair. Em termos simples: um terceiro número aleatório entre 0 e 1 é sorteado, e então convertido em um multiplicador entre 3 e 200 usando uma distribuição de Pareto truncada.
Detalhes técnicos
Os bytes aleatórios gerados pelo SHAKE256 são divididos em inteiros sem sinal de 4 bytes, variando de 0 a 2³²-1. Como o valor do dado tem 10001 resultados possíveis (0–10000 inclusive), a amostragem por rejeição usa P = 10001; o valor do Golden Ticket tem 9651 resultados possíveis (175–9825 inclusive), então seu P = 9651. (Veja a página do provably fair para entender por que essa etapa é importante.)
Selecionando os valores do dado e do Golden Ticket: o número aleatório do dado é calculado módulo 10001 para obter seu valor. O mesmo é feito para o número aleatório do Golden Ticket usando 9651, e então o resultado é incrementado em 175 (para que fique entre 175–9825). Ambos são então divididos por 100.
Selecionando o multiplicador do Golden Ticket (alguma familiaridade com estatística ajuda aqui): um número aleatório de 32 bits é sorteado e dividido pelo seu valor máximo possível, produzindo um número uniformemente distribuído entre 0 e 1. Esse valor é transformado em uma distribuição de Pareto truncada (limite inferior 3, limite superior 200, alfa 1,343 — escolhidos para que o valor esperado do multiplicador seja 9, o que sustenta a meta de RTP de 99% do DGT), e então arredondado para duas casas decimais.
Jogabilidade
Tanto o valor do dado quanto o do Golden Ticket são gerados no lado do servidor e mantidos ocultos até o fim da rodada — eles não podem ser alterados sem detecção depois que a jogada começa. Depois que você faz sua aposta, o seu limite escolhido é comparado com o valor do dado, e a distância do Golden Ticket em relação ao valor do dado é verificada contra a "zona dourada" de 1,75 para ver se você ganha o bônus.
Código para verificação independente
Fiel à implementação do DGT na Cloudbet — insira sua Seed do Servidor, Seed do Cliente e Nonce para verificar seus próprios jogos. (Para revelar a Seed do Servidor de um jogo na Cloudbet, você precisa já ter avançado para uma nova Seed do Servidor.)
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.
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
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(rng) {
// Dice
// Ranges from 0 to 100, with two decimal places
const diceMinValue = 0;
const diceMaxValue = 10000;
let diceValue = sampleFromRange(diceMinValue, diceMaxValue, rng);
diceValue = diceValue / 100; // Now the value ranges from 0 to 100
// Golden Ticket
// Ranges from 1.75 to 98.25 due to fairness
// (If it landed on 99, for example, then the chance of the dice landing near
// it would be smaller than the guarantee of 3.5%)
const gtMinValue = 175;
const gtMaxValue = 9825;
let goldenTicketValue = sampleFromRange(gtMinValue, gtMaxValue, rng);
goldenTicketValue = goldenTicketValue / 100;
// Golden Ticket Multiplier
const multiplier = getRandomNumberTruncatedPareto(rng); // Complicated maths, can be ignored ;)
return { diceValue, goldenTicketValue, multiplier };
}
// Sample a number using the truncated Pareto distribution
function getRandomNumberTruncatedPareto(rng) {
// Get a uniformly distributed number between 0 and 1
let randomInt32 = rng.next().value;
const fraction = randomInt32 / 0xFFFFFFFF;
// Truncated Pareto distribution. The expected value is 9.00
const m0 = 3;
const m1 = 200;
const alpha = 1.343;
const r = Math.pow(m0 / m1, alpha);
const inner = 1 - fraction * (1 - r);
let randomNumber = m0 / Math.pow(inner, 1 / alpha);
randomNumber = Math.round(randomNumber * 100) / 100; // Round to 2 decimal places
return randomNumber;
}
// Sample a number between 'min' to 'max' (inclusive) using Rejection Sampling
function sampleFromRange(min, max, rng) {
const P = max - min + 1;
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 + min;
}
// Example usage
(function main() {
let nonce = 1;
if (usingCustomData) { nonce = myNonce; }
const { serverSeed, commitment } = generateServerSeed();
const clientSeed = getClientSeed();
const roundSignature = createRoundSignature(serverSeed, clientSeed, nonce);
const numbersToGenerate = 3 * 2; // We need 3 random numbers, however due to rejection sampling we may need more
const rng = createRandomNumberSequence(numbersToGenerate, roundSignature);
const { diceValue, goldenTicketValue, multiplier } = getGameResult(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('🔁 Round Signature (can be verified after the game):', roundSignature);
console.log('🎯 Dice landed on:', diceValue);
console.log('🎫 Golden ticket landed on:', goldenTicketValue);
console.log('⭐ Multiplier:', multiplier);
})();
