> ## Documentation Index
> Fetch the complete documentation index at: https://docs.darkmatter.rdytobash.tech/llms.txt
> Use this file to discover all available pages before exploring further.

# Entropy Games

> Entropy Games — Dark Matter Protocol on Robinhood Chain.

# Dice Originals — Mines · Limbo · Plinko · Keno

The four Entropy dice games share one money model with Crash: bets are crash chips
(shared `crash_chips` ledger, ETH 18dp / USDG 6dp), debited at bet, credited at
settle. Every bet draws a **fresh server seed**; `keccak(seed)` is stored alongside
the result so any settled row can be audited — recompute the outcome from the stored
seed, and the hash proves the row wasn't rewritten.

## Shared economics

| Property | Value |
| - | - |
| Currencies | ETH (18dp) + USDG (6dp) |
| ETH bet bounds | 0.00005 – 0.05 ETH |
| USDG bet bounds | 0.01 – 500 USDG |
| RTP | **≈ 99%** by construction for all four games |
| House edge | 1% |
| Fairness | per-bet server seed; `keccak(seed)` persisted with the result |

```
ENTROPY_MIN_BET_ETH / ENTROPY_MAX_BET_ETH / ENTROPY_MIN_BET_USDG / ENTROPY_MAX_BET_USDG
```

Fee routing mirrors the crash side: realized edge accrues in the bank and flows to
the same sinks (VIP pots + LP treasury) through `routeEdge()`.

## Mines — single pick, M mines on a 5×5 grid

```
25 tiles, M mines (1–24). One pick.
P(win) = (25 − M) / 25
payout multiplier = 0.99 × 25 / (25 − M)     // 1% edge, exact
```

| Mines | Win chance | Multiplier |
| - | - | - |
| 3 | 88.0% | 1.125× |
| 5 | 80.0% | 1.238× |
| 10 | 60.0% | 1.650× |
| 24 | 4.0% | 24.750× |

Mine positions are drawn with `sampleDistinct` (Fisher–Yates partial shuffle over the
seed stream) — uniformly distinct positions, verifiable from the stored seed.

## Limbo — target the multiplier

```
u = uniform(0,1) from the seed
result = 0.99 / (1 − u), clamped to [1.00, 1_000_000]
win ⇔ result ≥ target
```

Same structure as Crash's formula with a 1% edge and a 1,000,000× ceiling:

| Target | Win chance | Payout |
| - | - | - |
| 2× | 49.5% | 2.00× |
| 10× | 9.9% | 10.00× |
| 100× | 0.99% | 100.00× |
| 10,000× | 0.0099% | 10,000.00× |

## Plinko — 16-row binomial drop

```
16 rows of pegs; ball direction per row = fair bit from the seed stream.
Bucket = Binomial(16, ½) — center-heavy distribution.
Payouts per risk table (low / medium / high); each row's EV = 0.99.
```

The multiplier tables are shipped in the API config (`GET /api/entropy` →
`plinkoTables`) so clients render exactly what the engine pays. Extreme buckets
(edges of the 17-bucket row) carry the huge multipliers (up to 170×/1000× on
high risk); the center buckets pay fractions of a stake.

## Keno — pick up to 10 of 40

```
40 numbers, 10 drawn. Player picks k numbers (1–10).
Hits h ~ Hypergeometric(40, 10, k); paytable per k, EV = 0.99.
```

Top multipliers are hit at extreme tails — 10/10 hits pays the table maximum
(\~238× at pick-10 in the current table). The full paytables ship in the API config.

## Verification walkthrough

For any settled bet:

1. Fetch the row (API exposes `seedHash`, `seed` after settle, plus full result meta).
2. Check `keccak(seed) === seedHash`.
3. Re-run the engine function on `(seed, bet params)` — pure, deterministic, and the
   same code path the settle used.
4. Confirm the payout matches the derived outcome × the paytable.

The same popup used for Crash (shared vfair-verify component) runs this flow for all
four games — one aligned theme, no white-page verification.

Next: [Lootboxes](lootbox.md).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.