How Basket works

Overview

A coin launched here is an ordinary pump.fun coin. What is different is where its creator fees go: at launch the site writes a fee-sharing config on pump.fun's own fees program naming a vault as the recipient, and pump.fun revokes that config's admin in the same transaction. From then on the fees belong to a program account nobody controls.

A vault is in one of two modes, fixed when it is created and visible on chain. Neither can be changed afterwards, by anyone, including the launcher.

After the launch every step is permissionless work anyone can press, and whoever presses it is paid 1% for the trouble: move the accrued fees to the vault, then book or buy them, then publish the day's payout root, then let holders claim against it.

What is live, and what is not

Read from the chain and from this site's own configuration when you loaded the page. No third party has reviewed the program, and neither has this page.

Everything the site cannot read renders as not available rather than as a zero, on this page and on every other. Every transaction it builds is simulated before your wallet opens, and it holds no keys: nothing the site does can move a vault's funds.

Pair

A pair coin is quoted in the asset it pays out. pump.fun lets a coin be quoted in any mint on its own lists, so a coin can be quoted in NVDAx, in WBTC or in PUMP, and every trade's creator fee is then paid in that asset. There is nothing to convert.

settle is the whole of it, and anyone may call it. The program works out what has arrived since the last one, which is the vault's token balance minus what it has already booked and what it still owes published epochs, then pays the creator their chosen split, 20% to the Basket treasury and 1% to whoever pressed it. What is left becomes the holders'. Below the minimum, which is 1 USDC or a hundredth of any other quote asset, it does nothing rather than churn.

Because nothing is priced, a pair coin can pay out an asset whose price feed nobody keeps current, it works at any hour of any day, and no part of the payout depends on who presses the button. That makes it the stricter of the two, and it is what the site offers first.

The one thing a pair coin needs is that pump.fun accepts the asset as a quote mint. See the universe for which do today, and why the rest do not.

Basket

A basket coin is quoted in SOL or USDC and carries 1 to 8 legs, each an asset with a weight in basis points, summing to 10 000. The legs, their weights and each leg's price feed are written when the vault is created and there is no instruction that edits them.

harvest takes one leg per call and anyone may press it. On the first leg of a round it takes the same three skims a settle takes, then works out that leg's budget from its weight and swaps it through Jupiter by CPI, with the vault PDA signing inside the call. The route is built off chain by whoever presses the button, and the program does not trust it: it checks that the target program is Jupiter's, that the quote account fell by at most the budget, and that the leg account rose by at least the floor. Anything else reverts.

The floor is the leg's Pyth price minus 5%, and that price must have been published within 5 minutes. It is what makes a badly routed swap impossible rather than merely unlikely.

A SOL-quoted vault is paid its fees as raw lamports on the vault account itself, so a harvest first calls wrap_quote, which moves everything above the account's rent into its wrapped-SOL token account. That step is permissionless too, and can be pressed on its own.

Where prices come from

Only a basket harvest needs a price. The program accepts any PriceUpdateV2 account owned by the Pyth receiver whose feed id matches the one pinned when the vault was created, whose verification level is Full and whose publish time is within 5 minutes. It does not care which shard of the push oracle the account belongs to, or who paid to refresh it.

That matters because Pyth's Hermes API has required a key since August 2026, and a key is entitled feed by feed, so plenty of assets with a feed in the directory cannot be fetched by us. The keeper therefore takes the first of these that works, per leg, per pass: post an update from Hermes when our key is entitled to that feed; otherwise use a feed account somebody else is already keeping fresh; otherwise skip the leg and try again next pass. Fees keep accruing meanwhile, so nothing is lost by waiting.

Because a leg with no usable price could never be harvested, the launch flow refuses to add one. That check is live: when you open the launch page the site reads both shards' feed accounts for every candidate and offers only the ones a harvest could actually use. Right now 23 of 102 assets pass it (USDC, PUMP, WBTC, cbBTC, ETH, HYPE, ZEC, MU, and others), and the rest are shown with the reason rather than hidden. A pair coin skips all of this, because it prices nothing.

An equity feed only publishes while the US market is open, so an equity leg is harvested during market hours and waits outside them. Crypto feeds publish continuously.

Fees

Which PumpSwap tier applies to a trade depends on the coin's market cap at that moment. A coin may also carry its own creator fee instead of the schedule rate, set once at creation and capped by pump.fun at 1% right now; the launch flow offers it and the review step states which rate the coin will carry, because traders pay it and the vault receives it.

The 20% treasury share is the protocol's only revenue. There is no launch fee, no listing fee and no fee on a claim. The three skims are capped by the program rather than by a promise, so whatever a launcher chooses, at least 29% of a coin's fee stream always reaches its holders.

Payouts

An epoch is one day, counted from the vault's own creation time. For epoch n, covering [created_at + n·3600s, created_at + (n+1)·3600s):

• harvested[i] is what leg i received in the vault during the window, taken from the program's own Harvested events. A pair vault emits the same event from settle, so both modes have one event stream and one payout rule.
• Each holder's time-weighted balance over the window comes from the coin's token-account history, excluding the vault, the bonding curve, the PumpSwap pool and the creator-vault addresses. Holding half the supply for half the day earns the same as holding a quarter of it all day.
• share(h) = twab(h) / Σ twab, and amounts[h][i] = floor(harvested[i] × share(h)). Dust left by the flooring stays in the vault and rolls into the next epoch.
• The leaf is keccak256("basket:claim" ‖ coin_mint ‖ epoch u32 LE ‖ holder ‖ amounts u64 LE…), pairs are hashed sorted, and a holder owed nothing is not in the tree.

What bounds a wrong root, and what does not

A root is published by the vault's root_publisher and is claimable at once. There is no waiting period. There used to be an hour, described here as a window for challenging a bad root, and it was removed because it was not one: publish_root moves the money from the vault's unencumbered balance into the epoch as it publishes, so during that hour the funds were already committed, redeem could not reach them, and no instruction exists to cancel an epoch. Noticing a bad root was all anyone could do, and they can still do that.

What does bound it is the cap. The program limits what an epoch may assign to what the vault actually holds and has already settled, so a wrong root can never pay out more than exists and can never touch another epoch's encumbered balance. The publisher can misallocate a settled epoch between holders; it cannot create value or take the vault. That is the trust this design asks for, stated plainly rather than dressed up as a challenge period.

Recomputing a root yourself

The keeper ships with a verifier that rebuilds an epoch from nothing but public chain data, using the same code that computed it, and prints both roots. It needs an RPC and nothing else:

BASKET_RPC_URL=https://your-rpc node --experimental-strip-types \
  keeper/src/verify.ts <coin mint> <epoch index>

It exits 0 when the roots match and 2 when they differ. It walks the coin's whole transfer history and reconciles every token account of the mint first, because a legacy Token-2022 transfer does not name the mint in its accounts and would otherwise be missed; the keeper does exactly the same before it computes a root.

The payouts page shows every published epoch for any wallet, what it is owed in each and what it has already claimed.

Redeem

redeem burns coin for a pro-rata slice of every asset the vault holds and has settled but not yet assigned to an epoch, against the coin's circulating supply. It is the floor under the coin and the backstop under the whole design: it needs no root, no publisher and no keeper, so it works even if nobody ever publishes another epoch.

It is not the usual way to get paid. Claiming an epoch pays you what you earned by holding; redeeming pays you a share of what has not been assigned yet, and destroys your coin to do it. Both are on the coin's own page, and both are simulated before your wallet opens.

Addresses

PDAs on the Basket program: Vault = ["vault", coin_mint], Epoch = ["epoch", coin_mint, index u32 LE], Claim = ["claim", coin_mint, index u32 LE, holder], Treasury = ["treasury"]. On pump.fun's fees program: SharingConfig = ["sharing-config", mint]. A vault's token accounts are ordinary associated token accounts of the vault PDA, one per leg, and in pair mode the quote account and the single leg account are the same address.

Risks

Specific and plain, in rough order of how much they matter.

• The program's code can still be changed. Its upgrade authority is still held by J8Srqqw9Uk5BPD3zwHBUWDN9rwsgqR21WzPt5mLq7XfQ, which means whoever holds that key can replace the program's code, including the parts that protect a vault. It is removed with solana program set-upgrade-authority --final before this should be treated as finished. No third party has reviewed the code.
• A pair asset is a claim on its issuer. A tokenised stock is a token whose value comes from whoever issues it and holds the share behind it, not from the chain. xStocks are issued by Backed Finance, Backpack's stocks by Backpack; some other mints have an active mint authority that is a single ordinary wallet, which means one key can issue more of them. Where the site knows something about an asset's provenance it prints it beside the asset, in the universe table and in the launch flow. What is worth holding is your call.
• A basket leg depends on its price feed. A harvest needs a Pyth price nobody has let go stale. If a leg's feed stops being kept current, that leg is simply not harvested: the fees stay in the vault as quote and wait. They are not lost, but they are not the asset you expected either, and they can wait a long time. Pair coins have no such dependency.
• The keeper is one operator today. The instructions it presses are permissionless and anyone can run one, but publishing roots is not: only the vault's root_publisher can do that, and today that is this operator for every coin launched here. If it stops, claims stop until the creator rotates the publisher; redeem keeps working throughout, because it needs no publisher at all.
• pump.fun's own rules can change. Its fee schedule, its quote lists and its creator-fee cap are its to change, and a coin's income comes from them. The site reads all three live rather than shipping a copy, so what it shows is what is true today, not what was true when it was written.
• The assets can fall. A vault holds what it bought. Holding a coin is not a claim on anything except the vault's own balance, and a coin's price is set by people trading it on pump.fun, not by what the vault holds.
• Thin liquidity cuts both ways. A leg with little depth is expensive to buy into and expensive to leave. The site refuses anything under $100K of liquidity for either mode, which is a floor, not a guarantee.
• A launch is a bundle, not one transaction. Creating the coin, freezing the split and creating the vault do not fit in a single Solana transaction for every quote asset, so they are signed in order. If one fails the earlier ones stand, and until the split is frozen the coin's fees accrue to your own pump.fun creator vault where you can collect them as usual. The review step says exactly what will be signed, and the flow can be retried from where it stopped.

FAQ