Provably FairPack Engine
Every pack opening on The Slab Lab is powered by deterministic cryptographic randomness. We commit to the outcome before you open, lock the inventory during selection, and publish full proof afterwards. No manipulation. No exceptions. Independently verifiable by anyone.
How it works
Commit
At purchaseWhen you buy a pack, our system generates a cryptographic server seed — a 32-byte random value. We immediately compute its SHA-256 hash and store it against your opening. You can see this hash before you ever open the pack. This is our commitment: we cannot change the seed after this point without the hash mismatching.
Reveal
At openingWhen you open your pack, a client seed is combined with the server seed. You can provide your own client seed for maximum control, or we generate one automatically. These seeds, along with your unique opening ID and a nonce value, are fed into SHA-256 to produce a deterministic random number. The same inputs will always produce the same output.
Select
DeterministicThe derived random value (a decimal between 0 and 1) is used to select a value band and then a specific card, both via weighted cumulative probability. The inventory is locked at the moment of selection — no cards can be added or removed during this process. A SHA-256 hash of the candidate pool is recorded to prove its integrity.
Verify
Post-openingAfter your pack is opened, the original server seed is published alongside all proof data. You can independently verify that SHA-256 of the server seed matches the hash we committed to before opening. A permanent public verification receipt is generated for every single pull.
Not just “random” — provably fair
Most digital pack platforms rely on opaque random number generators with no way to verify outcomes. Here is what we do differently.
Deterministic Randomness
Every outcome is derived from SHA-256 cryptographic hashing. No opaque random number generators. The same inputs always produce the same result.
Commit / Reveal Protection
The server seed hash is committed before you open. We cannot change the outcome after purchase — the maths would not add up.
Inventory Locking
At the moment of reveal, all eligible cards are locked in the database. Nothing can be added, removed, or reordered during selection.
Algorithm Versioning
Every opening records the exact algorithm version used. If we ever change the selection logic, the version increments and is permanently recorded.
Public Receipts
Every pull generates a permanent, publicly accessible verification receipt containing every piece of proof data needed to independently verify the outcome.
Pool Integrity Hashing
A SHA-256 hash of the sorted candidate card IDs is stored with each opening, proving the exact pool that was available at selection time.
Technical details
RNG Derivation
The random value that determines your pull is derived from a single cryptographic hash function. The formula is:
Two separate RNG values are derived per opening: one for band selection (nonce = 0) and one for card selection (nonce = 1). This ensures the band and card choices are independently determined from the same seed pair.
Weighted Probability Selection
Each value band has a configured probability weight. At reveal time, only bands with available stock are considered. The weights are normalised and a cumulative sum is built. The RNG value then falls into exactly one band's range.
The same process applies within the selected band to choose a specific card. Cards recently pulled by the same user receive a reduced cooldown weight, ensuring variety whilst remaining fully deterministic and verifiable.
Seed Commitment Scheme
The commit/reveal scheme is a well-established cryptographic pattern. It works because SHA-256 is a one-way function: you can easily compute the hash from a seed, but you cannot reverse it to find the seed from a hash.
At purchase: Server seed generated. Hash = SHA-256(server_seed) is stored and visible to you.
At reveal: Client seed combined, RNG derived, card selected. Server seed is published.
Verification: Anyone can compute SHA-256(published_server_seed) and confirm it matches the pre-committed hash.
Every pull has a public receipt
After opening a pack, you will find a verification link on your dashboard, decision screen, and share page. Each receipt contains everything needed to independently verify the outcome.
What the receipt contains:
Frequently asked questions
No. The server seed is generated and its hash committed at the moment of purchase. Changing the seed would change the hash, and the mismatch would be immediately detectable. This is mathematically guaranteed by the properties of SHA-256.
No. The outcome depends on both the server seed (which we generate) and the client seed (which you can provide). Since we do not know your client seed in advance, we cannot predict the outcome. Even with the default auto-generated client seed, the combination with your unique opening ID makes prediction infeasible.
A random client seed is generated automatically. The system is still provably fair — the server seed was committed before the client seed existed. Providing your own seed gives you additional control and eliminates any theoretical concern about auto-generation.
Every opened pack has a verification link. The receipt page shows all the cryptographic data. You can verify that SHA-256(server_seed) matches the pre-committed hash, and re-derive the RNG value yourself using the published formula.
The algorithm version is recorded with every opening. If we change any aspect of the selection logic, the version number increments. Historical openings always reference the exact version that was used, ensuring full traceability.
Ready to rip?
Every pack on The Slab Lab is backed by our Provably Fair engine. Browse our tiers and open your first pack with confidence.