How the calculations work

Model and source scope

The calculators model a PONSv2 bonding curve and a graduated pool using the published component equations at commit e9dfc58128e8534d2e9d4d65be18f1dea32c404f, inspected on September 11, 2026. Normal scenario outputs use continuous arithmetic. The advanced curve calculator uses integer arithmetic and the rounding rules of that curve component.

Opening snipe tax is excluded; trade calculations assume its opening window has ended. The PONSv2 documentation describes a recipient-dependent opening tax. The pinned factory references snipe-tax exemptions, but the pinned curve component contains neither that tax nor those methods. Reading the configuration below does not resolve this source-version mismatch or verify deployed bytecode. Confirm the launch version and fee policy; the integer calculator also models only the published curve component.

The default graduated model assumes only the initial PONSv2 liquidity position, with no added or removed liquidity. It approximates that full-range position with xq = k and zero core pool fee. Real v4 positions have finite tick bounds and integer rounding. At the default graduation price the finite-range TVL adjustment is about 1.6 × 10⁻¹⁵ ETH; this small difference does not justify using the approximation near extreme range boundaries. Additional positions, multi-pool routes, or altered hooks require actual liquidity and tick state. These results are continuous scenarios, not exact v4 execution quotes.

These scenarios hold quote USD price, supply basis, and liquidity fixed. With zero core fee, swaps, fee-conversion swaps, and buybacks move reserves along the same fixed-liquidity relationship. Their timing can still change an execution quote; an individual trade scenario does not schedule those operations. Transfer taxes, gas, router charges, and opening snipe tax are excluded. Inputs are editable assumptions initialized from the dated preset, not live chain state.

ETH/USD price sources

The trade and launch pages first request the latest ETH/USD trade price from Coinbase Exchange, then try Kraken if needed. Each source has a four-second timeout. Prices must be positive and finite, with a market timestamp no more than five minutes old or one minute ahead. The displayed status identifies the source, market time and retrieval time. If neither source provides a valid recent price, calculations use the disclosed $2,500 fallback.

A lookup runs once when a calculator opens or resets; there is no periodic refresh. If the default scenario is untouched, its dollar amounts update together to preserve graduation liquidity and the 0.01 ETH default buy. Once you edit any form input, an arriving price keeps entered dollar amounts fixed and recalculates results. Editing the price cancels a pending lookup. Shared prices, including invalid values requiring correction, are preserved without fetching; sharing during loading freezes the current price. Calculations and scenario inputs remain in this browser; price requests send no scenario data. This methodology page does not request a market price.

Verified native launch preset

The documented PONSv2 deployment on Robinhood chain 4663 was read through its official RPC at block 60,755,506 (0x39f0e32), timestamp 2026-09-12T02:35:37Z, hash 0xc1a5d108281241daf4b424f76a9f0f4d6d65fff6220125c4bea4d5dcf3e5840b. The factory is 0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e and hook is 0xE5e702641Ea86F4ae6cC3cDaeD2B886f976Be044.

Native configuration 0 has S = 1,000,000,000, φ = 1.68 ETH, T = 4.2 ETH, curve fee 100 bps, core pool fee 0, and tick spacing 200. The hook policy has fee 100 bps, protocol share 3,000 bps, and buyback share 5,000 bps of the creator bucket. Zero creator tax and enabled buybacks are editable scenario choices. This snapshot is stored locally; the pages do not fetch live configuration, and future launches may use changed settings.

Reproduce the factory read with Foundry cast against an RPC that retains this block. Returned fields are supply atoms, curve fee bps, phantom quote atoms, graduation quote atoms, core fee, tick spacing, and enabled status; token and native quote amounts use 18 decimals.

cast call --rpc-url https://rpc.mainnet.chain.robinhood.com \
  --block 0x39f0e32 \
  0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e \
  'getLaunchConfig(uint256)(uint256,uint256,uint256,uint256,uint24,int24,bool)' 0

Units, market cap, and TVL

When S is total supply, pS is total-supply valuation (often called FDV). It is circulating market cap only when S is circulating supply. Use the same basis for the input and target. Locked tokens still belong to total supply; locking a buyback does not burn it. Voluntary token burns can change current total supply.

For pool inputs, both-sided TVL values the quote and token reserves at the pool's own spot price: TVL = Q + xp = 2Q. If a source reports only quote-side liquidity, use the quote-only option. The initial-pool mode derives TVL from market cap or market cap from TVL using the graduation liquidity. The advanced custom-pool mode accepts both independently. TVL across other pools, inactive ranges, pending fee balances, or a token's treasury is not the liquidity of this modeled pool.

On the curve, real quote liquidity is Q. Its token reserve's spot-marked value is xp = Q + φ, so the displayed reserve mark is Q + xp = 2Q + φ. This marks actual held tokens; it does not count phantom quote as a held asset. It is not cash backing or an amount all holders can redeem. The pricing reserve q must not be entered as real quote TVL.

Initial pool: TVL ↔ market cap

Let T be graduation quote and V both-sided pool TVL. Graduation removes phantom quote and locks excess tokens, so its new pool invariant is not the curve invariant Sφ. With only this position and zero core pool fee:

Pool seed tokens: x_g = SφT / (φ + T)²
Pool invariant:   k_g = x_g T = SφT² / (φ + T)²
Pool valuation:   M = S q² / k_g = S V² / (4k_g)
Inverse:          V = 2√(M k_g / S)

Default ETH:      M = (7/24)V²; V = √(24M/7)
USD at ETH/USD u: M_USD = (7/24)V_USD²/u
                  V_USD = √(24u M_USD/7)

For the default preset, M = 20.58 ETH maps to V = 8.4 ETH; doubling TVL quadruples valuation. The USD formula includes the entered conversion rate because squaring a dollar TVL also squares that rate. Quote-only TVL is V/2. This mapping describes a pool state, not historical gross buying. Use the custom-pool mode for a different liquidity invariant.

At the fallback price of $2,500 per ETH, graduation pool TVL is $21,000 and graduation market cap is $51,450. The fixed seed gives V/Vg = √(M/Mg), so a $2,000,000 market cap gives $21,000 × √($2,000,000/$51,450) ≈ $130,930.73 TVL. A fetched or manually entered ETH/USD price changes these dollar figures. Using $69,000 graduation MC and $20,000 graduation TVL instead would give $107,676.38 at $2,000,000 MC; those anchors differ from this preset’s graduation MC/TVL ratio of 2.45.

Permanent graduation locks are L = Sφ²/(φ + T)². These tokens remain in total supply but cannot be sold, so pool tokens cannot exceed S − L. The model enforces q ≥ k_g/(S − L) and M ≥ S k_g/(S − L)², and rejects a sale larger than the tokens outside the pool excluding permanent locks. This is a physical upper bound; other vesting, burns, fee custody, or individual holdings may further restrict actual sellable balances.

Exact-input trade scenarios

Each trade starts with the selected reserves. Fees leave tradeable liquidity. For a buy, B is gross quote offered. For a sell, A is the number of tokens sold. Curve base fee and graduated hook fee are separate policy fields; enter the rate for the selected stage rather than assuming they are equal.

Bonding curve

Buy net quote:       b = B(1 − f − t)
Tokens received:     x b / (q + b)
After buy:           q′ = q + b; x′ = x − tokens received

Sell gross quote:    g = q A / (x + A)
Quote received:      g(1 − f − t)
After sell:          q′ = q − g; x′ = x + A

A sell cannot withdraw phantom reserves. It must fit the available real quote and the tokens outside the ideal curve. A buy stops at the reserved token allocation, spends only what fills that allocation, and returns the excess. Both curve directions close when that allocation is reached. The scenario ends there; it does not automatically spend the refund in the graduated pool.

Graduated pool

Buy gross tokens:    g = x B / (q + B)
Tokens received:     g(1 − f − t)
After buy:           q′ = q + B; x′ = x − g

Sell gross quote:    g = q A / (x + A)
Quote received:      g(1 − f − t)
After sell:          q′ = q − g; x′ = x + A

The published hook takes its cut from the unspecified currency. In an exact-input buy that is token output; in an exact-input sell it is quote output. Pending fee tokens stay outside pool liquidity until a separate conversion sweep. Applying the curve's buy-input fee formula to a graduated buy would therefore be wrong. These pages model exact-input trades; exact-output hook swaps have different fee placement.

Impact and slippage

Average execution price is quote paid divided by tokens received for buys, or quote received divided by tokens sold for sells. Fee-inclusive adverse impact is average / p − 1 on buys and 1 − average / p on sells. The fee-exclusive impact uses net quote entering the curve, or gross pool/sell output, to isolate the exchange curve. Terminal spot movement is the separate signed percentage p′ / p − 1.

A buy's average-price premium is different from its output shortfall. For example, a 10% average-price premium corresponds to 1 − 1/1.1 = 9.0909% fewer tokens than the initial spot would suggest. Labels here use the average-price convention.

Slippage tolerance is a separate allowance for changes after quoting. The displayed minimum is modeled output times (1 − tolerance); it is not an additional trading fee. The pinned curve's partial-fill transaction uses a proportional price constraint: spent × minTokensOut ≤ offered × actualTokensOut. A static minimum based on the already-filled scenario is not a transaction builder.

Target market cap, size limits, and liquidation

With fixed k = xq and supply basis, let r = target M / current M. A higher target needs effective quote input q(√r − 1). Divide that by 1 − f − t for a curve buy; a pool buy puts the entire gross input into its reserves. A lower target needs token input x(1/√r − 1). The resulting trade must pass curve reserve and graduation limits, or the initial pool's available-token limit.

The size-limit calculator applies those same equations to a specified terminal spot rise or fall. It does not cap the average execution premium, and its percentage is not the protocol's similarly named internal buyback-impact setting.

Position liquidation sells the entered holding in one trade from the current scenario. The spot mark holding × p is compared with fee-net executable proceeds. P&L subtracts the entered quote cost from those proceeds, and excludes gas. This demonstrates why a higher headline market cap does not mean every holder can exit at spot.

For break-even after selling a holding H with quote cost C, set g = C/(1 − f − t). The needed quote pricing reserve solves q′² − gq′ − gk/H = 0, giving q′ = (g + √(g² + 4gk/H))/2 and pre-sale valuation M′ = S q′²/k. This holds the position and invariant fixed while other traders first move the price. The result is checked by simulating the complete sale. A curve exit must fit its real reserves and occur before its sellable allocation is exhausted.

Launch funding and graduation

The ideal launch starts with all S tokens and phantom quote φ, so k = Sφ. At real quote reserve Q:

x = Sφ / (φ + Q)
p = (φ + Q)² / (Sφ)
M = (φ + Q)² / φ
Tokens outside curve = S − x

Let T be the graduation real-quote threshold. Continuous graduation economics are:

Reserved tokens:       R = Sφ / (φ + T)
Tokens sold:           S − R
Pool seed tokens:      R T / (φ + T)
Permanently locked:    R − pool seed tokens
Terminal valuation:    (φ + T)² / φ
Pool quote seed:       T
Pool both-sided TVL:   2T
Gross buy-only spend:  T / (1 − f − t)

The factory seeds only a fraction of the reserved tokens and permanently locks the rest. Removing phantom quote and that token fraction together preserves the terminal spot price. It also makes pool liquidity shallower than the curve's terminal pricing reserves. Real contract allocations floor in token atoms, and v4 minting can leave dust.

For the default S = 1,000,000,000, φ = 1.68 ETH, and T = 4.2 ETH, graduation reserves about 285,714,285.714286 tokens, seeds 204,081,632.653061 pool tokens, and permanently locks 81,632,653.061224 tokens. Total-supply valuation is 20.58 ETH and pool TVL is 8.4 ETH. The curve's reserve mark immediately before graduation is 10.08 ETH; graduation preserves price while reducing the reserve mark. Select the stage explicitly: later selling can put the graduated pool below its graduation valuation.

“Total buys to market cap” is a buy-only scenario. At constant fees and without sells or buybacks, net raised quote equals gross buys times 1 − f − t, and the equations above map it to valuation. Historical gross buys cannot be reconstructed from current TVL or market cap alone. In general, real reserve growth equals net quote from external buys, minus gross quote released by sells, plus internally funded buybacks; liquidity changes add further terms after graduation. Repeated buying and selling can create arbitrary volume around similar ending reserves.

The ideal curve ignores the small invariant growth from atomic rounding. For an actual reserve snapshot, use the advanced integer calculator with the curve's tracked reserves instead of inferring them from launch progress.

Fee distribution

For a quote-denominated fee basis V, base fee F = Vf, protocol share a, and buyback share b of the creator bucket:

Protocol allocation = Fa
Buyback allocation  = (F − Fa)b       (zero when disabled)
Creator allocation  = F − Fa − buyback allocation + Vt

Creator tax bypasses the base-fee split. Buyback funding purchases tokens for a five-year vest; it is not a burn. The allocation is an earmark, not guaranteed execution. If the permitted buyback cannot execute, that slice may go to the creator. The curve and hook floor accruals and clamp aggregates, so summing one continuous volume estimate need not match many rounded trades exactly.

The calculator accepts standard base fee and creator tax values up to 1,000 bps each, protocol share up to 5,000 bps of the base fee, and buyback share up to 10,000 bps of the remaining creator bucket, following the published policy bounds. The dated preset uses 100 bps base/hook fees, 3,000 bps protocol share, and 5,000 bps buyback share. Zero creator tax and enabled buybacks are scenario choices, not factory-wide defaults.

Use gross quote spent for curve buys and gross quote output for sells. Graduated exact-input buys accrue token-denominated fees whose eventual quote value depends on the later conversion trade. Multiplying that buy's quote input by a fee rate is not an exact prediction of pool fee payouts.

Integer curve quotes and validation

The advanced curve calculator accepts atomic-unit integers or human decimal amounts converted exactly using the entered token and quote decimals. One whole 18-decimal token is 10¹⁸ atoms; one whole 6-decimal quote token is 10⁶ atoms. It uses JavaScript BigInt and never converts those amounts through floating point. Read getReserves(), realQuoteReserve(), phantomQuote(), reservedTokens(), feeBps(), and creatorTaxBps() from the same curve at the same block. The quote value returned by getReserves() already includes phantom quote; the field labeled real quote reserve must exclude it.

Fees and creator tax floor separately. Output floors as amountIn × reserveOut / (reserveIn + amountIn) after the relevant fee deduction. A clamped buy uses the published exact-output helper's integer division plus one, then a ceiling division to gross up input for the two fees. These details can change tiny trades and graduation refunds. The integer calculator rejects untradeable amounts and uint256 arithmetic bounds; it does not simulate token transfers, account balances, or factory graduation calls.

Development checks exercise independent hand-calculated vectors, default graduation allocations, MC/TVL inverse mapping, native/USD conversions, initial-pool inventory limits, fee placement in both stages, raw rounding and partial refunds, invariant conservation, malformed input, share compatibility, and bilingual browser behavior. Tests run offline against deterministic values. The calculation module has its own enforced coverage floor of 80% lines and functions and 70% branches.

Primary references

• Curve state, fee accounting, buy/sell settlement, and reserved allocation
• Integer exact-input and exact-output helpers
• Graduated fee hook and later fee conversions
• Finite full-range pool mint and dust handling
• Uniswap's liquidity ranges and active liquidity