Collector Crypt for builders: marketplace API, gacha VRF, and on-chain programs

Collector Crypt reached $1B in trading volume by building something most crypto projects never manage: a consumer product that non-crypto users actually use. Physical trading cards vaulted in Delaware, tokenised as NFTs on Solana, opened via a gacha machine with provably fair randomness, instantly buyable back for 85% of expected value. The developer layer behind it is documented at docs.collectorcrypt.com and covers three distinct API surfaces plus two on-chain programs. API partnerships are starting to land. Here is what exists today.

The three API surfaces

Collector Crypt separates its developer surface into three areas that map to the three things the platform does: trade cards, open packs, and move physical cards in and out of the vault.

• Marketplace API — programmatic access to listings, offers, and trade history for tokenised cards. Backed by the on-chain marketplace program.
• Gacha API — pack purchase, opening, and buyback endpoints. The randomness for each open is anchored on-chain via VRF before the result is revealed.
• Shipping / Vault API — deposit and withdrawal of physical cards. When a user redeems an NFT, this API triggers the logistics flow that ships the physical card from the Delaware vault.

A development environment for the gacha machine is available at dev-gacha.collectorcrypt.com — useful for integration testing without spending real USDC on pack opens.

The marketplace program

The marketplace is a non-custodial Solana program at address CcmRKTuZCGJBWQwMHvDYApBRvSZNHqGJXkznqpDTSQUr. It handles pNFTs, cNFTs, standard NFTs, and MPL Core assets, each with their own instruction variants. The key architectural decision is delegation, not escrow: sellers never give up custody. The NFT stays in the seller's wallet; the program holds a transfer authority delegation via a listing PDA. When a buyer executes a purchase, the program transfers the NFT from seller to buyer and USDC minus fees from buyer to seller atomically.

// Account structure written by the marketplace program
// on each listing instruction
interface ListingAccount {
  seller: PublicKey;      // original owner, retains custody
  nftMint: PublicKey;     // the card being listed
  price: BN;              // in USDC (6 decimals)
  listedAt: i64;          // unix timestamp
  listingPda: PublicKey;  // holds delegation authority
}

// Fee: 0–2% configurable, deducted from seller proceeds
// Program ID: CcmRKTuZCGJBWQwMHvDYApBRvSZNHqGJXkznqpDTSQUr

The four core instruction families are list_*, buy_*, accept_offer_for_*, and escrow management (deposit_to_user_escrow / withdraw). Buyers can back multiple outstanding offers simultaneously from a single escrow USDC balance — useful for building offer-aggregation tools or automated bidding strategies.

// Key instructions per NFT type
// pNFTs:    list_pnft, buy_pnft, accept_offer_for_pnft
// cNFTs:    list_cnft, buy_cnft, accept_offer_for_cnft
// NFTs:     list_nft,  buy_nft,  accept_offer_for_nft
// MPL Core: list_core, buy_core, accept_offer_for_core

// Escrow — backs multiple offers from one balance
// deposit_to_user_escrow(amount: u64)
// withdraw_from_user_escrow(amount: u64)

Gacha VRF: provably fair pack opens

Every pack open on Collector Crypt uses RFC 9381 ECVRF-EDWARDS25519-SHA512-TAI, anchored by a standalone Solana program at ccvrfu3fSpbnPLiUqdWAt85Zn9nq96ekwGTbHqGtdgQ. The flow has two steps.

Step 1 — Tier roll. The VRF input is bound to your wallet's signature. The operator cannot know or influence the output until after you have signed. The VRF output deterministically selects your rarity tier: Common, Uncommon, Rare, or Epic.

Step 2 — Card selection. The same VRF output seeds a Feistel permutation that walks a frozen candidate pool for your tier, skipping already-claimed cards in a reproducible order. Your specific card is selected without the operator being able to steer it.

// What gets written to the chain for each pack open:
// 1. cc-vrf program freezes VRF public key on deploy (one-way)
// 2. For each pack: proof hash committed on-chain before reveal
// 3. Award transaction's immutable memo contains sel_anchor
//    (selected card anchor) derived from the VRF output

// To verify a past open:
// - Fetch the award transaction memo: sel_anchor
// - Fetch the proof hash from cc-vrf program
// - Re-run ECVRF verify with the operator's public key
// If outputs match, the result was not tampered with.

// VRF Program: ccvrfu3fSpbnPLiUqdWAt85Zn9nq96ekwGTbHqGtdgQ

The dual commitment — proof hash on-chain plus selection anchor in the transaction memo — makes it infeasible for the operator to steer outcomes or for buyers to predict results before signing. Any external audit tool or third-party verifier can replay the proof independently.

The swap program

A separate swap program handles the token mechanics behind the gacha economy — converting between USDC and $CARDS, the platform's native token used for pack purchases and buyback pricing. The swap program docs are at docs.collectorcrypt.com/swap/.

What you can build today

The on-chain programs are public — any Solana program or off-chain tool can read listing accounts, verify VRF proofs, and watch for buy/sell events via transaction logs. The Marketplace API layers REST access on top of this. API partnerships (allowing third-party frontends and aggregators to integrate the gacha machine) are actively being announced.

// Things you can build without waiting for partnership access:
//
// 1. Listing aggregator — read listing PDAs from the marketplace program
//    and surface price data across card types and sets
//
// 2. VRF audit tool — verify any historical pack open by re-running
//    ECVRF against the on-chain proof hash
//
// 3. Floor tracker — watch for buy_* transactions on the marketplace
//    program to build a real-time floor price feed
//
// 4. Offer bot — use deposit_to_user_escrow + accept_offer_for_*
//    to automate card acquisition at target prices

// Marketplace program: CcmRKTuZCGJBWQwMHvDYApBRvSZNHqGJXkznqpDTSQUr
// VRF program:         ccvrfu3fSpbnPLiUqdWAt85Zn9nq96ekwGTbHqGtdgQ
// Docs:                docs.collectorcrypt.com

No official SDK exists yet — the programs are the surface. If you are building on Collector Crypt data, the fastest path is the Marketplace API for off-chain reads and direct Solana RPC calls for on-chain events. The dev gacha environment at dev-gacha.collectorcrypt.com lets you test the full open flow without mainnet tokens.