Topic: Crash Game Reseeding Event @ BC.Game (Read 2117 times)

woww thats goods, best formula Shocked

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Cristiano Luiz de Almeida

newbie

Activity: 5

Merit: 0

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:56:44 PM

woww thats goods, best formula Shocked

Cristiano Luiz de Almeida

newbie

Activity: 5

Merit: 0

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Quote from: Ayush23 on October 21, 2023, 03:13:30 AM

woww thats goods, best formula Shocked

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Quote from: Monicaann0o on January 12, 2024, 06:06:16 PM

woww thats goods, best formula Shocked

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:56:44 PM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Quote from: Ayush23 on October 21, 2023, 03:13:30 AM

woww thats goods, best formula Shocked

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Quote from: Monicaann0o on January 12, 2024, 06:06:16 PM

woww thats goods, best formula Shocked

Quote from: ngocloi93 on December 06, 2023, 05:21:50 PM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:56:44 PM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Quote from: Ayush23 on October 21, 2023, 03:13:30 AM

woww thats goods, best formula Shocked

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Quote from: Monicaann0o on January 12, 2024, 06:06:16 PM

woww thats goods, best formula Shocked

Quote from: Vyrine on February 08, 2021, 02:06:09 AM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Quote from: BC.GAME on June 19, 2020, 05:26:46 AM

We made the decision to update Crash using a salted hash as requested by our players in order to provide the most randomized and fair results possible after Bet # 2561902
For further details, please visit https://bcsnproject.github.io/bcgame-crash/

Can I know what hash is used after the bet #2561902?

Cristiano Luiz de Almeida

newbie

Activity: 5

Merit: 0

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Quote from: Ayush23 on October 21, 2023, 03:13:30 AM

woww thats goods, best formula Shocked

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Quote from: Monicaann0o on January 12, 2024, 06:06:16 PM

woww thats goods, best formula Shocked

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Cristiano Luiz de Almeida

newbie

Activity: 5

Merit: 0

Quote from: zanno on June 19, 2022, 03:34:27 AM

woww thats goods, best formula :o

Agbe

hero member

Activity: 854

Merit: 1246

~

Have you contact the customer service because they have the best answer to give if the Manuel verification has been added to the site or not. Or you send them email to know anything you want to. Though I am not a fan of Crash Game so I can't input anything thing here.

Quote from: worldofcoins on February 17, 2023, 01:29:43 PM

Thank you for sharing this piece of valuable information with us.
However, many of us here might not be familiar with these code-based formulae, but it can be beneficial for the rest of the others who are well-known about it.

Exactly and that what I also noticed. I have heard Crash Game before but I have not played it to know the outcome. I also really appreciate the Op for bringing this here foe people to participate.

Monicaann0o

newbie

Activity: 1

Merit: 0

Dancer teja

newbie

Activity: 1

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

ngocloi93

newbie

Activity: 3

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Ayush23

newbie

Activity: 4

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Ayush23

newbie

Activity: 4

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Ayush23

newbie

Activity: 4

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Ayush23

newbie

Activity: 4

Merit: 0

Quote from: ngocloi93 on September 25, 2023, 12:15:21 AM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block

Quote from: ngocloi93 on September 25, 2023, 12:15:21 AM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Quote from: ngocloi93 on September 25, 2023, 12:15:21 AM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Quote from: ngocloi93 on September 25, 2023, 12:15:21 AM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

ngocloi93

newbie

Activity: 3

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Shiendyhana

newbie

Activity: 1

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Reuf

newbie

Activity: 3

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

kramtogo21

newbie

Activity: 1

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 758,160. This block has not been mined yet as of this pos

worldofcoins

sr. member

Activity: 1820

Merit: 418

Need a campaign manager? | Telegram:@worldofcoinss

Thank you for sharing this piece of valuable information with us.
However, many of us here might not be familiar with these code-based formulae, but it can be beneficial for the rest of the others who are well-known about it.

Nawteeboi

newbie

Activity: 1

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

const gameResult = (seed) => {
const nBits = 52; // number of most significant bits to use
// 1. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);
// 2. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));
// 3. X = 99 / (1-X)
X = 99 / (1 - X);
// 4. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

NEW GAME RESULT FORMULA

Code:

const gameResult = (seed, salt) => {
const nBits = 52; // number of most significant bits to use

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

// 2. r = 52 most significant bits
seed = seed.slice(0, nBits / 4);
const r = parseInt(seed, 16);

// 3. X = r / 2^52
let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
X = parseFloat(X.toPrecision(9));

// 4. X = 99 / (1-X)
X = 99 / (1 - X);

// 5. return max(trunc(X), 100)
const result = Math.floor(X);
return Math.max(1, result / 100);
};

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

one owner

newbie

Activity: 1

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

ArErD

newbie

Activity: 3

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

zanno

newbie

Activity: 1

Merit: 0

Hi all!

I'm currently going through the games at BC.game and among other things going through the steps to manually verify bets.

I'm not sure if the information about how to manually verify has been updated, because it doesn't add up for me.

Take this bet for example:

Bet id: 148106383
Bet link: https://bc.game/sd/?sd=10MYTKABGPT3BN

https://i.imgur.com/FODaesG.png

Verify link: https://bcgame-project.github.io/verify/crash.html?hash=c5e105efa0dd9f960cc77ebf43decf6f1dfd9a0d67e4acd5b84602b9ca9ebd5c

Hash: c5e105efa0dd9f960cc77ebf43decf6f1dfd9a0d67e4acd5b84602b9ca9ebd5c

13 first character of hash and add 0x in front

0xc5e105efa0dd9

Convert to decimal - 3481124126461401

Divide by (HEX) 0x10000000000000 - (DEC) 4503599627370496

3481124126461401 / 4503599627370496 = 0.77296483135

99/(1-0.77296483135) = 99/0.22703516865

99/0.22703516865 = 436.055790778

Round the decimals = 436

Divide by 100

436/100 = 4.36

Something isn't right.

https://i.imgur.com/CdXLAb9.png

Damian1989

newbie

Activity: 1

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Tonu

newbie

Activity: 1

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

mehdipik

newbie

Activity: 1

Merit: 0

Quote from: BC.GAME on June 19, 2020, 05:26:46 AM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

Taisoon00

newbie

Activity: 1

Merit: 0

سلام،خسته نباشید.اگر شما صادقانه حرف میزنید چرا با بیتکوین حساب میکنید،بروید با ترتل حساب کنید،ارز مرکزی است،اولین ارز است ،خواهش میکنم چند دقیقه با وژدان خود تنها باشید.اگر با بیتکوین شما نتیجه انصاف را اعلام می کنید در این صورت فقط ثروتمندان می توانند بردهای خوبی داشته باشند،من که جزو قشر ضعیف جامعه هستم چه،،باید فقط بیاورم در سایت شما خالی کنم و شاهد بردهای ثروتمندان باشم،این را انصاف نام نگذارید،انصاف این است گوش کن،اول همین که من در این سایت سرمایه گذاری می کنم،دوم همین که مشتری وکاربر فعال سایت شما هستم،همین که در سالن گفتگوهای سایت شرکت میکنم، انصاف این است همین که به هر تقاضای شما احترام کذاشتم،این را هم به من نگویید در عوضش شما ارز می گیرید،اگر من در عوض فعالیت در این سایت ارزی دریافت کرده باشم،همش ثبت شده آی دی من هم مشخص است ،پیگیری کنید متوجه می شوید،عزیز من ما مگر خواستیم به ما کمک کنید،خنده دار است کمک دیکر کجا بود شما به قول های که داده اید عمل کنید کمک بر سر من بخورد،تیم محترم وبزرگ قبل از میلاد آنقدر از کیف پولم در این سایت سرمایه گذاشتم که حسرت یک برد شیرین برایم مانند یک سرطان در گلویم گیر کرده،میدانم این را می خواهید،ولی عاقبت خوش در انتظار شما نیست

Vyrine

newbie

Activity: 14

Merit: 28

We made the decision to update Crash using a salted hash as requested by our players in order to provide the most randomized and fair results possible after Bet # 2561902
For further details, please visit https://bcsnproject.github.io/bcgame-crash/

Can I know what hash is used after the bet #2561902?

Celina14493

newbie

Activity: 1

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

apaktomy

newbie

Activity: 3

Merit: 0

MMMGLOBAL - a right step to make a better life

Quote from: apaktomy on December 30, 2020, 02:42:48 PM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

apaktomy

newbie

Activity: 3

Merit: 0

MMMGLOBAL - a right step to make a better life

apaktomy

newbie

Activity: 3

Merit: 0

MMMGLOBAL - a right step to make a better life

TBCT Boy

newbie

Activity: 2

Merit: 0

Quote from: FIFA worldcup on October 18, 2020, 04:43:44 AM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

BC.GAME

copper member

Activity: 238

Merit: 111

Good to see you update the code for the crash game but why you need to create a separate thread for its announcement.
It could have been done on the main thread of BC.Game 🔴🔴🔴BET RED IN CRASH!🔴🔴🔴 Find More Unique Games in BC.Game

So it could be easily found and referenced by anyone rather than being lost somewhere in the middle of our main thread. This has been the most common way of doing these seeding events here at the forum.

FIFA worldcup

full member

Activity: 1134

Merit: 105

Good to see you update the code for the crash game but why you need to create a separate thread for its announcement.
It could have been done on the main thread of BC.Game 🔴🔴🔴BET RED IN CRASH!🔴🔴🔴 Find More Unique Games in BC.Game

BC.GAME

copper member

Activity: 238

Merit: 111

Quote from: Zaynab on June 19, 2020, 05:04:02 AM

Quote from: BC.GAME on June 19, 2020, 05:26:46 AM

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

coco asked me to quote this. So I'm quoting this and fuck coco btw

LMAO af. I can't believe I didn't see this endearing comment!.

TBCT Boy

newbie

Activity: 2

Merit: 0

Thank you so much guys:))

Saint-loup

legendary

Activity: 2590

Merit: 2348

We made the decision to update Crash using a salted hash as requested by our players in order to provide the most randomized and fair results possible after Bet # 2561902
For further details, please visit https://bcsnproject.github.io/bcgame-crash/

Hello
Are you using a hash chain for your seeds?
If yes, why don't you post it like you've done for your other games :

Keno

Quote from: BC.GAME on June 16, 2020, 07:45:22 AM

Starting with a secret I've generated a chain of 10,000,000 SHA256 hashes. Each element is the hash of the lowercase, hexadecimal string representation of the previous hash. The hash of the chain's last element is 54fe30623823224ef8379e00f3d88a02ed3333937862ee0383b9cbb3d1e43763

Roulette game

Quote from: BC.GAME on June 27, 2019, 08:23:09 AM

Starting with a secret I've generated a chain of 10,000,000 SHA256 hashes. Each element is the hash of the lowercase, hexadecimal string representation of the previous hash. The hash of the chain's last element is
f6c4a94c4a2dd2912fbef23fb68aa56488313a343c9cf6c95e52b8ef74230991 .

If no, could you tell us how you are choosing your seeds please?

TYVM

lokieluke

newbie

Activity: 7

Merit: 0

Can i get a shit code.. but a good shit code.

nakamura12

hero member

Activity: 2254

Merit: 669

Bitcoin Casino Est. 2013

Quote from: ChuckBuck on June 19, 2020, 02:07:30 PM

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

Although I cannot understand the technical changes in your site details, but I appreciate upgrading your site system based on community feedback. This shows how much you value your customers Cheesy

Also, it is rare for me to see casinos publishing their algorithms publicly on this forum Cheesy

Hope you will have more and more customers Wink

Indeed, when a company is serving the customers first is one of the things that I want to a company or a platform which in my opinion will greatly improve the platform but also the reputation rather than not doing at all. I notice you did change some of the codw but I am not exoert at it so it is best that you did explained which you did and it help some to check the game fairness.

ChuckBuck

hero member

Activity: 1372

Merit: 783

better everyday ♥

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

Although I cannot understand the technical changes in your site details, but I appreciate upgrading your site system based on community feedback. This shows how much you value your customers Cheesy

Also, it is rare for me to see casinos publishing their algorithms publicly on this forum Cheesy

Hope you will have more and more customers Wink

BC.GAME

copper member

Activity: 238

Merit: 111

We made the decision to update Crash using a salted hash as requested by our players in order to provide the most randomized and fair results possible after Bet # 2561902
For further details, please visit https://bcsnproject.github.io/bcgame-crash/

Zaynab

newbie

Activity: 17

Merit: 0

Hello world,

Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:

OLD GAME RESULT FORMULA

Code:

  const gameResult = (seed) => {
   const nBits = 52; // number of most significant bits to use
   // 1. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);
   // 2. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));
   // 3. X = 99 / (1-X)
   X = 99 / (1 - X);
   // 4. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

NEW GAME RESULT FORMULA

Code:

  const gameResult = (seed, salt) => {
   const nBits = 52; // number of most significant bits to use

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

   // 2. r = 52 most significant bits
   seed = seed.slice(0, nBits / 4);
   const r = parseInt(seed, 16);

   // 3. X = r / 2^52
   let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1)
   X = parseFloat(X.toPrecision(9));

   // 4. X = 99 / (1-X)
   X = 99 / (1 - X);

   // 5. return max(trunc(X), 100)
   const result = Math.floor(X);
   return Math.max(1, result / 100);
  };

Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.

coco asked me to quote this. So I'm quoting this and fuck coco btw

BC.GAME

copper member

Activity: 238

Merit: 111

Block 635,380 has been mined, so we have our salt: 0000000000000000000e3a66df611d6935b30632f352e4934c21059696117f28
https://btc.com/0000000000000000000e3a66df611d6935b30632f352e4934c21059696117f28

BC.GAME

copper member

Activity: 238

Merit: 111

https://imgur.com/a/3briosC

okseo122

newbie

Activity: 6

Merit: 0