 Show Posts
|
|
Pages: [1]
|
Welcome! In preparation for the upcoming launch of our original game Crash Neymar, we're performing this seeding event to ensure fairness and immutable rolls. For this seeding event we are following the same approach as above. As part of our fairness we generated a chain of 10,000,000 SHA256 hashes where each hash is the hash of the hexadecimal representation of the previous hash. Being the last hash in the chain: c8c505ebcbb51fdd090f7269d6fe3c41c27455ef3e975751587f47606f4560dd const { createHmac } = require('crypto');
const divisible = (hash, mod) => {
// So ABCDEFGHIJ should be chunked like AB CDEF GHIJ
let val = 0;
let o = hash.length % 4;
for (let i = o > 0 ? o - 4 : 0; i < hash.length; i += 4) {
val = ((val << 16) + parseInt(hash.substring(i, i+4), 16)) % mod;
}
return val === 0;
};
const calculateCrashPointFromHash = function(hash) {
// In 1 of 15 games the game crashes instantly.
if (divisible(hash, 15))
return 0;
// Use the most significant 52-bit from the hash to calculate the crash point
let h = parseInt(hash.slice(0,52/4),16);
let e = Math.pow(2,52);
return (Math.floor((100 * e - h) / (e - h)) / 100).toFixed(2);
}
// these will be the 10M pre generated rolls to be used
const hashChain = [];
const gameHash = hashChain.pop();
// It's the hash we're gonna be using of the result of a yet to be mined block on the blockchain #840,535
const blockHash = '';
const hash = createHmac('sha256', gameHash).update(blockHash).digest('hex');
const crashPoint = calculateCrashPointFromHash(hash);
console.log({ crashPoint });
We’re gonna be using a BlockHash that hasn’t been mined at the time of this post, we’re expecting to use Bitcoin block 840,535 this to prove we have no influence over the outcome of the game. Archived post: https://archive.ph/KvGHJClient seed has been mined! Code: 000000000000000000014a6b3e88c09344189ea9b5f36a81e3d63130e9a450cf https://www.blockchain.com/explorer/blocks/btc/840535 |
|
|
|
Welcome! In preparation for the upcoming launch of our original game Crash Neymar, we're performing this seeding event to ensure fairness and immutable rolls. For this seeding event we are following the same approach as above. As part of our fairness we generated a chain of 10,000,000 SHA256 hashes where each hash is the hash of the hexadecimal representation of the previous hash. Being the last hash in the chain: c8c505ebcbb51fdd090f7269d6fe3c41c27455ef3e975751587f47606f4560dd const { createHmac } = require('crypto');
const divisible = (hash, mod) => {
// So ABCDEFGHIJ should be chunked like AB CDEF GHIJ
let val = 0;
let o = hash.length % 4;
for (let i = o > 0 ? o - 4 : 0; i < hash.length; i += 4) {
val = ((val << 16) + parseInt(hash.substring(i, i+4), 16)) % mod;
}
return val === 0;
};
const calculateCrashPointFromHash = function(hash) {
// In 1 of 15 games the game crashes instantly.
if (divisible(hash, 15))
return 0;
// Use the most significant 52-bit from the hash to calculate the crash point
let h = parseInt(hash.slice(0,52/4),16);
let e = Math.pow(2,52);
return (Math.floor((100 * e - h) / (e - h)) / 100).toFixed(2);
}
// these will be the 10M pre generated rolls to be used
const hashChain = [];
const gameHash = hashChain.pop();
// It's the hash we're gonna be using of the result of a yet to be mined block on the blockchain #840,535
const blockHash = '';
const hash = createHmac('sha256', gameHash).update(blockHash).digest('hex');
const crashPoint = calculateCrashPointFromHash(hash);
console.log({ crashPoint });
We’re gonna be using a BlockHash that hasn’t been mined at the time of this post, we’re expecting to use Bitcoin block 840,535 this to prove we have no influence over the outcome of the game. |
|
|
|
We've to migrate Double into a dedicate service, for that reason we have to generate a new seeding event. As part of our fairness we generated a chain of 10,000,000 SHA256 hashes where each hash is the hash of the hexadecimal representation of the previous hash. Being the last hash in the chain: b24f784dc4371781e85bf089ddb99ce56de899d8a6e8a09e652f92a40baada85 Script to calculate Double tail: const ROULETTE_TILES = [
{ number: 0, color: 'white' },
{ number: 11, color: 'black' },
{ number: 5, color: 'red' },
{ number: 10, color: 'black' },
{ number: 6, color: 'red' },
{ number: 9, color: 'black' },
{ number: 7, color: 'red' },
{ number: 8, color: 'black' },
{ number: 1, color: 'red' },
{ number: 14, color: 'black' },
{ number: 2, color: 'red' },
{ number: 13, color: 'black' },
{ number: 3, color: 'red' },
{ number: 12, color: 'black' },
{ number: 4, color: 'red' },
];
getRollFromHash = (hash) => {
// roulette number from 0-15
const integ = parseInt(hash, 16);
const MAX_RANGE = Math.pow(2, 256);
const randval = integ / MAX_RANGE;
const n = Math.floor(randval * 15);
const tile = ROULETTE_TILES.find((t) => t.number === n);
let color;
switch (tile.color) {
case 'white':
color = 0;
break;
case 'black':
color = 2;
break;
case 'red':
color = 1;
break;
}
return {
n,
color: color,
};
};
We’re gonna be using a BlockHash that hasn’t been mined at the time of this post, we’re expecting to use Bitcoin block 823307, this to prove we have no influence over the outcome of the game. Please guys feel free to quote this post so this will be all set in stone. Looking forward to show you guys Double migration very soon! |
|
|
|
We found a Bug due to an issue with gold multipliers all being around 8.52x instead of having variations between 8.5-250x. We had to change the code when we convert the hash into an integer. Existing line: let h = parseInt(hash.slice(0, 52 / 4), 16); We have replaced the line above with the next one: /**
* Uses the last 13 characters of the hash because the first 13 characters strongly affect the probability of landing on 0
* When converting the hash to an integer, the left most characters are the most significant digits
*/
let h = parseInt(hash.slice(-52 / 4), 16); Since the game was not released yet no users will affected from this change. |
|
|
|
We’re excited to announce that we’re releasing Fortune double game (Room 2) in https://blaze.com/en/games/fortune-double/2 , so we welcome you to our seeding event for Fortune double which we would be releasing soon. For this seeding event we are following the same approach we had for Crash, Slide and Double. As part of our fairness we generated a chain of 10,000,000 SHA256 hashes where each hash is the hash of the hexadecimal representation of the previous hash. Being the last hash in the chain: 4295b0febe29f98bd3ae14509e800b021196be239e8cbb14c582c1f00007dff3 Script to calculate Fortune double roll: const ROULETTE_TILES = [
{ number: 0, color: 'white' },
{ number: 11, color: 'black' },
{ number: 5, color: 'red' },
{ number: 10, color: 'black' },
{ number: 6, color: 'red' },
{ number: 9, color: 'black' },
{ number: 7, color: 'red' },
{ number: 8, color: 'black' },
{ number: 1, color: 'red' },
{ number: 14, color: 'black' },
{ number: 2, color: 'red' },
{ number: 13, color: 'black' },
{ number: 3, color: 'red' },
{ number: 12, color: 'black' },
{ number: 4, color: 'red' },
];
module.exports.getColorByRoll = (roll) => {
return ROULETTE_TILES.find((t) => t.number === roll).color;
};
const getWhiteMultiplierFromHash = (hash) => {
let h = parseInt(hash.slice(0, 52 / 4), 16);
let e = Math.pow(2, 52);
let multiplier = Math.floor((100 * e - h) / (e - h)) / 100 + 7.5;
multiplier = Math.max(8.5, Math.min(multiplier, 250));
return +multiplier.toFixed(2);
};
module.exports.getRollFromHash = (hash) => {
const integ = parseInt(hash, 16);
const MAX_RANGE = Math.pow(2, 256);
const randval = integ / MAX_RANGE;
const n = Math.floor(randval * 15);
const tile = ROULETTE_TILES.find((t) => t.number === n);
let color, multiplier;
switch (tile.color) {
case 'white':
color = 0;
multiplier = getWhiteMultiplierFromHash(hash);
break;
case 'black':
color = 2;
multiplier = 2;
break;
case 'red':
color = 1;
multiplier = 2;
break;
}
return {
n: n,
multiplier: multiplier,
color: color,
};
}; We’re gonna be using a BlockHash that hasn’t been mined at the time of this post, we’re expecting to use Bitcoin block 820782, this to prove we have no influence over the outcome of the game. Please guys feel free to quote this post so this will be all set in stone. Looking forward to show you guys Fortune double very soon! |
|
|
|
We’re excited to announce that we’re releasing Fortune double game (Room 1) in Blaze , so we welcome you to our seeding event for Fortune double which we would be releasing soon. For this seeding event we are following the same approach we had for Crash, Slide and Double. As part of our fairness we generated a chain of 10,000,000 SHA256 hashes where each hash is the hash of the hexadecimal representation of the previous hash. Being the last hash in the chain: d28e7aed46149e63ec8e2c95b4e829327f59b7dff56539cd232544904827dc35 Script to calculate Fortune double roll: Code const ROULETTE_TILES = [
{ number: 0, color: 'white' },
{ number: 11, color: 'black' },
{ number: 5, color: 'red' },
{ number: 10, color: 'black' },
{ number: 6, color: 'red' },
{ number: 9, color: 'black' },
{ number: 7, color: 'red' },
{ number: 8, color: 'black' },
{ number: 1, color: 'red' },
{ number: 14, color: 'black' },
{ number: 2, color: 'red' },
{ number: 13, color: 'black' },
{ number: 3, color: 'red' },
{ number: 12, color: 'black' },
{ number: 4, color: 'red' },
];
module.exports.getColorByRoll = (roll) => {
return ROULETTE_TILES.find((t) => t.number === roll).color;
};
const getWhiteMultiplierFromHash = (hash) => {
let h = parseInt(hash.slice(0, 52 / 4), 16);
let e = Math.pow(2, 52);
let multiplier = Math.floor((100 * e - h) / (e - h)) / 100 + 7.5;
multiplier = Math.max(8.5, Math.min(multiplier, 250));
return +multiplier.toFixed(2);
};
module.exports.getRollFromHash = (hash) => {
const integ = parseInt(hash, 16);
const MAX_RANGE = Math.pow(2, 256);
const randval = integ / MAX_RANGE;
const n = Math.floor(randval * 15);
const tile = ROULETTE_TILES.find((t) => t.number === n);
let color, multiplier;
switch (tile.color) {
case 'white':
color = 0;
multiplier = getWhiteMultiplierFromHash(hash);
break;
case 'black':
color = 2;
multiplier = 2;
break;
case 'red':
color = 1;
multiplier = 2;
break;
}
return {
n: n,
multiplier: multiplier,
color: color,
};
}; We’re gonna be using a BlockHash that hasn’t been mined at the time of this post, we’re expecting to use Bitcoin block 820749, this to prove we have no influence over the outcome of the game. Please guys feel free to quote this post so this will be all set in stone. Looking forward to show you guys Fortune double very soon! |
|
|
|
Hello again! Due to recent personnel changes we've decided to rotate the chain as a precaution following the same approach as before.
We've generated a new chain of 10,000,000 SHA256 hashes where each hash is the hash of the hexadecimal representation of the previous hash. Being the last hash in the chain: 97b14fa91456e0a94fd664476569bd665570ce46ba5c33c86ba636ed56ff3e75
We’re gonna be using a BlockHash that hasn’t been mined at the time of this post, we’re expecting to use Bitcoin block 815,804 this to prove we have no influence over the outcome of the game.
Archived post: https://archive.ph/V0sMBClient seed has been mined! 0000000000000000000028cf3f37570e363971e70ec5107ef0bb62f338736f5a
|
|
|
|
|
Hello again! Due to recent personnel changes we've decided to rotate the chain as a precaution following the same approach as before.
We've generated a new chain of 10,000,000 SHA256 hashes where each hash is the hash of the hexadecimal representation of the previous hash. Being the last hash in the chain: 97b14fa91456e0a94fd664476569bd665570ce46ba5c33c86ba636ed56ff3e75
We’re gonna be using a BlockHash that hasn’t been mined at the time of this post, we’re expecting to use Bitcoin block 815,804 this to prove we have no influence over the outcome of the game.
|
|
|
|
We’re excited to announce that we’re releasing Crash II game in http://Blaze.com, so we welcome you to our seeding event for Crash II which we would be releasing soon. For this seeding event we are following the same approach we had for Crash and Double. As part of our fairness we generated a chain of 10,000,000 SHA256 hashes where each hash is the hash of the hexadecimal representation of the previous hash. Being the last hash in the chain: 80bea5b63f9afdf51527f58b0467082a6b0dfe7f94c3bf9bb8f03e5e226152f1
Script to calculate Crash point:const { createHmac } = require('crypto');
const divisible = (hash, mod) => {
// So ABCDEFGHIJ should be chunked like AB CDEF GHIJ
let val = 0;
let o = hash.length % 4;
for (let i = o > 0 ? o - 4 : 0; i < hash.length; i += 4) {
val = ((val << 16) + parseInt(hash.substring(i, i + 4), 16)) % mod;
}
return val === 0;
};
const calculateIfIsBonusRound = (provablyFairHash) => {
return divisible(provablyFairHash, 72);
};
const calculateCrashPointFromHash = function (hash) {
// In 1 of 15 games the game crashes instantly.
if (divisible(hash, 15)) return 0;
// Use the most significant 52-bit from the hash to calculate the crash point
let h = parseInt(hash.slice(0, 52 / 4), 16);
let e = Math.pow(2, 52);
return (Math.floor((100 * e - h) / (e - h)) / 100).toFixed(2);
};
// these will be the 10M pre generated rolls to be used
const hashChain = ['random1', 'random2'];
const gameHash = hashChain.pop();
// It's the hash we're gonna be using of the result of a yet to be mined block on the blockchain #792,123
const blockHash = '';
const hash = createHmac('sha256', gameHash).update(blockHash).digest('hex');
const crashPoint = calculateCrashPointFromHash(hash);
// if it's bonus round you get double payout
const isBonusRound = calculateIfIsBonusRound(hash);
console.log({ crashPoint, isBonusRound });
We’re gonna be using a BlockHash that hasn’t been mined at the time of this post, we’re expecting to use Bitcoin block 809,654 this to prove we have no influence over the outcome of the game. Please guys feel free to quote this post so this will be all set in stone. Looking forward to show you guys Crash II very soon! |
|
|
|
We’re excited to announce that we’re releasing Slide game in Blaze.com, so we welcome you to our seeding event for Slide which we would be releasing soon. For this seeding event we are following the same approach we had for Crash and Double. As part of our fairness we generated a chain of 10,000,000 SHA256 hashes where each hash is the hash of the hexadecimal representation of the previous hash. Being the last hash in the chain: 6fd019734e950fe220446305b812e6308d1d49f0f4de113a1e5cbb624be6417b
Script to calculate Slide point:
const { createHmac } = require('crypto');
const divisible = (hash, mod) => {
// So ABCDEFGHIJ should be chunked like AB CDEF GHIJ
let val = 0;
let o = hash.length % 4;
for (let i = o > 0 ? o - 4 : 0; i < hash.length; i += 4) {
val = ((val << 16) + parseInt(hash.substring(i, i + 4), 16)) % mod;
}
return val === 0;
};
const calculateSlidePointFromHash = function (hash) {
// In 1 of 15 games the game slides instantly.
if (divisible(hash, 15)) return 0;
// Use the most significant 52-bit from the hash to calculate the slide point
let h = parseInt(hash.slice(0, 52 / 4), 16);
let e = Math.pow(2, 52);
return (Math.floor((100 * e - h) / (e - h)) / 100).toFixed(2);
};
// these will be the 10M pre generated rolls to be used
const hashChain = ['random1', 'random2'];
const gameHash = hashChain.pop();
// It's the hash we're gonna be using of the result of a yet to be mined block on the blockchain #792,123
const blockHash = '';
const hash = createHmac('sha256', gameHash).update(blockHash).digest('hex');
const slidePoint = calculateSlidePointFromHash(hash);
console.log({ slidePoint });We’re gonna be using a BlockHash that hasn’t been mined at the time of this post, we’re expecting to use Bitcoin block 792,123, this to prove we have no influence over the outcome of the game. Please guys feel free to quote this post so this will be all set in stone. Looking forward to show you guys Slide very soon! |
|
|
|
|
