¿Qué es Provably Fair?
Provably Fair (justicia demostrable) es un enfoque utilizado en los juegos en línea que permite verificar de forma independiente que cada resultado es verdaderamente aleatorio.
Ofrece una garantía criptográfica de que los resultados del juego no pueden alterarse una vez realizada la apuesta. Al combinar datos aportados por el jugador, datos generados por el servidor y compromisos criptográficos verificables públicamente, cualquier persona puede reproducir y verificar de forma independiente el resultado de una ronda.
Esto garantiza que cada resultado sea impredecible antes de la ronda y verificable una vez finalizada.
Cómo mantenemos nuestros juegos originales Provably Fair
Cada resultado se genera a partir de tres componentes:
Semilla del servidor
Un valor aleatorio secreto generado por el servidor.
Antes de que comience la partida, el servidor publica un hash criptográfico de la semilla del servidor. Esto funciona como un compromiso que demuestra que la semilla del servidor existía antes del inicio de la ronda, sin revelar su valor.
Una vez resuelta la ronda, se revela la semilla del servidor, que puede verificarse con el hash publicado previamente. Cada ronda utiliza una nueva semilla del servidor.
Semilla del cliente
Un valor aportado por el jugador.
Los jugadores pueden elegir su propia semilla del cliente o utilizar un valor generado por el sistema. La semilla del cliente forma parte del proceso de generación de aleatoriedad y puede cambiarse en cualquier momento, salvo durante una ronda en curso. En los juegos que se desarrollan en varios pasos (Mines, Hi-Lo y Blackjack), un cambio realizado durante una ronda se aplica a partir de la siguiente.
Nonce
Un contador que aumenta con cada evento aleatorio de una ronda.
Como cada ronda utiliza una nueva semilla del servidor, el nonce se reinicia en cada ronda. El primer evento aleatorio de la ronda utiliza el nonce 1. Utiliza siempre el nonce que se muestra para la ronda en la pestaña Verificar.
Provably Fair - Guía de verificación
Esta guía explica cómo el sistema Provably Fair genera la aleatoriedad y cómo puedes verificar de forma independiente el resultado de cualquier ronda.
El sistema funciona según un principio sencillo:
Comprometer → Jugar → Revelar
Primero, el servidor se compromete con una semilla del servidor publicando su hash. A continuación, la partida se desarrolla utilizando la semilla del servidor, la semilla del cliente y el nonce. Una vez finalizada la ronda, se revela la semilla del servidor para que todo el proceso pueda verificarse de forma independiente.
Índice
- Modelo de confianza
- Semillas, hashes y nonces
- Generación de aleatoriedad
- Conversión de la salida del RNG
- Barajado
- Compromiso de la configuración del juego
- Asignación de resultados
- Cómo verificar un resultado
- Verificador de referencia
- Ejemplo práctico
- Tablas de pagos de Plinko
- Notas
Modelo de confianza
Antes de que comience una ronda, el servidor genera una semilla del servidor secreta y publica:
serverSeedHash = SHA256(serverSeed)
Como los hashes criptográficos son funciones unidireccionales, la semilla del servidor permanece oculta mientras el compromiso sigue siendo visible públicamente.
Una vez resuelta la ronda, se revela la semilla del servidor. Los jugadores pueden entonces verificar:
SHA256(serverSeed) == serverSeedHash
Si los valores coinciden, la semilla del servidor no pudo haberse modificado después de realizar el compromiso.
Semillas, hashes y nonces
| Valor | Origen | Significado |
|---|---|---|
| serverSeed | Servidor | Valor aleatorio secreto, revelado después de la ronda |
| serverSeedHash | Derivado | Hash SHA256 de la semilla del servidor |
| clientSeed | Jugador | Fuente de aleatoriedad aportada por el jugador |
| nonce | Contador | Aumenta con cada evento aleatorio de una ronda, empezando en 1 |
| initialShuffle | Servidor | La configuración inicial del juego: la baraja ordenada en los juegos de cartas, o el rango, la rueda, la cuadrícula o la tabla de pagos en otros juegos |
| initialShuffleHash | Derivado | Compromiso con la configuración inicial, vinculado a la semilla del servidor de la ronda |
| finalShuffle | Servidor | El resultado bruto de la ronda: la baraja mezclada, las posiciones de las minas, la tirada o el sorteo |
Qué se publica y cuándo
| Valor | Antes / durante la ronda | Después de resolverse la ronda |
|---|---|---|
| clientSeed | ✓ | ✓ |
| serverSeedHash | ✓ | ✓ |
| nonce | ✓ | ✓ |
| initialShuffleHash | ✓ | ✓ |
| serverSeed | — | ✓ |
| initialShuffle | — | ✓ |
| finalShuffle | — | ✓ |
Generación de aleatoriedad
Cada valor aleatorio se genera a partir de la combinación de la semilla del servidor, la semilla del cliente y el nonce. Las entradas se combinan mediante HMAC-SHA256 y el resultado inicializa un generador de números aleatorios ChaCha20. En concreto:
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 semilla del servidor se utiliza como texto (sus caracteres UTF-8), no decodificada desde hexadecimal. La semilla del cliente y el nonce se unen con dos puntos, por ejemplo
myClientSeed:1
.
ChaCha20 es un algoritmo criptográfico ampliamente utilizado, diseñado para generar valores aleatorios seguros y estadísticamente uniformes.
Como el proceso es determinista, las mismas entradas siempre producirán la misma salida. Esto permite reproducir y verificar de forma independiente cada resultado una vez revelada la semilla del servidor.
Conversión de la salida del RNG
La salida del generador se lee de 4 en 4 bytes como enteros sin signo big-endian (de 0 a 2 32 − 1).
Cuando un juego necesita un número entero de 0 a n − 1, se utiliza el muestreo por rechazo para que todos los resultados sean igualmente probables:
limit = 2^32 − (2^32 mod n)
read the next integer; if it is ≥ limit, discard it and read another
result = integer mod n
Después, cada juego convierte estos números en su resultado (consulta Asignación de resultados ).
Barajado
Los juegos de cartas y Mines utilizan el algoritmo de barajado Fisher-Yates. Fisher-Yates es un método matemáticamente demostrado para generar permutaciones aleatorias sin sesgo y se utiliza ampliamente en toda la industria del juego.
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 barajado utiliza un único flujo aleatorio (una semilla del servidor, una semilla del cliente y un nonce) de principio a fin. Como el barajado es determinista, cualquier jugador puede reproducir el orden exacto una vez revelada la semilla del servidor.
Compromiso de la configuración del juego
Cada juego se compromete con su configuración inicial (
initialShuffle
) antes de que comience la ronda:
initialShuffleHash = SHA256(initialShuffle + "|" + serverSeed)
La configuración inicial y la semilla del servidor se unen con una barra vertical (
|
).
El hash se publica antes de que comience la partida. Una vez resuelta la ronda, se revelan la configuración inicial y la semilla del servidor, que pueden comprobarse con él. Esto garantiza que la baraja, la cuadrícula o la configuración del juego no pudieron modificarse después de realizar el compromiso.
Asignación de resultados
Dice
Se sortea un número entero de 0 a 10000 y se divide entre 100, lo que da una tirada de 0.00 a 100.00.
Limbo
Se sortea un número entero de 1 a 100,000,000 (el «sorteo bruto»). El multiplicador resultante es:
result = RTP × 100,000,000 ÷ rawDraw
redondeado hacia abajo a 2 decimales y limitado entre 1.00 y 10,000.00. RTP es el retorno al jugador del juego, por ejemplo, 99 %. La ronda gana cuando el resultado es igual o superior a tu multiplicador objetivo.
Roulette
Se sortea un número entero de 0 a 36: el número ganador.
Plinko
Cada combinación de filas y nivel de riesgo tiene una tabla de pagos publicada, en la que cada casilla de llegada tiene un peso. Se sortea un número entero desde 0 hasta el peso total de la tabla (sin incluirlo). Recorriendo las casillas en orden y sumando sus pesos, la bola cae en la primera casilla en la que el total acumulado es mayor que el número sorteado. Esa casilla determina el multiplicador. Las casillas con mayor peso son proporcionalmente más probables.
Los pesos y multiplicadores de cada combinación de filas y nivel de riesgo figuran en Tablas de pagos de Plinko , más abajo.
Mines
Las celdas de la cuadrícula se numeran de 0 a N − 1 (N = tamaño de la cuadrícula, por ejemplo, 25 en una cuadrícula de 5×5). Las celdas se barajan una vez por ronda mediante Fisher-Yates. Las primeras m celdas de la lista barajada son las minas, donde m es el número de minas elegido. La disposición de las minas queda fijada antes de revelar la primera casilla y no cambia durante la ronda.
Baccarat y Blackjack
Un zapato de 8 barajas (416 cartas) se baraja una vez por ronda mediante Fisher-Yates, y las cartas se reparten de él según las reglas del juego.
Hi-Lo
Cada carta se extrae de una baraja de 52 cartas recién barajada: la carta 1 utiliza el nonce 1, la carta 2 utiliza el nonce 2, y así sucesivamente. La carta superior de cada barajado es la carta repartida.
Cómo verificar un resultado
Para una ronda completada, la verificación consta de tres pasos.
Paso 1 - Verificar la semilla del servidor
Confirma que la semilla del servidor revelada coincide con el hash de la semilla del servidor mostrado antes de la ronda:
SHA256(serverSeed) == serverSeedHash
Esto demuestra que la semilla del servidor se comprometió antes de que comenzara la partida.
Paso 2 - Reproducir el resultado
Con la semilla del servidor revelada, la semilla del cliente y el nonce mostrado para la ronda, reproduce los valores aleatorios generados durante la ronda. Los valores reproducidos deben coincidir exactamente con el resultado publicado del juego.
Paso 3 - Verificar el compromiso de la configuración del juego
SHA256(initialShuffle + "|" + serverSeed) == initialShuffleHash
Esto confirma que la baraja, la cuadrícula o la configuración inicial del juego se comprometió antes de que comenzara la partida y no se modificó después.
Verificador de referencia
Cada juego Originals incluye un verificador integrado: abre el juego y luego ve a Provably Fair → Verificar . Muestra la semilla del servidor, la semilla del cliente y el nonce de la última ronda, y vuelve a calcular su resultado. También puedes introducir cualquier semilla y nonce revelados para comprobar otra ronda.
Si los valores reproducidos coinciden con los resultados publicados, la ronda se ha verificado correctamente.
Ejemplo práctico (Dice)
serverSeed = 1d9339ea6c9e0abc843a07ae63369f2ca65682a327efb8d849c6a1d12ae96bf5
serverSeedHash = 50a442504a8be61bc20deb0caa4bb62eebabff22c3d677a5d0ddaea0af2fb324
clientSeed = l9Chl4f9OV7AP3Pf
nonce = 1
initialShuffle = 0,10000
Paso 1:
SHA256(serverSeed) = 50a442504a8be61bc20deb0caa4bb62eebabff22c3d677a5d0ddaea0af2fb324
✓ matches serverSeedHash
Paso 2:
El generador descrito anteriormente da el número entero 2897, por lo que la tirada es 2897 ÷ 100 = 28.97. Una apuesta a «Más de 50.00» pierde con esta tirada.
Paso 3:
SHA256("0,10000|" + serverSeed) = a98a9aa999ea5d4ad8fb8802c871eaa37713c861612d14c8ac57e1ee0e476c65
✓ matches initialShuffleHash
Tablas de pagos de Plinko
Cada tabla indica el peso de cada casilla de llegada, numeradas desde 0 en el extremo izquierdo. Los pesos son los mismos para los riesgos Bajo, Medio y Alto; solo cambian los multiplicadores. Se sortea un número entero desde 0 hasta el peso total (sin incluirlo), y la bola cae en la primera casilla en la que el total acumulado de pesos es mayor que ese número.
8 filas
| Casilla | Peso | Probabilidad | Bajo | Medio | Alto |
|---|---|---|---|---|---|
| 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 filas
| Casilla | Peso | Probabilidad | Bajo | Medio | Alto |
|---|---|---|---|---|---|
| 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 filas
| Casilla | Peso | Probabilidad | Bajo | Medio | Alto |
|---|---|---|---|---|---|
| 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 filas
| Casilla | Peso | Probabilidad | Bajo | Medio | Alto |
|---|---|---|---|---|---|
| 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 filas
| Casilla | Peso | Probabilidad | Bajo | Medio | Alto |
|---|---|---|---|---|---|
| 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 filas
| Casilla | Peso | Probabilidad | Bajo | Medio | Alto |
|---|---|---|---|---|---|
| 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 filas
| Casilla | Peso | Probabilidad | Bajo | Medio | Alto |
|---|---|---|---|---|---|
| 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 filas
| Casilla | Peso | Probabilidad | Bajo | Medio | Alto |
|---|---|---|---|---|---|
| 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 filas
| Casilla | Peso | Probabilidad | Bajo | Medio | Alto |
|---|---|---|---|---|---|
| 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× |
Notas
- La semilla del servidor, la semilla del cliente y el nonce determinan por completo cada resultado.
- Las mismas entradas siempre generarán el mismo resultado.
- Cada ronda utiliza una nueva semilla del servidor; el nonce empieza en 1 en cada ronda.
- HMAC-SHA256 se utiliza para derivar aleatoriedad criptográfica a partir de los valores de las semillas.
- ChaCha20 se utiliza como generador de números aleatorios determinista.
- Fisher-Yates se utiliza para barajar las barajas y la cuadrícula de Mines.
- El muestreo por rechazo mantiene todos los resultados igualmente probables cuando se necesita un rango.
- Cualquier modificación de la semilla del servidor después del compromiso invalidaría el hash publicado y se detectaría de inmediato.
- Cada resultado puede reproducirse y verificarse de forma independiente una vez revelada la semilla del servidor.