How do I verify a case is fair on Lolanceizi?

Compute the SHA-256 hash of the revealed server seed and confirm it matches the hash shown before opening. Then recompute HMAC-SHA256 over the server seed and the client seed:nonce string. If the resulting roll matches the recorded one, the case was fair.

What do I need to run the verification?

You need the revealed server seed, the hash shown before opening, your client seed, the nonce, and any SHA-256 and HMAC-SHA256 calculator. With those values you can reproduce and check the result yourself.

How is the roll number calculated?

The roll comes from HMAC-SHA256 keyed with the server seed over the string client seed:nonce. You take the first 64 bits of that output and apply modulo 10001, giving a roll from 0 to 10000 that maps to your outcome.

What if my computed result does not match?

A mismatch usually means an input error, such as a wrong nonce or a stray space in the client seed:nonce string, so re-check your values first. When the system works correctly the result always reproduces. If it still fails, contact support.

Why does Lolanceizi show a hash before I open the case?

The hash is a cryptographic commitment to the hidden server seed. Publishing it in advance locks the outcome without revealing the seed. Because the seed cannot be changed later without breaking that hash, the hash makes tampering detectable.

What role does the nonce play?

The nonce is a counter that increments with each case you open, keeping every opening unique and ordered. It combines with your client seed as client seed:nonce inside HMAC-SHA256, so the same server seed produces a different roll each time.

Can I verify past openings later?

Yes. As long as you kept the server seed, client seed and nonce from an opening, you can recompute and verify it at any time. The calculation is deterministic, so an honest result reproduces identically whether you check it now or later.

Do I have to trust Lolanceizi for this to work?

No, that is the point of provably fair. You verify the outcome with your own SHA-256 and HMAC-SHA256 calculations instead of trusting the platform. The advance hash commitment and reproducible roll let you demonstrate fairness independently.

How to Verify Case Fairness

This page covers the separate optional entertainment mode, not the core task and social platform. To verify case fairness on Lolanceizi, reveal the server seed after opening, hash it with SHA-256 and match it against the hash shown beforehand, then recompute the roll with HMAC-SHA256 over the server seed and the string client seed:nonce. A match proves the case was fair.

Written by Lolanceizi Editorial TeamPublished: 2026-07-04Updated: 2026-07-10Editorial policy

What provably fair actually means

Provably fair is a cryptographic method that lets you confirm an outcome was decided before you opened a case, not adjusted afterward. Instead of trusting anyone's word, you check the math yourself. The system commits to a hidden server seed up front by publishing its SHA-256 hash, and that commitment is what makes tampering detectable.

The core idea rests on three inputs: a server seed generated by Lolanceizi, a client seed tied to your session, and a nonce that counts each opening. Because the server seed is locked in through its published hash before you act, the platform cannot swap it later. Once revealed, anyone can replay the calculation and reach the identical roll.

The three ingredients: server seed, client seed, nonce

The server seed is a secret value the platform creates and keeps hidden until the round ends; only its SHA-256 hash is visible in advance. This is the piece that guarantees the outcome was fixed at commit time. Revealing the raw seed afterward is what allows you to check that nothing changed between the promise and the result.

The client seed is a value associated with your side of the exchange, and the nonce is a counter that increments with each case you open. Combined as the string client seed:nonce, they make every opening unique and ordered. Keeping these details lets you reproduce the exact roll later, whether minutes or days after the fact.

Step 1: Check the server seed hash

Before you open a case, Lolanceizi shows you a SHA-256 hash of the server seed. This hash is the platform's advance commitment: it fixes the seed without revealing it. Save or note this value before opening so you have something concrete to compare against once the round is complete.

After the reveal, take the raw server seed the system now shows you and compute its SHA-256 hash yourself using any calculator or code library. Confirm that the hash you produce is identical to the one displayed before opening. If they match, the server seed was never altered, and the commitment held from start to finish.

Step 2: Recompute the roll

With the verified server seed in hand, recompute the roll. Take HMAC-SHA256 keyed with the server seed over the string client seed:nonce. This deterministic function always returns the same output for the same inputs, which is why it can be checked independently by anyone holding those values.

From the HMAC-SHA256 output, read the first 64 bits and take that number modulo 10001. The result is a roll from 0 to 10000. That single number is what Lolanceizi maps to your case outcome, so reproducing it correctly is the heart of the whole verification process.

Step 3: Compare the result

Now match your independently computed roll from 0 to 10000 against the roll the system recorded for that opening. Because the calculation is deterministic, the two numbers should be identical every time when everything is honest. This comparison is the final proof that the outcome was locked in at commit and not swapped afterward.

A match confirms two things at once: the server seed matched its published hash, and the roll derived from it matches what you were shown. Together these close the loop on the commitment. On Lolanceizi you can run this check on any opening, so fairness is something you demonstrate rather than something you simply take on faith.

Tools you need to verify

You do not need special software to verify a Lolanceizi case. Any SHA-256 calculator confirms the server seed hash, and any HMAC-SHA256 implementation reproduces the roll. Command-line tools, small scripts, or trustworthy online calculators all work, provided you supply the exact server seed, client seed and nonce.

Gather four things before you start: the revealed server seed, the hash shown before opening, your client seed, and the nonce for that specific case. Feed the server seed and client seed:nonce string into HMAC-SHA256, apply the first-64-bits modulo 10001 step, and compare. Keeping a record of these values from each opening makes verification possible at any later time.

When a check fails

If the SHA-256 hash of the revealed server seed does not match the hash shown before opening, or if your recomputed roll differs from the recorded result, stop and investigate. When the system is working correctly, the result always reproduces exactly, so a genuine mismatch should never happen. First rule out mistakes in your own inputs before assuming anything else.

The most common cause of a mismatch is a small input error: an extra space in the client seed:nonce string, the wrong nonce, or a mistyped seed. Re-check each value carefully and run the calculation again. If the numbers still disagree, contact support with the full opening details.

How do I verify a case is fair on Lolanceizi?: Compute the SHA-256 hash of the revealed server seed and confirm it matches the hash shown before opening. Then recompute HMAC-SHA256 over the server seed and the client seed:nonce string. If the resulting roll matches the recorded one, the case was fair.
What do I need to run the verification?: You need the revealed server seed, the hash shown before opening, your client seed, the nonce, and any SHA-256 and HMAC-SHA256 calculator. With those values you can reproduce and check the result yourself.
How is the roll number calculated?: The roll comes from HMAC-SHA256 keyed with the server seed over the string client seed:nonce. You take the first 64 bits of that output and apply modulo 10001, giving a roll from 0 to 10000 that maps to your outcome.
What if my computed result does not match?: A mismatch usually means an input error, such as a wrong nonce or a stray space in the client seed:nonce string, so re-check your values first. When the system works correctly the result always reproduces. If it still fails, contact support.
Why does Lolanceizi show a hash before I open the case?: The hash is a cryptographic commitment to the hidden server seed. Publishing it in advance locks the outcome without revealing the seed. Because the seed cannot be changed later without breaking that hash, the hash makes tampering detectable.
What role does the nonce play?: The nonce is a counter that increments with each case you open, keeping every opening unique and ordered. It combines with your client seed as client seed:nonce inside HMAC-SHA256, so the same server seed produces a different roll each time.
Can I verify past openings later?: Yes. As long as you kept the server seed, client seed and nonce from an opening, you can recompute and verify it at any time. The calculation is deterministic, so an honest result reproduces identically whether you check it now or later.
Do I have to trust Lolanceizi for this to work?: No, that is the point of provably fair. You verify the outcome with your own SHA-256 and HMAC-SHA256 calculations instead of trusting the platform. The advance hash commitment and reproducible roll let you demonstrate fairness independently.

Sources

Secure Hash Standard (FIPS 180-4) — NIST
The Keyed-Hash Message Authentication Code (HMAC) — NIST