# The Jackpot

The jackpot is the headline prize. It is real, it is on chain, and it already pays.

## How it grows

**10% of every race pot** feeds a single progressive pool. It carries from race to race and grows the longer it goes without popping. The bigger it gets, the more it pulls.

## How it pays

At a race finish, a roll decides if the jackpot **pops**. When it pops:

- The **entire pool** goes to **one winner**. Not split. Not shared.
- The winner is drawn from the **winning horse's [top 40 holders](/gluebook/payouts-and-the-split)**, weighted by their holdings under the same 3% cap. More you hold, better your odds. A whale's odds are still capped at 3%.
- The pool resets to zero and starts building again.

So your odds scale with conviction, not with whale size.

## It already happened

The first jackpot popped and paid **12.18 SOL** to a single holder of the winning horse, in one transaction, verifiable on chain:

[View the jackpot payout on Solscan](https://solscan.io/tx/aAUd84B2SwKLBcnPzRbjrVckzbZS2ZnbJJbBRv3r5hMhRQ9R7UgADqk4tPRxkZcR3fYHvvJnFiRr6C7gHvnzhcg)

## How the draw stays honest

The winner is computed **deterministically** from the race result and the frozen holder snapshot we publish. Same inputs always reproduce the same winner, so anyone can audit the draw after the fact. It is not a hidden roll behind a curtain.

## The math, for the curious

Three formulas run the whole thing, and all of it is reproducible from the [proof page](/gluebook/proofs-and-transparency).

**1. It accrues.** Every race, the jackpot slice of the pot is added to the pool, and the pool carries over until it pops.

```
pool_next = pool_now + (jackpot_share x race_pot)      // jackpot_share = 10%
```

**2. It gets more likely the longer it waits.** This is the "progressive" part. At each race finish a chance decides if it pops. That chance starts low and rises with every race that passes without a hit (the drought), capped at 100%. A minimum pool floor stops it ever popping a tiny pot.

```
pop_chance = min( 100% , base + rise x races_since_last_pop )
it pops when:   pool >= floor   AND   roll < pop_chance
```

A fat pool that has not paid in a while becomes very likely to pop. When it finally does, races_since_last_pop resets to 0 and the chance falls back down. The base, the rise and the floor are tunable parameters we announce.

**3. The winner is a weighted draw.** Among the winning horse's top 40 holders, your odds are your capped weight over the sum of all capped weights.

```
P(you win) = your_weight / sum(all_weights)       // weight = min(your share, 3%)
```

The 3% cap is the whole anti whale trick. Hold 8% and hold 3% and your odds are identical, because both clamp to 3%. Holding more than 3% buys you no extra edge in the draw.

**4. It is deterministic, so it is auditable.** The draw does not use a hidden number. We derive a value in [0, 1) deterministically from the race result (the race id and the winning coin's mint), lay the eligible holders on that line in a fixed order with each holder's slice sized by their weight, and the winner is whoever's slice the value lands in.

```
roll   = hash(race_id, winning_mint)  ->  a fixed value in [0, 1)
winner = the holder whose weighted slice contains roll
```

Same race result plus the same published snapshot always reproduce the same winner. Anyone can recompute it after the fact. Nothing behind a curtain.