Docs

How the pot buys a card

Every coin launched on Slabpad sends 100% of its creator fees into one pot. The pot buys graded trading cards one after another, never on a timer: the moment it holds the price of the card the devs voted for, that card is bought, a verifiable random number picks one ticket, and the dev who owns that ticket takes the slab. Then the next card.

01Epochs, not rounds

An epoch is the time between two purchases. Exactly one epoch is open at any moment. There is no clock: an epoch ends when its card is bought, and the next one opens in the same instruction.

Epoch state	What is true	What anyone can do
Open	Fees are coming in. Every collect adds weight and a ticket for the coin's dev. Devs vote. The card can be bought once the pot holds its price and the epoch reached its minimum age (so every draw has time to gather devs).	Collect fees into the pot, vote (devs with weight), launch coins, fill the leading lot once the pot holds its price.
Filled	The card is in the epoch's vault; the pot paid exactly its price. Tickets are frozen. The next epoch is already open.	Request the draw.
Drawing	The program committed its own randomness account to the oracle.	Settle the draw with the winning ticket once the oracle revealed.
Settled	The winner is written into the epoch.	The winner claims the card. It never expires.
Claimed	The slab is in the winner's wallet. The physical card is redeemed at Collector Crypt.	Close the epoch's tickets and weight accounts to return their rent.

02Weight: the square root of what you brought

Every collect moves a coin's waiting creator fees into the pot and credits them to the coin's dev in the open epoch. The dev's weight is isqrt(contribution in lamports). The growth of his weight becomes one ticket: a range of numbers [start, end) on the epoch's ribbon. Ranges are contiguous; the ribbon's length is the sum of all weights.

100× the fees = 10× the chance. A dev whose coins brought 0.1 SOL (weight 10,000) against one that brought 100 SOL (weight 316,227) still holds 3% of the ribbon instead of 0.1%.
Volume, not launches. A coin nobody trades brings nothing and gives no weight. All of a dev's coins add up before the square root, so splitting volume over coins of one wallet gains nothing.
Weight resets after every card. Contributions start at zero in each new epoch; the pot's remainder rolls over.
A collect below the minimum is refused (the fees wait), which keeps tickets from dust.

03The vote

Up to 8 lots are on the mat. Each is a real tokenized slab (a Collector Crypt programmable NFT) with a fixed price, grade, cert number, set and year. A new lot goes live only after a public notice of 24 h, a delisting takes effect only after the same notice (after it, the lot can no longer be voted for, bought or lead), and nothing about a listed lot can be edited.

A dev votes with his whole current weight. A re-vote moves all of it. When new fees raise his weight, the tally of the lot he voted for follows (the keeper passes that lot with every collect). The leader is the lot with the most weight in the open epoch; a tie goes to the lower lot number; with no votes at all, the lowest live lot leads. Tallies restart every epoch.

04The fill

As soon as the pot holds the leader's price, the epoch is at least 1 h old and it has tickets, anyone who holds that exact slab may call fill_card: in one instruction the slab moves into the epoch's vault (a Token Metadata transfer, as Collector Crypt slabs are programmable NFTs) and the pot pays exactly the price to whoever delivered it. In practice the keeper operator buys the slab on the market with its own money and is repaid by the fill, or the seller fills directly. If nobody delivers, the pot keeps growing; nothing is lost.

The program checks the mint, one-of-one supply, zero decimals, the token standard and that the vault received exactly one token. A fake card, a copy or a partial list of the live lots is refused.

05The draw

After a fill anyone requests the draw: the program commits its own Switchboard On-Demand randomness account (its PDA is the only authority, so nobody can bring or re-commit a randomness account). Once the oracle reveals, settle_draw computes r = u64_le(value[0..8]) mod tickets_total; the ticket with start ≤ r < end wins, and its dev is written as the winner. Draws run in epoch order. If the oracle stays silent past the draw timeout, the draw can be requested again with a fresh seed.

06Launching a coin

The launch creates the coin on pump.fun with the coin's own fee address (a program address with no key) as its creator, plus your optional first buy, in one transaction. The launch fee is 2.5% of the first buy actually spent, paid to the pad's treasury. Your first buy pays pump's normal trading fee; the creator share of it goes to the pot like every later trade.

07A worked example

The pot holds 2.00 SOL after the last card. The leading lot costs 3.60 SOL. Three devs trade their coins this epoch:

Dev	Fees his coins brought	Weight = isqrt(lamports)	Share of the ribbon
Ada	1.00 SOL	31,622	58.5%
Bo	0.40 SOL	20,000	37.0%
Cy	0.006 SOL	2,449	4.5%
Total	1.406 SOL	54,071	100%

Pot = 2.00 + 1.406 = 3.406 SOL: short of 3.60 by 0.194 SOL. The next 0.194 SOL of fees tops it up (and adds weight to whoever's coins bring it); the keeper delivers the slab in the next seconds, the pot pays 3.60 SOL, the new epoch opens with the remainder. The oracle reveals a value whose first 8 bytes read as, say, 18,446,744,073,709,000,000; mod 54,071 = r. The ticket holding r wins. With linear weight Cy would have 0.4%; with the square root he holds 4.5%.

08The transactions

Button on the site	Instruction	Signer	Effect
Consign coin	`launch`	you	pump `create_v2` with the fee address as creator + first buy; launch fee to the treasury. Must be alone in its transaction.
Move in (coin row, Mine)	`collect`	anyone	pump `collect_creator_fee` into the coin's fee address, everything above rent into the pot; weight + ticket for the dev.
Vote	`vote`	a dev with weight	his whole weight onto the lot; a re-vote moves it.
Deliver the slab	`fill_card`	whoever holds the leader's slab	slab into the vault, price out of the pot, next epoch opens.
Request / settle the draw	`request_draw`, `settle_draw`	anyone	commit the randomness, then pick the winning ticket.
Claim (draw, Mine)	`claim_card`	the winner	the slab from the vault to the winner.
Claim everything (Mine)	`claim_card`, `collect`, `close_ticket`, `close_dev_epoch`	you	cards you won, fees of your coins, rent of finished tickets you paid for.

09Parameters

Parameter	Value now	Mainnet default · bounds	What it does

Reading the live config.

10Program

Program id · (explorer). Anchor 0.31.

Account	Seeds	Holds
Config	`["config"]`	admin, treasury, params, open epoch, next draw, pot booked, totals, randomness account
Pot	`["pot"]`	system account holding the pot
Fees	`["fees", mint]`	the coin's pump creator (no key)
Coin	`["coin", mint]`	dev, launch time, fees total, collects, name, ticker
Epoch	`["epoch", id]`	state, tickets total, devs, the card (mint, price, title, grade), the draw (randomness, seed slot, value, r, winner)
DevEpoch	`["devep", epoch, dev]`	contribution, weight, tickets, vote
Ticket	`["ticket", epoch, seq]`	dev, coin, range [start, end)
Candidate	`["cand", idx]`	the lot: slab mint, price, grade, cert, title, set, year, image, notice times, tally
Card vault	`["cardvault", epoch]`	owns the epoch's slab until the claim
VRF authority	`["vrf"]`	the only authority of the pad's randomness account

11Errors

Rendered from the program's IDL: what the site shows when the program refuses a transaction.

Code	Name	Message

12Verify on chain

Pot: the balance of ["pot"] equals its rent floor plus pot_booked plus any unbooked treasury cut. pot_booked = credited_total + donations_total - paid_total.
Every epoch: tickets are contiguous from 0, the last end equals tickets_total, which equals the sum of the devs' weights; each weight equals isqrt(contribution).
Every draw: read the epoch's randomness account, take the first 8 bytes of the revealed value little-endian, mod tickets_total: that is the epoch's r, and the winner's ticket holds it.
Every card: the vault of the epoch held exactly one token between the fill and the claim; the claim sent it to the winner and nowhere else.

13Admin powers

The admin can	The admin cannot
List a lot (with its price, within the price bounds) after a public notice; delist a live lot after the same notice.	Edit a listed lot, list without notice, or fill a card that is not leading.
Change parameters within their bounds (they apply to future coins, listings and epochs).	Move the pot, a weight, a vote, a ticket or a card. Pick a winner.
Pause new launches; set the treasury (launch fees); set a treasury cut of creator fees (default 0, at most 10%, copied into each coin at launch).	Change the cut of a coin that already launched. Stop collects, fills, draws or claims.
Create the pad's randomness account once; replace it only while the waiting draw timed out unrevealed.	Re-roll a revealed draw.

14Risks

Listed prices. The admin sets each lot's price. An overpriced lot would pay a seller too much. Mitigated by the price cap, the public notice, no edits, and the devs' vote.
Someone must deliver the card. The pot pays whoever delivers the exact slab. If nobody does, the pot keeps growing.
Oracle. The draw trusts Switchboard On-Demand's oracle to reveal an unbiased value. The pad commits after the tickets froze, and a revealed value can only be settled.
Sybils. A whale that splits volume over k wallets gets up to sqrt(k) times the weight, at best linear weight, and pays real fees on every coin.
Wash trading your own coin buys weight only by paying pump's fees; the creator share of them goes into the pot for everyone.
Redemption. The physical card is held and shipped by Collector Crypt; that is outside this program.

15FAQ

Does the team keep any cards?

No. A card leaves the vault only to the drawn winner, who must be a dev with a ticket in that epoch.

Why can the pot hold the price and still wait?

Every epoch has a minimum age before its card can be bought. Without it, the first dev to bring fees after a purchase could fill the next card alone and win it with certainty. During the wait, fees keep adding tickets for everyone.

What if the leading lot changes right before the fill?

The fill must name the lot that leads at that moment, with every live lot passed so the program can check. A fill for any other lot is refused.

Do my old tickets count for the next card?

No. Weight is per epoch. Fees collected after a fill count for the new epoch.

Can I increase my chance?

Only by bringing more fees, and the square root damps it: four times the fees for twice the weight.

Who pays the rent of tickets?

Whoever runs the collect (usually the keeper). It comes back to that payer when the tickets are closed after the draw.