Launch lifecycle

A launch is one call to LaunchFactory.launch or launchWithBlocks with the creation fee as value. Inside that call the factory mints the token, prices and initialises the pool, freezes the hook state, mints the creator NFT and seeds the whole supply as a single locked position. If any step fails, the whole launch reverts and nothing exists. On Arc the whole thing is final about half a second after it is sent.

Inputs

struct LaunchParams {
    string name;      // up to 48 bytes in the UI; the contract does not limit it
    string symbol;    // ticker, leading "$" stripped by the UI
    Currency quote;   // USDC (0x3600…0000) or cirBTC (0x171A…bAA0), as registered
    bytes32 salt;     // caller-chosen; the token address is CREATE2(creator, salt)
}

launch uses an empty block config. launchWithBlocks takes a Blocks.Config and validates it first (see Blocks). The creation fee is CREATION_FEE = 1 USDC, paid as native value (msg.value = 1e18, because Arc's native USDC balance has 18 decimals) and must be sent exactly; it accrues in factory.creationFees for the factory owner. Gas is paid in native USDC too, so a launcher needs a little over 1 USDC on Arc and nothing else.

Choosing the quote

The quote is the currency the pool is priced in, pays fees in and, later, that the creator claims in. Two are registered:

Both open the pool at the same $10,000 valuation; the feed only decides how many tokens one USDC or one satoshi buys at the open. A USDC pool is the plain choice: one token is a fixed fraction of a dollar at launch and stays legible. A cirBTC pool denominates the token in Bitcoin, so its quote-side price moves with BTC even when nobody trades. The Launch page shows both as "Paired asset" chips with their registry state and feed age; a quote that is unregistered, disabled or halted right now cannot be picked, because priceUsd8 would revert the launch.

The Launch page

/launch is one form: two cards on the left (Token details, Rules), a live preview of the pool card on the right, and one Create token button at the bottom. Nothing is signed until the review dialog is confirmed.

1. 01
   Token details

   Image (drop a PNG, JPG, GIF or WebP; it is centre-cropped to a 512 px square in the browser and pinned to IPFS when the server has a Pinata key, or paste an https / ipfs URL), name (48 bytes), ticker (12, upper-cased), an optional 280-character description and optional website / X / Telegram links, and the paired asset. Everything except the details is immutable.
2. 02
   Rules

   A preset picks which blocks run: Fair launch (Anti-Snipe + Halt Guard, the default), Community (Nth-buy Pot + Auto Burn), Full stack (all four), Bare pool (none) or Custom (the Builder’s workbench inline; a ?stack= link or a stack saved from the Builder lands here). Every enabled block shows its settings as sliders with an exact input. The ring on the right is the drag the hook blocks add to a buy, on top of the fixed 0.30 % protocol + 0.50 % creator fees; the gas estimate sits under it.
3. 03
   Dev buy · optional

   An amount of the paired asset the creator buys right after the launch. It is a separate transaction (approve + Router.buy, exact input, the slippage saved in the swap settings), never part of the launch call: the launch lock makes a same-transaction buy impossible for everyone, including the creator. With Anti-Snipe on, the form caps it at the per-block cap (max buy per block × the opening FDV in quote units), because the first buy lands inside the guard window.
4. 04
   Create token → review

   A dialog lists the creator wallet, the network, the quote, the opening FDV and price, every block with its settings, the dev buy, the details, the costs and how many signatures follow. Esc or Back to details returns to the form.
5. 05
   Confirm → Launch

   The app re-reads launchesPaused, priceUsd8 and the release gate, then asks the wallet to sign launch / launchWithBlocks with the creation fee as value. Once mined, the pool id and token address come from the Launched event and the pool is live; a launch that is out is never re-sent, only re-checked.
6. 06
   Details

   Only when a detail was filled in: TokenMetadata.set(poolId, json), a second signature. Refusing or failing it does not affect the pool; the step can be retried, skipped, or done later from the token page.
7. 07
   Dev buy

   Only when an amount was entered: isLive(poolId) is re-read, the buy is quoted through the real hook path for a minimum output, the Router is approved if needed, then Router.buy is signed. A failed step offers Try again, Skip, or (when the quote itself is unavailable) an explicit buy with no minimum.
8. 08
   Ready

   isLive(poolId) is read once more and the token page opens after a few seconds (View token / Stay here).

The transaction

1. 01
   Preconditions

   The hook must be set (one-shot after deploy), launches must not be paused, and msg.value must equal the creation fee. Otherwise HookNotSet, LaunchesPaused or WrongCreationFee.
2. 02
   Quote price

   registry.priceUsd8(quote) returns the Chainlink answer only if the quote is known, still enabled for new launches, the answer is positive and no older than the registry heartbeat (90,000 s on mainnet). Any failure reverts the launch. The registry also hands back the quote’s decimals.
3. 03
   Token

   new LaunchToken{salt: keccak256(creator, userSalt)}(name, symbol, lpLocker, 1e9 × 1e18). The entire supply is minted to the LPLocker. predictTokenAddress() gives the address before launching.
4. 04
   Orientation

   Uniswap orders currencies by address. quoteIsCurrency0 = quote address < token address. USDC at 0x3600… sorts first against most token addresses; cirBTC at 0x171A… does not. Every later code path handles both orders; the flag is stored in the hook.
5. 05
   Opening price

   OpeningPrice.opening(usd8, quoteDecimals, quoteIsCurrency0) turns the $10,000 FDV into a sqrtPriceX96 and a tick floored to spacing 60, in raw units of both currencies. See Pricing.
6. 06
   Initialise

   poolManager.initialize(key, sqrtP). The hook’s beforeInitialize accepts only the factory as sender and only a key with fee 0 and tick spacing 60.
7. 07
   Register

   hook.register stores token, quote, creator, orientation and launch block; copies the block config if the mask is non-zero; derives snipeCapQuote in raw quote units; and writes the EIP-1153 launch lock so no swap can happen in this transaction.
8. 08
   Creator NFT

   creatorFeeNFT.mint(creator, uint256(poolId)). The NFT is the claim on creator fees and is transferable.
9. 09
   Seed

   lpLocker.seed(key, lower, upper, token, SUPPLY). The hook’s beforeAddLiquidity accepts the locker once and flips seeded = true. The position is single-sided: if the pool would owe any quote, NotSingleSided reverts. Tokens that do not fit the range are burned.
10. 10
    Launched

    The factory emits Launched(id, token, quote, creator, sqrtPriceX96, openingTick, liquidity). The indexer creates the pool row from it.

The launch lock

register() writes 1 into a transient storage slot namespaced by pool id. beforeSwap reads that slot and reverts LaunchLocked while it is set. Transient storage clears at the end of the transaction, so the lock exists exactly for the launch transaction and never needs clearing. The effect: nobody, including the creator, can be the first buyer inside the launch transaction, and no contract can atomically launch-and-snipe. Arc has no public mempool, so a launch is not visible before it lands either; the lock is what makes the guarantee hold regardless.

What the creator gets

• The CreatorFeeNFT for the pool. Its holder can call claimCreatorFees(tokenId, to) at any time.
• 50 bps of every buy and every sell in the quote currency, plus the AntiSnipe tax while that window is open.
• Nothing else: no tokens, no LP position, no admin key. The creator's only privileged action is claiming.

Optional details

Image, description and links (website, X, Telegram) are optional and live in a separate TokenMetadata contract, not in the launch. When any of them is filled in on the Launch page, the app asks for a second signature after the launch is mined: set(poolId, json), at most 2048 bytes, no fee beyond gas. Only the current holder of the pool's creator NFT can call it, so the right to edit travels with the fee rights; the token page shows an Edit card to that wallet and an empty string clears everything. Skipping or refusing the second signature does not affect the pool. The app sanitises what it reads (https or ipfs images, https links, x.com / t.me hosts, 280-character descriptions), so garbage JSON simply renders as no details.

What the creator cannot do

• Withdraw or move the liquidity. The locker has no such function and the hook reverts every removeLiquidity.
• Change the blocks, the fee, the quote or the price after launch.
• Mint, pause, blacklist or tax the token.