Így működik a provably fair a Roulette-ben
Íme, hogyan játssz Roulette-et a Cloudbeten, és hogyan ellenőrizheted, hogy minden pörgetés provably fair.
Hogyan játssz Roulette-et
A Roulette egy klasszikus kaszinójáték, ahol arra fogadsz, hogy egy pörgő labda hova esik egy számozott keréken. Egy vagy több tétet teszel a számtáblára, majd a kerék megpörgetésre kerül, és a labdát leejtik. Amint megáll egy számozott résben, az lesz a nyerőszám — minden tét, amely erre fedezetet nyújt, kifizetésre kerül, minden más veszít.
Tétek megtétele
Többféleképpen fogadhatsz az eredményre, és szabadon kombinálhatsz több tétet is ugyanabban a körben. A belső tétek (konkrét számokra) többet fizetnek, de nehezebb eltalálni őket; a külső tétek (szélesebb csoportokra) kevesebbet fizetnek, de gyakrabban nyernek:
- Teli szám / Egyszám (35:1): fogadás egy pontos számra (0–36, vagy 00 az amerikai Roulette-ben).
- Split (17:1): két szomszédos szám.
- Utca (11:1): három egymást követő szám.
- Sarok (8:1): négy, egy sarokban találkozó szám.
- Első Négy / Felső Sor (8:1 európai / 6:1 amerikai): lefedi a 0-t (és 00-t az amerikai verzióban), 1-et, 2-t, 3-at.
- Hatos sor (5:1): két szomszédos sor, hat szám.
- Oszlop (2:1): a három függőleges oszlop egyike.
- Tucatok (2:1): 1–12, 13–24, vagy 25–36.
- Piros/Fekete, Páros/Páratlan, Magas/Alacsony (egyenként 1:1).
Európai vs. amerikai Roulette
A Cloudbet mindkét verziót kínálja. Az európai Roulette-nek egyetlen zérója van (37 lehetséges kimenetel, 97,30%-os RTP); az amerikai Roulette egy második „00” rekesszel egészül ki (38 lehetséges kimenetel, 97%-os RTP), ami kissé megnöveli a házelőnyt. Hogy melyik verziót játszod, azt még a tét megtétele előtt egyértelműen jelezni kell. Mindkettőhöz elérhető egy Autoplay mód a folyamatos pörgetésekhez, előre beállított zsetonértékekkel és pörgetésszámmal.
Miután megtetted a tétedet és a kör lezárult, minden nyerő tétet automatikusan kifizetünk az odds szerint, majd az asztal alaphelyzetbe áll a következő körhöz.
Ez az oldal azt mutatja be, hogyan alakít a Roulette egy provably fair véletlenszám-sorozatot nyerőszámmá. Hogy ez a véletlenszám-sorozat hogyan jön létre — server seed, client seed, nonce, hash-elés, SHAKE256 —, azt lásd a Cloudbet provably fair magyarázatában.
Véletlenszámokból Roulette-eredmény
A Roulette esetében a provably fair rendszernek bizonyítania kell, hogy a nyerőszámot ellenőrizhető véletlenszerűség választja ki, nem utólag választják ki.
A folyamat egyszerű: az európai Roulette-ben egy 0 és 36 közötti egész számot mintavételezünk a véletlenszám-sorozatból — ez lesz a nyerőszám. Az amerikai Roulette-ben a mintavételezett szám 0 és 37 között lehet, ahol a „37” a dupla zérónak, a „00”-nak felel meg; a 0-tól 36-ig terjedő eredményeket változatlanul vesszük.
Hogyan választódik ki a nyerőszám
A SHAKE256 által generált véletlenszerű byte-okat (lásd a provably fair oldalunkat) 4 byte-os előjel nélküli egészekre osztjuk, 0-tól 2³²−1-ig. A Roulette nyerőszáma 37 lehetséges kimenetel (európai) vagy 38 (amerikai) közül kerül kiválasztásra — tehát az alábbi lépésekben P értéke 37 vagy 38.
Hogy tisztességesen válasszunk egy nyerőszámot e P kimenetel közül, elutasításos mintavételt alkalmazunk (lásd Így működik a provably fair), majd az eredményt modulo P-vel elosztva vesszük — a maradék lesz a nyerőszám (amerikai Roulette esetén a „37” „00”-ként jelenik meg).
Az így legenerált nyerőszám elmentésre és elrejtésre kerül a szerveren — a kör kezdete után észrevétlenül nem lehet megváltoztatni. Miután megtetted a tétedet, ehhez az előre meghatározott számhoz hasonlítjuk, hogy lezárjuk a kört.
Ellenőrizd saját Roulette-eredményeidet
Írtunk egy kis Node.js programot, amely pontosan megfelel a Cloudbet Roulette implementációjának (mind az európai, mind az amerikai verzióhoz). Add meg a Server Seededet, a Client Seededet és a Nonce-odat, hogy visszaállítsd az eredményedet. (Emlékeztető: ahhoz, hogy egy kör Server Seedjét felfedd a Cloudbeten, már át kellett váltanod egy új seed-párra.)
Függőségek:
npm install js-sha3
A kód:
// 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);
})();
További provably fair játékmagyarázatok:
Provably fair Roulette Játékok
