> ## 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 una ronda

> Una verificación completa de una ronda terminada a partir de datos públicos, más las comprobaciones más cortas de Dice y Mines.

Puedes verificar tú mismo cualquier ronda terminada a partir de datos públicos on-chain, sin cuenta y sin ningún acceso especial. Hay tres cosas que comprobar: que el hash del compromiso se publicó antes de que empezara la ronda, que el hash del secreto revelado coincide con ese compromiso y que, al recalcular la fórmula pública, se obtiene el resultado con el que se pagó la ronda.

Esta guía toma una ronda terminada de [Crash](/es/docs/games/crash) y la verifica de principio a fin: que el secreto del operador se fijó **antes** de la ronda y que el punto de crash es exactamente el que produce la [fórmula pública](/es/docs/provably-fair/crash). No necesitas ningún acceso especial: todo sale de datos públicos on-chain. Una sección corta al final trata [Dice](#dice-and-mines) y Mines, que se verifican con una sola transacción cada uno.

## Qué estás demostrando

1. **El compromiso fue primero.** El hash del secreto estaba on-chain antes de que empezara la ronda, así que el resultado no pudo elegirse después de tu apuesta.
2. **El secreto coincide con el compromiso.** `sha256(secret)` es igual al hash fijado.
3. **El multiplicador es honesto.** Al recalcular la fórmula a partir del secreto y el hash de bloque se obtiene exactamente el punto de crash con el que se pagó la ronda.

## Paso 1: Abre los datos de equidad de la ronda en la app

Abre tu historial de apuestas (o el historial de rondas) y haz clic en una ronda terminada para ver sus detalles. Junto al resultado de la ronda encontrarás:

* **Crash en**: el multiplicador final que vas a verificar.
* **Hash del secreto del juego**: el secreto revelado de 32 bytes. Enlaza a la **transacción de compromiso** en un explorador de Solana.
* **Hash de bloque**: el hash de slot de Solana usado como entropía de la cadena. Enlaza a la **transacción de inicio de la ronda**.
* **“¿Este juego es justo? Usa la herramienta de equidad”**: abre la herramienta de verificación de equidad con esta ronda ya cargada. La herramienta obtiene las firmas de las tres transacciones de la ronda (compromiso, hash de bloque, revelación) y la red, y recalcula por ti todo lo que sigue con un solo clic.

La herramienta de equidad es el camino cómodo. El resto de esta página es el camino totalmente independiente, en el que no confías en nada más que en la cadena y en tu propia computadora.

## Paso 2: Las tres transacciones de una ronda

| Dato de equidad | Instrucción on-chain | Qué publica |
| - | - | - |
| Transacción de compromiso | `start_new_round` | El compromiso `sha256(secret)`, en el evento `CrashRoundPrepared`, antes de que se abran las apuestas |
| Transacción del hash de bloque | `start_game` | El hash de slot de Solana capturado, en el evento `CrashGameStarted`; el resultado queda fijado desde ese momento |
| Transacción de revelación | `crash` | El secreto revelado y el punto de crash final, en el evento `CrashRoundFinalized` |

## Paso 3: Lee los valores en un explorador de Solana

Abre cada transacción en el explorador que prefieras (Solscan, Solana Explorer, SolanaFM…), en la red en la que funciona la app. En la página de la transacción, busca los **eventos** decodificados del programa (a veces en “Logs” o “Instruction data”; los exploradores que conocen el IDL del programa decodifican los campos del evento por nombre).

Reúne cuatro valores:

* `commit_hash`: 32 bytes, de la transacción de compromiso.
* `blockhash`: 32 bytes, de la transacción del hash de bloque.
* `local_e`: el secreto de 32 bytes, de la transacción de revelación.
* `crash_point_bps`: el punto de crash final en puntos básicos, de la transacción de revelación (29948 significa 2.9948x).

<Tip>
  **Codificaciones**

  Según el sitio, los exploradores muestran los valores de 32 bytes en hexadecimal, en base58 o como arreglos de bytes. El script de abajo espera **hexadecimal**; conviértelos si tu explorador los muestra en base58 (sirve cualquier decodificador de base58; lo que importa son los valores de los bytes, no la notación).
</Tip>

## Paso 4: Comprueba el orden

En el explorador, compara el **slot** (o la hora del bloque) de la transacción de compromiso y de la transacción del hash de bloque. El compromiso tiene que ser anterior. Este es el núcleo del esquema: el secreto quedó sellado antes de que existiera la entropía con la que se combina.

## Paso 5: Recalcula el punto de crash

Ejecuta esto con Node.js (sin dependencias), completando las tres cadenas hexadecimales del Paso 3:

```js theme={null}
const { createHash } = require("node:crypto");
const sha256 = (buf) => createHash("sha256").update(buf).digest();

// ── Completa estos valores con los eventos on-chain de la ronda (hex, 32 bytes cada uno) ──
const commit = Buffer.from("<commit_hash hex>", "hex"); // de la tx de compromiso
const blockhash = Buffer.from("<blockhash hex>", "hex"); // de la tx del hash de bloque
const secret = Buffer.from("<local_e hex>", "hex"); // de la tx de revelación
const edgeBps = 150n; // ventaja de la casa en bps al momento de la ronda; ver Comisiones y límites

// 1. El secreto revelado debe coincidir con el compromiso
console.log("commitment ok:", sha256(secret).equals(commit));

// 2. Recalcula el punto de crash: la misma aritmética entera que ejecuta el programa
const hash = sha256(Buffer.concat([blockhash, secret])); // primero blockhash, luego secret
const X = BigInt(hash.readUInt32BE(0)); // primeros 4 bytes, big-endian
const TWO32 = 1n << 32n;
const cappedX = X < TWO32 - 1000n ? X : TWO32 - 1000n;
const raw = ((10000n - edgeBps) * TWO32) / (TWO32 - cappedX); // la división BigInt redondea hacia abajo
const crashBps = raw > 10000n ? raw : 10000n;

console.log("crash point:", `${Number(crashBps) / 10000}x`, `(${crashBps} bps)`);
```

Ambas comprobaciones deben pasar: `commitment ok: true`, y el punto de crash impreso debe ser igual al multiplicador **Crash en** de la ronda (y al `crash_point_bps` del evento de revelación). Si es así, demostraste, sin confiar en nadie, que el resultado de esta ronda quedó fijado antes de que empezara y se calculó exactamente con la fórmula pública.

<h2 id="dice-and-mines">
  Dice y Mines
</h2>

Los juegos instantáneos se verifican de la misma manera, con menos transacciones:

* **Dice**: una transacción por apuesta. Su evento `DiceBetSettled` contiene todas las entradas de la derivación (`slothash`, `user`, `nonce`) más el `roll` y el pago. Recalcula con la fórmula de [Equidad en Dice](/es/docs/provably-fair/dice).
* **Mines**: dos transacciones por partida. La transacción de inicio publica el compromiso del tablero y el hash de slot; la transacción de liquidación revela la semilla y el tablero completo. Recalcula con la fórmula de [Equidad en Mines](/es/docs/provably-fair/mines).

## Si algo no coincide

Primero descarta los sospechosos de siempre: un valor en base58 pegado donde se esperaba hexadecimal, la transacción equivocada (cada ronda tiene tres) o una ventaja de la casa distinta de la vigente al momento de la ronda (la ventaja vive en la configuración on-chain, y cada cambio es en sí una transacción on-chain).

Si aun así obtienes una discrepancia real, eso es justamente lo que este sistema existe para sacar a la luz: los datos son públicos y permanentes, así que cualquiera puede repetir tu comprobación. Contacta a soporte con el número de ronda, y ten en cuenta que no existe ninguna explicación honesta para una discrepancia real en el compromiso o en la fórmula, y por eso mismo el esquema hace imposible ocultarlas.