4249 4C4C 5320 4152 4520 5041 4944 2049 4E20 5355 5050 4C59 · 424C 4541 4B2F 5052 4F54 4F43 4F4C 2F30 31

the protocol

A Solana program owns the coin's creator revenue and can do exactly one thing with it: buy that same coin back and burn what it bought. Not a policy. Not a promise. The only path the lamports have.

81,856program bytes

0.5703deploy rent, SOL

240scrank interval

0-10000burn share, bps

1pinned mint

the protocol

proven on a mainnet fork

where the money comes from

Every trade of the coin pays a creator fee. On pump.fun that fee is paid to whatever address was handed in as the coin's creator at launch. One wallet deploys this program, launches the coin, and passes the program's vault PDA as that creator. From that instant the revenue is addressed to an account no human holds a key to.

There is no other income. No treasury behind the treasury, no emissions, no yield manufactured in a back room. When the chart is quiet the vault is thin, and a thin vault burns a small number. The machine does not have an opinion about this.

creator := vault PDA = find_program_address(["vault"], program_id) the address the fees are paid to is derived, not chosen. it exists before the coin does and it has no private key, because there is no private key that solves for it.

the vault carries no data

The vault deliberately stores nothing. This is not tidiness. pump.fun's buy pays out of the buyer with a System transfer, and the System program refuses to debit an account that carries data. A vault with a single byte of state in it could receive fees forever and never spend one of them. The account is empty so that it can pay.

the cycle

Claim, buy, burn. One instruction, one signature, atomic. Either every leg lands or the slot reverts and the vault is exactly as it was.

leg	program	moves
collect_creator_fee	pump.fun	creator vault to our vault PDA
buyback_curve / buyback_amm	bleak	vault SOL to the same mint
settle	bleak	bought tokens to burn, remainder to treasury

Two variants exist and they differ only in whose name is on the buy. cycle has the vault PDA buy, which is airtight and shows on charts as a program address. cycle_via_dev routes the same lamports through the dev wallet so the buy is attributed to it everywhere a human would look. The fees cannot stop at the dev wallet: the transfer out of the vault and the buy back into the coin are the same instruction, so one cannot occur without the other, and the unspent remainder is swept back before the instruction ends.

the dial

One number decides how much of each buyback is destroyed. At 10000 every bought token burns. At 0 nothing burns and the whole buyback lands in the treasury. Anything between splits. Nothing else about the flow changes, at any setting.

burned = bought · burn_bps / 10000 treasury = bought − burned the dial is the only discretion in the machine, and it is bounded at both ends. it cannot point the money anywhere that is not one of these two places.

the reserve

The program holds a hard rent floor. The vault will not spend itself below reserve_lamports, because an account that falls under rent exemption stops being an account, and a machine that can drain itself into failure will eventually do so on the one night nobody is watching.

spendable = vault.lamports − reserve_lamports spendable < 0 ⇒ no buy the balance is never the budget. the floor is enforced in the program, not in the process that calls it, so a broken crank cannot spend through it.

the crank

Something has to choose the moment. A crank process claims, buys and burns on a fixed interval, defaulting to 240 seconds, with a floor below which it does not bother, a dry run mode, and an on-chain pause that stops it from the program's side rather than the operator's.

The crank holds no power the program does not grant it. Its key is cranker, it can call the buy legs, and it can be rotated by the authority at any time. It cannot change the mint, the treasury, the dial, or the destination of a single lamport. The worst a stolen crank key achieves is buying the correct coin at a bad price.

token programs

pump.fun's live launch path is create_v2, and its mints are Token-2022, not classic SPL. The first build of this program pinned classic SPL and would have failed on any coin launched today. It now reads the token program off the mint account itself and routes the burn, the transfer and the buy CPI at whichever program owns it, so coins launched this morning and coins launched two years ago both work. Wrapped SOL is always classic SPL, so the quote side stays pinned.

how that was established Forty two of forty two recently graduated mainnet coins sampled: every mint owned by TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb. create_v2 on a mainnet fork produced a Token-2022 mint of 354 bytes. pump.fun's own documentation states the token program account for create_v2 is hardcoded to Token-2022. Three independent reads, one answer.

what cannot happen

enforced on chain

Every protocol has a list of things it promises not to do. This is the shorter list of things it is not able to do, which is a different document entirely. Each of these is checked by the program on every call, not by the process that runs it.

the fees cannot buy another token The mint is pinned once by register_mint and checked on every buyback against both the config and the bonding curve's own creator field. A stolen crank key cannot point the vault's SOL at a different coin. There is no instruction that repins it.
the launch buy cannot be burned The deployer's launch buy lands in the deployer's own wallet and never passes through the vault. It is untouchable by construction rather than by an accounting rule that could drift. Under cycle_via_dev, where both balances share one token account, the burn is taken from the measured increase across the buy, never from the balance that was already sitting there.
the vault cannot pay a human Every destination is fixed in config: the mint it buys, the burn, the treasury. The permissionless instructions are permissionless precisely because a caller chooses only the moment, never the recipient.
the vault cannot drain itself into failure The rent floor is in the program. Below it, the buy does not happen.
a partial cycle cannot exist Claim, buy and burn are one instruction. There is no state in which the fees have left the vault and the tokens have not come back.

∀ t : supply(t+1) ≤ supply(t) supply is monotonic downward. the program contains no mint instruction, no authority over one, and no path to acquire one. the only direction is fewer. □

the instruction surface

shipped

Two accounts. config at seeds ["config"] holds the authority, the cranker, the treasury, the pinned mint, the burn share and the running stats. vault at seeds ["vault"] is the address pump.fun is handed as creator, and holds both the SOL and the bought tokens. That is the entire state.

instruction	who may call	what it does
cycle	cranker, authority	claim, buy and burn in one atomic instruction. the vault is the buyer
cycle_via_dev	cranker, authority	the same, but the dev wallet is the on chain buyer
initialize	authority	creates config, records the vault bump
register_mint	authority	pins the coin. once, and only once
set_burn_bps	authority	the dial, bounded 0 to 10000
set_paused	authority	halt, from the program's side
set_reserve	authority	lamports the vault always keeps
set_cranker	authority	rotate the crank key
set_treasury	authority	rotate the treasury
set_authority	authority	hand over the keys
collect_curve_fees	anyone	pulls bonding curve creator fees into the vault
collect_amm_fees	anyone	the same after graduation. arrives as wrapped SOL
wrap_sol	anyone	moves value between the vault's two forms, never out
unwrap_wsol	anyone	the return trip
buyback_curve	cranker, authority	vault buys its own coin on the curve
buyback_amm	cranker, authority	the same on PumpSwap
settle	anyone	burns burn_bps of the vault's tokens, treasury takes the rest

settle and both collect instructions are open to anyone because every destination is already fixed by config. Handing a stranger the ability to press the button is safe exactly when the button is wired to one place. If you want to pay the transaction fee to make the burn happen sooner, the protocol will not stop you.

the maths

current

revenue

dR/dt = φ · V(t) the vault fills at the fee rate times traded volume. a quiet chart is a cold room. this is a burn engine, not a printing press.

the burn

B_k = q_k · β, β = burn_bps / 10000, T_k = q_k(1 − β) q is what the buy actually returned, measured across the instruction, not estimated before it. beta is the dial. the two terms are exhaustive: every bought token is burned or banked, and there is no third place.

cumulative supply removed

ΔS(t) = − β · ∑_k≤t q_k the counter on the desk is this sum and nothing else. it is read from the chain, not from the engine's own memory, because a number that reports on itself is not a report.

the spend ceiling

spend_k ≤ vault.lamports − reserve_lamports the engine may spend what it holds above the floor and not one lamport more. the balance is never the budget, because a balance can contain rent that is not the protocol's to move.

lemma: the destination is not a choice

Let m be the pinned mint. Every buyback instruction asserts ctx.mint == config.mint and, on the curve, that the curve's own creator field resolves to the vault. Both reads are on chain accounts, neither is supplied by the caller. Therefore for any caller, authorised or stolen, the set of reachable destinations has cardinality one. □

lemma: the cycle has no partial state

Claim, buy and burn execute as inner instructions of a single top level instruction. Solana reverts a failed instruction in full. Therefore no slot exists in which the fees have been claimed and the tokens have not been bought, or bought and not settled. The intermediate states are unobservable because they are never committed. □

lemma: rotation does not move value

The authority may rotate cranker, treasury and authority itself. None of these instructions touch the vault, and none of them can repin the mint. Rotation changes who may press a button whose wiring is fixed. □

the distribution layer

specification, not yet live

status Everything above this line is implemented and proven. This section is the specification for the holder distribution layer being fitted to the same engine. It is written here so the mechanism is public before it runs, not after. Nothing in this section is live, and no number in it has been paid.

Let h(t) be a wallet's balance. Its accepted shares are the integral, not the balance. Balance is a rate; shares are what the rate accumulated.

w_i = ∫ h_i dt tokens held times minutes held, accumulated since the last reduction. any reduction of any size marks w stale and restarts the integral at zero.

cut_i = w_i / ∑w your shares over everyone's, at the instant the round settles. this is how real pools pay, and that is not a coincidence.

lemma: a balance cannot buy a history

dw/dt = h. The rate is purchasable; the integral is not. A wallet arriving at minute forty with ten million tokens has exactly the accumulated history of a wallet arriving at minute forty with one token: none. □

lemma: splitting changes nothing

Split a balance h across k wallets. The sum of the integrals equals the integral of the sum. Sybils purchase bookkeeping, not shares. □

the round

L ~ U(180s, 420s) each round's length is drawn from the launch instant's own seed, identical for every visitor, and not published. a published round length is a queue of people gaming a clock.

The round meter is correct at the endpoints and theatre in between, which is true of every luck estimate ever displayed on any pool. It fills when a round ends. The settlement itself is whatever the engine actually paid, read from the ledger and nowhere else. □

the dust floor

p_i = R · w_i/∑w < θ ⇒ owed_i += p_i a payout below theta cannot be delivered at all: 890,880 lamports is rent for an empty account, and a transfer under it bounces off a fresh wallet. it is not rounded away. it is booked, and it accumulates until it clears the floor.

owed is nondecreasing between sends and cleared only by a confirmed payout, so no sub-threshold share is ever lost. □

conservation

claimed = paid + owed + remaining the identity is checked against a live read of the wallet balance each cycle, not derived from itself. a books check that cannot fail is not a check.

Every lamport claimed sits in exactly one of the three terms. It becomes owed at a settlement and becomes paid only on a confirmed transfer, so the sum is invariant. □

backlog first

pay(owed) before pay(new) ranked by debt standing before this round. when a round is cut short, no new share was ranked ahead of any waiting debt, and whatever missed the cut stays owed, at the front of the next round.

The list is ranked by prior debt, and an unpaid entry keeps its debt into the next round's ranking, so a waiting debt is never written off and never re-ranked below a new share. □

the reserve

reserve += β_r · claimed, deploy ≤ 0.40 · ∑reserve a fixed slice of every claim is held back and deployed to top up thin rounds when the chart goes quiet. the buffer is capped so it cannot spend itself during the loud hours it was never meant for. a floor survives into the night.

records and failure

current

what was proven, and where

Both venues are proven end to end on a mainnet fork against the real pump.fun programs. Not a mock, not a testnet stub. The bonding curve run launched a Token-2022 coin through create_v2 with the vault PDA as creator, generated third party volume, then ran cycle.

measurement	value
signatures for claim, buy and burn	1
inner instructions under one top level	12
slot	442,390,593
supply removed at burn_bps 10000	5,114,988,429,911
deployer launch buy, untouched	66,285,714,223,523
vault remaining	0

The dial was then exercised at 10000, 0 and 5000, and the PumpSwap path was run against a real mainnet pool whose coin_creator was rewritten to the vault, so real trades accrued real creator fees before collect_amm_fees, buyback_amm and settle.

the attestation

At every cycle the engine checks its own books against a live read of the vault and publishes the drift. Books claiming more than the chain holds is the alarm that outranks every other alarm. A number the engine derives from itself is decoration.

what is promised

Nothing. No yield, no appreciation, no roadmap, no future. The protocol promises conduct: fees claimed, supply burned, records kept, failures published. Whether the coin is worth holding is a judgement this page is not equipped to make, and any page that offers to make it for you is selling something.

5468 6520 6F6E 6C79 2064 6972 6563 7469 6F6E 2069 7320 6665 7765 72 · the vanity id is not in this repository · rotate cranker before anything runs unattended