Qu’est-ce que le Provably Fair ?
Le Provably Fair (équité prouvable) est une approche utilisée dans les jeux en ligne qui permet de vérifier de manière indépendante que chaque résultat est réellement aléatoire.
Il offre une garantie cryptographique que les résultats d’une partie ne peuvent pas être modifiés une fois la mise placée. En combinant des données fournies par le joueur, des données générées par le serveur et des engagements cryptographiques vérifiables publiquement, n’importe qui peut reproduire et vérifier de manière indépendante le résultat d’une manche.
Ainsi, chaque résultat reste à la fois imprévisible avant la manche et vérifiable une fois celle-ci terminée.
Comment nos jeux originaux restent Provably Fair
Chaque résultat est généré à partir de trois composants :
Seed serveur
Une valeur aléatoire secrète générée par le serveur.
Avant le début de la partie, le serveur publie un hash cryptographique de la seed serveur. Celui-ci fait office d’engagement : il prouve que la seed serveur existait avant le début de la manche, sans en révéler la valeur.
Une fois la manche terminée, la seed serveur est révélée et peut être comparée au hash publié auparavant. Chaque manche utilise une nouvelle seed serveur.
Seed client
Une valeur fournie par le joueur.
Les joueurs peuvent choisir leur propre seed client ou utiliser une valeur générée par le système. La seed client entre dans le processus de génération de l’aléatoire et peut être modifiée à tout moment, sauf pendant une manche en cours. Dans les jeux qui se déroulent en plusieurs étapes (Mines, Hi-Lo et Blackjack), une modification effectuée pendant une manche s’applique à partir de la manche suivante.
Nonce
Un compteur qui augmente à chaque événement aléatoire d’une manche.
Comme chaque manche utilise une nouvelle seed serveur, le nonce est réinitialisé à chaque manche. Le premier événement aléatoire de la manche utilise le nonce 1. Utilisez toujours le nonce affiché pour la manche dans l’onglet Vérifier.
Provably Fair - Guide de vérification
Ce guide explique comment le système Provably Fair génère l’aléatoire et comment vous pouvez vérifier de manière indépendante le résultat de n’importe quelle manche.
Le système repose sur un principe simple :
S’engager → Jouer → Révéler
Le serveur s’engage d’abord sur une seed serveur en publiant son hash. La partie se déroule ensuite à l’aide de la seed serveur, de la seed client et du nonce. Une fois la manche terminée, la seed serveur est révélée afin que l’ensemble du processus puisse être vérifié de manière indépendante.
Table des matières
- Modèle de confiance
- Seeds, hashs et nonces
- Génération de l’aléatoire
- Conversion de la sortie du RNG
- Mélange
- Engagement sur la configuration du jeu
- Correspondance des résultats
- Comment vérifier un résultat
- Vérificateur de référence
- Exemple détaillé
- Tables de paiement de Plinko
- Remarques
Modèle de confiance
Avant le début d’une manche, le serveur génère une seed serveur secrète et publie :
serverSeedHash = SHA256(serverSeed)
Les hashs cryptographiques étant des fonctions à sens unique, la seed serveur reste cachée tandis que l’engagement reste visible publiquement.
Une fois la manche terminée, la seed serveur est révélée. Les joueurs peuvent alors vérifier :
SHA256(serverSeed) == serverSeedHash
Si les valeurs correspondent, la seed serveur n’a pas pu être modifiée après l’engagement.
Seeds, hashs et nonces
| Valeur | Origine | Signification |
|---|---|---|
| serverSeed | Serveur | Valeur aléatoire secrète, révélée après la manche |
| serverSeedHash | Dérivée | Hash SHA256 de la seed serveur |
| clientSeed | Joueur | Source d’aléatoire fournie par le joueur |
| nonce | Compteur | Augmente à chaque événement aléatoire d’une manche, à partir de 1 |
| initialShuffle | Serveur | La configuration de départ du jeu : le paquet ordonné pour les jeux de cartes, ou la plage, la roue, la grille ou la table de paiement pour les autres jeux |
| initialShuffleHash | Dérivée | Engagement sur la configuration de départ, lié à la seed serveur de la manche |
| finalShuffle | Serveur | Le résultat brut de la manche : le paquet mélangé, la position des mines, le lancer ou le tirage |
Ce qui est publié et quand
| Valeur | Avant / pendant la manche | Après la fin de la manche |
|---|---|---|
| clientSeed | ✓ | ✓ |
| serverSeedHash | ✓ | ✓ |
| nonce | ✓ | ✓ |
| initialShuffleHash | ✓ | ✓ |
| serverSeed | — | ✓ |
| initialShuffle | — | ✓ |
| finalShuffle | — | ✓ |
Génération de l’aléatoire
Chaque valeur aléatoire est générée à partir de la combinaison de la seed serveur, de la seed client et du nonce. Les entrées sont combinées à l’aide de HMAC-SHA256, et le résultat initialise un générateur de nombres aléatoires ChaCha20. Précisément :
mac = HMAC-SHA256(key = serverSeed, message = clientSeed + ":" + nonce)
chachaKey = SHA256(mac)
chachaNonce = first 12 bytes of mac
stream = ChaCha20 keystream (IETF variant: 96-bit nonce,
block counter starting at 0)
La seed serveur est utilisée sous forme de texte (ses caractères UTF-8) et non décodée depuis l’hexadécimal. La seed client et le nonce sont joints par deux-points, par exemple
myClientSeed:1
.
ChaCha20 est un algorithme cryptographique largement utilisé, conçu pour générer des valeurs aléatoires sûres et statistiquement uniformes.
Le processus étant déterministe, les mêmes entrées produiront toujours la même sortie. Cela permet de reproduire et de vérifier de manière indépendante chaque résultat une fois la seed serveur révélée.
Conversion de la sortie du RNG
La sortie du générateur est lue par blocs de 4 octets sous forme d’entiers non signés big-endian (de 0 à 2 32 − 1).
Lorsqu’un jeu a besoin d’un nombre entier compris entre 0 et n − 1, un échantillonnage par rejet est utilisé afin que chaque résultat soit équiprobable :
limit = 2^32 − (2^32 mod n)
read the next integer; if it is ≥ limit, discard it and read another
result = integer mod n
Chaque jeu convertit ensuite ces nombres en son résultat (voir Correspondance des résultats ).
Mélange
Les jeux de cartes et Mines utilisent l’algorithme de mélange de Fisher-Yates. Fisher-Yates est une méthode mathématiquement éprouvée pour générer des permutations aléatoires non biaisées, largement utilisée dans l’ensemble du secteur du jeu.
for i from (size − 1) down to 1:
j = random whole number from 0 to i (using the method above)
swap items i and j
Un mélange utilise un seul flux aléatoire (une seed serveur, une seed client et un nonce) du début à la fin. Le mélange étant déterministe, n’importe quel joueur peut reproduire l’ordre exact une fois la seed serveur révélée.
Engagement sur la configuration du jeu
Chaque jeu s’engage sur sa configuration de départ (
initialShuffle
) avant le début de la manche :
initialShuffleHash = SHA256(initialShuffle + "|" + serverSeed)
La configuration de départ et la seed serveur sont jointes par une barre verticale (
|
).
Le hash est publié avant le début de la partie. Une fois la manche terminée, la configuration de départ et la seed serveur sont révélées et peuvent être comparées à celui-ci. Cela garantit que le paquet, la grille ou la configuration du jeu n’a pas pu être modifié après l’engagement.
Correspondance des résultats
Dice
Un nombre entier compris entre 0 et 10000 est tiré puis divisé par 100, ce qui donne un lancer compris entre 0.00 et 100.00.
Limbo
Un nombre entier compris entre 1 et 100,000,000 est tiré (le « tirage brut »). Le multiplicateur obtenu est :
result = RTP × 100,000,000 ÷ rawDraw
arrondi à l’inférieur à 2 décimales et maintenu entre 1.00 et 10,000.00. Le RTP correspond au taux de retour au joueur du jeu, par exemple 99 %. La manche est gagnée lorsque le résultat est supérieur ou égal à votre multiplicateur cible.
Roulette
Un nombre entier compris entre 0 et 36 est tiré : le numéro gagnant.
Plinko
Chaque combinaison de nombre de rangées et de niveau de risque dispose d’une table de paiement publiée, dans laquelle chaque case d’arrivée possède un poids. Un nombre entier est tiré entre 0 (inclus) et le poids total de la table (exclu). En parcourant les cases dans l’ordre et en additionnant leurs poids, la bille tombe dans la première case où le total cumulé est supérieur au nombre tiré. Cette case détermine le multiplicateur. Les cases ayant un poids plus élevé sont proportionnellement plus probables.
Les poids et multiplicateurs de chaque combinaison de nombre de rangées et de niveau de risque sont indiqués dans Tables de paiement de Plinko , ci-dessous.
Mines
Les cases de la grille sont numérotées de 0 à N − 1 (N = taille de la grille, par exemple 25 pour une grille de 5×5). Les cases sont mélangées une fois par manche à l’aide de Fisher-Yates. Les m premières cases de la liste mélangée sont les mines, m étant le nombre de mines choisi. La disposition des mines est fixée avant que la première tuile soit révélée et ne change pas pendant la manche.
Baccarat et Blackjack
Un sabot de 8 jeux (416 cartes) est mélangé une fois par manche à l’aide de Fisher-Yates, et les cartes sont distribuées à partir de celui-ci selon les règles du jeu.
Hi-Lo
Chaque carte est tirée d’un jeu de 52 cartes fraîchement mélangé : la carte 1 utilise le nonce 1, la carte 2 utilise le nonce 2, et ainsi de suite. La carte du dessus de chaque mélange est la carte distribuée.
Comment vérifier un résultat
Pour une manche terminée, la vérification se déroule en trois étapes.
Étape 1 - Vérifier la seed serveur
Confirmez que la seed serveur révélée correspond au hash de la seed serveur affiché avant la manche :
SHA256(serverSeed) == serverSeedHash
Cela prouve que la seed serveur a été engagée avant le début de la partie.
Étape 2 - Reproduire le résultat
À l’aide de la seed serveur révélée, de la seed client et du nonce affiché pour la manche, reproduisez les valeurs aléatoires générées pendant la manche. Les valeurs reproduites doivent correspondre exactement au résultat publié de la partie.
Étape 3 - Vérifier l’engagement sur la configuration du jeu
SHA256(initialShuffle + "|" + serverSeed) == initialShuffleHash
Cela confirme que le paquet, la grille ou la configuration de départ du jeu a été engagé avant le début de la partie et n’a pas été modifié par la suite.
Vérificateur de référence
Chaque jeu Originals intègre un vérificateur : ouvrez le jeu, puis Provably Fair → Vérifier . Il affiche la seed serveur, la seed client et le nonce de la dernière manche, et recalcule son résultat. Vous pouvez également saisir n’importe quelles seeds et n’importe quel nonce révélés pour vérifier une autre manche.
Si les valeurs reproduites correspondent aux résultats publiés, la manche a été vérifiée avec succès.
Exemple détaillé (Dice)
serverSeed = 1d9339ea6c9e0abc843a07ae63369f2ca65682a327efb8d849c6a1d12ae96bf5
serverSeedHash = 50a442504a8be61bc20deb0caa4bb62eebabff22c3d677a5d0ddaea0af2fb324
clientSeed = l9Chl4f9OV7AP3Pf
nonce = 1
initialShuffle = 0,10000
Étape 1 :
SHA256(serverSeed) = 50a442504a8be61bc20deb0caa4bb62eebabff22c3d677a5d0ddaea0af2fb324
✓ matches serverSeedHash
Étape 2 :
Le générateur décrit ci-dessus donne le nombre entier 2897, le lancer est donc de 2897 ÷ 100 = 28.97. Une mise sur « Plus de 50.00 » est perdante avec ce lancer.
Étape 3 :
SHA256("0,10000|" + serverSeed) = a98a9aa999ea5d4ad8fb8802c871eaa37713c861612d14c8ac57e1ee0e476c65
✓ matches initialShuffleHash
Tables de paiement de Plinko
Chaque table indique le poids de chaque case d’arrivée, numérotées à partir de 0 à l’extrême gauche. Les poids sont identiques pour les risques Faible, Moyen et Élevé ; seuls les multiplicateurs changent. Un nombre entier est tiré entre 0 (inclus) et le poids total (exclu), et la bille tombe dans la première case où le total cumulé des poids est supérieur à ce nombre.
8 rangées
| Case | Poids | Probabilité | Faible | Moyen | Élevé |
|---|---|---|---|---|---|
| 0 | 39 | 0.3902% | 5.6× | 13× | 29× |
| 1 | 312 | 3.1212% | 2.1× | 3× | 4× |
| 2 | 1,093 | 10.9344% | 1.1× | 1.3× | 1.5× |
| 3 | 2,187 | 21.8788% | 1× | 0.7× | 0.3× |
| 4 | 2,734 | 27.3509% | 0.5× | 0.4× | 0.2× |
| 5 | 2,187 | 21.8788% | 1× | 0.7× | 0.3× |
| 6 | 1,093 | 10.9344% | 1.1× | 1.3× | 1.5× |
| 7 | 312 | 3.1212% | 2.1× | 3× | 4× |
| 8 | 39 | 0.3902% | 5.6× | 13× | 29× |
9 rangées
| Case | Poids | Probabilité | Faible | Moyen | Élevé |
|---|---|---|---|---|---|
| 0 | 19 | 0.1901% | 5.6× | 18× | 43× |
| 1 | 175 | 1.7511% | 2× | 4× | 7× |
| 2 | 703 | 7.0342% | 1.6× | 1.7× | 2× |
| 3 | 1,640 | 16.4098% | 1× | 0.9× | 0.6× |
| 4 | 2,460 | 24.6148% | 0.7× | 0.5× | 0.2× |
| 5 | 2,460 | 24.6148% | 0.7× | 0.5× | 0.2× |
| 6 | 1,640 | 16.4098% | 1× | 0.9× | 0.6× |
| 7 | 703 | 7.0342% | 1.6× | 1.7× | 2× |
| 8 | 175 | 1.7511% | 2× | 4× | 7× |
| 9 | 19 | 0.1901% | 5.6× | 18× | 43× |
10 rangées
| Case | Poids | Probabilité | Faible | Moyen | Élevé |
|---|---|---|---|---|---|
| 0 | 9 | 0.0901% | 8.9× | 22× | 76× |
| 1 | 97 | 0.9708% | 3× | 5× | 10× |
| 2 | 439 | 4.3935% | 1.4× | 2× | 3× |
| 3 | 1,171 | 11.7194% | 1.1× | 1.4× | 0.9× |
| 4 | 2,050 | 20.5164% | 1× | 0.6× | 0.3× |
| 5 | 2,460 | 24.6197% | 0.5× | 0.4× | 0.2× |
| 6 | 2,050 | 20.5164% | 1× | 0.6× | 0.3× |
| 7 | 1,171 | 11.7194% | 1.1× | 1.4× | 0.9× |
| 8 | 439 | 4.3935% | 1.4× | 2× | 3× |
| 9 | 97 | 0.9708% | 3× | 5× | 10× |
| 10 | 9 | 0.0901% | 8.9× | 22× | 76× |
11 rangées
| Case | Poids | Probabilité | Faible | Moyen | Élevé |
|---|---|---|---|---|---|
| 0 | 4 | 0.0400% | 8.4× | 24× | 120× |
| 1 | 53 | 0.5304% | 3× | 6× | 14× |
| 2 | 268 | 2.6821% | 1.9× | 3× | 5.2× |
| 3 | 805 | 8.0564% | 1.3× | 1.8× | 1.4× |
| 4 | 1,611 | 16.1229% | 1× | 0.7× | 0.4× |
| 5 | 2,255 | 22.5681% | 0.7× | 0.5× | 0.2× |
| 6 | 2,255 | 22.5681% | 0.7× | 0.5× | 0.2× |
| 7 | 1,611 | 16.1229% | 1× | 0.7× | 0.4× |
| 8 | 805 | 8.0564% | 1.3× | 1.8× | 1.4× |
| 9 | 268 | 2.6821% | 1.9× | 3× | 5.2× |
| 10 | 53 | 0.5304% | 3× | 6× | 14× |
| 11 | 4 | 0.0400% | 8.4× | 24× | 120× |
12 rangées
| Case | Poids | Probabilité | Faible | Moyen | Élevé |
|---|---|---|---|---|---|
| 0 | 2 | 0.0200% | 10× | 33× | 170× |
| 1 | 29 | 0.2901% | 3× | 11× | 24× |
| 2 | 161 | 1.6108% | 1.6× | 4× | 8.1× |
| 3 | 537 | 5.3727% | 1.4× | 2× | 2× |
| 4 | 1,208 | 12.0860% | 1.1× | 1.1× | 0.7× |
| 5 | 1,933 | 19.3397% | 1× | 0.6× | 0.2× |
| 6 | 2,255 | 22.5613% | 0.5× | 0.3× | 0.2× |
| 7 | 1,933 | 19.3397% | 1× | 0.6× | 0.2× |
| 8 | 1,208 | 12.0860% | 1.1× | 1.1× | 0.7× |
| 9 | 537 | 5.3727% | 1.4× | 2× | 2× |
| 10 | 161 | 1.6108% | 1.6× | 4× | 8.1× |
| 11 | 29 | 0.2901% | 3× | 11× | 24× |
| 12 | 2 | 0.0200% | 10× | 33× | 170× |
13 rangées
| Case | Poids | Probabilité | Faible | Moyen | Élevé |
|---|---|---|---|---|---|
| 0 | 1 | 0.0100% | 8.1× | 43× | 260× |
| 1 | 15 | 0.1501% | 4× | 13× | 37× |
| 2 | 95 | 0.9506% | 3× | 6× | 11× |
| 3 | 349 | 3.4921% | 1.9× | 3× | 4× |
| 4 | 872 | 8.7252% | 1.2× | 1.3× | 1× |
| 5 | 1,571 | 15.7194% | 0.9× | 0.7× | 0.2× |
| 6 | 2,094 | 20.9526% | 0.7× | 0.4× | 0.2× |
| 7 | 2,094 | 20.9526% | 0.7× | 0.4× | 0.2× |
| 8 | 1,571 | 15.7194% | 0.9× | 0.7× | 0.2× |
| 9 | 872 | 8.7252% | 1.2× | 1.3× | 1× |
| 10 | 349 | 3.4921% | 1.9× | 3× | 4× |
| 11 | 95 | 0.9506% | 3× | 6× | 11× |
| 12 | 15 | 0.1501% | 4× | 13× | 37× |
| 13 | 1 | 0.0100% | 8.1× | 43× | 260× |
14 rangées
| Case | Poids | Probabilité | Faible | Moyen | Élevé |
|---|---|---|---|---|---|
| 0 | 6 | 0.0060% | 7.1× | 58× | 420× |
| 1 | 85 | 0.0850% | 4× | 15× | 56× |
| 2 | 555 | 0.5550% | 1.9× | 7× | 18× |
| 3 | 2,221 | 2.2212% | 1.4× | 4× | 5× |
| 4 | 6,109 | 6.1094% | 1.3× | 1.9× | 1.9× |
| 5 | 12,219 | 12.2199% | 1.1× | 1× | 0.3× |
| 6 | 18,328 | 18.3293% | 1× | 0.5× | 0.2× |
| 7 | 20,947 | 20.9485% | 0.5× | 0.2× | 0.2× |
| 8 | 18,328 | 18.3293% | 1× | 0.5× | 0.2× |
| 9 | 12,219 | 12.2199% | 1.1× | 1× | 0.3× |
| 10 | 6,109 | 6.1094% | 1.3× | 1.9× | 1.9× |
| 11 | 2,221 | 2.2212% | 1.4× | 4× | 5× |
| 12 | 555 | 0.5550% | 1.9× | 7× | 18× |
| 13 | 85 | 0.0850% | 4× | 15× | 56× |
| 14 | 6 | 0.0060% | 7.1× | 58× | 420× |
15 rangées
| Case | Poids | Probabilité | Faible | Moyen | Élevé |
|---|---|---|---|---|---|
| 0 | 3 | 0.0030% | 15× | 88× | 620× |
| 1 | 45 | 0.0451% | 8× | 18× | 83× |
| 2 | 320 | 0.3207% | 3× | 11× | 27× |
| 3 | 1,288 | 1.2907% | 2× | 5× | 8× |
| 4 | 4,165 | 4.1736% | 1.5× | 3× | 3× |
| 5 | 9,164 | 9.1829% | 1.1× | 1.3× | 0.5× |
| 6 | 15,274 | 15.3055% | 1× | 0.5× | 0.2× |
| 7 | 19,638 | 19.6785% | 0.7× | 0.3× | 0.2× |
| 8 | 19,638 | 19.6785% | 0.7× | 0.3× | 0.2× |
| 9 | 15,274 | 15.3055% | 1× | 0.5× | 0.2× |
| 10 | 9,164 | 9.1829% | 1.1× | 1.3× | 0.5× |
| 11 | 4,165 | 4.1736% | 1.5× | 3× | 3× |
| 12 | 1,288 | 1.2907% | 2× | 5× | 8× |
| 13 | 320 | 0.3207% | 3× | 11× | 27× |
| 14 | 45 | 0.0451% | 8× | 18× | 83× |
| 15 | 3 | 0.0030% | 15× | 88× | 620× |
16 rangées
| Case | Poids | Probabilité | Faible | Moyen | Élevé |
|---|---|---|---|---|---|
| 0 | 1 | 0.0010% | 16× | 110× | 1000× |
| 1 | 24 | 0.0240% | 9× | 41× | 130× |
| 2 | 183 | 0.1830% | 2× | 10× | 26× |
| 3 | 854 | 0.8541% | 1.4× | 5× | 9× |
| 4 | 2,771 | 2.7714% | 1.4× | 3× | 4× |
| 5 | 6,665 | 6.6661% | 1.2× | 1.5× | 2× |
| 6 | 12,219 | 12.2210% | 1.1× | 1× | 0.2× |
| 7 | 17,456 | 17.4588% | 1× | 0.5× | 0.2× |
| 8 | 19,638 | 19.6411% | 0.5× | 0.3× | 0.2× |
| 9 | 17,456 | 17.4588% | 1× | 0.5× | 0.2× |
| 10 | 12,219 | 12.2210% | 1.1× | 1× | 0.2× |
| 11 | 6,665 | 6.6661% | 1.2× | 1.5× | 2× |
| 12 | 2,771 | 2.7714% | 1.4× | 3× | 4× |
| 13 | 854 | 0.8541% | 1.4× | 5× | 9× |
| 14 | 183 | 0.1830% | 2× | 10× | 26× |
| 15 | 24 | 0.0240% | 9× | 41× | 130× |
| 16 | 1 | 0.0010% | 16× | 110× | 1000× |
Remarques
- La seed serveur, la seed client et le nonce déterminent entièrement chaque résultat.
- Les mêmes entrées génèrent toujours le même résultat.
- Chaque manche utilise une nouvelle seed serveur ; le nonce commence à 1 à chaque manche.
- HMAC-SHA256 est utilisé pour dériver un aléatoire cryptographique à partir des valeurs des seeds.
- ChaCha20 est utilisé comme générateur de nombres aléatoires déterministe.
- Fisher-Yates est utilisé pour mélanger les paquets et la grille de Mines.
- L’échantillonnage par rejet garantit que chaque résultat reste équiprobable lorsqu’une plage est nécessaire.
- Toute modification de la seed serveur après l’engagement invaliderait le hash publié et serait immédiatement détectée.
- Chaque résultat peut être reproduit et vérifié de manière indépendante une fois la seed serveur révélée.