Jak działa provably fair w Ruletce
Oto jak grać w Ruletkę na Cloudbet oraz jak sprawdzić, że każdy spin jest provably fair.
Jak grać w Ruletkę
Ruletka to klasyczna gra kasynowa, w której obstawiasz, gdzie zatrzyma się wirująca kulka na ponumerowanym kole. Stawiasz jeden lub więcej zakładów na stole liczb, następnie koło się kręci, a kulka zostaje wypuszczona. Gdy osiądzie w ponumerowanej kieszeni, ta liczba jest zwycięska — wszystkie zakłady, które ją obejmują, są wypłacane, a pozostałe przegrywają.
Stawianie zakładów
Możesz obstawiać wynik na kilka różnych sposobów i możesz swobodnie łączyć kilka zakładów w tej samej rundzie. Zakłady wewnętrzne (na konkretne liczby) płacą więcej, ale trudniej je trafić; zakłady zewnętrzne (na szersze grupy) płacą mniej, ale trafiają się częściej:
- Plein / pojedyncza liczba (35:1): zakład na jedną konkretną liczbę (0–36 lub 00 w ruletce amerykańskiej).
- Cheval (17:1): dwie sąsiadujące liczby.
- Transwersal pełny (11:1): trzy liczby w rzędzie.
- Carré (8:1): cztery liczby stykające się w rogu.
- Pierwsza czwórka / Top Line (8:1 w wersji europejskiej / 6:1 w amerykańskiej): obejmuje 0 (i 00 w wersji amerykańskiej), 1, 2, 3.
- Six Line (5:1): dwa sąsiadujące rzędy, sześć liczb.
- Kolumna (2:1): jedna z trzech pionowych kolumn.
- Tuzin (2:1): 1–12, 13–24 lub 25–36.
- Czerwone/Czarne, Parzyste/Nieparzyste, Wysokie/Niskie (po 1:1 każdy).
Ruletka europejska a amerykańska
Cloudbet oferuje obie wersje. Ruletka europejska ma jedno zero (37 możliwych wyników, RTP 97,30%); ruletka amerykańska dodaje drugą kieszeń „00” (38 możliwych wyników, RTP 97%), co nieznacznie zwiększa przewagę kasyna. Wersja, w którą grasz, powinna być wyraźnie widoczna przed postawieniem zakładu. Obie wersje zawierają tryb Autoplay do ciągłych spinów z ustalonymi wartościami żetonów i liczbą spinów.
Po postawieniu zakładów i rozstrzygnięciu rundy zwycięskie zakłady są wypłacane automatycznie zgodnie z ich kursami, a stół resetuje się do kolejnej rundy.
Ta strona opisuje, jak Ruletka przekształca sekwencję liczb losowych provably fair w zwycięską liczbę. Informacje o tym, jak ta sekwencja losowa jest w ogóle generowana — seed serwera, seed klienta, nonce, hashowanie, SHAKE256 — znajdziesz w wyjaśnieniu provably fair Cloudbet.
Zamiana liczb losowych w wynik Ruletki
W przypadku Ruletki system provably fair musi udowodnić, że zwycięska liczba jest wybierana w oparciu o weryfikowalną losowość, a nie wybrana po fakcie.
Proces jest prosty: w Ruletce europejskiej z sekwencji liczb losowych losowana jest jedna liczba całkowita z zakresu od 0 do 36 — to jest zwycięska liczba. W Ruletce amerykańskiej wylosowana liczba może mieścić się w zakresie od 0 do 37, przy czym „37” jest mapowane na podwójne zero, „00”; wyniki od 0 do 36 są przyjmowane bez zmian.
Jak wybierana jest zwycięska liczba
Losowe bajty generowane przez SHAKE256 (zobacz naszą stronę provably fair) są dzielone na 4-bajtowe liczby całkowite bez znaku, z zakresu od 0 do 2³²−1. Zwycięska liczba w Ruletce jest wybierana spośród 37 możliwych wyników (Europejska) lub 38 (Amerykańska) — więc w poniższych krokach P wynosi 37 lub 38.
Aby uczciwie wybrać zwycięską liczbę spośród tych P wyników, stosujemy próbkowanie odrzucające (zobacz Jak działa provably fair), a następnie bierzemy wynikową liczbę modulo P — reszta staje się zwycięską liczbą (w Ruletce amerykańskiej „37” jest wyświetlane jako „00”).
Po wygenerowaniu zwycięska liczba jest zapisywana i ukrywana po stronie serwera — nie można jej zmienić ani zmodyfikować niezauważenie po rozpoczęciu rundy. Po postawieniu zakładu jest on porównywany z tą wcześniej ustaloną liczbą, aby rozstrzygnąć rundę.
Zweryfikuj własne wyniki Ruletki
Napisaliśmy niewielki program w Node.js zgodny z implementacją Ruletki na Cloudbet (zarówno europejskiej, jak i amerykańskiej). Wprowadź swój Seed serwera, Seed klienta i Nonce, aby odtworzyć swój wynik. (Przypomnienie: aby ujawnić Seed serwera danej rundy na Cloudbet, musisz już dokonać rotacji na nową parę seedów.)
Zależności:
npm install js-sha3
Kod:
// 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);
})();
Więcej wyjaśnień provably fair dla poszczególnych gier:
Provably fair Roulette Gry
