GatchaGremlins

1. Fees in. $GREM creator fees accrue to the crew's wallet on pump.fun (bonding curve, then PumpSwap after graduation). The keeper collects them once at least 0.01 SOL is waiting.
2. Split. 75% is swapped to USDC through Jupiter (once 0.05 SOL has piled up) and becomes pack money. 25% is set aside for buybacks and burns.
3. The lever. Each round starts with a random gremlin at the lever: sha256(blockhash + ":lever:" + round) mod 3, with the latest finalized Solana blockhash and round = the pack number, published with the round. That gremlin picks the machine it wants.
4. The rip. The crew saves up, and the moment the USDC covers that machine the keeper buys one real pack from the gacha. The gacha's random roll picks the card and sends it to the crew's wallet as an NFT.
5. The draw. A snapshot of $GREM holders plus a future blockhash picks one winner.
6. Delivery. The card NFT is sent to the winner, with the draw proof written in the transaction memo.
7. Next round. As soon as the card is delivered, a new round starts: new lever draw, new machine.
8. Publication. Every step, every transaction and the full holder list of each draw are published on this page.

Packs come from Collector Crypt's gacha machines: real graded cards (PSA and others), vaulted, minted as MPL Core NFTs. The crew only plays the machines listed in Slots.

For each pack the gacha prepares a transaction that pays the pack price in USDC. Before signing, the keeper checks it line by line and refuses anything else: exactly one USDC transfer, of exactly the machine's price, from the crew's wallet to the gacha's treasury, plus the pack memo and compute budget. Nothing else can be signed.

Once paid, the gacha rolls the card (its own verifiable random roll) and sends the NFT to the crew. The keeper reads the asset on chain and only goes on once the card really belongs to the crew.

Each card in the Album shows three receipts: the purchase tx (USDC paid), the opening tx (the gacha hands the card over) and the delivery tx (the card sent to the winner).

1. Snapshot. At a finalized slot, the keeper lists every $GREM token account (Token-2022) and sums balances per owner.
2. Who is out. Owners holding less than 50,000 $GREM; program-owned addresses (bonding curve, AMM pools: anything that is not a regular wallet key); the crew's wallet; the incinerator.
3. Weight. weight = floor(sqrt(balance in whole tokens)). A whale counts more, but not a hundred times more.
4. Root. Holders sorted by address, one address:weight line each, joined with \n: root = sha256(lines).
5. Seed. The keeper waits 32 slots after the snapshot and takes the blockhash of the first block produced after that. Nobody knows it at snapshot time, the crew included.
6. Ticket. ticket = sha256(blockhash + ":" + root + ":" + label) mod total_weight, read as a 256-bit integer, with label = pack-<n>.
7. Winner. Walk the sorted list adding weights; the first holder whose running total passes the ticket wins.

The delivery memo reads gg:<pack>:<seed slot>:<first 16 hex of the root>, so the proof is on chain next to the transfer.

Press Verify the draw on any card: your browser downloads the holder list and recomputes the root, the ticket and the winner. Or run it anywhere with Node 18+:

import { createHash } from "node:crypto";
const sha = (s) => createHash("sha256").update(s).digest("hex");
const N = 1;                       // pack number
const BLOCKHASH = "...";           // "Seed" line of the card
const snap = await (await fetch(`https://gatchagremlins.fun/api/snapshot?n=${N}`)).json();
const rows = snap.rows.sort((a, b) => (a.address < b.address ? -1 : a.address > b.address ? 1 : 0));
const root = sha(rows.map((r) => `${r.address}:${r.weight}`).join("\n"));
const total = rows.reduce((s, r) => s + r.weight, 0);
const ticket = BigInt("0x" + sha(`${BLOCKHASH}:${root}:pack-${N}`)) % BigInt(total);
let acc = 0n;
const winner = rows.find((r) => (acc += BigInt(r.weight)) > ticket).address;
console.log({ root, ticket, winner });

Compare root with the card's Snapshot line and winner with "Went to".

Chance picks which gremlin pulls the lever each round, from a public blockhash.

The gremlins only pick which machine to play (each has its own taste: Sprocket likes sports, Mildew the cheapest slot, Glint the priciest odds) and what they say. They hold no keys and move no money.

The code decides how much is spent, checks every transaction before signing, runs the draw and sends the card. The rules are fixed in the keeper and shown in Fine print.

The gacha decides which card comes out of a pack, with its own random roll.

At launch: fee collection, USDC conversion, a pack as soon as the fees cover the chosen machine, the holder draw, delivery with on-chain proof, and full publication on this page.

Shortly after launch: buybacks and burns from the 25% share (counted on the page until then); smash, where cards insured at $250 or more are sold back to the machine and every dollar buys and burns $GREM (until then they stay in the crew's wallet); the nest and nest night.