bitZino is Provably Fair

Every gamble you make on bitZino is immediately independently verifiable by you.

Verify now

Use this javascript hand verifier to prove the fairness of any hand you play on bitZino. Just copy the values from any hand into this form and click "Verify".

Verify hand

How does it all work?

We utilize a novel cryptographic approach which ensures that neither you nor us can possibly know the shuffle of a deck until the moment it is dealt. To verify any hand, click on the Provably Fair link below any table, and copy the values into the form above.

Want all the nitty-gritty details of how we do this? Keep on reading!

Before every hand

Card encodings
0 Ac
1 2c
2 3c
3 4c
4 5c
5 6c
6 7c
7 8c
8 9c
9 10c
a Jc
b Qc
c Kc
d Ad
e 2d
f 3d
g 4d
h 5d
i 6d
j 7d
k 8d
l 9d
m 10d
n Jd
o Qd
p Kd
q Ah
r 2h
s 3h
t 4h
u 5h
v 6h
w 7h
x 8h
y 9h
z 10h
A Jh
B Qh
C Kh
D As
E 2s
F 3s
G 4s
H 5s
I 6s
J 7s
K 8s
L 9s
M 10s
N Js
O Qs
P Ks

Our servers create a new deck and shuffle it utilizing a hardware random number generator. We call this deck the initial_shuffle. See the table to the right to see what card each character in the initial_shuffle represents. Most casinos proceed to deal to you at this point, but for us this is just the beginning of our shuffle process.

Our servers also generate a random string, called the server_seed. We combine the initial_shuffle and the server_seed strings into a single JSON encoded string. We call this JSON string the secret.

Finally, we hash the secret using the SHA256 one-way hashing algorithm. This is called the Hash(secret). We show you this value to you before the hand starts, so you can independently verify that we didn't manipulate the server_seed or the initial_shuffle.

Now, in order to truly be fair, we need to do something like letting you cut the deck.

We don't just let you cut the deck, we let you Mersenne Twist it

Next hand window Before every hand, the javascript in your browser generates a random string called the client_seed. For the most security, we recommend using a browser that supports crypto.getRandomValues(), so your browser can generate a cryptographically secure string. If you'd like, you can modify this string to anything you want (up to 32 characters). If you're superstitious, this is a great place to put something lucky, because whatever you put here has a direct impact on the final shuffle of the deck.

When you hit the Bet button, your browser sends the client_seed to our servers. Our servers then hash the combination of the server_seed and the client_seed (using SHA256 again). We use this hash to seed the Mersenne Twister pseudorandom number generator. We then fully reshuffle the deck using this random number generator. Since the random number generator was seeded using a number that only you knew before the deal, there is no possible way for us to know the outcome of this shuffle.

Finally, we deal the cards to you. You are guaranteed a provably fair game.

What about non-card games?

Roulette encodings
0 0g
1 1r
2 2b
3 3r
4 4b
5 5r
6 6b
7 7r
8 8b
9 9r
a 10b
b 11b
c 12r
d 13b
e 14r
f 15b
g 16r
h 17b
i 18r
j 19r
k 20b
l 21r
m 22b
n 23r
o 24b
p 25r
q 26b
r 27r
s 28b
t 29b
u 30r
v 31b
w 32r
x 33b
y 34r
z 35b
A 36r
Dice encodings
0 1, 1
1 1, 2
2 1, 3
3 1, 4
4 1, 5
5 1, 6
6 2, 1
7 2, 2
8 2, 3
9 2, 4
a 2, 5
b 2, 6
c 3, 1
d 3, 2
e 3, 3
f 3, 4
g 3, 5
h 3, 6
i 4, 1
j 4, 2
k 4, 3
l 4, 4
m 4, 5
n 4, 6
o 5, 1
p 5, 2
q 5, 3
r 5, 4
s 5, 5
t 5, 6
u 6, 1
v 6, 2
w 6, 3
x 6, 4
y 6, 5
z 6, 6

We use this same approach for our Roulette and Craps games, we simply use a different deck of cards. A Roulette "deck" contains only 37 cards (0-36 inclusive). Each card in the Roulette deck represents an outcome of a spin of the wheel. A Craps "deck" contains 36 cards, each card representing a distinct outcome of a roll of a pair of dice.

After fully shuffling using the above process, we simply use the top card for the outcome of the Roulette wheel spin or the Craps dice roll.

Using the top card works great for Roulette and Craps, but Slots requires a more in-depth approach:

Provably Fair Slots

For slots, we still allow you to re-shuffle a deck of cards in the same way as our other games. Once we have a shuffled deck, we use factoradics to convert the deck into a specific number depending on how many reels and how many icons per reel the slots game has. We then convert that number into a specific spin configuration. Because this is a repeatable process, the same provably fair shuffle will always result in the same spin configuration.

You can use the javascript Slots Calculator below to compute the result of any spin based on the shuffle. The unobfuscated source code for this calculator is embedded in this page. Additionally, the method that we use to convert a shuffled deck into a slots result is documented in detail on our tech blog.

Once you've calculated the icon numbers using the below calculator, just click on the Pay table link from your Slots game. Then, look for the Reel configuration box. This box will include a number next to each icon for your Slots game, so you can verify that the calculated numbers match the middle row of numbers from your spin.

Use this javascript slots verifier to compute the results of any slots spin.

Slots calculator

Want to know even more details?

We have implemented a javascript hand verifier, which is embedded in this page. It's written in less than 100 lines of clean, unobfuscated, well-commented javascript. Check it out, and see for yourself!

Our tech blog has an even more in-depth description of this approach to Provably Fair Shuffling.

Loading qr code...