> ## Documentation Index > Fetch the complete documentation index at: https://docs.raydium.io/llms.txt > Use this file to discover all available pages before exploring further. # Bonding curves > The mathematics behind token-issuance curves — quadratic, linear, and virtual-reserves CPMM variants — derivations for cost / proceeds / spot price, and the graduation-threshold math used by LaunchLab. This page derives the general bonding-curve mathematics. For LaunchLab's specific implementation, see [`products/launchlab/bonding-curve`](/products/launchlab/bonding-curve). The derivations are given in continuous form; the on-chain code implements the discrete analog in fixed-point arithmetic. ## What a bonding curve is A **bonding curve** is a deterministic price function `p(s)` that relates the price of a token to the amount currently in circulation (`s` for "supply sold"). Buyers purchase by sending collateral to the contract; the contract emits new token units at the marginal price dictated by the curve. Sellers return token units and receive the integrated refund. Two key properties compared to a CPMM pool: * **No counterparty needed.** The issuing contract is the market maker; liquidity exists by fiat. * **Monotonic price.** Price rises with every net-buy and falls with every net-sell. Bonding curves are the standard launch mechanism when the issuing entity does not want to pre-seed an AMM pool with collateral. ## Generic pricing formulas For any continuous price function `p(s)`: **Spot price** at supply `s`: ``` p(s) = the curve formula ``` **Cost to buy** supply from `s_0` to `s_1` (with `s_1 > s_0`): ``` cost(s_0, s_1) = ∫_{s_0}^{s_1} p(s) ds = P(s_1) − P(s_0) ``` where `P(s) = ∫ p(s) ds` is the curve's antiderivative. Geometrically, `cost` is the area under `p` between `s_0` and `s_1`. **Proceeds from selling** supply back from `s_1` to `s_0`: ``` proceeds(s_1, s_0) = cost(s_0, s_1) ``` (Symmetry: buying and selling across the same interval exchanges the same collateral — modulo fees.) **Average price** for the buy: ``` avg = cost(s_0, s_1) / (s_1 − s_0) ``` ## Common curve families ### Linear ``` p(s) = a + b · s ``` ``` P(s) = a·s + (b/2)·s² cost(s_0, s_1) = a·(s_1 − s_0) + (b/2)·(s_1² − s_0²) ``` Price rises proportionally with supply. Used for "steady" launches where the issuer wants a predictable, moderate markup over the lifetime. ### Quadratic ``` p(s) = k · s² // or k · (s / S_max)² for a normalized form ``` ``` P(s) = (k / 3) · s³ cost(s_0, s_1) = (k / 3) · (s_1³ − s_0³) ``` Price rises quadratically. Early buyers get a near-zero price (flat starting region); late buyers pay a steeper premium. This is the curve type LaunchLab defaults to (`curve_type = 0`). ### Virtual-reserves CPMM (Pump-style) The curve is a standard CPMM with a pretend initial quote reserve `V_q`: ``` effective_y = V_q + collateral_received effective_x = S_max − s (effective_x) · (effective_y) = V_q · S_max // invariant ``` Spot price: ``` p(s) = effective_y / effective_x = V_q · S_max / (S_max − s)² · ... (derivable via implicit differentiation) ``` Cost to move from `s_0` to `s_1`: ``` cost(s_0, s_1) = V_q · S_max / (S_max − s_1) − V_q · S_max / (S_max − s_0) = V_q · (s_1 − s_0) · S_max / ((S_max − s_0) · (S_max − s_1)) ``` This variant has the elegant property that at graduation (where `s = S_graduate`), the marginal price equals the opening price of the downstream CPMM pool seeded with reserves `(S_max − S_graduate, V_q + cost(0, S_graduate))`. Handoff is seamless. LaunchLab exposes this as `curve_type = 1`. ## Discrete implementation On-chain, `s` and `cost` are both integers (smallest-denomination units). The continuous integral `cost(s_0, s_1)` is computed directly from the closed form whenever one exists (linear, quadratic). For curves without a closed-form inverse (quadratic, given `cost`, find `s_1`), Newton iteration is used: ``` # Solve quadratic: (k/3)·s_1³ = (k/3)·s_0³ + cost # Initialize with s_guess ≈ cbrt(3·cost/k + s_0³) for i in 0..MAX_ITER: f = (k/3)·s_guess³ − (k/3)·s_0³ − cost f' = k·s_guess² step = f / f' s_guess -= step if |step| < precision_floor: break ``` LaunchLab caps iterations at \~10 and reverts with `NotConverged` if the residual is still above tolerance. In practice this only triggers near the domain's extremities; production swaps converge in 2–3 iterations. ## Fee integration Fees are applied on top of the curve cost, not inside it. On buy: ``` cost_curve = cost(base_sold, base_sold + base_out) fee = ceil(cost_curve · buy_numerator / buy_denominator) quote_in = cost_curve + fee ``` On sell: ``` proceeds_curve = cost(base_sold − base_in, base_sold) fee = ceil(proceeds_curve · sell_numerator / sell_denominator) quote_out = proceeds_curve − fee ``` The LP portion of the fee is retained in `quote_vault` and effectively makes the curve stiffer for later buyers — the reserve grows without issuing more supply. The protocol and creator portions are tracked in separate counters for later sweep. ## Graduation threshold A curve "graduates" when it has received enough collateral to seed an external AMM pool at a price matching the current curve price. For a quadratic curve with parameters `(k, S_max, S_graduate)`: ``` quote_to_graduate = cost(0, S_graduate) · (1 + buy_fee_rate) = (k / 3) · S_graduate³ · (1 + f_buy) ``` Once `quote_vault ≥ quote_to_graduate`, the `Graduate` instruction creates a CPMM pool with: ``` cpmm_base_reserve = S_max − S_graduate // unsold curve supply cpmm_quote_reserve = quote_vault − accrued_fee_counters cpmm_initial_price = cpmm_quote_reserve / cpmm_base_reserve ``` For the virtual-reserves curve, by construction: ``` cpmm_initial_price == p(S_graduate) // exact equality ``` For the quadratic, the equality is approximate; the "slop" is absorbed into the rounding of `S_graduate` (typically `0.8 · S_max`) and the surplus collateral from the final threshold-crossing buy. ## Impermanence vs a CPMM pool A pure bonding-curve launch has **no impermanence** in the Uniswap sense: there is no "other side" of the market to rebalance against. The curve issues supply on demand, and the only "LP" is the contract itself. Post-graduation, the resulting CPMM pool behaves like any other CPMM pool — if the LP was not burned, they are subject to the usual impermanent-loss dynamics. This is why the **burn** post-graduation policy is dominant in public launches: it keeps the pool permanent and removes any LP-withdrawal-driven price shocks. ## Worked example Curve: quadratic, `k = 40`, `S_max = 1e9`, `S_graduate = 0.8 · S_max = 8e8`. Buy fee 1%. ### Price at `s = 5e8` ``` p(5e8) = 40 · (5e8 / 1e9)² = 40 · 0.25 = 10 ``` 10 units of quote per base unit. ### Cost of the first buy of 1e6 base ``` cost(0, 1e6) = (40/3) · (1e6)³ = (40/3) · 1e18 ≈ 1.333e19 (smallest quote units) ``` With 1% fee: ``` quote_in = 1.333e19 · 1.01 ≈ 1.347e19 ``` ### Graduation threshold ``` cost(0, 8e8) = (40/3) · (8e8)³ = (40/3) · 5.12e26 ≈ 6.827e27 quote_to_graduate ≈ 6.827e27 · 1.01 ≈ 6.895e27 ``` ### Price at graduation ``` p(8e8) = 40 · 0.64 = 25.6 ``` ### Post-graduation CPMM reserves ``` cpmm_base = 1e9 − 8e8 = 2e8 cpmm_quote ≈ 6.827e27 (less fee-counter deductions) cpmm_price ≈ 3.41e19 per base — which matches p(8e8) after units are accounted for ``` (Units: decimals need to be tracked carefully; the example is illustrative.) ## Pointers * [`products/launchlab/bonding-curve`](/products/launchlab/bonding-curve) — the on-chain LaunchLab implementation of these formulas. * [`products/launchlab/instructions`](/products/launchlab/instructions) — `Buy`, `Sell`, `Graduate` account-level specs. * [`algorithms/constant-product`](/algorithms/constant-product) — what the post-graduation CPMM does with the reserves. Sources: * Raydium LaunchLab program source (quadratic + virtual-reserves curve implementations). * Bancor white paper (linear bonding curves, historical). * Pump.fun public post-mortems (virtual-reserves variant).