real target spread : : : : : : : : : : : : · · · · · · · · · · · · : : : : : : : : : : : : · · · · · · · · · · · · : : : : : : : : : : : : · · · · · · · · · · · · : : : : : : : : : : : : · · · · · · · · · · · · : : : : : : : : : : : : · · · · · · · · · · · · : : : : : : : : : : : : · · · · · · · · · · · · : : : : : : : : : : : :
| step | time | spread before | kernel | spend | bought | burned | spread after | trigger | tx |
|---|
e/curve is one coin on Solana, launched on pump.fun, with a program attached to its creator fees. The program holds those fees in a vault and spends them in one direction only: buying the coin and burning it, whenever the market cap sits below a target. The target is not a fixed number. It is the anchor cap, recorded once at initialization, multiplied by e raised to eight times the fraction of supply the program has burned. Every burn raises the target. The coin chases a floor that climbs each time it is defended.
There is nothing to operate. There are no votes, no admin keys after initialization, no schedule, and no clock. The program moves when trades move the price, and it moves in proportion to how far the price fell.
Why an exponential. A linear target would raise the floor by a fixed amount per token burned, which makes early burns matter as much as late ones. An exponential target makes each burn compound on the last: the tenth percent burned lifts the target by the same ratio as the first percent did, but from a higher base. That is what keeps the mechanism from going quiet as supply thins.
Why k equals eight. At k = 8 the target doubles when 8.66 percent of supply has been burned, and reaches ten times the anchor at 28.78 percent burned. These figures follow from ln 2 over k and ln 10 over k and are computed, not chosen; k was chosen so that a plausible burn history over the life of a coin maps onto a plausible range of targets.
The spread is the real market cap over the target, minus one. The band is two percent either side of zero. Inside the band the program does nothing. Above the band the program does nothing, because it never sells. Below the band the program spends. The band exists so that ordinary noise does not drain the reserve on trades that would have reverted on their own.
When the state is below, the fraction of the reserve to spend is one minus e to the minus spread magnitude over kappa, with kappa equal to five hundredths. This is the same shape as the target, turned around: a small breach spends a small fraction, and the fraction saturates toward one as the breach grows. Two caps sit on top of it. Gamma limits any single step to a quarter of the reserve, so that a deep breach is answered by several steps over several trades rather than one. Rho keeps five hundredths of a SOL in the vault at all times so that the program can always pay for its own transactions.
| spread | raw kernel fraction | capped fraction | fires |
|---|---|---|---|
| −2.00% | 32.97% | inside | |
| −2.10% | 34.30% | 25.00% | below |
| −2.25% | 36.24% | 25.00% | below |
| −2.50% | 39.35% | 25.00% | below |
| −3.00% | 45.12% | 25.00% | below |
| −4.00% | 55.07% | 25.00% | below |
| −5.00% | 63.21% | 25.00% | below |
| −7.50% | 77.69% | 25.00% | below |
| −10.00% | 86.47% | 25.00% | below |
| −15.00% | 95.02% | 25.00% | below |
| −20.00% | 98.17% | 25.00% | below |
This table is computed from the constants alone. It holds for every value of the anchor cap.
| burned share | burned tokens | exponent k f | multiplier |
|---|---|---|---|
| 0.0% | 0 | 0.0000 | 1.0000× |
| 0.5% | 5,000,000 | 0.0400 | 1.0408× |
| 1.0% | 10,000,000 | 0.0800 | 1.0833× |
| 2.0% | 20,000,000 | 0.1600 | 1.1735× |
| 3.0% | 30,000,000 | 0.2400 | 1.2712× |
| 5.0% | 50,000,000 | 0.4000 | 1.4918× |
| 8.0% | 80,000,000 | 0.6400 | 1.8965× |
| 10.0% | 100,000,000 | 0.8000 | 2.2255× |
| 15.0% | 150,000,000 | 1.2000 | 3.3201× |
| 20.0% | 200,000,000 | 1.6000 | 4.9530× |
| 25.0% | 250,000,000 | 2.0000 | 7.3891× |
| 30.0% | 300,000,000 | 2.4000 | 11.0232× |
| 40.0% | 400,000,000 | 3.2000 | 24.5325× |
| 50.0% | 500,000,000 | 4.0000 | 54.5982× |
Suppose the anchor cap is recorded as one hundred thousand dollars and no tokens have been burned. The target is exactly the anchor. A sell pushes the market cap to ninety seven thousand. The spread is minus three percent, which is below the band. On the next observed trade the program evaluates, finds the state below, and computes the kernel: one minus e to the minus zero point six, which is a little over forty five percent of the reserve. The ceiling γ cuts that to twenty five percent. If the reserve holds two SOL above the floor, the program buys with half a SOL and burns what it receives.
The burn raises b. If the buy received one million tokens, f becomes one thousandth, the exponent becomes zero point zero zero eight, and the target rises to about one hundred thousand eight hundred and three dollars. The buy itself moved the market cap up as well. The spread narrows from both ends: the real cap climbed and the target climbed a little. If the coin is now inside the band, the program rests until a trade moves it out again.
Because the target rises with every burn, the coin is never allowed to settle at its anchor. Each step lifts the floor the next step will defend. The reserve refills from creator fees on every trade, so the program's capacity to defend the target is a function of trading activity on the coin, not of anyone's decision.
The coin is created on pump.fun with the vault as the creator fee recipient. pump.fun pays the creator share of every trade's fee to that address, before graduation on the bonding curve and after graduation on PumpSwap. No other address funds the vault. The program cannot withdraw from the vault to any address; the only outgoing path is the buy instruction, and the only thing the buy instruction can do with tokens is burn them.
The keeper is a server function named evaluate. It runs only when the poller observes a trade signature it has not seen. It reads the vault balance, the state account, and the live market cap, computes the spread, writes a row to the evaluations table, and if the state is below and the vault is above the floor, builds and sends the step transaction. Each evaluation is keyed on the trigger signature, so a repeated observation of the same trade cannot produce a second evaluation, and each step is keyed on its evaluation, so a retry cannot produce a second step.
The program is written in Anchor and named ecurve. It has three instructions and two accounts.
| account | seeds | size | holds |
|---|---|---|---|
| state | ["state", mint] | 8 + 32 + 32 + 8 + 8 + 8 + 8 + 1 = 105 bytes | mint, vault, anchor cap, burned, steps fired, spent lamports, bump |
| vault | ["vault", mint] | 0 bytes (system account owned by the program's PDA) | the SOL reserve; receives creator fees |
| instruction | signer | what it does |
|---|---|---|
| initialize(anchor_cap_micro) | the deploy authority, once | creates state and vault for the mint, stores the anchor cap, then the authority is set to the system program so nothing can call an admin path again |
| step(max_sol, min_tokens, evaluation_id) | the keeper key | transfers up to max_sol from the vault into the pump.fun buy, requires at least min_tokens received, burns the full received amount, increments burned and steps fired, records spent lamports, and stores evaluation_id in a small record account seeded by it so the same evaluation cannot step twice |
| record_fee() | anyone | no state change; exists so the vault balance can be read through a program log for indexers |
The keeper key can only call step. Step can only spend into the pump.fun program or PumpSwap program (their program ids are hard coded and checked), and can only burn what it received. There is no instruction that moves SOL or tokens anywhere else.
| time | side | SOL | tokens | price | tx |
|---|
| time | trade | market cap | target | spread | state | action |
|---|
| rank | address | balance | share |
|---|
Holders grouped by the size of their position. Computed from the top fifty only, which is what the source returns.
| band | holders | tokens | share |
|---|---|---|---|
| ≥ 1% | |||
| 0.1% to 1% | |||
| 0.01% to 0.1% | |||
| < 0.01% |