How many tokens must be sold for a token to be graduated from the curve?

[0xcryptosei]

Graduation is the moment a launch stops trading on its curve and becomes a normal Uniswap pool. It happens when the curve has sold everything it was ever going to sell.

Not all of the supply is for sale on the curve. A fixed share is held back from the start, and that held-back share is what becomes the liquidity in the pool. It is decided when the launch is created and nobody can change it later, so there is no moment where a creator decides how much liquidity to provide, and no opportunity for them to provide less than expected.

Because the reserved share is fixed, every launch on the same settings graduates into a pool of the same size, at the same price. It does not matter whether the curve was bought out by one large purchase or by hundreds of small ones. You can work out in advance what the pool will look like, and it will look that way every time.

If your purchase is larger than what is left on the curve, you are not rejected. You buy what remains, you are charged only for what you actually received, and the rest is returned to you in the same transaction. This matters most for the buy that finishes a launch, because otherwise anyone could block it by slipping a small purchase in first. Your protection against a bad price still applies: you can receive fewer tokens than you asked for, but never at a worse price per token than you agreed to.

[koriyoshi2041]

For integrators, the exact answer is available from the curve and can also be computed before launch.

Let:

• S = launch token total supply
• P = phantomQuote
• T = graduationThreshold

At initialization the curve sets:

reservedTokens = floor(S * P / (P + T))
tokens that must leave the curve = S - reservedTokens

The Solidity implementation uses Math.mulDiv with its default floor rounding, so integrations should use integer arithmetic rather than floating point. The direct runtime answer is curve.sellableTokens(): graduation becomes ready exactly when this reaches zero (readyToGraduate() == true).

Example: if S = 1,000,000,000, P = 1 quote unit, and T = 4 quote units, the curve reserves 200,000,000 tokens and must sell (or move through its bounded internal buyback path) 800,000,000 tokens before graduation.

Minimal viem reads:

const curveAbi = parseAbi([
  "function reservedTokens() view returns (uint256)",
  "function sellableTokens() view returns (uint256)",
  "function readyToGraduate() view returns (bool)",
]);

const [reserved, remaining, ready] = await Promise.all([
  client.readContract({ address: curve, abi: curveAbi, functionName: "reservedTokens" }),
  client.readContract({ address: curve, abi: curveAbi, functionName: "sellableTokens" }),
  client.readContract({ address: curve, abi: curveAbi, functionName: "readyToGraduate" }),
]);

One nuance: “sold” is best interpreted as “removed from the curve's sellable allocation.” A configured fee buyback can also remove tokens from that allocation and lock them, while sells put tokens back and therefore increase the remaining amount. For live progress, sellableTokens() is more accurate than summing CurveBuy events.

[0xcryptosei]

800, 000, 000 is fixed value?

[koriyoshi2041]

No — 800,000,000 was only the result of the example values (S = 1,000,000,000 and P:T = 1:4). It is not a protocol-wide constant.

For each launch, calculate the amount from that launch's own immutable curve parameters:

tokens removed before graduation
= totalSupply - floor(totalSupply * phantomQuote / (phantomQuote + graduationThreshold))

So two launches can have different token amounts if their supply or phantomQuote:graduationThreshold ratio differs. For launches created with the same values, the amount is the same.

For an existing launch, the safest integration is not to hard-code 800,000,000: read sellableTokens() from its curve. That returns the exact amount still remaining before graduation, including the effects of buys, sells, and enabled internal buybacks. The launch's constructor parameters are immutable, so later factory config changes do not alter an already-created curve.