Crash Game Reseeding Event @ BC.Game

[Vyrine]

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?

[Taisoon00]

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

[mehdipik]

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]

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.

[Damian1989]

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]

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

[ArErD]

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]

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.

[Nawteeboi]

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.

[worldofcoins]

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.

[kramtogo21]

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

[Reuf]

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]

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]

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]

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

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.

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.

[Ayush23]

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]

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]

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]

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.

[Dancer teja]

 

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.