O QUE É PROVADAMENTE JUSTO?

O Rocketpot usa algoritmosProvavelmente justos. Você pode verificar o resultado do jogo com o código fonte fornecido abaixo.

O sistema Provably Fair é um método matemático que é usado para garantir que ninguém, nem os jogadores nem o operador do site, possa saber o resultado do jogo antes de ele começar e ninguém possa mexer nos números aleatórios do jogo.

COMO FUNCIONA?

Nós geramos uma cadeia de8.000.000 hashes SHA256. Cada elemento é o hash do hash em minúsculas e hexadecimais representando o hash anterior.

O hash do último elemento da cadeia é5de24be2ba88f21070aca0b909a23ba8977a60e047e750dc6bd637aa3b4defc8

Todos os mapas de jogo para um hash na cadeia: O8.000.000º elemento da cadeia é o hash do jogo #1 e o primeiro elemento da cadeia é o hash do jogo#8.000.000.

COMO VERIFICÁ-LO?

Para verificar que um hash pertence a um jogo #n, simplesmente o hash n vezes e compare o resultado com o hash que o termina.

Para calcular o resultado de um jogo a partir do seu hash:

 
const CryptoJS = require("crypto-js");

função generateGameResultFromSeed(roundSeed, sal) {

  // Número de bits mais significativos a utilizar
  const nBitsToUse = 52;

  // Passo 1. HMAC_SHA256(message=seed, key=salt)
  const hmac = CryptoJS.HmacSHA256(roundSeed, sal);
  const roundHash = hmac.toString(CryptoJS.enc.Hex);

  // Passo 2. r = 52 bits mais significativos
  const roundRandSource = roundHash.slice(0, nBitsToUse / 4);
  const r = parseInt(roundRandSource, 16);

  // Passo 3. Calcular o crash = r / 2^52, uniformemente distribuído em [0; 1)
  const twoPower52 = Math.pow(2, nBitsToUse);
  let crash = r / twoPower52;

  // Passo 4. Calcular o crash normalizado no intervalo 100 - 100B
  crash = Math.floor(97 / crash);
  crash = Math.min(crash, 100000000000);
  crash = Math.max(crash, 100);

  // Passo 5. Pegue os próximos 52 bits como semente para a seleção do jogador na rodada do Jackpot
  const jpPlayerRandSource = roundHash.slice(nBitsToUse / 4, 2 * nBitsToUse / 4);
  const jpPlayerRandom = parseInt(jpPlayerRandSource, 16);

  // Passo 6. Pegue os próximos 52 bits como semente para apanhar o valor do Jackpot na roda
  const jpValueRandSource = roundHash.slice(2 * nBitsToUse / 4, 3 * nBitsToUse / 4);
  const jpValueRandom = parseInt(jpValueRandSource, 16);

  retornar {roundHash, jpPlayerRandom, jpValueRandom, crash, roundSeed};
}

Antes de ser usado para calcular o resultado correspondente, cada hash de jogo é salgado com a representação em minúsculas, hexadecimais de corda do hash de um bloco de bitcoin.

O número do bloco a usar foi publicado no fórum Bitcointalk (URL https://bitcointalk.org/index.php?topic=5178349) antes de ser minado, provando que não escolhemos deliberadamente uma corrente que seja desfavorável para os jogadores.

Este bloco é#591433 com hash00000000000000000014ccc7303b1be1fd8c6b2cb5e961d57fbdc57f661db418

Pode-se verificar que publicamos o número do bloco a ser usado antes de ser minado nas seguintes fotos do evento de semeadura de bitcointalk post: https://archive.is/Mwq4s , http://loyce.club/archive/posts/5224/52246534.html e https://archive.is/r8zCU (obrigado LoyceV por raspar e arquivar o post!)

SELEÇÃO DO JOGADOR DO JACKPOT E POSIÇÕES DAS RODAS

Os resultados da roda do jackpot podem ser verificados com o seguinte código:https://jsfiddle.net/7uackeqo/

Etapas de preparação:

  • 1. Dividir o hash redondo por 3 partes (52 bits cada).
  • 2. Gerar números inteiros de cada parte.
  • 3. A 1ª parte é para o multiplicador (ponto de colisão).
  • 4. A 2ª parte é para a selecção do jogador com jackpot.
  • 5. A 3ª parte é para determinar o resultado do giro da roda do jackpot.

Comentário:O processo de gerar um inteiro a partir do hash é semelhante a qualquer jogo de "crash", nós apenas geramos 3 inteiros em vez de 1.

Etapas de seleção do jogador:

  • 1. Ordene a lista de jogadores por nomes de usuário (elenco em minúsculas, não permitimos nomes duplicados que diferem apenas em caso de caso).
  • 2. Some todas as apostas dos jogadores como valor total da aposta.
  • 3. Verifique se existe um jogador cuja aposta é maior que 90% do valor total da aposta.
    a. Se não existir tal jogador, continue com o passo #4.
    b. Caso contrário - normalize as apostas, limitando a chance deste jogador a 90%.
  • 4. Atribua a cada jogador o intervalo de valores baseado no valor da sua aposta, nome de usuário (após o pedido) e aposta total (após a normalização, se esta ocorreu).
  • 5. Use o valor do passo de preparação #4 como uma semente para a sequência PRNG mersenne twister.
  • 6. Pegue o próximo valor imparcial da seqüência Mersenne Twister PRNG que é menor que a aposta total (valor do passo #2).
  • 7. Escolha um jogador que esteja no intervalo do valor selecionado.

Comentário:Uma forma intuitiva de explicar o processo de selecção do jogador é que cada jogador recebe 1 bilhete por cada satoshi da aposta. E então um bilhete é escolhido com base no valor da cadeia de hash. Dada a lista de jogadores (que consiste de nomes de jogadores e suas apostas) e hash redondo, qualquer um pode verificar o resultado da seleção do jogador. Uma vez que todas as apostas são comprometidas, não há como o operador manipular a seleção do jogador.

Passos para rodar a roda:

  • 1. Use o valor do passo de preparação #5 como uma semente para a seqüência PRNG do twister mersenne.
  • 2. Tome o próximo valor imparcial da sequência Mersenne Twister PRNG que é inferior ao número de sectores na roda do jackpot.
  • 3. Se o valor selecionado for um setor respin, pegue o próximo valor não enviesado da seqüência Mersenne Twister PRNG e repita até que o setor não respin seja escolhido.

Comentário:Dada a configuração da roda (índices de setor e seus valores) e hash redondo, qualquer um pode verificar o resultado do giro da roda e não há maneira de manipular o resultado do giro após a ocorrência do evento da semente.

Este texto foi editado no dia 24 de Setembro de 2019.