Így működik a provably fair a Dice-ban
Íme, hogyan játssz Dice-t a Cloudbeten, és hogyan ellenőrizheted, hogy minden dobás provably fair.
Hogyan játssz Dice-t
A Dice egy gyors tempójú játék, ahol arra fogadsz, hogy egy véletlenszerűen generált szám egy általad választott érték fölé vagy alá esik-e. Válassz egy célértéket, és döntsd el, hogy arra fogadsz, hogy az eredmény Roll Over (fölé esik) vagy Roll Under (alá esik). Minél közelebb van a célértéked a tartomány széléhez, annál kisebb az esélyed a nyerésre — de annál nagyobb a nyereményed, ha mégis bejön. Miután megtetted a tétedet, az eredmény azonnal kiderül.
Cloudbet Originals Dice
A Cloudbet saját Originals Dice játéka 0,00 és 100,00 közötti célértéktartományt, 99%-os RTP-t és x9 800-as maximális szorzót használ, valamint 0,01 $ és 10 000 $ közötti téteket fogad el. Az Auto Bet funkcióval automatizálhatsz több kört is.
Ez az oldal azt mutatja be, hogyan alakít a Dice egy ellenőrzött véletlenszámot a dobásoddá. Hogy maga az alapul szolgáló véletlenszerűség hogyan jön létre és hogyan biztosított — Server Seed, Client Seed, Nonce, hash-elés —, azt lásd a provably fair oldalunkon. Dice: Golden Tickettel játszol? Ott ugyanígy mintavételezik a dobókocka értékét, mint itt, majd ehhez hozzáadódik egy Golden Ticket-érték és szorzó.
Véletlenszámokból Dice-eredmény
A Dice eredményének bizonyíthatóan ugyanahhoz az ellenőrizhető véletlenszerűséghez kell kötődnie, mint minden más Cloudbet Original játéknak. Miután egy kör véletlenszám-sorozata elkészült (SHAKE256 segítségével — lásd a provably fair folyamatot), a Dice így használja fel:
A sorozatból mintavételezünk egy 0 és 10 000 közötti egész számot (a végpontokkal együtt), majd elosztjuk 100-zal — ez egy 0 és 100 közötti, két tizedesjegyű értéket ad. Ez a Dice-eredményed.
Hogyan működik a mintavételezés
A Dice-nak 10 001 lehetséges kimenetele van (0,00-tól 100,00-ig, 0,01-es lépésekben), tehát ennél a játéknál P = 10 001.
Hogy tisztességesen válasszunk e 10 001 kimenetel közül, a Dice ugyanazt az elutasításos mintavételi módszert használja, amelyet a provably fair útmutatónkban leírtunk — egy véletlenszerű 32 bites számot generálunk, majd elutasítjuk és újra mintavételezzük, ha torzítaná az eredményt, amíg egy tisztességeset nem találunk. Ezt a számot ezután modulo 10 001 műveletnek vetjük alá, hogy egy 0 és 10 000 közötti értéket kapjunk, amelyet elosztunk 100-zal a végeredményért.
Játékmenet
Az eredmény a szerveren jön létre és zárolódik, mielőtt megtennéd a tétedet — a kör kezdete után észrevétlenül nem lehet megváltoztatni. Miután megtetted a tétedet, az általad választott küszöbértéket összehasonlítjuk ezzel az előre generált számmal, hogy eldöntsük, helyesen tippeltél-e.
Kód a Dice provably fair működésének független ellenőrzéséhez
Ez a program pontosan megfelel a Cloudbet Dice implementációjának. Add meg a Server Seededet, a Client Seededet és a Nonce-odat, hogy ellenőrizd saját eredményeidet. Megjegyzés: ahhoz, hogy egy játék Server Seedjét felfedd a Cloudbeten, előbb új Server Seedre kell váltanod.
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.
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 getDiceResult(rng) {
const diceMinValue = 0;
const diceMaxValue = 10000;
let number = sampleFromRange(diceMinValue, diceMaxValue, rng);
number = number / 100; // So that the dice's value ranges from 0 to 100
return number;
}
// 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 = 1 * 2; // We need 1 random number, however due to rejection sampling we may need more
const rng = createRandomNumberSequence(numbersToGenerate, roundSignature);
const diceValue = getDiceResult(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);
})();
