How Rips Work
Provably fair
Every pack commits to a sealed server seed before the rip. Anyone can re-derive the outcome afterwards and check our work.
Every digital pack we sell publishes enough information for anyone, including someone with no account, to re-derive the outcome and confirm we did not change it after the fact.
The short version
- Our half is locked in before you buy. For every pack we pick a secret random value and show you a sealed copy of it: the pack code, shown under Fairness and in small print when you confirm a purchase.
- Your half comes from you. Your browser makes your code at random, or you can type your own. Every card is drawn from both halves together, so nobody, including us, can steer what you pull.
- We unseal ours after the rip. Once your pack is opened we publish the secret value. Anyone can check that it matches the pack code you were shown, and re-run the draw to get exactly the same pulls.
- You don't need to do anything. The defaults are fair, and checking is optional.
The rest of this page is for anyone who wants to verify a rip themselves. In it, the pack code is called the fingerprint (the SHA-256 hash of our server seed), and your code is the client seed.
The idea
Before you buy, the server generates a random server seed and shows you only its SHA-256 hash: the fingerprint in the Fairness panel under More Info. That hash is the commitment. It pins the seed down without revealing it, and you receive it before you have told us anything else.
Your browser then draws a client seed of its own, after the fingerprint has arrived. You can keep it or type any seed you like. Every card in the pack is drawn from both seeds together, so the outcome depends on a value we fixed before we knew yours and on a value you chose after we could no longer change ours.
Buying several packs in one purchase works the same way. You get one fingerprint per pack, every one fixed before your seed exists and every one published with its pack. In the pack picker, all of them are on screen in the Fairness panel before you confirm. Purchase Again reuses the same order without showing them, so open the picker if you want to record a fingerprint before you buy.
We withhold the server seed until the pack is opened. If we published it early, anyone holding it, whether a buyer or the assigned streamer, could compute the contents before the rip.
After the reveal we publish the seed. A SHA-256 hash cannot in practice be worked backwards or collided, so a seed that matches the fingerprint you were shown earlier can only be the seed we were already committed to. We could not have looked at the outcome, or at your seed, and picked a different one.
What we commit to
The seed is not the only thing fixed before the roll. Each card slot's outcome is a function of the seeds plus four published inputs, and all of them are recorded on the pull with a fingerprint of their own:
| Input | What it decides | How it is committed |
|---|---|---|
| The slot's odds table | which rarity tier the first roll lands on | hashed in the exact stored order |
| The rarity tier's candidate set | which slab the second roll selects | versioned, hashed in the exact stored order |
| The rarity tier's target value | how the candidates are weighted | recorded on the pull |
| Any slabs excluded: earlier picks in the pack, other copies of those cards, and slabs lost on a retry | the final candidate list | recorded on the pull |
Order matters because the rolls walk these lists from top to bottom. A fingerprint that ignored order would stay the same if a list were shuffled, so our fingerprints cover the order too.
If a pack cannot be completed
If a slot lands on a rarity tier that holds no slab we can give you, the purchase does not complete and you are not charged. We never substitute a cheaper card. Every such void is written to a public ledger with its seed revealed, so anyone can confirm the roll really did land where we say it did, and can see how often voids happen for each pack:
GET /api/packs/voids?template_id={id}&days=30
Without the seed, a pack we chose not to sell would look the same as a pack we could not fill. The revealed seed shows which one it was.
Getting the data
Anyone can fetch it, with no account and no authentication:
GET /api/packs/verify/{packId}
The response contains:
| Field | What it is |
|---|---|
commitment.server_seed_hash | The fingerprint we committed to before the roll, as recorded on every pull |
commitment.issued_server_seed_hash | The fingerprint as it was issued on the commitment record. It must equal server_seed_hash |
commitment.issued_before_purchase_request | true means you held this pack's fingerprint before your seed was sent. false appears only on packs bought before we pre-issued a fingerprint per pack (an additional pack in a multi-pack purchase, committed just before its roll). null means the pack predates commitments |
commitment.client_seed | Your seed, mixed into every message |
commitment.server_seed | The seed itself, null until the pack is opened |
commitment.commitment_id | The commitment the pack was rolled under |
commitment.issued_at | When the fingerprint was issued to the buyer |
commitment.purchased_at | When the pack was paid for, always after issued_at |
pulls[] | One entry per card slot: its nonce, slot_index, the recorded roll_tier and roll_card, the rarity tier it landed on, the tier_table_hash, and excluded_inventory_ids (the slabs removed from the candidate set before the pick) |
pulls[].bucket_commitment | A sealed fingerprint of the candidate set the slot draws from. It is shown before the pack is opened without saying which set it is, and can be checked once the seed is revealed |
buckets | For each slot, the candidate set the card was drawn from, with a content_hash, its members and their values |
how_to_verify | The steps below, returned alongside the data |
Checking it yourself
- Check the commitment. Compute
SHA-256(server_seed)and confirm it equals theserver_seed_hashpublished before the rip, which is the fingerprint you saw before buying. - Check the fingerprint on record.
issued_server_seed_hash, the fingerprint as it was issued, must equal theserver_seed_hashrecorded on the pull, and both must equalSHA-256(server_seed). - Check the timing.
issued_atmust precedepurchased_at, andissued_before_purchase_requestmust betrue, meaning this pack's fingerprint was in your hands before your seed was sent to us. Since we began pre-issuing a fingerprint per pack, that holds for every pack in a multi-pack purchase, so check each pack rather than taking one pack's word for the others. (On a pack bought before that change the field readsfalse; for those, check the fingerprint against the revealed seed rather than against your seed's timing.) - Rebuild each slot's digest. For each pull, compute
HMAC-SHA256(server_seed, message)where the message is exactly{client_seed}:{nonce}:{slot_index}. - Read the two rolls. Take hex characters 0 to 12 of that digest as
roll_tierand characters 13 to 25 asroll_card, each parsed as an integer and divided by 2^52. They should match the recorded values. - Find the rarity tier. Walk the slot's published odds table with
roll_tierto get the rarity tier it landed on. - Check the candidate set was fixed in advance. Compute
HMAC-SHA256(server_seed, message)where the message is exactlybucket/{client_seed}:{nonce}:{slot_index}:{bucket_content_hash}. It must equal the slot'sbucket_commitment, the value this endpoint showed before the pack was opened. Before the rip that value tells nobody which rarity tier the slot landed on; after it, it proves we could not have swapped the candidate set. - Build the candidate list. Take the bucket's members in the order given and remove every id in the pull's
excluded_inventory_idsbefore weighting. Those are cards already awarded to an earlier slot of the same pack, any other copy of those cards at the same grade (a pack never holds two of the same card), and any slab another buyer claimed a moment earlier. - Re-solve the weighting. Derive
alphayourself from the candidates' values and the rarity tier's target value. You do not have to trust thealphawe recorded. - Find the card. Weight each candidate by
value^(-alpha), normalise, and select withroll_card. That is your slab.
If every step reproduces, the outcome was fixed before the rip and drawn from the candidate set we published.
Why the numbers are built this way
Both of these choices remove a source of bias.
13 hex characters instead of a modulus
Thirteen hex characters is 52 bits, exactly the mantissa of a double, so every drawn value is represented exactly. Dividing by 2^52 instead of taking a remainder avoids modulo bias, where some outcomes come up slightly more often than others only because the range does not divide evenly.
One digest, two slices
The rarity tier roll and the card roll are independent slices of a single HMAC. That keeps verification to one hash per slot instead of two, and the two rolls are still uncorrelated.
What this does and does not prove
Verification proves that the outcome of your pack was fixed before it was opened, that we committed to our half of it before you bought and before we knew your seed, that the card came from the published candidate set, and that the roll matches the published chances.
One caveat is yours to manage. If you type a seed of your own and reuse it on a later purchase, we have seen it before that purchase's fingerprints were made. Let the browser draw a fresh seed (it does that for you after every purchase) or type a new one each time, and the ordering holds.
It does not prove that the chances themselves are generous, or that a card's displayed market value is correct. Those are covered in how we set the chances and the vault.