How pricing works

A bonding curve is a rule for exchanging tokens against a reserve. Blast uses a constant-product rule. Buying changes the reserves and therefore changes the price for the next buyer. There is no fixed sale price.

This guide builds the rule from first principles. Try every idea in the bonding-curve builder. The executable formulas follow curve.move; the integrator reference gives exact atomic-unit pseudocode and call requirements.

1. What does x × y = k mean?

Multiplication gives a product. If x × y = k and k is held constant, changing x requires changing y in the opposite direction.

x × y = k
    y = k / x
    x = k / y

For example, keep k = 100,000:

x: tokens in the curve	y: effective quote reserve	Product x × y
1,000	100	100,000
800	125	100,000
500	200	100,000
250	400	100,000

This is x × y = k, not x = y × x. The latter would imply y = 1 whenever x is non-zero and would not describe this pricing rule.

A constant product, changing reserves

The graph is a curve, not a straight line: halving the token reserve doubles the effective quote reserve. You cannot take half the remaining tokens for half the quote cost of a previous purchase.

The examples in this section deliberately use a small, no-fee teaching inventory. A generated Blast launch starts with one billion whole tokens, only part of which is assigned to the curve.

2. Map the letters to the contract

Symbol	Meaning	Spendable?
M, or x	Tokens still held in the curve reserve	Available to buy while trading is live
Q	Real quote coins held by the curve	Funds sells and the graduation allocation
V	Virtual quote reserve, fixed for this launch	No; it is a pricing parameter
y = V + Q	Effective quote reserve used in the equation	Only the Q part is real
k = M × (V + Q)	Reserve product for deriving this trade	A number, not a coin balance
T	Graduation target for real quote reserve	Reached when Q = T

At opening, Q = 0. The curve can still quote a non-zero price because V > 0. The creator does not deposit V quote coins. It never counts toward the target, pool liquidity, or a seller’s available payout.

The continuous derivations below hold the product constant. The contract calculates each trade in integers and rounds output down, so the product can increase slightly after a trade. Use the current reserves for every quote rather than assuming the opening k stays exactly constant forever.

3. Derive a buy, one step at a time

Start with M = 1,000, V = 100, Q = 0. Ignore fees and atomic rounding for this first example. A buyer puts in 25 quote coins.

Before: k = 1,000 × (100 + 0) = 100,000
After effective quote reserve: y′ = 100 + 0 + 25 = 125
After token reserve: M′ = k / y′ = 100,000 / 125 = 800
Tokens paid to buyer: 1,000 − 800 = 200
After real quote reserve: Q′ = 25

The 100 virtual quote coins remain virtual. The curve has 25 real quote coins, not 125.

Substitute arbitrary reserves and a net quote input n:

M′ = M × (V + Q) / (V + Q + n)
tokens_out = M − M′
           = M × n / (V + Q + n)

The contract floors tokens_out to an integer number of token atoms, then removes the token fee. Quote fees come out of the buyer’s input before this calculation.

If you want a particular number of tokens

Rearrange the no-fee buy formula for a desired output a:

a = M × n / (V + Q + n)
a × (V + Q) = n × (M − a)
n = a × (V + Q) / (M − a)

At the teaching opening state, wanting 200 tokens requires 200 × 100 / (1,000 − 200) = 25 quote coins. As a approaches the entire reserve, the denominator approaches zero and the required input grows without bound. A finite buy cannot empty a curve with positive virtual quote. The graduation cap may close trading much earlier.

This inverse is a continuous, no-fee explanation. To build an exact-output transaction, gross up for both fees in their correct order, respect atomic ceilings and the target cap, and verify the final executable quote. The builder quotes exact input amounts.

4. Why does price increase?

For a very small trade, the reserve ratio gives the spot price:

spot price = (V + Q) / M        [quote per token, with matching units]

One way to see this is to increase the effective quote reserve by a tiny dy while removing dx tokens:

(M − dx) × (y + dy) = M × y
M × dy − y × dx − dx × dy = 0
For a vanishingly small trade, dx × dy vanishes:
dy / dx = y / M

In the 25-quote example:

Price	Calculation	Quote per token
Before the buy	100 / 1,000	0.1
Average paid, no fees	25 / 200	0.125
After the buy	125 / 800	0.15625

The buyer pays across a changing curve. Multiplying 200 tokens by the opening spot price would understate the cost. Multiplying by the ending spot price would overstate it. Neither spot is the execution price for the whole trade.

With no sells and ignoring rounding, substitute M = M₀ × V / (V + Q):

M(Q) = M₀ × V / (V + Q)
p(Q) = (V + Q)² / (M₀ × V)
p(Q) / p(0) = (1 + Q / V)²

Spot price rises as real quote enters

For M₀ = 1,000 and V = 100:

Real quote reserve Q	Token reserve M	Spot price	Multiple of opening price
0	1,000	0.1	1×
25	800	0.15625	1.5625×
50	666.666…	0.225	2.25×
100	500	0.4	4×

This is a buy-only illustration, not a prediction of demand or returns. Sells move back along the reserve relationship using their effective token input; fees, deferred burns and atomic rounding change the balances that actually arrive.

5. What does the virtual reserve change?

For a fixed opening token reserve M₀, opening price is V / M₀. Increasing V increases the starting price. For a fixed real quote target, it also reduces the multiple by which the curve price grows.

How the virtual reserve changes the price path · Solid: V = 100. Dashed: V = 200.

Same 1,000 curve tokens and 100 real quote target	V = 100	V = 200
Opening spot price	0.1	0.2
Final spot price, no rounding	0.4	0.45
Final / opening price	4×	2.25×
Tokens remaining at target	500	666.666…

Choose a price path from a target multiple

For a no-sell, no-rounding plan with a desired final/opening price multiple r > 1:

r = (1 + T / V)²
V = T / (sqrt(r) − 1)
M₀ = V / opening_price

For a 4× multiple, sqrt(4) − 1 = 1, so V = T. For a 9× multiple, V = T / 2. A larger multiple concentrates more price movement into the same real quote target. These are design equations, not promised returns. The derived inventory must still fit the fixed original supply, LP allocation, Blast’s share and every project recipient.

A higher virtual reserve does not add real sell liquidity. At Q = 0, an attempted sell has no real quote backing. Even when a formula returns a positive number, the transaction cannot pay more than the real reserve.

6. Add both asset fees

Blast can snapshot a quote-side fee and a token-side fee, each from 0% to 10%, when creating a launch. They are independent and can both be non-zero. One basis point is 0.01%; 100 BPS is 1%; the denominator D is 10,000.

The contract rounds fees up and user outputs down in atomic units. Here is an executable-sized example, entirely in atoms, not whole coins:

M = 1,000,000       V = 100,000       Q = 0       T = 100,000
Quote fee = 1%     Token fee = 1%    Quote supplied = 10,000

Quote fee       = ceil(10,000 × 100 / 10,000) = 100
Net quote       = 10,000 − 100 = 9,900
Gross tokens    = floor(1,000,000 × 9,900 / 109,900) = 90,081
Token fee       = ceil(90,081 × 100 / 10,000) = 901
Delivered       = 90,081 − 901 = 89,180 token atoms
New M           = 909,919
New Q           = 9,900

The reserve loses all 90,081 gross token atoms. Of those, the buyer receives 89,180 and the fee ledger receives 901. The buyer’s average price uses the 10,000 quote atoms spent divided by the 89,180 delivered token atoms, with decimal conversion if the coins have different decimals.

Blast’s live share of each fee is ceil(fee × protocol_share / D); the creator gets the remainder. A partner’s cut comes out of Blast’s part at payout. It adds no extra fee to the trader. See Fees and rewards.

7. Derive a sell and deferred burn

A sell adds effective tokens to the curve and removes quote. With x effective token atoms reaching the reserve:

M′ = M + x
y′ = M × (V + Q) / (M + x)
gross_quote_out = (V + Q) − y′
                = (V + Q) × x / (M + x)

The effective input is smaller than the wallet’s input when a token fee or sell burn applies:

token_fee = ceil(input_tokens × token_fee_bps / D)
after_fee = input_tokens − token_fee
pending_burn = ceil(after_fee × sell_burn_bps / D)
x = after_fee − pending_burn
gross_quote = floor((V + Q) × x / (M + x))
quote_fee = ceil(gross_quote × quote_fee_bps / D)
delivered_quote = gross_quote − quote_fee

Continuing from the previous buy, sell 10,000 token atoms with a 1% sell burn. The token fee is 100, pending burn is 99, and 9,801 tokens reach the reserve. Gross quote output is floor(109,900 × 9,801 / 919,720) = 1,171; its quote fee is ceil(1,171 × 1%) = 12, leaving 1,159 quote atoms. The new token reserve is 919,720 and the real quote reserve is 8,729. The builder shows every step and refuses a sell that cannot be funded by real reserves.

The sell burn is held until graduation; recorded supply has not fallen at the moment of the sell. Burn-only launches later burn it. Fixed-supply launches instead send disposal tokens to the zero address. A burn is not a quote-coin refund or an additional payout.

Sells require a live publicly shared launch. Once the target is reached, both curve buys and curve sells stop; the DEX pool is a later trading venue.

8. Price impact and slippage are different

Price impact is the movement caused by the trade itself. A large buy consumes a meaningful part of the token reserve; its average price is worse than the initial marginal price even if nobody else trades.

Slippage tolerance sets how much less output a transaction accepts compared with a previously calculated quote. Other transactions or a stale reserve snapshot can change the net output. Live routing-policy changes can also change who receives fees, while the launch’s total trade-fee rates stay fixed. A minimum output makes the transaction abort instead of accepting less.

minimum_output = floor(quoted_net_output × (10,000 − tolerance_bps) / 10,000)

This calculation belongs in atomic units. A tolerance of 1% does not mean the trade’s price impact is only 1%. It also does not make an old quote executable or keep the launch live after another buyer reaches the target.

9. Cap the last buy at graduation

The target tracks real quote reserve after fees and sells, not gross volume. Let R = T − Q and fq be the quote-fee rate:

If supplied_quote − ceil(supplied_quote × fq / D) <= R:
    use all supplied quote
Otherwise:
    gross_used = ceil(R × D / (D − fq))
    refund = supplied_quote − gross_used

For R = 99 atoms, a 1% quote fee and 150 supplied atoms, the contract uses 100, takes 1 as fee, adds exactly 99 to the reserve, and returns 50. Refunded quote is not charged again.

The final buy can reach the target while rounding to zero token output. That special terminal trade succeeds only with minimum output zero. A nonterminal zero-output buy aborts. A sell always needs positive net quote output. Tiny trades can therefore behave very differently from a continuous graph.

10. Pool price is a second design decision

At graduation, the contract does not pour all remaining curve tokens into the pool. It disposes of unsold curve tokens and accumulated sell burn, then seeds the pool with its separately allocated token amount and its share of the final real quote reserve.

Nominal pool price = allocated_real_quote / allocated_pool_tokens

For an illustrative billion-token launch with 700 million curve tokens, 200 million pool tokens, V = 1,000 and T = 3,000, ignoring rounding:

Opening price       = 1,000 / 700,000,000 ≈ 0.000001428571 quote/token
Final curve reserve = 700,000,000 × 1,000 / 4,000 = 175,000,000 tokens
Final curve price   = 4,000 / 175,000,000 ≈ 0.000022857143
Pool quote at 90%   = 2,700
Nominal pool price  = 2,700 / 200,000,000 = 0.0000135

The pool opens at a different ratio. A matching nominal ratio would need pool_tokens = pool_quote / final_curve_price, but that amount must still fit every supply allocation and atomic-unit requirement. Rounding in the concentrated-liquidity venue can leave residual assets. The builder compares both ratios; it does not promise a fill at either one.

11. Decimals, valuation and liquidity

A coin with 9 decimals has one billion atoms per whole coin; a coin with 6 decimals has one million. The reserve formula uses atoms, so convert the ratio before presenting a whole-token price:

whole-token price = (V_atoms + Q_atoms) / M_atoms × 10^token_decimals / 10^quote_decimals

For example, 1,000,000 quote atoms at 6 decimals and 1,000,000,000 token atoms at 9 decimals represent one whole coin each: their whole-token ratio is 1, not 0.001. Keep ratios until formatting; integer division before decimal scaling can display a legitimate price as zero.

Valuation multiplies a price by a token-supply measure. Liquidity is the assets available in the reserve or pool. A one-million-quote valuation does not mean one million quote coins can be withdrawn. Current recorded supply and the original billion-token supply give different valuations after a burn. Neither measure establishes circulating supply or realizable sale proceeds.

The venue seed is floor(sqrt(coin_B_atoms / coin_A_atoms) × 2^64). Canonical coin order can invert the ratio. Display decimals do not enter that atomic calculation; pool bounds, ticks and position rounding still matter.

12. Opening rounds and path dependence

An opening round aggregates bids into one buy after 60–300 seconds. A participant receives a proportional share of the remaining delivered tokens and unused quote. Each delivery floors the share; the final delivery takes the remainder. It is not a sequence of individually timed curve purchases, and bids cannot be withdrawn.

Without a round, a creator may buy before public sharing. In either mode, disclose the actual launch flow. A round does not change the curve formula or remove contract, custody or administrative risks.

A useful analysis always states its path: one aggregate buy, many buys, buys and sells, or an opening-round settlement. The builder states its two-leg buy-only baseline; a leg splits into bounded buys only if its input would exceed u64. Do not infer guaranteed future prices, yield, or target-miss refunds from any chart. Read Allocations and design choices and Safety and authority before using a plan.

Terminology at a glance

Term	Meaning here
Quote coin	Payment and payout asset, such as SUI; different from the launched token
Atom	Smallest integer unit of a coin
Virtual reserve	Fixed number used in pricing, with no matching coin deposit
Gross / net	Amount before / after the stated fees or deductions
Spot price	Marginal reserve ratio for a tiny trade
Average execution	Actual quote spent or received divided by actual tokens received or supplied
Price impact	Movement caused by the trade’s own size
Slippage minimum	Transaction’s minimum acceptable net output
Graduation	Closure at the real quote target, followed by a separate pool migration
Pool allocation	Assets reserved to seed the DEX, separate from unsold curve inventory
LP fees	Fees earned by a DEX position, collected and routed through the vault
Valuation	Price multiplied by a stated supply measure, not withdrawable quote liquidity

For settings and operational limits, continue to Allocations and design choices. For object IDs, package versions, errors and exact calls, use the contract integration guide.