The curve and graduation · Rearctor Docs

A reaction begins with a bonding curve backed by real tokens and real USDC. When its accounted USDC reserve reaches 5,042 USDC, the same transaction initializes its registered Uniswap V4 pool and deposits liquidity into a locked position. Trading continues through the token page after that transition.

These mechanics are available in the connected Arc Testnet deployment. Mainnet remains in Preview. Testnet uses test USDC; see deployment status.

Launch requirements#

The creator provides at least the current owner-set minimum (1 USDC initially), and less than 5,042 USDC, as seed liquidity. The full initial supply of one billion tokens is minted to the pool. Fees and their allocation are fixed at creation.

An optional dev buy is an ordinary paid curve purchase performed atomically by the factory. It must purchase no more than 20% of the initial supply and must leave the curve below its graduation target. A large seed does not exempt the dev buy from either rule.

Public buy, guarded buys and the project buyback purchase path require a block strictly later than the launch block. The factory’s capped dev buy is the designated exception. This restriction prevents an atomic launch-plus-extra-buy from bypassing the dev-buy limit. It does not limit purchases in later blocks, aggregate holdings across wallets, or guarantee a bot-free market. The sell entry point does not impose this launch-block restriction.

Units and constants#

Contract amounts are unsigned integers in base units:

One project token = 10^18 token units.
One USDC = 10^6 quote units.
S = 1,000,000,000 × 10^18: initial token supply.
s: seed, in USDC base units; minimumSeed() <= s < 5,042 × 10^6 (default minimum: 1 × 10^6).
G = 5,042 × 10^6: graduation target.
B = floor(G / 3) = 1,680,666,666: virtual quote offset, equal to 1,680.666666 USDC.
T and Q: current real, accounted token and quote reserves.
A: virtual token offset, fixed from the launch’s seed.

The offset is calculated with downward integer rounding:

A = floor(S × B × (s + B) / ((G + B)^2 - B × (s + B)))

virtual token reserve = T + A
virtual quote reserve = Q + B

The curve follows the constant-product relationship between those virtual reserves. With integer rounding, the product does not decrease during ordinary curve trades:

K = (T + A) × (Q + B)

The offsets determine the curve’s shape. They are not assets, cannot pay sellers and are never deposited into V4. A sell is executable only if its gross USDC output is covered by the real quote reserve.

Curve buys#

Let a be the user’s requested USDC input and b the buy fee in basis points. Division below explicitly uses floor or ceiling as shown:

capacity = ceil((G - Q) × 10,000 / (10,000 - b))
spent    = min(a, capacity)
fee      = ceil(spent × b / 10,000)
net      = spent - fee
out      = floor((T + A) × net / (Q + B + net))

T_next = T - out
Q_next = Q + net

The trader supplies a nonzero minimum output and deadline. Zero-output buys or outputs below that minimum revert.

For the final curve buy, the pool spends only the amount required to reach the target. Excess input is returned to the payer in the same transaction. The payer still needs the balance and allowance for the requested input because the pool pulls that input before refunding the unused part.

previewBuy returns output, fee and actual spend. maxCurveBuy returns the gross input needed to finish the curve, including the buy fee. A quote is not a reservation: other trades can change the available capacity before execution.

Curve sells#

For token input a and sell fee b:

gross = floor((Q + B) × a / (T + A + a))
fee   = ceil(gross × b / 10,000)
out   = gross - fee

T_next = T + a
Q_next = Q - gross

If gross > Q, the virtual quote offset cannot cover the shortfall; the quote returns zero and the trade cannot execute. A successful sell transfers out USDC to the trader and allocates the USDC fee to the vault.

Sells can move the reserve farther from graduation. Trading fees and direct transfers to the pool do not count toward the graduation target. Successful fee-free project buyback purchases on the curve do add their actual USDC spend to its reserve and can complete graduation.

For the curve’s marginal spot price, convert the ratio of virtual reserves into human units:

USDC per token = ((Q + B) / (T + A)) × 10^12

This marginal price does not equal the average execution price of a finite trade. Price impact, fees and integer rounding affect execution. A displayed market cap or FDV is not a promise that the supply can be sold for that amount.

The graduation transaction#

The threshold-reaching purchase performs the transition automatically:

Apply the final curve purchase and its applicable fees.
Confirm Q is exactly G and sufficient real tokens remain.
Derive the starting V4 price from the curve’s final virtual-reserve ratio.
Initialize the registered V4 key through the pool’s authorized hook.
Deposit real token and USDC reserves into the locked V4 position.
Record the deposited amounts and locked remainders, clear the curve-reserve counters, set graduated = true, and emit Graduated.

The automatic path requires the deposit to include at least 20% of the initial token supply and at least 99% of each remaining real reserve. Small unusable remainders remain locked in the pool. Direct donations are excluded from the accounted reserves used for migration.

Initialization and deposit are atomic. If the PoolManager is unavailable, the deposit fails, the output minimum is not met, or any other check fails, the whole threshold trade reverts. The earlier curve state remains intact. The trader still pays gas for a mined reverting transaction.

A keeper is not needed to trigger automatic graduation. Updated pool implementations also expose the owner-only manualGraduate method described below. The final purchase itself pays the additional migration gas, so its cost can be materially higher than an ordinary curve trade.

Liquidity after graduation#

The V4 key contains the sorted token/USDC currencies, dynamic-fee flag, tick spacing 200 and Rearctor’s registered hook address. The pool ID derives from this entire key; another hook or fee configuration identifies another pool.

The native V4 position belongs to the launch’s RearctorPool, uses ticks −887200 to 887200, and uses position salt zero. There is no withdrawable LP token or transferable LP NFT. The pool has no negative-liquidity operation, principal withdrawal or upgrade entry point. Later fee-funded liquidity additions increase the same locked position.

The hook permits only the registered RearctorPool to initialize this key or add liquidity to it. Third-party LPs cannot add a competing position to that same canonical key. Fee collection realizes earned fees without reducing the locked principal.

“Locked” describes withdrawal permissions. It does not freeze price, asset composition or token value, and it does not guarantee executable liquidity at every possible price.

Buying and selling after graduation#

The public pool methods remain buy and sell. At execution, the contract detects graduation and swaps through its stored V4 key. The application checks the factory registration, pair, manager and hook before approving or trading, and refreshes the quote after approval. It does not select an aggregator or an alternative pool.

The curve quote methods return zero after graduation. Integrators must use the matching V4 Quoter with the canonical pool key. A stale indexed graduation flag must not select the quote path; read the live contract state.

The hook applies the configured buy fee to input USDC and the sell fee to input project tokens. These fees also apply if an external router trades through the canonical pool. Anyone can create independent markets for a transferable ERC-20 using a different key; those markets are outside Rearctor’s hook and fee guarantees.

Trading remains subject to balances, allowances, available liquidity, minimum output, deadlines, USDC transfer restrictions and network availability. Budget guard failures do not automatically disable ordinary trades.

Read Tokenomics and fees, Smart contracts and Permissions and liquidity for allocation rules, APIs and contract roles.

Owner-directed early graduation#

The current factory owner can call manualGraduate(minToken, minQuote, maxDeadTokens, deadline) after the launch block. It uses the same canonical V4 key, hook, full-range position and virtual-reserve marginal price as automatic migration. It cannot select a recipient or withdraw liquidity.

Early migration requires at least 200 million tokens deposited and at least 99% of accounted USDC paired. It relaxes only the automatic path’s requirement to use 99% of the remaining token reserve. Any accounted token remainder is transferred to the fixed DEAD_ADDRESS, 0x000000000000000000000000000000000000dEaD, up to the caller's maxDeadTokens limit. Neither the owner nor the creator can redirect it. Only the remainder of accounted curve reserves is sent: direct donations, fee budgets and tokens deposited in V4 are excluded. Any USDC remainder remains locked in the pool.

This is an ERC-20 transfer, not a token burn: totalSupply does not decrease. The pool records deadTokenRemainder and emits GraduationRemainderSentToDead(recipient, amount) for the transfer. These amounts are separate from buyback burns and their counters. Automatic graduation continues to keep both small remainders locked in the pool.

previewGraduation() returns (usedToken, usedQuote, remainderToken, remainderQuote, eligible). For manual graduation, remainderToken is the predicted amount sent to dead; remainderQuote stays locked. The preview excludes donations. Low reserves can fail the 200-million-token deposit floor. Eligibility depends on actual reserves and integer rounding; it is not a fixed second USDC threshold. The preview is not owner authorization or an execution guarantee.

Control Room shows the deposits, dead-address recipient and transfer maximum before wallet confirmation. It enforces minimum deposits, the accepted maxDeadTokens and a deadline, and rechecks the current owner and market state. The transfer cap is not silently increased when the preview changes; an excessive new remainder requires another review. A zero cap permits only a zero token remainder. Early migration preserves marginal price but can increase price impact because market depth changes. It emits Graduated(..., true). The automatic path keeps its original checks and emits false.

Older immutable pool clones do not acquire the four-argument method or dead-transfer behavior from a website update. See Admin & networks.