Bitcoin Forum
May 10, 2021, 06:09:44 AM *
News: Latest Bitcoin Core release: 0.21.1 [Torrent]
 
   Home   Help Search Login Register More  
Pages: [1] 2 3 4 5 6 7 »  All
  Print  
Author Topic: ETCBets.com - Provably Fair iGaming for Ethereum Classic  (Read 7154 times)
gordonhill
Legendary
*
Offline Offline

Activity: 1260
Merit: 1006



View Profile WWW
May 08, 2017, 11:01:44 PM
Last edit: July 18, 2017, 03:18:31 PM by gordonhill
 #1






Advertised sites are not endorsed by the Bitcoin Forum. They may be unsafe, untrustworthy, or illegal in your jurisdiction. Advertise here.
Bjorn_Blockchain
Sr. Member
****
Offline Offline

Activity: 449
Merit: 250

Belief in the immutable.


View Profile
May 08, 2017, 11:01:55 PM
 #2

1) We have generated a chain of 10 million sha256 hashes, starting with a server secret that has been repeatedly fed the output of sha256 back into itself 10 million times. The sha256 of the final hash in the chain is: c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75, by publicising it here we are preventing any ability to pick an alternate sha256 chain.


2) Parabolic will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point in a probably fair manner.

3) To avoid criticism that the Bitcoin address 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 465525.


The reference code (javascript) is as follows:

The method to create the hash chain is simply sha256:
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 game multiplier:

Code:
function crashPointFromHash(serverSeed, clientSeed) {
  function divisible(hash, mod) {
    // We will read in 4 hex at a time, but the first chunk might be a bit smaller
    // So ABCDEFGHIJ should be chunked like  AB CDEF GHIJ
    var val = 0;
    
    var o = hash.length % 4;
    for (var 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;
  }

  var hash = crypto.createHmac('sha256', serverSeed).update(clientSeed).digest('hex');

  /* In 1 of 101 games the game crashes instantly. */
  if (divisible(hash, 101))
     return 0;

  /* Use the most significant 52-bit from the hash
     to calculate the crash point */
  var h = parseInt(hash.slice(0,52/4),16);
  var e = Math.pow(2,52);

  return Math.floor((100 * e - h) / (e - h));
}

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 c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75.

https://coinhub.news for crypto news, podcasts, reddit, bitcointalk and more!
https://www.krediblepolitics.com get your politics on!
DiCE1904
Legendary
*
Offline Offline

Activity: 1118
Merit: 1002


View Profile WWW
May 08, 2017, 11:26:28 PM
 #3

1) We have generated a chain of 10 million sha256 hashes, starting with a server secret that has been repeatedly fed the output of sha256 back into itself 10 million times. The sha256 of the final hash in the chain is: c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75, by publicising it here we are preventing any ability to pick an alternate sha256 chain.


2) Parabolic will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point in a probably fair manner.

3) To avoid criticism that the Bitcoin address 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 465525.


The reference code (javascript) is as follows:

The method to create the hash chain is simply sha256:
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 game multiplier:

Code:
function crashPointFromHash(serverSeed, clientSeed) {
  function divisible(hash, mod) {
    // We will read in 4 hex at a time, but the first chunk might be a bit smaller
    // So ABCDEFGHIJ should be chunked like  AB CDEF GHIJ
    var val = 0;
    
    var o = hash.length % 4;
    for (var 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;
  }

  var hash = crypto.createHmac('sha256', serverSeed).update(clientSeed).digest('hex');

  /* In 1 of 101 games the game crashes instantly. */
  if (divisible(hash, 101))
     return 0;

  /* Use the most significant 52-bit from the hash
     to calculate the crash point */
  var h = parseInt(hash.slice(0,52/4),16);
  var e = Math.pow(2,52);

  return Math.floor((100 * e - h) / (e - h));
}

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 c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75.


Saved

EvilDave
Hero Member
*****
Offline Offline

Activity: 854
Merit: 1001



View Profile
May 08, 2017, 11:38:54 PM
 #4

1) We have generated a chain of 10 million sha256 hashes, starting with a server secret that has been repeatedly fed the output of sha256 back into itself 10 million times. The sha256 of the final hash in the chain is: c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75, by publicising it here we are preventing any ability to pick an alternate sha256 chain.


2) Parabolic will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point in a probably fair manner.

3) To avoid criticism that the Bitcoin address 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 465525.


The reference code (javascript) is as follows:

The method to create the hash chain is simply sha256:
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 game multiplier:

Code:
function crashPointFromHash(serverSeed, clientSeed) {
  function divisible(hash, mod) {
    // We will read in 4 hex at a time, but the first chunk might be a bit smaller
    // So ABCDEFGHIJ should be chunked like  AB CDEF GHIJ
    var val = 0;
    
    var o = hash.length % 4;
    for (var 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;
  }

  var hash = crypto.createHmac('sha256', serverSeed).update(clientSeed).digest('hex');

  /* In 1 of 101 games the game crashes instantly. */
  if (divisible(hash, 101))
     return 0;

  /* Use the most significant 52-bit from the hash
     to calculate the crash point */
  var h = parseInt(hash.slice(0,52/4),16);
  var e = Math.pow(2,52);

  return Math.floor((100 * e - h) / (e - h));
}

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 c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75.


Saved

Quoted by me, and all. Hi, BTT peeps  Cheesy

Nulli Dei, nulli Reges, solum NXT
Love your money: www.nxt.org  www.ardorplatform.org
www.nxter.org  www.nxtfoundation.org
edmundduke
Legendary
*
Offline Offline

Activity: 1470
Merit: 1001


View Profile
May 09, 2017, 05:31:06 AM
 #5

1) We have generated a chain of 10 million sha256 hashes, starting with a server secret that has been repeatedly fed the output of sha256 back into itself 10 million times. The sha256 of the final hash in the chain is: c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75, by publicising it here we are preventing any ability to pick an alternate sha256 chain.


2) Parabolic will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point in a probably fair manner.

3) To avoid criticism that the Bitcoin address 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 465525.


The reference code (javascript) is as follows:

The method to create the hash chain is simply sha256:
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 game multiplier:

Code:
function crashPointFromHash(serverSeed, clientSeed) {
  function divisible(hash, mod) {
    // We will read in 4 hex at a time, but the first chunk might be a bit smaller
    // So ABCDEFGHIJ should be chunked like  AB CDEF GHIJ
    var val = 0;
    
    var o = hash.length % 4;
    for (var 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;
  }

  var hash = crypto.createHmac('sha256', serverSeed).update(clientSeed).digest('hex');

  /* In 1 of 101 games the game crashes instantly. */
  if (divisible(hash, 101))
     return 0;

  /* Use the most significant 52-bit from the hash
     to calculate the crash point */
  var h = parseInt(hash.slice(0,52/4),16);
  var e = Math.pow(2,52);

  return Math.floor((100 * e - h) / (e - h));
}

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 c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75.


Saved.

Also looking forward to the launch!



▐█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█▌
▐█▐█ΦΦΓ        ▄▄ΦΦ██▄▄        ΦΦ██ █▌
▐█▐█         █▀└  ▄∩  ▀█▄        ▐█ █▌
▐█          █▀   █▀█╕   █▌          █▌
▐█         ▐█ ªΓ ▀▀█▄ ▀⌐▐█          █▌
▐█          █▄   ▀██▀   █▌          █▌
▐█▐█         ▀█▄  ▀^ ▄█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█▄
▐█ ▀▀▀╛         ▀▀▀▀▀█ ██▀▀▀▀▀▀▀▀▀▀▀█▌ █
▐█▙▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█ █▌           █▌ █
  ▄▄▄                █ ██▄▄▄▄▄▄▄▄▄▄▄█▌ █
  █▄█▄         █▀█   █ ▗▄▄▄ ▗▄▄▄ ▗▄▄▄▖ █
 ▗▄▄▄ ▀█▄▛▜▄█▀▀▀▀▀   █ ▐▙▄█ ▐▙▄█ ▐█▄█▌ █
 ▐▌ █   ▀▙▟▀  ▄▄▄▄   █                 █
 ▐▌ █   ▄▄▄▖  █▌ █   █ ▐▛▀█ ▐▛▀█ ▐█▀█▌ █
 ▐▌ █   █ ▐▌  █▌ █   █ ▝▀▀▀ ▝▀▀▀ ▐█ █▌ █
 ▐▌ █   █ ▐▌  █▌ █   █ ▐▛▀█ ▐▛▀█ ▐█ █▌ █
 ▐▌ █   █ ▐▌  █▌ █   █ ▐▙▄█ ▐▙▄█ ▐█▄█▌ █
▄█▙▄█▄▄▄█▄▟▙▄▄█▙▄█▄  ▀█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▀
.
Up to 100x
Leverage
.


,▄▄██████   N╦╥,
,   ██`    ██   ╫╫╫╫╫╬╦,
╔Ñ░¼   ██ ,,╓██   ╫╫╫╫╫╫╫╫╬╗
]░░░░░H   █▀▀▀╙└└   ╩╣╫╫╫╫╫╫╫╫╫╦
,Ñ░░░░░╫░r               "╩╫╫╫╫╫╫╫╬
,Ñ░░░╫░░Ñ`                  `╣╫╫╫╫╫╫╫╕
Ñ░░╫░░░╨      ,▄▄,     ,      ╙╫╫╫╫╫╫╫
]░╫░░░░Ñ      ║█└"█▌  ▄█▀       ````````
]░░░░░░        ▀██▀,▄█▀          ,,,,,,,
╦░░░░╫░          ,▄█▀▄▄▄▄        █▀▀▀▀██
]░╫░░░░N       ,██^ ▐█, ██      ▐█    ██
░░░░░░╫╕      ▀-    ▀▀▀▀      ╓█▀   ,█⌐
╙░░░╫░░░¼                    ▄█┘    █▌
╙╫░░░░░░╫╥                 ██¿   ╓█▀
╩░░░╫░░░░Ñ╦w,      ,╥g,   ╙██µ▄█^
`╩░░░░░░░░░░░░╫░░░░░░░╫╥   '▀▀
"Ñ╫░░░░░░╫░░░░░░╫░░░░Ñw
`^╨Ñ╫░░░░░░╫░░Ñ╨╙`
Huge Competition - Over 100 BTC prizepool.
.
.


╓▄▄▄;          ,▄▄▄▄
╓█▀└ └▀██▄    ▄██▀" └▀█▄
██       ▀█▄▄█▀`      ██
██▄,,,,,,;██▄,,,,,,╓▄█▌
██▀▀▀▀▀▀▀▀▀▀▀▀██▀▀▀▀▀▀██▀▀▀▀▀▀▀▀▀▀▀▀▀█
█▌            ██      ██            ▐█
█▌            ██      ██            ▐█
█▌            ██      ██            ▐█
▀▀██▀▀▀▀▀▀▀▀▀▀██      ██▀▀▀▀▀▀▀▀▀▀██▀▀
██          ██      ██          ██
██          ██      ██          ██
██          ██      ██          ██
██          ██      ██          ██
██          ██      ██          ██
██          ██      ██          ██
██          ██      ██          ██
██          ██      ██          ██
██████████████████████████████████
.
Up to 60$ Welcome Bonus
.
.

.
.

kryptopojken
Hero Member
*****
Offline Offline

Activity: 768
Merit: 532


View Profile
May 09, 2017, 06:51:01 AM
 #6

1) We have generated a chain of 10 million sha256 hashes, starting with a server secret that has been repeatedly fed the output of sha256 back into itself 10 million times. The sha256 of the final hash in the chain is: c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75, by publicising it here we are preventing any ability to pick an alternate sha256 chain.


2) Parabolic will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point in a probably fair manner.

3) To avoid criticism that the Bitcoin address 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 465525.


The reference code (javascript) is as follows:

The method to create the hash chain is simply sha256:
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 game multiplier:

Code:
function crashPointFromHash(serverSeed, clientSeed) {
  function divisible(hash, mod) {
    // We will read in 4 hex at a time, but the first chunk might be a bit smaller
    // So ABCDEFGHIJ should be chunked like  AB CDEF GHIJ
    var val = 0;
    
    var o = hash.length % 4;
    for (var 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;
  }

  var hash = crypto.createHmac('sha256', serverSeed).update(clientSeed).digest('hex');

  /* In 1 of 101 games the game crashes instantly. */
  if (divisible(hash, 101))
     return 0;

  /* Use the most significant 52-bit from the hash
     to calculate the crash point */
  var h = parseInt(hash.slice(0,52/4),16);
  var e = Math.pow(2,52);

  return Math.floor((100 * e - h) / (e - h));
}

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 c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75.


Quoted
Bassica
Sr. Member
****
Offline Offline

Activity: 283
Merit: 250


View Profile
May 09, 2017, 04:54:20 PM
 #7

1) We have generated a chain of 10 million sha256 hashes, starting with a server secret that has been repeatedly fed the output of sha256 back into itself 10 million times. The sha256 of the final hash in the chain is: c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75, by publicising it here we are preventing any ability to pick an alternate sha256 chain.


2) Parabolic will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point in a probably fair manner.

3) To avoid criticism that the Bitcoin address 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 465525.


The reference code (javascript) is as follows:

The method to create the hash chain is simply sha256:
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 game multiplier:

Code:
function crashPointFromHash(serverSeed, clientSeed) {
  function divisible(hash, mod) {
    // We will read in 4 hex at a time, but the first chunk might be a bit smaller
    // So ABCDEFGHIJ should be chunked like  AB CDEF GHIJ
    var val = 0;
    
    var o = hash.length % 4;
    for (var 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;
  }

  var hash = crypto.createHmac('sha256', serverSeed).update(clientSeed).digest('hex');

  /* In 1 of 101 games the game crashes instantly. */
  if (divisible(hash, 101))
     return 0;

  /* Use the most significant 52-bit from the hash
     to calculate the crash point */
  var h = parseInt(hash.slice(0,52/4),16);
  var e = Math.pow(2,52);

  return Math.floor((100 * e - h) / (e - h));
}

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 c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75.


Quoted
qiwoman2
Legendary
*
Offline Offline

Activity: 2100
Merit: 1022


Oikos.cash | Decentralized Finance on Tron


View Profile
May 10, 2017, 05:08:02 AM
 #8

1) We have generated a chain of 10 million sha256 hashes, starting with a server secret that has been repeatedly fed the output of sha256 back into itself 10 million times. The sha256 of the final hash in the chain is: c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75, by publicising it here we are preventing any ability to pick an alternate sha256 chain.


2) Parabolic will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point in a probably fair manner.

3) To avoid criticism that the Bitcoin address 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 465525.


The reference code (javascript) is as follows:

The method to create the hash chain is simply sha256:
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 game multiplier:

Code:
function crashPointFromHash(serverSeed, clientSeed) {
  function divisible(hash, mod) {
    // We will read in 4 hex at a time, but the first chunk might be a bit smaller
    // So ABCDEFGHIJ should be chunked like  AB CDEF GHIJ
    var val = 0;
    
    var o = hash.length % 4;
    for (var 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;
  }

  var hash = crypto.createHmac('sha256', serverSeed).update(clientSeed).digest('hex');

  /* In 1 of 101 games the game crashes instantly. */
  if (divisible(hash, 101))
     return 0;

  /* Use the most significant 52-bit from the hash
     to calculate the crash point */
  var h = parseInt(hash.slice(0,52/4),16);
  var e = Math.pow(2,52);

  return Math.floor((100 * e - h) / (e - h));
}

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 c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75.



█▀█ █ █▄▀ █▀█ █▀ ░ █▀▀ ▄▀█ █▀ █░█
█▄█ █ █░█ █▄█ ▄█ ▄ █▄▄ █▀█ ▄█ █▀█



DeFi on Tron
and trustless token exchange
█████











█████

██████████████████████████████████████████████████████

JOIN OIKOS

██████████████████████████████████████████████████████

█████
    █
    █
    █
    █
    █
    █
    █
    █
    █
    █
    █
█████
ether19
Sr. Member
****
Offline Offline

Activity: 532
Merit: 250

BTC. ETC. EOS


View Profile WWW
May 10, 2017, 09:41:53 AM
 #9

1) We have generated a chain of 10 million sha256 hashes, starting with a server secret that has been repeatedly fed the output of sha256 back into itself 10 million times. The sha256 of the final hash in the chain is: c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75, by publicising it here we are preventing any ability to pick an alternate sha256 chain.


2) Parabolic will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point in a probably fair manner.

3) To avoid criticism that the Bitcoin address 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 465525.


The reference code (javascript) is as follows:

The method to create the hash chain is simply sha256:
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 game multiplier:

Code:
function crashPointFromHash(serverSeed, clientSeed) {
  function divisible(hash, mod) {
    // We will read in 4 hex at a time, but the first chunk might be a bit smaller
    // So ABCDEFGHIJ should be chunked like  AB CDEF GHIJ
    var val = 0;
    
    var o = hash.length % 4;
    for (var 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;
  }

  var hash = crypto.createHmac('sha256', serverSeed).update(clientSeed).digest('hex');

  /* In 1 of 101 games the game crashes instantly. */
  if (divisible(hash, 101))
     return 0;

  /* Use the most significant 52-bit from the hash
     to calculate the crash point */
  var h = parseInt(hash.slice(0,52/4),16);
  var e = Math.pow(2,52);

  return Math.floor((100 * e - h) / (e - h));
}

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 c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75.


quoted  Smiley
458Italia
Newbie
*
Offline Offline

Activity: 14
Merit: 0


View Profile
May 10, 2017, 04:51:58 PM
 #10

1) We have generated a chain of 10 million sha256 hashes, starting with a server secret that has been repeatedly fed the output of sha256 back into itself 10 million times. The sha256 of the final hash in the chain is: c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75, by publicising it here we are preventing any ability to pick an alternate sha256 chain.


2) Parabolic will play through that chain of hashes, in reverse order, and use the hashes to determine the crash point in a probably fair manner.

3) To avoid criticism that the Bitcoin address 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 465525.


The reference code (javascript) is as follows:

The method to create the hash chain is simply sha256:
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 game multiplier:

Code:
function crashPointFromHash(serverSeed, clientSeed) {
  function divisible(hash, mod) {
    // We will read in 4 hex at a time, but the first chunk might be a bit smaller
    // So ABCDEFGHIJ should be chunked like  AB CDEF GHIJ
    var val = 0;
    
    var o = hash.length % 4;
    for (var 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;
  }

  var hash = crypto.createHmac('sha256', serverSeed).update(clientSeed).digest('hex');

  /* In 1 of 101 games the game crashes instantly. */
  if (divisible(hash, 101))
     return 0;

  /* Use the most significant 52-bit from the hash
     to calculate the crash point */
  var h = parseInt(hash.slice(0,52/4),16);
  var e = Math.pow(2,52);

  return Math.floor((100 * e - h) / (e - h));
}

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 c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75. That is to say, the first game's hash played under the new provably fair scheme, when hashed will be c56c9fe892bd23ff6d20da0b505c86db9acecb6a257a2b79b23dfface1d4ea75.


Smiley Sweeeeeeeeeeet!
Etcbets
Newbie
*
Offline Offline

Activity: 8
Merit: 0


View Profile
May 10, 2017, 05:45:16 PM
 #11

Hi everyone, before someone starting spamming the same question, some things we ´ve planned won´t be fully operational at launch like Parabolic automatic bet feature or 2fa*, but will come later this week.

This is a  perfect window of time for our development team to wrap up the features not included at launch, also gives us time to test the site under much greater user bulky.

Good luck, and keep playing at ETCBets.com


- The ETCBets Team.


* We will enable 2fa within 24-48 hours.
BetterBets.io
Hero Member
*****
Offline Offline

Activity: 728
Merit: 500


Betterbets.io Casino


View Profile WWW
May 10, 2017, 06:53:48 PM
 #12

Confirming this is the same team as BB for transparency. Good fortune to players.

    █ █
██████████
 ██      ██
 ██      ██
 █████████  ███
 ██      ██   ██
 ██      ██   ██
██████████ ████
    █ █       ██
              ██
     ██████████

[

███████████████████████████████████████████████████████████████████████████
█████████████████████████████████████████████████████████████████████████████
██████████████████▀█████▀███████▀█████▀██████▀████████████▀██████████████████
███████████████████████████▀█████████████▀█████████████████████████████████████
████████████████████▄▄▄▄▄████▀████▄▄▄▄▄████▀███▄▄▄▄▄▄▄▄▄███████████████████████
██████████████████████████▄████▀████████▄████▀█████████████████████████████████
████████████████████▀▀▀▀▀███▄████▀▀▀▀▀████▄████▀▀▀▀▀▀▀███▄▄████████████████████
██████████████████████████████▄█████████████▄██████████████████████████████████
██████████████████▄█████▄██████▄█████▄███████▄███████▄███████████████████████
█████████████████████████████████████████████████████████████████████████████
███████████████████████████████████████████████████████████████████████████
Bitcoin and NXT Betting!!]    █ █
██████████
 ██      ██
 ██      ██
 █████████  ███
 ██      ██   ██
 ██      ██   ██
██████████ ████
    █ █       ██
              ██
     ██████████

DiCE1904
Legendary
*
Offline Offline

Activity: 1118
Merit: 1002


View Profile WWW
May 10, 2017, 06:54:31 PM
 #13

Smooth launch guys, site looks great!

gordonhill
Legendary
*
Offline Offline

Activity: 1260
Merit: 1006



View Profile WWW
May 10, 2017, 09:36:33 PM
 #14


Bjorn_Blockchain
Sr. Member
****
Offline Offline

Activity: 449
Merit: 250

Belief in the immutable.


View Profile
May 10, 2017, 10:38:34 PM
 #15

Smooth launch guys, site looks great!

Thanks Dice glad you like 😍

https://coinhub.news for crypto news, podcasts, reddit, bitcointalk and more!
https://www.krediblepolitics.com get your politics on!
DiCE1904
Legendary
*
Offline Offline

Activity: 1118
Merit: 1002


View Profile WWW
May 11, 2017, 01:51:09 AM
 #16

Don't forget the rakeback on ETCBets while holding some Janus : https://bitcointalk.org/index.php?topic=1677509.msg18960381#msg18960381

moooonu
Hero Member
*****
Offline Offline

Activity: 560
Merit: 500



View Profile
May 11, 2017, 02:32:06 AM
 #17

I love the graphics of your site but sad I can't register an account there. It's showing "your registration information was incomplete and not be validated. Please try again"
Raizou
Sr. Member
****
Offline Offline

Activity: 760
Merit: 250


View Profile
May 11, 2017, 05:08:02 AM
 #18

Hello Dev, I joined the campaign 2 ETC free, will it take 24 hours to confirm?
The site is very beautiful and nice, congratulations! Shocked
gribble
Hero Member
*****
Offline Offline

Activity: 966
Merit: 552



View Profile
May 11, 2017, 06:02:43 AM
 #19

It is great gambling game be made on ethereum classic, unfortunately it is still enough because igaming is new service.
Hey OP do you have plan to make promotion about your service in the future?
I think it is good ideas for make igaming be popular and many gamblers play on there and it is interesting battle in gaming
industry with ethereum.
gordonhill
Legendary
*
Offline Offline

Activity: 1260
Merit: 1006



View Profile WWW
May 11, 2017, 10:57:32 AM
Last edit: May 11, 2017, 06:14:07 PM by gordonhill
 #20

 


-The ETCBets Team
Pages: [1] 2 3 4 5 6 7 »  All
  Print  
 
Jump to:  

Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!