Overview
Hive Pad is a Solana launchpad on top of pump.fun. Every coin dropped here is a cell of the comb. Its honey is its bonding progress, read from the pump.fun curve: honey = 1 - real_token_reserves / initial_real_token_reserves (100 % once migrated). The coin's creator fees, the nectar, are split on chain every time anyone collects them. A migration seals the cell with wax and opens its honey jar, a one-time $QUEEN buy that is burned. Every 100 sealed cells the hive swarms: the program launches a new queen and airdrops it to holders of the current one.
Coins trade on pump.fun and PumpSwap as usual. There is no tax, no pause and no gate on buying: the pad only owns the creator-fee lever (each coin's pump creator is a program address of Hive Pad).
Compromise: the swarm airdrop snapshot is attested. Pump keeps no on-chain holder list, so an attestor key samples holders off chain and signs the merkle root; a guardian can veto it for 2 h and the full report is published. Everything else (honey, the split, seal, jar, winter, pollination, drones, the beekeeper discount, the royalty chain) is decided by the program alone.
Lifecycle
| State | What happens | Who moves it |
|---|---|---|
| Dropped | launch: create_v2 with creator = the coin's Fees PDA, then the drones' brood buy, then the dev buy, in one instruction. Launch fee booked for the treasury. | the dev |
| Filling | Honey rises along the curve. collect splits nectar into the buckets. | anyone (the keeper every round) |
| Near bonded | Between 70 % and 95 % honey, in winter the reserve may pollinate the cell. | anyone, only in winter |
| Sealed | pump migrates the coin to PumpSwap (and burns the migration LP in that transaction). seal marks the cell, counts it toward the swarm and opens the jar; drip_jar spends the jar on $QUEEN, burned. | anyone |
| Swarm | At the threshold swarm launches the next queen with a buy from the reserve into an escrow; holders of the current queen claim it by merkle proof. | anyone; the root by the attestor |
Nectar split
Creator fees of a coin (pump curve 0.30 %, the PumpSwap creator tier after migration) accrue to pump's creator vault of the coin's Fees PDA. collect pulls them in and splits them:
| Bucket | Curve | Sealed | Where it goes |
|---|---|---|---|
| Dev | 40 % | 40 % | the coin's dev (anyone can push it, it only pays the dev) |
Queens of generation 2 and later have no dev: their dev share goes to the stakers, and 10 % of their nectar buys and burns the queen before them. A beekeeper (a dev who launched a cell that is now sealed) pays a smaller treasury share on later launches: 50 % of the treasury share goes to the dev instead.
Wax and the jar
pump.fun migrates a finished curve to its canonical PumpSwap pool. In that same transaction pump mints the pool's LP tokens to itself and burns them: the liquidity pump adds at migration is locked forever (the pool can still mint LP for later depositors). Hive Pad does not do this; it links the migration transaction on every sealed cell and the /seal/<mint>.json fact shows LP minted = LP burned.
seal (anyone, after migration) marks the cell sealed, adds it to the swarm count and opens the jar. The jar spends on $QUEEN under the price guard, in steps of at most a 1 % price move, and every token bought is burned. A jar below the minimum buy is folded into the queen pot instead of a dust buy.
Drones
Drones are $QUEEN stakers who also deposit SOL into the brood pool. To deposit you need 1,000,000 $QUEEN staked and warm (stakes earn after a 1 h warm-up; a flash stake earns nothing).
- Brood epochs last 24 h. A deposit joins the current epoch while it has had no launch yet, otherwise the next one. From the first launch of an epoch its pool is final.
- Every launch in the epoch buys first, inside its create instruction, at the start price:
brood buy = min(pool x 2 %, 0.5 SOL, what is left, 10 % of supply). The dev sees this number before signing and the transaction carries a cap he accepted. - Your tokens of launch L =
brood_tokens_L x your deposit / pool. Claim them any time in the claim window (30 d); after it the unclaimed bag is burned. - At epoch end the unspent SOL rolls into the next epoch, or is paid back by
brood_settle.
Winter
The hive keeps a ring of pad fees per season (24 h). It is winter when the last closed season brought less than 50 % of the average of the seven before it (at least 3 closed seasons of history, the current one never counts).
In winter anyone may pollinate a curve cell at 70 % to 95 % honey: the reserve buys min(0.25 SOL, 10 % of the reserve, the 1 % impact cap) of it and burns the tokens. Once per cell per 6 h, at most 1 SOL per cell in its life.
Swarm
When sealed_count >= 100 x generation, swarm launches the next queen. Its name and ticker are set by the admin at least 24 h ahead (visible on chain). The program buys up to 1 SOL (and at most 25 % of the reserve) of it into an escrow. Holders of the current queen with a minimum balance over the 24 h before the swarm (staked $QUEEN counts for its staker) share the escrow pro rata; the attestor posts the merkle root, the guardian can veto it, and after the window anyone claims by proof. Unclaimed tokens are burned after 30 d.
A vetoed root can never come back: a corrected root needs a fresh attestor signature with a newer snapshot time. The airdrop size is the posted total; if someone donates tokens to the escrow, the root may be below the escrow balance and the rest is burned at the sweep. The guardian can also revoke the attestor key at once; roots then pause until a new key passes its 3-day rotation.
$QUEEN stays the pad token for every $QUEEN bucket. Each later queen pays the royalty into buying and burning the queen before it, forever.
Drop a cell
- Name (1-32 characters), ticker (1-10 letters A-Z or digits), a picture (PNG, JPG, GIF or WEBP, up to 4 MB). Picture and metadata go to IPFS.
- Pick a dev buy. The page reads the brood buy this transaction will make from the chain and shows it before you sign.
- Sign one transaction: create_v2 + the drones' brood buy + your dev buy + the launch fee of 0.02 SOL. If you launched a cell that is sealed now, tick Beekeeper.
Worked example
The brood pool holds 10 SOL this epoch. Dana drops $COMET with a 1 SOL dev buy. In the create instruction the drones buy first for min(10 x 2 %, 0.5) = 0.2 SOL at the start price, then Dana's 1 SOL buy runs. A drone who put in 2 SOL of the 10 gets 20 % of the brood's $COMET.
A week later $COMET has paid 1.00 SOL of creator fees. A collect splits it: 0.40 to Dana, 0.15 buys and burns $QUEEN, 0.15 to stakers, 0.10 to the reserve, 0.10 into $COMET's jar, 0.10 to the treasury. $COMET bonds and pump migrates it: seal stamps the cap and the jar's 0.10 SOL buys $QUEEN, burned.
Rules
- Every program buy (queen pot, jars, royalty, pollen, swarm) is price-guarded: an on-chain median of fresh observations sets min_out, a buy may move the price by at most 1 %, one program buy per coin per observation gap, and the transaction may hold no other trade.
- Everything the program buys is burned, except the swarm escrow (airdropped) and the brood bags (claimed by drones).
- Donations: anyone can send SOL straight into a coin's creator vault and it looks like fees. It is split like fees, so it funds the burns; nothing in Hive Pad pays a caller in proportion to fees he can donate.
- Pots are small. The site shows the real lamports in each bucket and the last transaction that moved them, never a projected yield.
Parameters
Read live from the Config account. Hive parameters change only through a 24 h timelock the guardian can cancel; brood and season lengths never change.
| Parameter | Now | Bounds |
|---|---|---|
| Reading the chain. | ||
Program
Program id Hivu1t5PS5q9HP1krrRX2nERD1GgUysUDx9tAEpfryAg. Anchor 0.31, pump.fun create_v2 / buy / collect_creator_fee and PumpSwap buy by CPI. Every event is emitted by self-CPI (two pump buys in one instruction truncate the logs).
| Account | Seeds | Holds |
|---|---|---|
| Config | ["config"] | admin, treasury, attestor + guardian, pause, coin and hive params, $QUEEN mint, next queen metadata |
| Hive | ["hive"] | cells, sealed count, generation, season fee ring + winter flag, pot books |
| Coin | ["coin", mint] | dev, launcher, splits, fee books, jar, observations, pollen, brood buy + claim bitmap |
| Fees PDA | ["fees", mint] | the coin's pump creator; holds dev / treasury / jar / royalty pending |
| Queen | ["queen", gen] | queen mint, airdrop total, root, claims bitmap |
| Stake | ["stake", owner] | warm + warming $QUEEN, reward debt, drone lock |
| BroodEpoch / BroodStake | ["bepoch", epoch] / ["brood", epoch, owner] | the epoch pool, spent, lock / one drone's deposit and claims |
| queen pot / stake pot / reserve / brood vault | ["qpot"] ["spot"] ["reserve"] ["brood"] | SOL for $QUEEN buys / stakers / pollen + swarms / drones |
| Who | Instructions |
|---|---|
| Anyone | launch (the dev signs), collect, claim_dev, collect_treasury, seal, observe, turn_season, buy_queen, drip_jar, pay_royalty, pollinate, poke, claim_stake, brood_settle, brood_roll, close_brood_stake, close_brood_epoch, sweep_bag, swarm, post_swarm_root (with the attestor's signature), claim_swarm, sweep_swarm |
| Holders | stake, unstake, close_stake, brood_deposit, brood_withdraw, brood_set_roll, brood_claim; the dev: propose_dev, the new dev: accept_dev |
| Guardian | veto_swarm_root, cancel pending params, keys and the next queen |
| Admin | set_coin_params (future coins only), propose_hive_params (timelocked), set_treasury, set_paused, key rotations (2-step, timelocked), set_pad_mint (once), set_next_queen (timelocked) |
Errors
| Code | Name | What it means |
|---|---|---|
| Reading the IDL. | ||
Verify on chain
- A coin's pump creator (bonding curve bytes 49-81) is
["fees", mint]of the program: only Hive Pad can collect it. - Every bucket is a book in the Coin account;
fees_totalequals the sum of the buckets, and the Fees PDA holds at least the pending ones. - Open a sealed cell: the linked migration transaction mints the pool LP to pump and burns the same amount; the LP mint supply is 0.
- Every program buy is a
Boughtevent with the median, the price, min_out and the burned amount; the /tx page decodes it. - The swarm root, total and tree hash are in the Queen account; /swarm/<gen>.json is the report they hash, so anyone can rebuild the tree.
Admin powers
Can
- Pause new cells, swarms, stakes and drone deposits (unstake, claims and cranks keep working).
- Set the split for future coins (a launch checks the version the page showed).
- Propose hive params, attestor, guardian, admin: timelocked, the guardian can cancel.
- Set $QUEEN once and the next queen's name, 24 h ahead.
Cannot
- Move a coin's, a staker's or a drone's SOL or tokens.
- Change a coin's split after its launch.
- Choose who gets an airdrop or how much beyond the escrow: the attestor picks among holders, the guardian can veto.
Risks
- The airdrop snapshot depends on the attestor service sampling holders; with too few samples the flash-holder protection weakens to the samples that exist.
- Winter is computed from collected fees; the keeper collects every round, and anyone can, but a long keeper outage can make a season look quiet. Pollen per cell is capped and burned.
- A spam of junk launches makes the drones buy junk at the start price (each costs the spammer the launch fee and rents); the drones can sell back near cost.
- Price observations can be biased by multi-transaction bundles within the 10 % clamp; every program buy is limited to a 1 % move.
- Smart contracts can have bugs. The program was tested end to end on a validator with byte-exact pump.fun programs and reviewed by an independent audit; its fixes are applied before mainnet.
FAQ
- Can the dev or the pad dump the drones' tokens?
- No. The brood bag is held by the brood vault PDA and only pays drones by their share.
- Why does the brood buy before the dev?
- So nobody, the dev included, can trade between the create and the drones' buy: the drones get the start price.
- What is a beekeeper?
- A dev whose earlier cell from this pad is sealed. His next launches pay half the treasury share; the difference goes to him.
- Is the LP locked?
- The liquidity pump adds at migration is locked forever: pump burns that LP in the migration transaction, and every sealed cell links it.
- Where do the numbers come from?
- From the program accounts and pump.fun accounts on each load. Nothing on this site is projected.