Pages:
Author

Topic: FaucetPay.io Provably Fair Seeding Event for Crash! - page 2. (Read 938 times)

copper member
Activity: 60
Merit: 10
Block 635017 is mined

Our client seed will be: 0000000000000000001221b64a1e49b293a743ff06f662ea713ca564d5e20b1e
copper member
Activity: 60
Merit: 10
Welcome to the FaucetPay Provably Fair Seeding Event for Crash!

This will reuse the idea posted by Ryan and used for Bustabit v1.
   
A chain of 10 million (1e7) sha256 hashes was generated, starting with a Server Secret that has been repeatedly fed the output of sha256 hash back into itself 10 million times.

The final hash in the chain is: e3ac72b2b84cb8b64669e0441e50bb24834980ed065a479113505c0984ac32c5, by publicizing it here we are preventing any ability to pick an alternate sha256 chain.
FaucetPay.io will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point.
To avoid criticism that the Server Secret used in step 1 was carefully chosen to generate lots of "bad" crash points, each hash in the chain will be salted with a client seed, which we have no control of.

The client seed will be the block hash of a Bitcoin block that hasn't yet been mined: block 635017

The reference code (javascript) is as follows:

Code:
function genGameHash(serverSeed) {
  return crypto.createHash('sha256').update(serverSeed).digest('hex');
}


The method to convert a game hash, mix it with the picked client seed to a money pot multiplier:

Code:
function toFixed(num, fixed) {
    var re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fixed || -1) + '})?');
    return num.toString().match(re)[0];
}

function crashPointFromHash(serverSeed, clientSeed) {

  var actual_hash = CryptoJS.SHA512(clientSeed + "-" + serverSeed).toString();

  var p1 = parseInt((actual_hash.substr(0, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);
  var p2 = parseInt((actual_hash.substr(2, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);
  var p3 = parseInt((actual_hash.substr(4, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);
  var p4 = parseInt((actual_hash.substr(6, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);

  var roll = Math.floor(((p1 / Math.pow(256, 1)) + (p2 / Math.pow(256, 2)) + (p3 / Math.pow(256, 3)) + (p4 / Math.pow(256, 4))) * 1000000);

  var crash_point = toFixed(parseFloat(1000000 / (roll + 1) * 0.96), 2);

  return crash_point;

}

The chain could be generated with code such as:

Code:
var serverSecret =  'If you knew this, you could steal all my money';
var clientSeed = '0000examplehash';

var gamesToGenerate = 1e7;

var serverSeed = serverSecret;

for (var game = gamesToGenerate; game > 0; --game) {
  serverSeed = genGameHash(serverSeed);
  console.log('Game ' +  game + ' has a crash point of ' + (crashPointFromHash(serverSeed, clientSeed) / 100).toFixed(2) +'x', '\t\tHash: ' + serverSeed);
}

var terminatingHash = genGameHash(serverSeed);

console.log('The terminating hash is: ', terminatingHash);

Using our chosen starting serverSeed, the hash terminating the chain is e3ac72b2b84cb8b64669e0441e50bb24834980ed065a479113505c0984ac32c5. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be e3ac72b2b84cb8b64669e0441e50bb24834980ed065a479113505c0984ac32c5.


Quoted to make sure nothing changes.

Archived the Opening post to make sure nothing changes -> https://web.archive.org/web/20200615104847/https://bitcointalk.org/index.php?topic=5255740.msg54623486

Awesome! Thank you.  Smiley
sr. member
Activity: 574
Merit: 272
Buy Bitcoin!
Welcome to the FaucetPay Provably Fair Seeding Event for Crash!

This will reuse the idea posted by Ryan and used for Bustabit v1.
   
A chain of 10 million (1e7) sha256 hashes was generated, starting with a Server Secret that has been repeatedly fed the output of sha256 hash back into itself 10 million times.

The final hash in the chain is: e3ac72b2b84cb8b64669e0441e50bb24834980ed065a479113505c0984ac32c5, by publicizing it here we are preventing any ability to pick an alternate sha256 chain.
FaucetPay.io will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point.
To avoid criticism that the Server Secret used in step 1 was carefully chosen to generate lots of "bad" crash points, each hash in the chain will be salted with a client seed, which we have no control of.

The client seed will be the block hash of a Bitcoin block that hasn't yet been mined: block 635017

The reference code (javascript) is as follows:

Code:
function genGameHash(serverSeed) {
  return crypto.createHash('sha256').update(serverSeed).digest('hex');
}


The method to convert a game hash, mix it with the picked client seed to a money pot multiplier:

Code:
function toFixed(num, fixed) {
    var re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fixed || -1) + '})?');
    return num.toString().match(re)[0];
}

function crashPointFromHash(serverSeed, clientSeed) {

  var actual_hash = CryptoJS.SHA512(clientSeed + "-" + serverSeed).toString();

  var p1 = parseInt((actual_hash.substr(0, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);
  var p2 = parseInt((actual_hash.substr(2, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);
  var p3 = parseInt((actual_hash.substr(4, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);
  var p4 = parseInt((actual_hash.substr(6, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);

  var roll = Math.floor(((p1 / Math.pow(256, 1)) + (p2 / Math.pow(256, 2)) + (p3 / Math.pow(256, 3)) + (p4 / Math.pow(256, 4))) * 1000000);

  var crash_point = toFixed(parseFloat(1000000 / (roll + 1) * 0.96), 2);

  return crash_point;

}

The chain could be generated with code such as:

Code:
var serverSecret =  'If you knew this, you could steal all my money';
var clientSeed = '0000examplehash';

var gamesToGenerate = 1e7;

var serverSeed = serverSecret;

for (var game = gamesToGenerate; game > 0; --game) {
  serverSeed = genGameHash(serverSeed);
  console.log('Game ' +  game + ' has a crash point of ' + (crashPointFromHash(serverSeed, clientSeed) / 100).toFixed(2) +'x', '\t\tHash: ' + serverSeed);
}

var terminatingHash = genGameHash(serverSeed);

console.log('The terminating hash is: ', terminatingHash);

Using our chosen starting serverSeed, the hash terminating the chain is e3ac72b2b84cb8b64669e0441e50bb24834980ed065a479113505c0984ac32c5. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be e3ac72b2b84cb8b64669e0441e50bb24834980ed065a479113505c0984ac32c5.


Quoted to make sure nothing changes.

Archived the Opening post to make sure nothing changes -> https://web.archive.org/web/20200615104847/https://bitcointalk.org/index.php?topic=5255740.msg54623486
copper member
Activity: 60
Merit: 10
Welcome to the FaucetPay Provably Fair Seeding Event for Crash!

This will reuse the idea posted by Ryan and used for Bustabit v1.
   
A chain of 10 million (1e7) sha256 hashes was generated, starting with a Server Secret that has been repeatedly fed the output of sha256 hash back into itself 10 million times.

The final hash in the chain is: e3ac72b2b84cb8b64669e0441e50bb24834980ed065a479113505c0984ac32c5, by publicizing it here we are preventing any ability to pick an alternate sha256 chain.
FaucetPay.io will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point.
To avoid criticism that the Server Secret used in step 1 was carefully chosen to generate lots of "bad" crash points, each hash in the chain will be salted with a client seed, which we have no control of.

The client seed will be the block hash of a Bitcoin block that hasn't yet been mined: block 635017

The reference code (javascript) is as follows:

Code:
function genGameHash(serverSeed) {
  return crypto.createHash('sha256').update(serverSeed).digest('hex');
}


The method to convert a game hash, mix it with the picked client seed to a money pot multiplier:

Code:
function toFixed(num, fixed) {
    var re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fixed || -1) + '})?');
    return num.toString().match(re)[0];
}

function crashPointFromHash(serverSeed, clientSeed) {

  var actual_hash = CryptoJS.SHA512(clientSeed + "-" + serverSeed).toString();

  var p1 = parseInt((actual_hash.substr(0, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);
  var p2 = parseInt((actual_hash.substr(2, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);
  var p3 = parseInt((actual_hash.substr(4, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);
  var p4 = parseInt((actual_hash.substr(6, 2) + '').replace(/[^a-f0-9]/gi, ''), 16);

  var roll = Math.floor(((p1 / Math.pow(256, 1)) + (p2 / Math.pow(256, 2)) + (p3 / Math.pow(256, 3)) + (p4 / Math.pow(256, 4))) * 1000000);

  var crash_point = toFixed(parseFloat(1000000 / (roll + 1) * 0.96), 2);

  return crash_point;

}

The chain could be generated with code such as:

Code:
var serverSecret =  'If you knew this, you could steal all my money';
var clientSeed = '0000examplehash';

var gamesToGenerate = 1e7;

var serverSeed = serverSecret;

for (var game = gamesToGenerate; game > 0; --game) {
  serverSeed = genGameHash(serverSeed);
  console.log('Game ' +  game + ' has a crash point of ' + (crashPointFromHash(serverSeed, clientSeed) / 100).toFixed(2) +'x', '\t\tHash: ' + serverSeed);
}

var terminatingHash = genGameHash(serverSeed);

console.log('The terminating hash is: ', terminatingHash);

Using our chosen starting serverSeed, the hash terminating the chain is e3ac72b2b84cb8b64669e0441e50bb24834980ed065a479113505c0984ac32c5. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be e3ac72b2b84cb8b64669e0441e50bb24834980ed065a479113505c0984ac32c5.
Pages:
Jump to: