> ## 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.
# Verificar uma rodada
> Uma verificação completa de uma rodada encerrada a partir de dados públicos, com as verificações mais curtas do Dice e do Mines.
Você mesmo pode verificar qualquer rodada encerrada a partir de dados públicos on-chain, sem conta e sem nenhum acesso especial. São três coisas a conferir: que o hash de commit foi publicado antes de a rodada começar, que o hash do segredo revelado bate com esse commit e que recalcular a fórmula pública reproduz o resultado com base no qual a rodada pagou.
Este passo a passo pega uma rodada encerrada de [Crash](/pt-BR/docs/games/crash) e a verifica de ponta a ponta: que o segredo do operador foi registrado (commit) **antes** da rodada e que o ponto de crash é exatamente o que a [fórmula pública](/pt-BR/docs/provably-fair/crash) produz. Você não precisa de nenhum acesso especial: tudo vem de dados públicos on-chain. Uma seção curta no final cobre o [Dice](#dice-and-mines) e o Mines, que são verificados a partir de uma única transação cada.
## O que você está provando
1. **O commit veio primeiro.** O hash do segredo já estava on-chain antes de a rodada começar, então o resultado não pode ter sido escolhido depois da sua aposta.
2. **O segredo bate com o commit.** `sha256(secret)` é igual ao hash registrado.
3. **O multiplicador é honesto.** Recalcular a fórmula a partir do segredo e do hash do bloco gera exatamente o ponto de crash com base no qual a rodada pagou.
## Passo 1: abra os dados de verificação da rodada no app
Abra seu histórico de apostas (ou o histórico de rodadas) e clique em uma rodada encerrada para ver os detalhes. Junto com o resultado da rodada, você vai encontrar:
* **Crash em**: o multiplicador final a verificar.
* **Hash do segredo do jogo**: o segredo revelado de 32 bytes. Ele leva à **transação de commit** em um explorador da Solana.
* **Hash do bloco**: o hash do slot da Solana usado como entropia da blockchain. Ele leva à **transação de início da rodada**.
* **“Este jogo é justo? Use a ferramenta de verificação”**: abre a ferramenta de verificação com esta rodada já preenchida. A ferramenta busca as três assinaturas de transação da rodada (commit, hash do bloco, revelação) e a rede em que ela rodou, e recalcula tudo o que está abaixo para você com um clique.
A ferramenta de verificação é o caminho prático. O restante desta página é o caminho totalmente independente, em que você não confia em nada além da blockchain e do seu próprio computador.
## Passo 2: as três transações de uma rodada
| Dado de verificação | Instrução on-chain | O que ela publica |
| - | - | - |
| Transação de commit | `start_new_round` | O commit `sha256(secret)`, no evento `CrashRoundPrepared`, antes de as apostas abrirem |
| Transação do hash do bloco | `start_game` | O hash do slot da Solana capturado, no evento `CrashGameStarted`; o resultado fica definido a partir daqui |
| Transação de revelação | `crash` | O segredo revelado e o ponto de crash final, no evento `CrashRoundFinalized` |
## Passo 3: leia os valores em um explorador da Solana
Abra cada transação no explorador que preferir (Solscan, Solana Explorer, SolanaFM…), na rede em que o app roda. Na página da transação, procure os **eventos** decodificados do programa (às vezes em “Logs” ou “Instruction data”; os exploradores que conhecem a IDL do programa decodificam os campos do evento pelo nome).
Anote quatro valores:
* `commit_hash`: 32 bytes, da transação de commit.
* `blockhash`: 32 bytes, da transação do hash do bloco.
* `local_e`: o segredo de 32 bytes, da transação de revelação.
* `crash_point_bps`: o ponto de crash final em pontos-base, da transação de revelação (29948 significa 2.9948x).
**Codificações**
Os exploradores mostram valores de 32 bytes em hex, base58 ou como arrays de bytes, dependendo do site. O script abaixo espera **hex**; converta se o seu explorador mostrar base58 (qualquer decodificador base58 serve; o que importa são os valores dos bytes, não a notação).
## Passo 4: confira a ordem
No explorador, compare o **slot** (ou o horário do bloco) da transação de commit com o da transação do hash do bloco. O commit tem que ser anterior. Esse é o coração do esquema: o segredo foi selado antes de existir a entropia com a qual ele é combinado.
## Passo 5: recalcule o ponto de crash
Rode isto com Node.js (sem dependências), preenchendo as três strings hex do Passo 3:
```js theme={null}
const { createHash } = require("node:crypto");
const sha256 = (buf) => createHash("sha256").update(buf).digest();
// ── Preencha com os eventos on-chain da rodada (hex, 32 bytes cada) ──
const commit = Buffer.from("", "hex"); // da tx de commit
const blockhash = Buffer.from("", "hex"); // da tx do hash do bloco
const secret = Buffer.from("", "hex"); // da tx de revelação
const edgeBps = 150n; // vantagem da casa em bps na época da rodada; veja Taxas e limites
// 1. O segredo revelado precisa bater com o commit
console.log("commitment ok:", sha256(secret).equals(commit));
// 2. Recalcula o ponto de crash: a mesma matemática inteira que o programa executa
const hash = sha256(Buffer.concat([blockhash, secret])); // primeiro o blockhash, depois o segredo
const X = BigInt(hash.readUInt32BE(0)); // primeiros 4 bytes, big-endian
const TWO32 = 1n << 32n;
const cappedX = X < TWO32 - 1000n ? X : TWO32 - 1000n;
const raw = ((10000n - edgeBps) * TWO32) / (TWO32 - cappedX); // a divisão BigInt arredonda para baixo
const crashBps = raw > 10000n ? raw : 10000n;
console.log("crash point:", `${Number(crashBps) / 10000}x`, `(${crashBps} bps)`);
```
As duas verificações precisam passar: `commitment ok: true`, e o ponto de crash impresso tem que ser igual ao multiplicador **Crash em** da rodada (e ao `crash_point_bps` do evento de revelação). Se forem, você provou, sem confiar em ninguém, que o resultado desta rodada foi travado antes de ela começar e calculado exatamente pela fórmula pública.
Dice e Mines
Os jogos instantâneos são verificados do mesmo jeito, com menos transações:
* **Dice**: uma transação por aposta. O evento `DiceBetSettled` contém todos os dados de entrada da derivação (`slothash`, `user`, `nonce`), além do `roll` e do pagamento. Recalcule com a fórmula da página [Justiça no Dice](/pt-BR/docs/provably-fair/dice).
* **Mines**: duas transações por jogo. A transação de início publica o commit do tabuleiro e o hash do slot; a transação de liquidação revela a seed e o tabuleiro completo. Recalcule com a fórmula da página [Justiça no Mines](/pt-BR/docs/provably-fair/mines).
## Se algo não bater
Primeiro, descarte os suspeitos de sempre: um valor em base58 colado onde se esperava hex, a transação errada (cada rodada tem três) ou uma vantagem da casa diferente da que valia na época da rodada (a vantagem fica na configuração on-chain, e toda mudança nela é, por si só, uma transação on-chain).
Se mesmo assim a diferença for real, é exatamente isso que este sistema existe para expor: os dados são públicos e permanentes, então qualquer pessoa pode refazer a sua verificação. Entre em contato com o suporte informando o número da rodada, e saiba que não existe explicação honesta para uma divergência real de commit ou de fórmula, e é justamente por isso que o esquema torna impossível escondê-las.