PROVABLY FAIR

Provably Fair

All rolls on CSGOatse.com are generated using a provably fair system. This means the operators cannot manipulate the outcome of any roll.

NOTE: You are not logged, you can only verify blockchain games.

Introduction

Provable fairness is a transparent way for us to guarantee to our users that our system is truly random without manipulation.

The provably fair algorithm used to handle outcomes is completely transparent and verifiable. You as the user are in control of your gambling experience and can know for certain that all outcomes are indeed random and have not been tempered with.

All round values on CSGOatse.com are generated using a provably fair system. This means the operators cannot manipulate the outcome of any roll.

Daily blockchain

We generated a chain of 1 000 SHA256 hashes for day, starting with a server secret that has been repeatedly fed the output of SHA256 back into itself 1 000 times. Blockchain system started from 2019-09-01.

Current blockchain hash is not visible because it is used to generate all random values for games. We reveal current hash after midnight. You can verify all historical hashes.

Daily blockchain is used in roulette, crash, jackpot and giveaway.

All hashes are generated with algorithm:

generateHash(seed) {
  return crypto.createHash('sha256').update(seed).digest('hex');
}

Seeds

In the provably fair tab in user settings, you can change server and client seed.

Server seed is SHA256 hash generated from random 32 bytes. You can regenerate server seed any time. Your current server hash is hidden, you can see hashed value to confirm the hash after revealing. You can verify your previous games after regenerating server_seed.

Client seed is generated first time for user, same way like server seed but you are able to put any text you want (minimum 6 characters, maximum 64 characters, alfanum).

Nonce is a numer used for generating random value, it increments every time you play any game based on seeds (dice, minesweeper, blackjack, freeflip).

We reset nonce to 0 when you regenerate server seed.

Default seed algorithm:

randomSeed() {
  return crypto.randomBytes(32).toString('hex');
}

Roulette / Jackpot / Giveaway

Every day we generate a chain of 5 000 (10 000 for jackpot, 50 for giveaway) SHA256 hashes for incoming rolls. First seed is:

${BlockchainDailyHash}:${GameName}

For example

7566D368B19996FDA9487E2E36C6B0677D1B42C5B9D8C6EAF7B4912C589D7A0C:roulette

We reveal hash after each game.

Value of the round is generated from game hash, using algorithm:

calculateValueFromHash({ hash = null, seed = null, min = 0, max }) {
  if (!hash) {
    hash = this.generateHash(seed.join(':'));
  }
  return (min + (parseInt(hash.substr(0, 13), 16) % (max - min + 1)));
}
Roulette parameters: min = 0, max = 14
Roulette megaround parameters: min = 0, max = 250
Jackpot parameters: min = 0, max = 10 000
Jackpot megaround parameters: min = 0, max = 250
Giveaway parameters: min = 0, max = 10000

Crash

Every day we generate a chain of 5 000 SHA256 Hashes for incoming rounds. First seed is:

${BlockchainDailyHash}:${GameName}

For example

7566D368B19996FDA9487E2E36C6B0677D1B42C5B9D8C6EAF7B4912C589D7A0C:crash

We reveal hash after each game.

Value of the round is generated from game hash, using algorithm:

divisible(hash, mod) {
  let val = 0;
  const 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;
}

getCrashValue({ hash }) {
  let value = 1.00;
  if (!this.divisible(hash, 25)) {
    const h = parseInt(hash.slice(0, 13), 16);
    const e = 2 ** 52;
    value = (Math.floor(((e - h / 50) / (e - h)) * 100) / 100).toFixed(2);
  }

  return { value: Number(value) };
}

Dice / Freeflip

Dice random number is generated with algorithm:

getSingleGameValue({ server_seed, nonce, client_seed, max, min = 0, index = 0 }) {
  const seed = [client_seed, server_seed, nonce, index].filter(i => i);

  const value = this.calculateValueFromHash({
    seed, min, max,
  });

  return {
    value,
  };
}

Russian roulette

For russian games we are using creator's server seed and client seed. While opponent joins the match we are sending query to random.org API and find random string (10 characters). This random string is used to generate game hash.

You can verify random.org results any time.

Russian random bullet locations are generated with algorithm:

getSingleGameValue({ server_seed, nonce, client_seed, max, min = 0, index = 0, secret }) {
  const seed = [client_seed, server_seed, nonce, index, secret].filter(i => i);

  const value = this.calculateValueFromHash({
    seed, min, max,
  });

  return {
    value,
  };
}
}
Russian parameters: min = 1, max = 6, index = 0, secret = random.org value

Blackjack

Each blackjack game starts with shuffling 4 decks of 52 cards.

Blackjack random cards order is generated with algorithm:

getBlackjackValues({ server_seed, nonce, client_seed, decks = 4, cards = 52 }) {
  const cards_available = [];
  for (let i = 0; i < decks; i += 1) {
    cards_available.push(...Array.from(Array(cards).keys()));
  }
  const cards_selected = [];
  for (let index = 1; cards_available.length; index += 1) {
    const { value } = this.getSingleGameValue({
      client_seed, server_seed, nonce, max: cards_available.length - 1, index,
    });
    cards_selected.push(...cards_available.splice(value, 1));
  }
  return { value: cards_selected };
}
}
Blackjack parameters: decks = 0, cards = 52
Provably fair loading in progress... It can take a while.
direct message view profile Ignore player Show ignore list