BC Game Provavelmente justo

Limbo

Fórmula justa

Como são calculados os resultados?

Para obter os resultados.

Hex string: hash = HMAC_SHA256(clientSeed:nonce, serverSeed)

Exemplo: 6b5124897c3c48d0e46cc9249f08c7e560792459f1bad1171224643b5d2be231

  1. Pegue um valor aleatório entre 2^52, digamos 16^13, um número hexadecimal de 13 bits (porque o valor hash é hexadecimal, 2^52 === 16^13)6b5124897c3c4 (6b5124897c3c4 igual a 1887939992208324 no sistema decimal).
  2. Distribua o valor aleatório a 0~1, dividindo-o pelo valor máximo de 13 fs, ou seja 6b5124897c3c4/fffffffffffffffff. Dada a natureza aleatória do valor de hash, podemos então pensar que qualquer valor de hash pode ser transformado em um número aleatório de 0~1 (fffffffffffffffff é igual a 45035996270496 no sistema decimal) 1887939992208324/4503599627370496 = 0,419206889692064.
  3. Defina a margem da casa 1%. Além disso, para calcular 99/(1-X), onde X é o valor aleatório calculado na Etapa 2. Quando X é 0, o resultado é 99; quando X é 1, o resultado é infinito positivo; quando X é 0,01, o resultado é 100; quando X é inferior a 0,01, o resultado é inferior a 100.

99/(1-0.419206889692064) = 170.45656748150867

  1. Todos os valores inferiores a 100 serão definidos para 100. Em outras palavras, há uma probabilidade de 1% de que 100 aparecerá. Arredonde o número e divida-o por 100 para obter o resultado final.

170/100 = 1.70

Nota: Uma nova seed deve ser definida para verificar os dados anteriores (a seed do servidor é criptografada).

Você realmente precisava saber isto? Provavelmente não. Está aqui para aqueles que esperam transparência e precisão em um jogo de azar comprovadamente justo.

Nós colocamos nossas cartas na mesa.

Boa sorte!

Classic Dice

Fórmula justa

Como são calculados os resultados?

Para obter os resultados.

  • Primeiro calculamos o valor hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce, serverSeed).
  • Finalmente, pegamos 8 caracteres do hash e o convertemos para um valor int32. Então dividimos o valor convertido por 0x100000000, multiplicamos por 10001 e dividimos por 100 para que o número resultante esteja de acordo com as restrições da faixa de dados.

Nota: Uma nova seed deve ser definida para verificar os dados anteriores (a seed do servidor é criptografada).

Você realmente precisava saber isto? Provavelmente não. Está aqui para aqueles que esperam transparência e precisão em um jogo de azar comprovadamente justo.

Nós colocamos nossas cartas na mesa.

Boa sorte!

Hash Dice

Fórmula justa

HashDice é um jogo justo?

Somos uma plataforma de apostas justa e transparente, com o objetivo de eliminar todos os fatores injustos e deixar os jogadores se divertirem, mostramos que a HashDice é um sistema comprovado e verificado, que permite que cada sequência de jogos seja realizada de forma criptografada.

A fim de permitir aos jogadores verificar suas apostas, um par de Server Seed e Client Seed é usado para calcular o número da rodada.

Conhecendo Server Seed, Client Seed e Nonce, é possível calcular o resultado da aposta. Para evitar que um jogador preveja o resultado, a Server Seed é escondida e um hash SHA-256 da seed é mostrado em seu lugar. Após a próxima randomização, o Server Seed anterior é revelado e um jogador é capaz de verificar a aposta. Além disso, os jogadores podem certificar-se de que a Server Seed não foi alterada comparando seus hashes antes e depois da aleatorização.

Como os dados são calculados?

Para gerar um número de jogada entre 0 e 99.999:

  1. Primeiro calculamos o valor do hash da combinação com HMAC_SHA512. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA512 (clientSeed:nonce, serverSeed).
  2. Então pegamos os primeiros 5 caracteres desse hash e os convertemos para um número decimal variando de 0 a 1.048.575 (16 ^ 5 – 1). Se for inferior a 1 milhão, dividimos por 100.000 e o usamos como resultado do seu rolo. Caso contrário, repetimos usando os próximos cinco caracteres. Somos capazes de repetir o processo até 25 vezes.
  3. No caso muito raro ((48.576 / 1.000.000) ^ 25) de nenhuma das 25 tentativas ser inferior a 1 milhão quando convertido em decimal, usamos os 3 caracteres restantes e os convertemos em seu número de rolo.

Exemplo de código

O seguinte exemplo de código pode ser usado para verificar uma aposta:

function getRoll (serverSeed, clientSeed, nonce) {    var hash = hmac_sha512(clientSeed:nonce, serverSeed);    var index = 0;    do {      var lucky = parseInt(hash.substr(index, 5), 16);      index += 5;    } while (lucky >= 1000000);    return lucky % 100000;  }

Por favor, verifique você também sua aposta online.

Dica: Uma nova seed deve ser definida para verificar os dados anteriores (a seed do servidor é criptografada).

Ultimate Dice

Fórmula justa

Como são calculados os resultados?

Para obter os resultados.

  1. Primeiro calculamos o valor hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce, serverSeed).
  2. Finalmente, pegamos 8 caracteres do hash e o convertemos para um valor int32. Então dividimos o valor convertido por 0x100000000, multiplicando-o por 10000 para que o número resultante esteja de acordo com as restrições da faixa de dados.

Nota: Uma nova seed deve ser definida para verificar os dados anteriores (a seed do servidor é criptografada).

Você realmente precisava saber isto? Provavelmente não. Está aqui para aqueles que esperam transparência e precisão em um jogo de azar comprovadamente justo.

Nós colocamos nossas cartas na mesa.

Boa sorte!

Plinko

Fórmula justa

Verificação de justiça

Resolvendo a questão da confiança com jogos de azar online

O conceito subjacente de justiça comprovável é que os jogadores têm a capacidade de provar e verificar que seus resultados são justos e não manipulados. Isto é alcançado através do uso de sistema de compromisso, juntamente com o hashing criptográfico.

O sistema de compromisso é usado para garantir que o jogador tenha influência em todos os resultados gerados. O hashing criptográfico é usado para garantir que o cassino também permaneça fiel a este esquema de compromisso. Ambos os conceitos combinados criam um ambiente comprovadamente justo para jogar online.

Isto é demonstrado na seguinte equação:

  • Primeiro, hash = HMAC_SHA512(clientSeed:nonce, serverSeed)
  • Finalmente, dividimos o hash em 16 grupos de 8 caracteres, cada grupo será convertido em um número na faixa [0, 1)]. Se for inferior a 0,5, a bola cairá para a esquerda, caso contrário, cairá para a direita.

Nota: Uma nova seed deve ser definida para verificar os dados anteriores (a seed do servidor é criptografada)

Crash

Fórmula justa

O jogo é justo?

Somos uma plataforma de jogos justa e imparcial. Nosso objetivo é eliminar todos os fatores injustos e fazer com que os jogadores se sintam confortáveis e se divirtam.

Geramos um total de 10 milhões de hashes (a cadeia de geração é verificável) e cada hash corresponde a uma curva de multiplicador crash.

Lançamos estes 10 milhões de números em ordem inversa, cada um correspondendo a uma volta do jogo (ou seja, temos 10 milhões de voltas no total).

Em outras palavras, o número de crashes de cada curva já existe e não é calculado após o início do jogo. Os jogadores podem, portanto, fazer suas apostas sem preocupação.

O jogo será manipulado pela plataforma? GitHub Verifica

O valor da verificação de integridade é fundamental para verificar se há alguma manipulação oficial; o algoritmo de teste é fornecido da seguinte forma.

Exemplo: 6b5124897c3c48d0e46cc9249f08c7e560792459f1bad1171224643b5d2be231

  1. Pegue um valor aleatório no intervalo 2^52, digamos 16^13, ou seja, um número hexadecimal de 13 bits (porque o valor hash é hexadecimal, 2^52 === 16^13)6b5124897c3c4 (0x6b5124897c3c4 igual a 1887939992208324 no sistema decimal).
  2. Distribua o valor aleatório a 0~1, dividindo-o pelo valor máximo de 13 fs, ou seja 0x6b5124897c3c4/0x10000000000000. Dada a natureza aleatória do valor de hash, podemos então pensar que qualquer valor de hash pode ser transformado em um número aleatório de 0~1, 1887939992208324/4503599627370496 = 0,419206889692064.
  3. Calcule a margem da casa de 1%. Além disso, para calcular 99/(1-X), onde X é o valor aleatório calculado na Etapa 2. Quando X é 0, o resultado é 99; quando X é 1, o resultado é infinito positivo; quando X é 0,01, o resultado é 100; quando X é inferior a 0,01, o resultado é inferior a 100.

Conclusão: A distribuição geral do número aleatório é 99 a infinito positivo; e quando a distribuição do número aleatório é 0~0,01, o resultado é inferior a 100.

99/(1-0.419206889692064) = 170.45656748150867

  1. Todos os valores inferiores a 100 serão definidos para 100. Em outras palavras, há uma probabilidade de 1% de que 100 aparecerá. Arredonde o número e divida-o por 100 para obter o resultado final.

170/100 = 1.70

Conclusão: O valor de hash usado no jogo é de ordem inversa. Portanto, com o algoritmo SHA256, um hash anterior usado no jogo pode ser calculado a partir de seu hash subsequente. Como há uma correspondência um-para-um entre a chave e o valor do hash, podemos concluir que se um hash pode ser usado para calcular o hash que o precede, então este hash já deveria ter sido gerado quando o prêmio anterior for anunciado. Da mesma forma, toda a cadeia de hash é gerada logo no início e não pode ser alterada uma vez gerada. Caso contrário, não pode passar na verificação por SHA256, e no que diz respeito ao pagamento, isto nada mais é do que um jogo de probabilidade no qual o crash é um dado adquirido. O organizador oficial não pode manipular nenhum conjunto de jogo. Portanto, o CRASH é mais transparente do que outros métodos de jogo. Esta é a pedra angular sobre a qual nosso jogo é construído.

Cálculo simples:

Quando o valor do hash de 13 bits é 8000000000000 = 1,98, 0xb000000000 = 3,168, 0xc000000000 = 3,96, ou seja, quando o primeiro dígito é maior que 8((16-8)/16≈0,5), o resultado é aproximadamente 2x; quando o primeiro dígito é maior que b((16-11)/16≈0. 3), o resultado é aproximadamente 3x; e quando o primeiro dígito é maior que c((16-12)/16≈0.25), o resultado é aproximadamente 4x, e a mesma regra se aplica ao resto.

Quando o valor do hash de 13 bits é f0000000000000000 = 15,84, ff00000000000 = 253,44, fff000000

Roleta

Fórmula justa

Como são calculados os resultados?

Para obter os resultados.

  • Primeiro calculamos o valor hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce, serverSeed).
  • Finalmente, pegamos 8 caracteres do hash e o convertemos para um valor int32. Então dividimos o valor convertido por 0x100000000, multiplicando-o por 37 para que o número resultante esteja de acordo com as restrições do intervalo.

Nota: Uma nova seed deve ser definida para verificar os dados anteriores (a seed do servidor é criptografada).

Você realmente precisava saber isto? Provavelmente não. Está aqui para aqueles que esperam transparência e precisão em um jogo de azar comprovadamente justo.

Nós colocamos nossas cartas na mesa.

Boa sorte!

Keno

Fórmula justa

Como são calculados os resultados?

Para obter os resultados, calculamos o valor de hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce, serverSeed).

Cave of Plunder

Fórmula justa

Verificação de justiça

P: Como é gerado o resultado do jogo?

Um número aleatório entre 0 e 99.999 é gerado usando um algoritmo comprovadamente justo. Esse processo é descrito abaixo.

O número aleatório (entre 0 e 99.999) é então comparado com a tabela de probabilidade e o símbolo correspondente da tabela é o resultado do jogo.

P: Como é gerado o número aleatório?

Primeiro, combine a seed do servidor, a seed do cliente e a seed do nonce para obter o hash SHA512.

  1. Nós usamos a combinação para calcular o hash HMAC_SHA512. Isto nos dá uma string hexadecimais de 128 caracteres: hash = HMAC_SHA512 (clientSeed:nonce, serverSeed)
  2. Depois pegamos os primeiros 5 caracteres da cadeia hexagonal de 128 caracteres e os convertemos para um número decimal de 0 a 1.048.575 (16 ^ 5-1). Se for inferior a 1 milhão, ele é usado como número aleatório. Se for superior a 1 milhão, usamos os próximos cinco caracteres da mesma cadeia hexadecimais de 128 caracteres. Somos capazes de repetir o processo até 25 vezes.
  3. Em casos muito raros ((48.576 / 1.000.000) ^ 25) Ao converter para decimal, nenhuma das 25 tentativas está abaixo de 1 milhão, usamos os 3 caracteres restantes e os convertemos para seu número aleatório

Exemplo de código:

O seguinte exemplo de código pode ser usado para verificar as apostas:

function get (serverSeed, clientSeed, nonce) {   var hash = hmac_sha512(this.client_seed + ":" +this.nonce, this.server_seed);   var index = 0;   do {     var lucky = parseInt (hash.substr (index, 5), 16);     index + = 5;   } while (lucky> = 1000000);     return lucky;   } }

Como utilizar a tabela de probabilidades?

Camada/Layer = Quão alta você escalou cada uma das três colunas e o efeito que ela tem sobre a faixa de probabilidade de cada símbolo.

Esquerda/Left = Símbolo do livro

Meio/Middle = Símbolo da cruz

Direita/Right = Símbolo de gema

Fantasma/Ghost = Símbolo do crânio

Em branco/Blank = Sem símbolo

Exemplo: Você tem atualmente 2 camadas de livros, 1 camada de cruzes e 3 camadas de poções. Isto significa que a camada para referência no próximo giro é a camada 213. O número aleatório que você obteve do hash SHA512, convertido em decimal, como descrito acima, é 503140. A camada correspondente em sua tabela é a Camada 213. A faixa é Ghost [200800 + 122711 + 92033, 200800 + 122711 + 92033 +146113)

Ação Spin:

Se a torre central alcançar o nível superior, os primeiros 10 caracteres do hash HMAC_SHA512 são convertidos em números decimais e modulo 5 para obter um número aleatório de [0,4], o que corresponde a 100-500 vezes o prêmio por vez.

Exemplo de código:

function get (serverSeed, clientSeed, nonce) {   var hash = hmac_sha512(this.client_seed + ":" +this.nonce, this.server_seed);   var lucky = parseInt (hash.substr (0, 10), 16);   return lucky%5; }

Egyptian

Verificação de justiça

Nota: Para obter mais detalhes, vá para Minha Aposta -> Escolher Game ID -> Verificar.

Favor verificar os seguintes documentos para método de verificação e tabela de comparação:

EgyptianAdventure.pdf

Mines

Fórmula justa

Como são calculados os resultados?

Para obter os resultados, calculamos o valor de hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce, serverSeed).

const crypto = require("crypto");  function getResult(hash) {   const allNums = [     7, 2, 19, 25, 1, 13, 5, 24, 14, 6, 15, 9, 22, 16, 3, 17, 18, 20, 8, 21, 4,     12, 10, 23, 11,   ];   let seed = hash;   let finalNums = createNums(allNums, seed);   seed = crypto.createHash("SHA256").update(seed).digest("hex");   finalNums = createNums(finalNums, seed);   return finalNums.map((m) => m.num.num); }  function createNums(allNums, hash) {   let nums = [];   let h = crypto.createHash("SHA256").update(hash).digest("hex");   allNums.forEach((c) => {     nums.push({ num: c, hash: h });     h = h.substring(1) + h.charAt(0);   });   nums.sort(function (o1, o2) {     if (o1.hash < o2.hash) {       return -1;     } else if (o1.hash === o2.hash) {       return 0;     } else {       return 1;     }   });   return nums; }  function main (serverSeed, clientSeed, nonce) {   let resultArr = [clientSeed, nonce];   let hmacSha256Result = crypto.createHmac("sha256", serverSeed).update(resultArr.join(":")).digest("hex")   let resultList = getResult(hmacSha256Result);   console.log(resultList); }  // main("server seed", "client seed", "nonce");

Tower Legend

Fórmula justa

Como são calculados os resultados?

Para obter os resultados, calculamos o valor de hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce:row, serverSeed).

Nota: Uma nova seed deve ser definida para verificar os dados anteriores (a seed do servidor é criptografada).

Você realmente precisava saber isto? Provavelmente não. Está aqui para aqueles que esperam transparência e precisão em um jogo de azar comprovadamente justo.

Nós colocamos nossas cartas na mesa.

Boa sorte!

Flip Coin

Fórmula justa

Como são calculados os resultados?

Para obter os resultados:

  • Primeiro calculamos o valor hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce:round, serverSeed).
  • Finalmente, pegamos 8 caracteres do hash e o convertemos para um valor int32. Então dividimos o valor convertido por 0x100000000, multiplicando-o por 2.

Nota: Uma nova seed deve ser definida para verificar os dados anteriores (a seed do servidor é criptografada).

Você realmente precisava saber isto? Provavelmente não. Está aqui para aqueles que esperam transparência e precisão em um jogo de azar comprovadamente justo.

Nós colocamos nossas cartas na mesa.

Boa sorte!

Hilo

Fórmula justa

Como são calculados os resultados?

Calculamos o valor hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce:round, serverSeed).

Wheel

Fórmula justa

Como são calculados os resultados?

Para obter os resultados do Wheel, primeiro combinamos a seed de seu client e seu nonce.

  • Primeiro calculamos o valor de hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce, serverSeed).
  • Finalmente, pegue os primeiros 8 caracteres do hash e converta-o para um valor int32 de acordo com Big-endian. Divida o valor convertido por 0x100000000 e multiplique pelo número de segmentos a serem arredondados para cima para obter a posição da tabela de probabilidades. Verifique a tabela para obter as probabilidades.

Nota: Uma nova seed deve ser definida para verificar os dados anteriores (a seed do servidor é criptografada).

Você realmente precisava saber isto? Provavelmente não. Está aqui para aqueles que esperam transparência e precisão em um jogo de azar comprovadamente justo.

Nós colocamos nossas cartas na mesa.

Boa sorte!

Sword

Fórmula justa

Verificação de justiça

Para obter os resultados:

  • Primeiro, hash = HMAC_SHA512(clientSeed:nonce:round, serverSeed)
  • Finalmente, obtemos 8 caracteres do hash, e os convertemos para um valor int32. Então dividimos o valor convertido por 0x100000000 e multiplicamos o peso, de modo que o número resultante esteja de acordo com as restrições da faixa.

Para obter mais detalhes, vá para Minha Aposta -> Escolher Game ID -> Verificar.

Beauties

Fórmula justa

Verificação de justiça

Para obter os resultados:

  • Primeiro calculamos o valor hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce:round, serverSeed).
  • Finalmente, obtemos 8 caracteres do hash, e os convertemos para um valor int32. Então dividimos o valor convertido por 0x100000000 e o multiplicamos pelo número de símbolos em cada bobina, de modo que o número resultante esteja de acordo com as restrições do intervalo da bobina.

Nota: O número de símbolos para as bobinas regulares e para as bobinas livres são diferentes. Para obter mais detalhes, vá para Minha Aposta -> Escolher Game ID -> Verificar.

Se três símbolos BONUS aparecerem na primeira rodada, você entrará no jogo bônus, e pode virar até 4 quebra-cabeças.

  • Primeiro calculamos o valor de hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce:round:puzzle, serverSeed).
  • Finalmente, pegamos 8 caracteres do hash, e os convertemos para um valor int32. Então dividimos o valor convertido por 0x100000000 e o multiplicamos pela probabilidade do quebra-cabeça correspondente. Se o resultado chegar a 0, o jogo bônus termina.

Baccarat

Fórmula justa

Como são calculados os resultados?

Para obter os resultados:

  • Calculamos o valor de hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce, serverSeed).

Video Poker

Fórmula justa

Resolvendo a questão da confiança com jogos de azar online

O conceito de justiça comprovada é que os jogadores têm a capacidade de provar e verificar que seus resultados são justos e não manipulados. Isto é conseguido através do uso de um sistema de compromisso, juntamente com o hashing criptográfico.

O sistema de compromisso é usado para garantir que o jogador tenha influência em todos os resultados gerados. O hashing criptográfico é usado para garantir que o cassino também permaneça honesto a este esquema de compromisso. Ambos os conceitos combinados criam um ambiente de confiança quando se joga online.

Veja mais com a seguinte demonstração

Hex string: hash = HMAC_SHA512(clientSeed:nonce, serverSeed)

Lógica de embaralhamento:

  1. Crie um baralho de cartas chamado ß, a carta é sequenciada como espada A-K, coração A-K, taco A-K e diamante A-K.
  2. Use combinação para obter o valor de hash, que será usado como o valor da primeira carta (Spades A) na carta ß.
  3. Apagar o primeiro pedaço do valor de hash e adicioná-lo como último caractere do hash value (por exemplo 54321 a 43215, o novo valor de hash será usado como o valor da segunda carta de ß (Spades 2).
  4. Repita a etapa 2 para calcular o peso de toda a carta em ß
  5. Finalmente, embaralhe ß de acordo com os pesos correspondentes das cartas, de pequenas a grandes. As cartas reordenadas são as embaralhadas ß.

Nota: Uma nova seed deve ser definida para verificar os dados anteriores (a seed do servidor é criptografada)

Rings of Fortune

Fórmula justa

Como são calculados os resultados?

Para obter os resultados, calculamos o valor hash da combinação com HMAC_SHA256. Isto nos dá uma cadeia hexadecimal de 64 caracteres: hash = HMAC_SHA256 (clientSeed:nonce, serverSeed).

Blackjack

Fórmula justa

Verificação da sequência de cartões

  1. A seed aleatória do lado do servidor gera primeiro o hash1, o hash1 é a sequência de cartões;
  2. Use hash1 para gerar hash2 e hash2 é público;
  3. Após o término da rodada, o hash1 e a sequência de cartas da rodada serão públicos;

A lógica de embaralhamento do baralho único

Use seeds para embaralhar

As etapas de embaralhamento são as seguintes:

  1. Crie um baralho de cartas chamado ß, a carta é sequenciada como espadas A-K，copas A-K， paus A-K e ouros A-K.
  2. Hash256 a seed para obter o valor de hash, que será usado como o peso da primeira carta (espada A) na carta ß
  3. Apague o primeiro bit do valor de hash e adicione-o de volta como último caracter do hash value（por exemplo 54321 a 43215， o novo valor de hash será usado como o peso da segunda carta de ß (Espadas 2)
  4. Repita a etapa 2 para calcular o peso de todo o cartão em ß
  5. Finalmente, embaralhar ß de acordo com os pesos correspondentes das cartas, de pequenas a grandes. As cartas reordenadas são as embaralhadas ß.

A lógica de embaralhamento para baralhos múltiplos

Quando vários decks precisam ser embaralhados:

  1. Primeiro, embaralhe o primeiro deck e execute os passos de baralhamento de um único baralho 2-4.
  2. Use o valor de hash do primeiro baralho como seed para o segundo baralho, depois baralhe o segundo baralho executando os passos 2-4 do baralhamento de um único baralho.
  3. Use o valor de hash do segundo deck como seed para o terceiro deck, depois baralhe o segundo deck executando os passos 2-4 do baralhamento de um deck.
  4. Por analogia, todas as cartas dos baralhos terão seu peso, e finalmente juntar todas as cartas e executar a quarta etapa da lógica de baralhamento do baralho único para a classificação.

Keno Multiplayer

Fórmula justa

Começando com um segredo, gerei uma corrente de 10.000.000 hashes SHA256. Cada elemento é o hash do hash em minúsculas, hexadecimais, representação em cadeia do hash anterior. O hash do último elemento da cadeia é 54fe30623823224ef8379e00f3d88a02ed3333937862ee0383b9cbb3d1e43763 

Cada jogo mapeia um hash na cadeia: O elemento 10.000.000 da cadeia é o hash do jogo #1 e o primeiro elemento da cadeia é o hash do jogo #10.000.000. Para verificar se um hash pertence a um jogo #n, simplesmente o hash n vezes e comparar o resultado com o hash que o termina.

Para calcular o resultado de um jogo a partir de seu hash: Código:

const crypto = require("crypto");   function seedGenerator(hash, salt) {     const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(hash), salt);     return hmac.toString(CryptoJS.enc.Hex);   }   function createNums(allNums, hash) {     const nums = [];     let h = CryptoJS.SHA256(hash).toString(CryptoJS.enc.Hex);     allNums.forEach((c) => {       nums.push({ num: c, hash: h });       h = h.substring(1) + h.charAt(0);     });     nums.sort(function (o1, o2) {       if (o1.hash < o2.hash) {         return -1;       } else if (o1.hash === o2.hash) {         return 0;       } else {         return 1;       }     });     return nums;   }   function keno(hash) {     const allNums = [       1, 30, 11, 40, 2, 29, 12, 39, 3,       28, 13, 38, 4, 27, 14, 37, 5, 26,       15, 36, 6, 25, 16, 35, 7, 24, 17,       34, 8, 23, 18, 33, 9, 22, 19, 32,       10, 21, 20, 31     ];     let seed = hash;     let finalNums = createNums(allNums, seed);     seed = String(CryptoJS.SHA256(seed));     finalNums = createNums(finalNums, seed);     return finalNums.slice(0, 10).map((m) => m.num);   }   let hash = "game hash";   console.log( "result =>", keno(hash).map((item) => item.num).join(","));

Este é nosso evento de seed de keno multiplayer em bitcointalk

Então nosso salt será 00000000000000076973be291d219d283d4af9135601ff37df46491cca7e

Roulette Multiplayer

Fórmula justa

O que é uma roleta?

A roleta é um jogo de tabuleiro com um total de 37 números, incluindo os números 1 a 36 e 0; os números na roda estão espaçados em vermelho e preto, mas os números não estão em ordem.

Como funciona a roleta?

Há um tempo de preparação de 10s antes do início de cada jogo. Após o início do jogo, a roleta girará em alta velocidade e parará lentamente. A posição final do ponteiro é o resultado do jogo.

Como eu devo jogar?

Tamanho: 1-18, 19-36: O número da aposta pode estar na metade superior (pequena) ou na metade inferior (grande), e as probabilidades são de 1:2.

Número 0: Número de aposta 0, cotações 1:36.

Justiça do jogo?

O jogo é baseado em um hash hash (https://dwz.cn/5f5VdLtp). O criador gerou um total de 10 milhões de hash hashes (gerando cadeia verificável), e cada hash corresponde a um resultado da roleta. O jogo libera os 10 milhões de números em reverso para corresponder a cada sorteio no jogo.

Como verificar a imparcialidade?

O SHA256 do hash do jogo 23654 é: 33d8be75c9f6cb219a1763e77e307ac0a1107c85bd9fee53e81be0ec592ff4c5

O hash final do jogo é sh256: 5bf9a3fae704667be2d3704ea8b6e703796defaa5f328e1a8d46b3a0fa12269f

Você pode verificar o shasha do hash correspondente a qualquer período da loteria!

Verifique o endereço: http://www.ttmd5.com/hash.php?type=9

Algoritmo do resultado da verificação:

Para gerar um número aleatório entre 0 e 36, pegamos os 3 primeiros caracteres do hash e os convertemos para um número decimal de 0 a 4096 (16^3). Se for inferior a 3700, dividimos por 100 e arredondamos para cima para usar como resultado da roleta, caso contrário, reutilizamos os 3 caracteres seguintes.

Em casos muito raros, a probabilidade de (64*2/(16^64)), nenhuma das 62 tentativas está abaixo de 3700, usamos o último caractere e os convertemos para o resultado de seu jogo.

Por exemplo: 5bf9a3fae704667be2d3704ea8b6e703796defaa5f328e1a8d46b3a0fa12269f 

Pegue os 3 primeiros caracteres do hash 5bf, converta para decimal igual a 880,880/100=8.8, após o arredondamento, o resultado do jogo é 8.