> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mycryptocasino.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Vérifier une manche
> Une vérification complète d'une manche terminée à partir de données publiques, avec les contrôles plus courts de Dice et de Mines.
Vous pouvez vérifier vous-même n'importe quelle manche terminée à partir des données publiques on-chain, sans compte et sans accès particulier. Il y a trois choses à contrôler : que le hash de l'engagement a été publié avant le début de la manche, que le secret révélé correspond bien à cet engagement une fois hashé, et que le recalcul de la formule publique redonne exactement le résultat sur lequel la manche a payé.
Ce guide prend une manche de [Crash](/fr/docs/games/crash) terminée et la vérifie de bout en bout : le secret de l'opérateur a bien été engagé **avant** la manche, et le point de crash est exactement celui que produit la [formule publique](/fr/docs/provably-fair/crash). Aucun accès particulier n'est nécessaire : tout provient de données publiques on-chain. Une courte section en fin de page traite de [Dice](#dice-and-mines) et de Mines, qui se vérifient chacun à partir d'une seule transaction.
## Ce que vous prouvez
1. **L'engagement est venu en premier.** Le hash du secret était on-chain avant le début de la manche : le résultat n'a donc pas pu être choisi après votre mise.
2. **Le secret correspond à l'engagement.** `sha256(secret)` est égal au hash engagé.
3. **Le multiplicateur est honnête.** Recalculer la formule à partir du secret et du hash de bloc donne exactement le point de crash sur lequel la manche a payé.
## Étape 1 : ouvrir les données d'équité de la manche dans l'app
Ouvrez votre historique de mises (ou l'historique des manches) et cliquez sur une manche terminée pour en afficher le détail. À côté du résultat de la manche, vous trouverez :
* **Crash à** : le multiplicateur final à vérifier.
* **Hash du secret de jeu** : le secret de 32 octets révélé. Il renvoie vers la **transaction d'engagement (commit)** sur un explorateur Solana.
* **Hash de bloc** : le hash de slot Solana utilisé comme entropie de la chaîne. Il renvoie vers la **transaction de début de manche**.
* **« Ce jeu est-il équitable ? Utilisez l'outil d'équité »** : ouvre l'outil de vérification d'équité avec cette manche pré-remplie. L'outil récupère les trois signatures de transaction de la manche (commit, hash de bloc, révélation) ainsi que le réseau, et recalcule pour vous tout ce qui suit, en un clic.
L'outil d'équité est la voie la plus pratique. Le reste de cette page décrit la voie entièrement indépendante, qui ne fait confiance qu'à la chaîne et à votre propre ordinateur.
## Étape 2 : les trois transactions d'une manche
| Donnée d'équité | Instruction on-chain | Ce qu'elle publie |
| - | - | - |
| Transaction d'engagement | `start_new_round` | L'engagement `sha256(secret)`, dans l'événement `CrashRoundPrepared`, avant l'ouverture des mises |
| Transaction du hash de bloc | `start_game` | Le hash de slot Solana capturé, dans l'événement `CrashGameStarted` ; le résultat est figé à partir de ce moment |
| Transaction de révélation | `crash` | Le secret révélé et le point de crash final, dans l'événement `CrashRoundFinalized` |
## Étape 3 : lire les valeurs sur un explorateur Solana
Ouvrez chaque transaction sur l'explorateur de votre choix (Solscan, Solana Explorer, SolanaFM…), sur le réseau utilisé par l'app. Sur la page de la transaction, cherchez les **événements** décodés du programme (parfois sous « Logs » ou « Instruction data » ; les explorateurs qui connaissent l'IDL du programme décodent les champs des événements par leur nom).
Relevez quatre valeurs :
* `commit_hash` : 32 octets, depuis la transaction d'engagement.
* `blockhash` : 32 octets, depuis la transaction du hash de bloc.
* `local_e` : le secret de 32 octets, depuis la transaction de révélation.
* `crash_point_bps` : le point de crash final en points de base, depuis la transaction de révélation (29948 signifie 2,9948x).
**Encodages**
Selon le site, les explorateurs affichent les valeurs de 32 octets en hexadécimal, en base58 ou sous forme de tableaux d'octets. Le script ci-dessous attend de l'**hexadécimal** ; convertissez si votre explorateur affiche du base58 (n'importe quel décodeur base58 fait l'affaire : ce qui compte, ce sont les valeurs des octets, pas la notation).
## Étape 4 : vérifier l'ordre
Sur l'explorateur, comparez le **slot** (ou l'horodatage du bloc) de la transaction d'engagement et de la transaction du hash de bloc. L'engagement doit être antérieur. C'est le cœur du mécanisme : le secret a été scellé avant même que l'entropie avec laquelle il est combiné n'existe.
## Étape 5 : recalculer le point de crash
Exécutez ceci avec Node.js (aucune dépendance), en renseignant les trois chaînes hexadécimales de l'étape 3 :
```js theme={null}
const { createHash } = require("node:crypto");
const sha256 = (buf) => createHash("sha256").update(buf).digest();
// ── À renseigner depuis les événements on-chain de la manche (hex, 32 octets chacun) ──
const commit = Buffer.from("", "hex"); // depuis la tx d'engagement
const blockhash = Buffer.from("", "hex"); // depuis la tx du hash de bloc
const secret = Buffer.from("", "hex"); // depuis la tx de révélation
const edgeBps = 150n; // avantage de la maison en bps au moment de la manche ; voir Frais et limites
// 1. Le secret révélé doit correspondre à l'engagement
console.log("commitment ok:", sha256(secret).equals(commit));
// 2. Recalculer le point de crash : les mêmes calculs entiers que le programme
const hash = sha256(Buffer.concat([blockhash, secret])); // blockhash d'abord, puis secret
const X = BigInt(hash.readUInt32BE(0)); // 4 premiers octets, big-endian
const TWO32 = 1n << 32n;
const cappedX = X < TWO32 - 1000n ? X : TWO32 - 1000n;
const raw = ((10000n - edgeBps) * TWO32) / (TWO32 - cappedX); // la division BigInt arrondit à l'inférieur
const crashBps = raw > 10000n ? raw : 10000n;
console.log("crash point:", `${Number(crashBps) / 10000}x`, `(${crashBps} bps)`);
```
Les deux contrôles doivent réussir : `commitment ok: true`, et le point de crash affiché doit être égal au multiplicateur **Crash à** de la manche (ainsi qu'au `crash_point_bps` de l'événement de révélation). Si c'est le cas, vous avez prouvé, sans faire confiance à personne, que le résultat de cette manche était verrouillé avant son début et calculé exactement selon la formule publique.
Dice et Mines
Les jeux instantanés se vérifient de la même manière, avec moins de transactions :
* **Dice** : une transaction par mise. Son événement `DiceBetSettled` contient toutes les entrées de la dérivation (`slothash`, `user`, `nonce`) ainsi que le `roll` et le gain. Recalculez avec la formule de la page [Équité de Dice](/fr/docs/provably-fair/dice).
* **Mines** : deux transactions par partie. La transaction de départ publie l'engagement du plateau et le hash de slot ; la transaction de règlement révèle le seed et le plateau complet. Recalculez avec la formule de la page [Équité de Mines](/fr/docs/provably-fair/mines).
## Si quelque chose ne correspond pas
Écartez d'abord les suspects habituels : une valeur en base58 collée là où l'hexadécimal était attendu, la mauvaise transaction (chaque manche en compte trois), ou un avantage de la maison différent de celui en vigueur au moment de la manche (l'avantage est stocké dans la configuration on-chain, et chaque modification est elle-même une transaction on-chain).
Si vous obtenez malgré tout une véritable divergence, c'est précisément ce que ce système existe pour mettre au jour : les données sont publiques et permanentes, donc n'importe qui peut refaire votre vérification. Contactez le support avec le numéro de la manche, et gardez en tête qu'aucune explication honnête ne peut justifier une vraie divergence d'engagement ou de formule : c'est justement pour cela que le mécanisme les rend impossibles à dissimuler.