Table rules

The UI renders this; the contract enforces it.

The game

The rules are the standard Yahtzee rules: 2–6 players per table, 13 rounds. Every seat plays every round at its own pace — there is no shared turn order, so you are never waiting on someone else's dice. Each round you get up to three rolls: after each roll you click the dice you want to keep (nothing marked means reroll everything) and either roll again or score — you may score with the category of your choice after any roll, not only the third, which is also the one lever you have over how many transactions your turn costs. Upper-section bonus: +35 when your six upper categories total 63+. Extra fives of a kind: +100 each while your Five of a Kind box holds 50, with the standard joker placement rules: a further five of a kind must go in its matching upper box if that is open; if it is filled, any open lower box scores its full value (Full House 25, Small Straight 30, Large Straight 40); if only upper boxes remain, one of those at face value. Under those rules a five of a kind cannot be burned for 0, and the +100 bonus is paid only while the box holds 50, not 0.

Stakes and payout

Four table tiers: 100 / 1,000 / 10,000 / 100,000 NIGHT per seat. Your stake goes into the table pot when you take a seat.
The winner takes 99% of the pot. 1% (rounded down; the rounding remainder stays with the winner) goes to the table operator's rake address, which is fixed at table creation and publicly visible on-chain.
Ties never split the pot. Highest total wins; if tied, a finished card beats an unfinished one; if still tied, the lower seat number — the earlier to join — wins. In a full game every finisher completes in the same round, so between two finished cards the seat number decides. Deterministic, and enforced by the contract: the table page says which rule decided a tied game.

Fees, and two warnings your wallet will thank you for

Every move you make is a transaction paid in DUST. DUST regenerates from NIGHT you hold and have designated — NIGHT locked in a pot generates nothing.

Moves cost DUST, not NIGHT

Every roll and score is a transaction paid in DUST. DUST builds up slowly from NIGHT you hold and have designated, and runs down just as slowly once that NIGHT moves — both over days, not minutes — so staking for one game barely changes it. What matters is the DUST your wallet holds now: it is shown beside your NIGHT above, and a fast table needs it for one transaction per turn, an on-chain table for up to four.

Your winnings are already in your wallet

Nothing to claim — the settle transaction paid your wallet directly.

Timeouts — a table can never trap your stake

Every round has a deadline. Miss it while you still owe the round and anyone can eliminate your seat — permissionlessly, for no reward to them. The penalty is a fraction of your stake, r/13 for round r (round 1 costs a thirteenth; round 13 costs everything): the more of the game you have played, the more your leaving costs the players who stayed. The forfeited share stays in the pot for the winner; the rest is yours, redeemable once the table finishes.
If the table itself stalls (the operator stops resolving rolls), anyone can trigger an abort after the table deadline: every seated player gets their full stake back (minus any penalty already applied to an eliminated seat), and the rake gets nothing.
If every seat is eliminated before the game ends, the table becomes abandoned — a pending, not payable, state. One more permissionless call (abortTable) then waives every penalty, so everyone still redeems their full stake; only the 1% rake is still paid, since the operator did its work regardless of how the players fared.

Fairness — verify any game yourself

Dice come from a commit–reveal scheme: the operator commits to a secret seed before the table opens; your per-round entropy is forced from a key you commit to when you join; every roll mixes in the digest of the round as it stood when the round opened. Neither you, other players, nor the operator can steer a single die — the operator's only power is to stop resolving (which ends in the refund above, never in a changed outcome). When a game ends, the seed becomes public: the Verify this game panel re-derives every roll of the game in your browser, and you can do the same offline from the chain log alone.

The operator does not play at tables it operates — with interactive holds, a seed-knowing player could otherwise compute every hold outcome before choosing.

How long does a table take, and what does a turn cost?

A fast table has been measured with people at it: five complete two-seat games ran 30 to 49 minutes, median 40 — about three minutes a round. Under a minute of each round is the chain (one settlement per player, one close by the operator, and the wait for a finalized block); the rest is you and your opponents rolling, choosing what to hold and where to score, and your wallets proving every move. A slow machine proving on device makes a round longer for everyone, because the round ends when its slowest player has played. Seats play in parallel, so a fuller table adds a little, not a multiple.

An on-chain table puts every roll on the chain as its own transaction — roughly 19 seconds each. A full three-roll turn is 4 transactions you sign and 3 the operator submits to resolve your rolls, one after the other; scoring right after your first roll is 2 + 1. Stopping early is the biggest lever you have over how long such a table takes. Nobody has played one for real yet, so that column is an estimate and says so.

Seats	⚡ Fast table	⛓ On-chain table	Source
2	39 min	46 min	fast: measured over five real games (30–49 min); on-chain: estimated
4	43 min	51 min	not yet measured — assumed a little slower than two seats
6	47 min	56 min	not yet measured — assumed a little slower than two seats

Audit it yourself

The contracts are public and Apache-2.0 licensed: github.com/chrispalaskas/dust-dice-contract at tag v0.5.0 — the Compact source of the table and lobby circuits, their TypeScript mirrors, and the independent verifier this site's Verify page runs.

A link to source proves nothing on its own, so here is the part that does. Every table is pinned to one compilation: the chain checks each call against that build's verifier keys, and a hash of those keys is the build fingerprint. The operator is running reading…, asked of it live. Compilation is reproducible — clone the tag, run npm run compact -w contract, and hash the verifier keys the same way (service/src/build-id.ts). If your fingerprint matches, the circuits deciding your dice and holding your stake are the ones you just read.

If it does NOT match, something is running that this source does not describe — which is worth knowing, and is the reason the number is published at all.

What this site is not

Dice and scorecards are public — this is an open-information game and we make no privacy claims about play. This deployment is a technology demo on a test network; the NIGHT staked here is test value. See the legal note in the project README.