BaseLaunchFactory

Whether an ERC-20 is approved as a pair asset for new launches.

The buyback vault that locks and vests bought-back coins.

Whether launcher may launch right now: true while the public gate is open, and true for whitelisted addresses while it is closed. The same predicate launchToken enforces on its caller.

A matured override must execute during this window. Expiration prevents an old, forgotten proposal from remaining executable indefinitely.

Advance notice the protocol owner's creator-fee-recipient override must wait out before it can be executed. The creator's own self-service transferCreatorFeeRecipient is never subject to this delay.

The fee escrow that holds every claimable fee balance for this launcher set.

Returns one token launch configuration.

Returns the immutable record for a token created by this factory.

Returns the fee policy frozen for a launch.

How long a launch must sit in Swept before its reserves may be released manually. Seeding is permissionless and retryable, so this window is what separates a genuinely unseedable launch from one that merely hit a transient failure, and it denies the owner a same-block escape hatch.

Time after a sweep (30 days) before the owner may rescue the reserves of a launch whose pool seed still looks viable.

The graduation executor that mints each graduated pool's position. Wired once by the owner.

The stateless graduation guard this factory created in its constructor, used to check that a pool seed is mintable.

Returns the number of launch configurations.

The deployer helper that creates each coin and its curve with CREATE2.

Whether launching is open to everyone. While false only whitelisted launchers may launch.

The fixed fee, in wei of ETH, a launch must send as msg.value. It is forwarded to the protocol fee recipient.

The router trusted to launch on behalf of the account that called it (launchTokenFor).

The Uniswap v4 hook every graduated pool uses; it also holds the current fee policy.

The locker that holds every graduated pool position and the excess coins, forever.

The highest creator fee a new launch may choose, in basis points (at most 10%).

Returns the address of the current owner.

Inherited from Ownable.

Virtual reserve, graduation target and decimals set for an ERC-20 pair asset, in that asset's own units.

An owner-proposed creator fee recipient change for a coin: new recipient, time it becomes executable and time it expires. Zero when none is pending.

Returns the address of the pending owner.

Inherited from Ownable2Step.

The Permit2 contract used to approve the PositionManager when a pool is seeded.

The Uniswap v4 PoolManager graduated pools are created in.

The Uniswap v4 PositionManager that mints each graduated pool's full-range position.

Returns the economics digest a launch of launchConfigId in pairToken would produce right now, for a creator to pass back as TokenParams.expectedEconomics.

Reading the digest and launching in separate transactions still leaves the terms free to move in between; the pin is what makes that movement revert instead of silently repricing the launch.

Permanently disabled. An ownerless factory could never approve a pairToken, adjust fee ceilings, or recover a creator's fee recipient, and every launch already live would keep depending on those powers. Ownership can still be handed to a new owner via the two-step transfer.

Seconds over which the launch tax decays to zero, snapshotted by every new launch.

The launch tax a buy pays in the launch second, in basis points of the pair asset spent, snapshotted by every new launch. Zero turns the launch tax off for new launches.

Release of the BaseLaunch launcher contracts.

Whether an address may launch while public launching is closed.

The new owner accepts the ownership transfer.

Inherited from Ownable2Step.

Adds a launch configuration new tokens can be deployed against.

Cancels a pending protocol-owner override before it takes effect.

Initializes the V4 pool with the swept reserves, mints a full-range position directly to the locker, and registers the pool with the launch hook. The curve already holds the pool's quote asset, so this seeds with exactly what it swept and needs no slippage bound. Permissionless and retryable: a launch stays in Swept until a seed succeeds, so a transient failure can never strand reserves.

Applies a protocol-owner's proposed creator fee recipient change once its timelock has elapsed. Permissionless: anyone can execute an already-matured proposal.

Sweeps a curve whose seed the preflight refuses, moving its reserves into this factory so the delayed rescue path can return them.

The preflight in graduate runs before the irreversible sweep, so a launch it refuses stays in NotGraduated. Trading is already closed at that point, because the curve shuts its sell side the moment it is ready to graduate, and rescueSweptGraduation keys off the Swept phase, so without this the reserves would have no exit at all. Restricted to launches the preflight genuinely refuses: while a seed is still viable anyone can call graduate and this reverts, so it cannot be used to take a healthy launch's reserves in place of seeding its pool. The rescue timelock still runs from the sweep recorded here.

Sweeps the curve's remaining quote and token reserves into this factory and halts curve trading. Purely internal to the curve's own balances, so it is safe for the curve to call this automatically the instant a buy crosses the graduation threshold.

Same launch flow, plus a creator-declared list of wallets exempted from the snipe tax before trading opens to anyone else. This is the sanctioned pathway for organized teams that bundle their opening buys across several wallets: declared wallets clear at the untaxed price during the launch window while undeclared snipers pay the decaying tax.

Deploys a bonding curve and its launch token, wires them together, and records the launch. Trading starts immediately on the curve; the graduation pool's pairToken is fixed here, chosen by the caller. The caller and their creator fee recipient are exempted from the snipe tax automatically; a launch with additional bundle wallets should use the overload that takes an exemption list.

Launches for the initiating user of the trusted atomic launch-and-buy router, with its declared opening-buy exemptions.

Only the configured launchForwarder may supply originalDeployer. This preserves the real caller without tx.origin, which breaks through account-abstraction relayers and must never be used for authorization.

Pays a still-trading launch's pending curve fees directly to the protocol and creator recipients, bypassing the escrow, when its quote asset has stopped delivering there.

Also the only way to unwedge such a launch's graduation, since graduate sweeps fees before handing over the reserves and cannot succeed while that sweep reverts. Clearing the buckets makes the sweep a no-op and lets graduation proceed.

Releases a swept launch's reserves to recipient when its quote asset can no longer satisfy the seed step. graduate accepts a quote asset that under-delivers, because it credits the balance it actually received, but the seed leg funds the executor through _transferExact and requires the full nominal amount. An asset that becomes fee-on-transfer, rebasing, or blocklisting after approval therefore leaves a launch that has already halted its curve with a seed step that can never succeed, and every holder's quote asset frozen behind it. Deliberately does not use _transferExact: the asset's inability to deliver exactly is the reason this path exists, so requiring it here would reproduce the failure it recovers from. The reserves are moved whole to a single recipient for off-chain distribution rather than split on chain, since a launch in this state has no reliable way to pay many holders in an asset that cannot pay one. The owner is trusted here, bounded by two delays from the sweep. A launch whose seed the preflight refuses (the same check that gates forceSweptGraduation) is rescuable after GRADUATION_RESCUE_DELAY. A launch that still looks seedable reverts with GraduationStillViable until GRADUATION_RESCUE_LONG_DELAY, so a healthy launch can only go to createGraduatedPool, which stays permissionless throughout. The preflight is a math probe and cannot see a pair asset that stopped delivering after the sweep; a launch still unseeded after the long delay is in practice undeliverable, so the reserves are never frozen for good. Mirrors BaseLaunchHook.rescuePoolFees, which covers the same asset class for the post-graduation pool.

Enables or disables buyback-and-lock for one launch. Only the current creator recipient may enable it, since the buyback slice is funded from the creator's own bucket. The protocol owner may only disable it (a strictly creator-favorable action), so the owner can never force a creator's fees into the buyback vault to capture the protocol's 30% release share against the creator's wishes.

Proposes a protocol-owner override of a launch's creator fee recipient. Its motivating case is recovery when a creator loses access to their wallet, but the power is deliberately not conditioned on that: the owner may redirect the recipient of any launch. Takes effect only after CREATOR_FEE_RECIPIENT_TIMELOCK has elapsed and someone calls executeCreatorFeeRecipientChange, giving the community advance notice instead of applying instantly. A new proposal for the same token replaces any earlier pending one and resets the clock.

A matured proposal takes precedence over any creator transfer made while it was pending. transferCreatorFeeRecipient deliberately does not cancel it, so the timelock is a notice period rather than a window in which the creator can veto by moving the recipient themselves. The override is therefore a standing protocol power over creator fee routing, not a narrowly scoped lost-key recovery, and it is documented as such rather than left to whichever call lands last. The collision is observable without extra state: this function emits the recipient as it stood at proposal time, and _setCreatorFeeRecipient emits the recipient it actually replaced. A creator transfer landing in between shows up as a mismatch between the two.

One-time wiring of the graduation executor, set after both are deployed since the executor's constructor needs this factory's already-known address.

One-time wiring of the launch deployer, set after both are deployed since the deployer's constructor needs this factory's already-known address.

Opens or closes launches to non-whitelisted callers.

Changes the fixed native launch fee.

Sets the router allowed to preserve the initiating user across an atomic launch-and-buy call. May be rotated when the router is upgraded without replacing the rest of the launch stack.

Kept separate from whitelistedLaunchers: that list controls who may launch while the public gate is closed, whereas this address is trusted to identify another account for CREATE2 namespacing and launch attribution.

Adjusts the ceiling a creator's chosen trade tax is validated against at launch time. Already-launched tokens keep the immutable tax rate they launched with regardless of later ceiling changes.

Approves or removes a standard ERC-20 quote asset for new launches. Because curves collect the quote asset directly, approving one needs nothing beyond a real token contract and the economics its curves will price against.

The stored scale is re-verified here rather than trusted from the economics call. Approval is the point where the asset enters service, and it is the only point at which the address is guaranteed to hold code, so this is what closes the gap for an asset configured before it was deployed or one that has since changed its reported decimals.

Sets the curve economics a quote asset's launches use, in that asset's own decimals. Required before the asset may be approved, and updatable afterwards so the peg to a target native-quote value can be refreshed as rates move. Existing launches are unaffected: each curve receives both figures as constructor immutables, so this only governs launches created after it.

Sets the decay window new launches snapshot at creation, in seconds. Capped at one minute so a misconfiguration cannot leave a launch effectively closed to the public for minutes; disabling the tax is done through setSnipeTaxStartBps, so a zero window is refused rather than overloaded to mean off.

Sets the launch-second snipe tax that new launches snapshot at creation. Curves already trading keep the figure they launched under. Zero disables the tax for launches created while it is zero; a nonzero figure must exceed the 20% combined base fee ceiling, so the launch-window tax always dominates the ordinary fee take, and stays below 100% so a taxed buy always nets the buyer something.

Grants or revokes permission to launch while the public gate is closed.

Lets the current creator fee recipient hand off future creator fees for token to a new address, whether the launch is still trading on its bonding curve or has already graduated into its Uniswap V4 pool.

Does not clear a pending protocol-owner override. If one is outstanding, it still executes on schedule and supersedes the address set here. See setCreatorFeeRecipient.

Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner. Setting newOwner to the zero address is allowed; this can be used to cancel an initiated ownership transfer.

Inherited from Ownable2Step.

Replaces an existing launch configuration. Already-launched tokens are unaffected since their pool parameters were snapshotted.

Accepts ETH swept out of a graduating curve and any dust the Uniswap PositionManager refunds while seeding a pool.

A coin's buyback-and-lock was turned on or off; controller is the account that did it.

Emitted by setBuybackEnabled

The owner cancelled a pending creator fee recipient change for a coin.

Emitted by cancelCreatorFeeRecipientChange

The owner proposed a new creator fee recipient for a coin; it can be executed between effectiveAt and expiresAt.

Emitted by setCreatorFeeRecipient

A coin's creator fee recipient changed, by the creator's own transfer or by an executed owner proposal.

Emitted by executeCreatorFeeRecipientChange, transferCreatorFeeRecipient

The graduation executor was wired (once).

Emitted by setGraduationExecutor

At graduation, the coins not needed to seed the pool at the curve's final price were locked in the locker forever.

Emitted by createGraduatedPool

The owner added a launch configuration.

Emitted by addLaunchConfig

The owner replaced or disabled a launch configuration.

Emitted by updateLaunchConfig

The launch deployer was wired (once).

Emitted by setLaunchDeployer

Public launching was opened or closed.

Emitted by setLaunchEnabled

The launch fee changed.

Emitted by setLaunchFee

The owner swept a finished curve whose pool seed the guard refuses, so the delayed rescue can return its reserves.

Emitted by forceSweptGraduation

The trusted launch forwarder (router) changed.

Emitted by setLaunchForwarder

The owner released a swept launch's reserves to a recipient after the rescue delay.

Emitted by rescueSweptGraduation

Graduation phase one: the curve's reserves moved into the factory and curve trading stopped.

Emitted by forceSweptGraduation, graduate

The ceiling on the creator fee changed.

Emitted by setMaxCreatorTaxBps

Ownership moved to a new owner (at deployment, or when a pending owner accepted).

Emitted by acceptOwnership, constructor

The owner named a pending owner; ownership moves when that account accepts.

Emitted by transferOwnership

An ERC-20 pair asset was approved or removed for new launches.

Emitted by setPairTokenApproved

The virtual reserve and graduation target of an ERC-20 pair asset changed.

Emitted by setPairTokenEconomics

Graduation phase two: the Uniswap v4 pool was created and seeded, and its position locked.

Emitted by createGraduatedPool

The launch tax decay window for new launches changed.

Emitted by setSnipeTaxSeconds

The starting launch tax for new launches changed.

Emitted by setSnipeTaxStartBps

A coin and its bonding curve were created. deployer is the account the launch was made for.

Emitted by launchToken, launchToken (4 args), launchTokenFor

An address was added to or removed from the launch whitelist.

Emitted by setWhitelistedLauncher