Docs

Technical reference for the rippers program, the keeper and the gacha integration. For the plain-language version, see How it works.

Architecture

• rippers program holds every round's USDC in a PDA vault, records tickets, runs the draw and releases only the pack price.
• Swap: tickets are paid in $RIPPERS; buy_tickets CPIs into the configured swap program (Jupiter on mainnet) with the vault as the destination and measures the result.
• Keeper: a bot that calls the permissionless steps, buys the pack from Collector Crypt with the released USDC and confirms the card reached the winner.
• Collector Crypt: sells the pack, rolls the card with its own VRF, and sends it to the winner via altPlayerAddress.

Program

The config account is the program's settings: admin, keeper, mints, treasury, allowed swap program and the ticket split. Open it in the explorer to check every number the site shows. Program and upgrade authority both start with Rip. On mainnet the official $RIPPERS mint is set at launch; until then the config holds a placeholder and every $RIPPERS feature stays closed.

Round lifecycle

Accounts

Instructions

Parameters

Verify a draw

The draw transaction emits the slot hash it read. The seed and index are pure functions of public data:

seed  = keccak256("rippers-draw" || slot_hash || round_address)
index = u64_le(seed[0..8]) mod total_weight

Recompute it from the round account:

import { Connection, PublicKey } from "@solana/web3.js";
import { decodeRound } from "./rippers.mjs";

const cx = new Connection("https://api.mainnet-beta.solana.com");
const round = new PublicKey(process.argv[2]);
const r = decodeRound((await cx.getAccountInfo(round)).data);
const index = r.seed.readBigUInt64LE(0) % r.totalWeight;
console.log({ drawSlot: r.drawSlot, index, onChain: r.winningIndex, ok: index === r.winningIndex });

Then check the slot hash in the Drawn event of the draw transaction hashes to the stored seed, and that the draw slot is after the slot the round locked in.

Verify a holder drop

1. Download snapshots/round-<id>.json published by the keeper.
2. Its SHA-256 must equal the round's snapshot_hash.
3. Rebuild the tree: leaf = keccak256(0x00 || holder || start u64 LE || weight u64 LE), node = keccak256(0x01 || min(a,b) || max(a,b)). The root must equal root.
4. The winner's row must contain winning_index in [start, start + weight).

Keeper

Polls every few seconds and moves each round one step:

• locked and past the draw slot → draw (or redraw if expired)
• drawn → finds the winning entry or proof → settle_*
• won → release_for_purchase
• purchasing → buy the pack from Collector Crypt for the winner → confirm_pull
• holder drop holds a pack's worth of fees → fresh snapshot → lock_drop (one random winner per pack)
• finished round with leftover USDC → sweep into the open round of the same kind, so the next drop starts right away
• always keeps one open round of each kind

Every step except release, lock and confirm is permissionless, so anyone can run a keeper if ours stops.

Gacha integration

A paid pack must be opened within 2 hours or Collector Crypt refunds it, so the keeper opens immediately after paying.

Admin powers

The admin can change the keeper, treasury, swap program, ticket price, split and draw delay; cancel a round before its draw; and sweep leftovers between rounds.

The admin cannot withdraw a vault, choose a winner, change a drawn result, or move funds anywhere except another round's vault.

Errors