Skip to content
log(swap)

Token creator

A token launch is one floored position, minted at the current price.

At the floor the position is pure base: the creator deposits the supply and nothing else — no seed capital, no matching stablecoin, no pre-funded pool. From there it sells into a rising market, on a schedule fixed in log-price and published before the first buy.

There is no bonding curve to graduate out of, no migration transaction, and no second pool. The launch venue and the permanent market are the same position.

The three identities that make it a sale

For a floored position with floor ξ\xi and exposure LL:

Q(ξ)=0Q(\xi) = 0 — the mint costs zero quote. This is what makes the primitive a launchpad rather than a pool that needs bootstrapping. Total base deposited is S=L/pmin⁡S = L/p_{\min}.

pR≡LpR \equiv L — price multiple and float divisor are equal, exactly. Sell the float down to a fifth and the price is 5×; to a tenth, 10×. Nothing to tune and nothing path-dependent: the supply schedule is the price. Sold fraction at multiple mm is 1−1/m1 - 1/m.

dQ=L dxdQ = L\,dx — impact is scale-free. Equal quote in produces equal log displacement wherever price sits. The buyer at 2× and the buyer at 40× face the same percentage impact per unit of quote.

There is only one number

Pick the supply SS and the launch price p0p_0. Then L=S p0L = S\,p_0 — which is the launch valuation. So

raise at multiple m  =  FDV0⋅log⁡m.\text{raise at multiple } m \;=\; \mathrm{FDV}_0 \cdot \log m .

The proceeds are the launch valuation times the natural log of the multiple. That is the whole parameterisation.

The standard shape — 1B tokens at p0=10−6p_0 = 10^{-6}, so FDV0=L=1,000\mathrm{FDV}_0 = L = 1{,}000:

multiplepricesoldfloat leftraiseend FDVavg fill
2×2.0e-650.0%500,000,0006932,0001.386e-6
5×5.0e-680.0%200,000,0001,6095,0002.012e-6
10×1.0e-590.0%100,000,0002,30310,0002.558e-6
100×1.0e-499.0%10,000,0004,605100,0004.652e-6
1000×1.0e-399.9%1,000,0006,9081,000,0006.915e-6

Three things to read off it.

There is a ceiling. Since the raise is Llog⁡mL\log m and the ending valuation is LmLm,

raiseFDVend=log⁡mm,\frac{\text{raise}}{\mathrm{FDV}_{\text{end}}} = \frac{\log m}{m},

which peaks at m=em = e with 1/e=36.8%1/e = 36.8\% and decays after — 23.0% at 10×, 4.6% at 100×, 0.7% at 1000×. A log-pool launch can never capture more than ~37% of its ending valuation as proceeds. That is a property to size against, not a defect to fix.

The raise grows only logarithmically. A 100× launch raises twice what a 10× launch does, not ten times. The position is deliberately a bad seller into strength — which is the same statement as constant LVR.

The average fill is far below the ending price. At 10× the average fill is 2.56 p02.56\,p_0, i.e. 25.6% of the price it ends at.

The recipe

A launch is a pad: an F-pool under the pad policy, one base against one quote.

  1. initialize(key) with the token as the one base and the pad policy. Anyone may call it.
  2. seed(poolId, L0, [S], 0) — the supply SS and no quote, with L0=S p0L_0 = S\,p_0. At Q=0Q = 0 the floor sits at the launch price, so the pool is an all-base resting ask.

The pad's policy mints every seed share to 0xdead. That is the escrow, done by the contract: nobody holds the shares, so nobody can burn the position and take the float back. The creator holds the authority — the right to run the pool — and never the liquidity.

Getting the raise out

It does not come out. The raise is the pool's bid under the token, and the pad's policy keeps it there: a harvest may take the floor back up to the reference floor ξ0\xi_0 and never past it, so it releases fee income only, never proceeds. A round trip that earned a fee is harvestable to the wei, and a pad that has earned nothing has nothing to harvest.

A harvest pays the creator nothing directly. It is a dividend to every share, and the seed shares are 0xdead's, so their part banks as the pot: income nobody can claim. The creator receives its share of the pot at a graduation (below). Outside minters receive their pro-rata part of every harvest like any other holder.

What the creator cannot do

The mark is not writable. xx is derived from reserves and moves only on trades, so no balance-sheet operation lowers the ask. "Lower the floor, then buy the book" is impossible by construction — which is the property that makes a pool safe to hand a creator at all.

Re-marking upward is not free. Refilling while the floor sits a gap gg below the mark costs L(g−1+e−g)≈12Lg2L(g - 1 + e^{-g}) \approx \tfrac12 Lg^2 — quadratic in the gap, and independent of refill depth.

The floor deepens by itself

Because ξ=ξ0−F\xi = \xi_0 - F, every swap pushes the floor down by fee/L\text{fee}/L. Volume deepens the bid with no new mechanism and no new capital. The one case it cannot reach is price sitting at the floor in a falling market — no bid, so no trades, so no fees. That is a floored position that got filled on the way down.

Graduation

Every competing launchpad gamifies the migration threshold — and the day the bar fills, the launchpad stops being the venue. A pad has no migration. It graduates in place, as many times as its income allows, and each graduation is recorded forever in the pool's generation.

The gate is the pot. A pad graduates when its creator calls regenerate and the pot has reached the threshold for its generation, T(g)=base⋅growthgT(g) = \text{base}\cdot\text{growth}^{g}. Faking the gate means paying fees into the pool, so it cannot be gamed by a round trip. The schedule is the pad policy's (at deployment: the threshold doubles each generation).

The step, in order:

  1. The generation's income is harvested into the pot.
  2. 0xdead is carried into generation g+1g + 1. Every outside minter is frozen out pro rata into generation gg's bundle, at the marks, and keeps the dividend it earned. It can redeem in kind or roll into the new generation.
  3. The pot splits, all in quote: the creator's share to the creator, 50% to the protocol, and the burn share spent buying the token at the pool's own curve and burning it — every mark up by the same amount, the floor where it was.
  4. The rest deepens the bid: it stays in the pool as quote, at fixed LL and marks, so the floor moves down and the pad's bid gets deeper, owned by the dead shares for good.
  5. The reference floor ξ0\xi_0 resets to where the step leaves it, so the next generation's income counts from there.

You choose the creator's share (0–50% at deployment) and the burn share (0–10%) when you launch. They ride in the pool's key, so every buyer sees them before buying and they never change. The protocol's 50% is the pad policy's number, recorded at the pad's birth.

The milestone axis is already in the maths. Since pR≡LpR \equiv L, a price milestone is a distribution milestone to the wei. And since dQ=L dxdQ = L\,dx, every equal-log rung costs the same money — a progress bar in price is linear in money by construction. At rung spacing Δ=0.5\Delta = 0.5:

rungmultiplefloat soldcumulative quote in
11.65×39.3%1⋅LΔ1\cdot L\Delta
22.72×63.2%2⋅LΔ2\cdot L\Delta
34.48×77.7%3⋅LΔ3\cdot L\Delta
47.39×86.5%4⋅LΔ4\cdot L\Delta
512.18×91.8%5⋅LΔ5\cdot L\Delta
620.09×95.0%6⋅LΔ6\cdot L\Delta
733.12×97.0%7⋅LΔ7\cdot L\Delta

No constant-product curve can offer this: there each successive rung costs a wildly different amount, so the bar misrepresents progress. These price rungs are the client's readout; the generation is the protocol's.

The burn is a pure translation. Burning δ\delta base from the pool reserve at fixed LL gives

Δx=Δξ=log⁡RR−δ,\Delta x = \Delta\xi = \log\frac{R}{R - \delta},

so mark and floor move up by the same amount, ℓ\ell is untouched, and the position is carried to a new price level with its shape intact — scale-covariance doing the work. Marked value is invariant (the base leg is worth LL before and after); liquidation value is not, since the pool holds strictly fewer tokens. That is what makes the burn a real cost to the pool and a real gain to everyone holding outside. It is the only thing that lifts the floor above launch: fees push the floor down, a harvest brings it back to at most ξ0\xi_0, and a burn ratchets it up for good.

A pad never retires. A pad sold back to its floor stays live: it trades, earns, and can graduate again. A fresh start is a new pad, with a new pool id.

Colour is a derived function, never a stored one — hue from the generation and the high-water rung, saturation from the burned fraction, ring from the drawdown. One read of the lens's pool. No metadata server, no database, and no way for a front end to misreport it.

The lesson taken from the benchmark

pump.fun's Dynamic Fees V1 tiered creator fees by market cap and was criticised for misaligning incentives. The failure is worth naming precisely: they funded the creator's progression out of the trader's fee. Here ϕ\phi is LVR-calibrated, and detuning it to pay for a game breaks the one property the protocol is built on.

So the rule is fixed: the trader's fee never moves. The game is entirely on the creator's side of the ledger, gating income that has already accrued.