What a bonding curve actually is

Most explanations of a bonding curve stop at "the price goes up as more people buy." That is true of almost every market ever built and so it explains nothing. What makes a bonding curve different is that there is no counterparty. You are not buying from another person who chose to sell. You are buying from a contract that will sell to anyone, at a price it computes from one number: how much it has already sold.

That single property is what the rest of this article unpacks.

There is no order book, and no one on the other side

An order book market needs two people who disagree. You want to buy at 10, someone else is willing to sell at 10, and the exchange matches you. If nobody wants to sell, there is no price — there is just a gap.

A bonding curve replaces the seller with a function. The contract holds a fixed allocation of tokens and a formula that answers one question: given how many tokens I have already sold, what does the next one cost? Because the formula always has an answer, the market is always open. There is no spread, no depth chart, no market maker who can walk away, and no moment where nothing trades because nobody showed up.

The cost of that convenience is that the price is not an opinion. Nobody is expressing a view when the price rises. The price rose because tokens left the contract, and the formula says tokens leaving make the next one dearer. This is worth internalising, because a rising curve price is frequently read as demand, and it is more precisely read as volume. They are correlated, but they are not the same thing, and the difference matters when you are deciding what a chart is telling you.

The formula: constant product over reserves

The common design — and the one used here — is the constant product rule, the same identity behind Uniswap. The contract tracks two reserves, one of ETH and one of tokens, and insists their product never falls:

eth_reserve × token_reserve = k

When you send ETH in, the ETH reserve grows. For k to hold, the token reserve must shrink — and the amount it shrinks by is exactly the number of tokens you receive. Rearranged, the tokens you get for Δeth are:

tokens_out = token_reserve − k / (eth_reserve + Δeth)

The marginal price at any moment is simply eth_reserve / token_reserve. Buy, and the numerator rises while the denominator falls, so the price rises twice over. That is the entire mechanism. Everything else is parameter choice.

One wrinkle that trips people up: these reserves are virtual. The contract does not literally hold 1.125 billion tokens at launch and pretend. It starts the two counters at chosen values so the curve has a defined shape from the very first wei, without anyone having to seed real liquidity. The ETH you send is real and it is held. The starting reserves are a coordinate system.

Graduation is arithmetic, not a milestone

"Graduation" sounds like a threshold someone decided on — hit a certain market cap and the team promotes you. It is not. In a properly parameterised curve, graduation is the moment the curve's token allocation runs out, and the point at which that happens is fixed by the starting reserves before anyone trades.

Here is how it works on The Hood, with the real constants from BondingCurve.sol:

Call the curve allocation C (750M), the pool allocation L (250M) and the graduation target T (the ETH to be raised). The contract seeds itself with:

virtual_token_reserve = C + R      where R = L × C / (C − L)
virtual_eth_reserve   = T × R / C

With C = 750M and L = 250M, R works out to exactly 375,000,000 — so the token reserve starts at 1.125 billion and the ETH reserve starts at exactly T / 2. No rounding, no dust. (This, incidentally, is why the split is 75/25 and not a rounder-looking 80/20: at 80/20, R becomes a repeating fraction and the exactness below stops being exact.)

Now watch what falls out. Take a target of 10 ETH:

• Starting reserves: 5 ETH and 1,125,000,000 tokens, so k = 5,625,000,000.
• Opening price: 5 / 1,125,000,000 ≈ 0.00000000444 ETH per token.
• When 10 ETH have been raised, the ETH reserve is 5 + 10 = 15, so the token reserve must be 5,625,000,000 / 15 = 375,000,000.
• Tokens sold to get there: 1,125,000,000 − 375,000,000 = 750,000,000.

That last number is the curve allocation, exactly. Not approximately — the final token is sold by the wei that completes the target. The curve cannot run out early and leave the target unmet, and it cannot hit the target with tokens still to sell. The two events are the same event, by construction.

Why the pool opens at the price the curve closed at

This is the part that separates a considered curve from a careless one, and it is worth checking on any launchpad you use.

At graduation the raised ETH and the reserved 250M tokens are placed into a pool. That pool has an opening price of its own: T / L. The curve, meanwhile, closed at a marginal price of (x₀ + T) / R — its final ETH reserve over its final token reserve.

Continuing the worked example:

• Curve's closing price: 15 / 375,000,000 = 0.00000004 ETH per token.
• Pool's opening price: 10 / 250,000,000 = 0.00000004 ETH per token.

They are the same number. That is not a coincidence and it is not tuning — it is what choosing R = L × C / (C − L) guarantees, for any target, for any split.

Why care? Because if those two prices differ, the difference is free money for whoever gets there first. A pool that opens below the curve's closing price hands an instant arbitrage to a bot, paid for by the last people who bought on the curve. A pool that opens above it does the reverse and punishes the first buyers in the pool. Either way, someone is worse off for reasons that have nothing to do with the project. Matching the two prices removes the gap, so the first trade in the pool is a trade, not a collection.

The 9x, by the way, also falls out of the constants: closing price over opening price is 2,250,000,000 / 250,000,000 = 9, always, regardless of the target. A curve with a 10 ETH target and one with a 100 ETH target both run exactly 9x from first buy to graduation. The target changes what the token is worth, not how far the curve travels.

What to actually check on a curve

Concepts are only useful if they turn into questions. These are the ones worth asking of any bonding curve, including this one:

• Do the closing and opening prices match? Compute T / L and compare it with the curve's final marginal price. A mismatch is a transfer from users to whoever is watching.
• Where does the raised ETH go at graduation? Into the pool, or into a wallet? These are very different products wearing the same word.
• Can the pool's liquidity be withdrawn afterwards? A timelock is a promise that expires. The absence of a withdraw function is not a promise at all.
• Can anyone trigger graduation? If only the creator can, holders are waiting on one address to show up. Here it is permissionless — a completed curve can be graduated by anybody.
• What happens to unsold tokens? On this curve, tokens still unsold at graduation go into the pool alongside the 250M rather than to anyone's wallet, and tokens donated to the curve are burned rather than pooled, so a donor cannot shift the opening price.
• Are transfers restricted during the curve phase? Here they are: before graduation a launch token can only move between a wallet and its own curve. That keeps the curve the single price source until a real pool exists, and it stops the token being traded on a venue with nothing behind it.

None of this makes a token a good idea. A curve is a pricing mechanism, not a judgement — it will price a serious project and a joke with identical enthusiasm. What a well-built curve buys you is the knowledge that the mechanism itself is not the thing working against you, which lets you spend your scepticism on the project instead.

If you want to go a level deeper on what to inspect before committing money to any launch, the companion piece on reading a token launch covers the on-chain checks. And before anything else, the risk disclosure is the short version of everything that can go wrong here.