BaseLaunchHook

The single Uniswap v4 hook on every graduated pool: takes the trading fee and creator fee after each swap, pays any referrer, converts and sweeps pool fees, and holds the fee policy new launches snapshot.

Singleton Uniswap V4 hook shared by every graduated launcher pool. Takes a fee cut on every swap via afterSwap, and whenever that cut lands in the memecoin, converts it back to the pool's quote currency (ETH for the common native pairToken, or the launch's chosen ERC-20 pairToken otherwise) against the pool's own liquidity before it is ever distributed. The same protocol / creator / buyback-and-burn split that governs BaseLaunchBondingCurve's pre-graduation fee sweep lives here, read live by the curve through IFeePolicy so both phases behave identically.

Part of the contract reference.

Deployed at

BaseLaunchHook (2.1.0)0x9eBcb19b5075E9e87d62141a360bC39c3F92a044

BaseLaunchHook (2.0)0x14C3c3d571b2E4383a2a67377312764c60Fba044

Read functions (21)

Function	What it does
buybackBurnBps`buybackBurnBps() view returns (uint256)`selector 0x49127e2aAnyone	Current share of the creator part of the base fee that goes to buyback-and-lock, in basis points. Snapshotted by new launches.
buybackVault`buybackVault() view returns (address)`selector 0xf1f5c993Anyone	The buyback vault bought-back coins are locked into.
currentFeePolicy`currentFeePolicy() view returns (FeePolicySnapshot)`selector 0x89a69bd8Anyone	Returns the policy terms new launches snapshot immutably.
factory`factory() view returns (address)`selector 0xc45a0155Anyone	The launch factory; the only account that can initialize a pool with this hook and register it.
feeEscrow`feeEscrow() view returns (address)`selector 0xc4b7de97Anyone	The fee escrow every pool payout is credited to.
feeSweepOperator`feeSweepOperator() view returns (address)`selector 0x8a36a6bbAnyone	The operator key that runs fee conversions and buybacks with minimum outputs.
getHookPermissions`getHookPermissions() pure returns (Permissions)`selector 0xc4e833ceAnyone	Only `afterSwap` is enabled: fee collection happens once per swap, after the pool's own core swap math has already run.
hookFeeBps`hookFeeBps() view returns (uint256)`selector 0xea26abcfAnyone	Current pool trading fee in basis points. Snapshotted by new launches.
interfaceRegistry`interfaceRegistry() view returns (address)`selector 0xd181120eAnyone	Registry of launch interfaces, read when the creator side of a fee is paid out.
launches`launches(bytes32) view returns (bool registered, bool memecoinIsCurrency0, address memecoin, address quoteToken, address creator, address buybackCreatorRecipient, uint16 creatorTaxBps, uint16 protocolFeeShareBps, uint16 buybackBurnBps, uint16 hookFeeBps, uint16 maxInternalPriceImpactBps, bool buybackEnabled)`selector 0xad091230Anyone	A graduated pool's record by pool id: coin and pair asset, coin side, creator fee recipient, buyback recipient, and the fee terms frozen at launch.
maxInternalPriceImpactBps`maxInternalPriceImpactBps() view returns (uint256)`selector 0x90addc1eAnyone	Current cap on how far a fee conversion or buyback swap may move the pool price, in basis points. Snapshotted by new launches.
owner`owner() view returns (address)`selector 0x8da5cb5bAnyone	Returns the address of the current owner. Inherited from Ownable.
pendingBuyback`pendingBuyback(bytes32, address currency) view returns (uint256 amount)`selector 0xe356a181Anyone	The slice of pendingFees already earmarked for buyback-and-lock, set aside as each swap's fee was charged under whatever the pool's buyback flag said at that moment. Bucketing at accrual rather than deriving the slice at sweep time keeps the flag forward-looking: toggling it decides how the next swap's fee is split, never how an already-charged one is. Held per currency and carried across the memecoin-to-quote conversion in proportion to the fee it rode in on, so an earmark accrued in the memecoin still reaches the vest.
pendingCreatorTax`pendingCreatorTax(bytes32, address currency) view returns (uint256 amount)`selector 0xc8eaa792Anyone	Pending creator fee for a pool, per currency. Kept apart from pendingFees so it never counts toward the buyback.
pendingFees`pendingFees(bytes32, address currency) view returns (uint256 amount)`selector 0x359b4f30Anyone	Pending creator part of the base fee for a pool, per currency (the coin or the pair asset).
pendingOwner`pendingOwner() view returns (address)`selector 0xe30c3978Anyone	Returns the address of the pending owner. Inherited from Ownable2Step.
pendingProtocol`pendingProtocol(bytes32, address currency) view returns (uint256 amount)`selector 0xb51e0eebAnyone	Pending protocol part of the base fee for a pool, per currency, net of referrer payments.
poolManager`poolManager() view returns (address)`selector 0xdc4c90d3Anyone	The Uniswap v4 PoolManager this hook serves. Inherited from BaseHook.
protocolFeeRecipient`protocolFeeRecipient() view returns (address)`selector 0x64df049eAnyone	The address the protocol share is credited to, read live for every coin.
protocolFeeShareBps`protocolFeeShareBps() view returns (uint256)`selector 0x9040f866Anyone	Current protocol share of the base fee, in basis points. Snapshotted by new launches.
renounceOwnership`renounceOwnership() pure`selector 0x715018a6Anyone	Permanently disabled. An ownerless hook could never rotate the fee sweep operator, so accrued fees on every graduated pool would stay stranded. Ownership can still be transferred to a new owner.

Write functions (27)

Function	What it does
acceptOwnership`acceptOwnership()`selector 0x79ba5097Pending owner	The new owner accepts the ownership transfer. Inherited from Ownable2Step.
afterAddLiquidity`afterAddLiquidity(address sender, PoolKey key, ModifyLiquidityParams params, int256 delta0, int256 delta1, bytes hookData) returns (bytes4, int256)`selector 0x9f063efcUniswap PoolManager only	The hook called after liquidity is added Inherited from BaseHook.
afterDonate`afterDonate(address sender, PoolKey key, uint256 amount0, uint256 amount1, bytes hookData) returns (bytes4)`selector 0xe1b4af69Uniswap PoolManager only	The hook called after donate Inherited from BaseHook.
afterInitialize`afterInitialize(address sender, PoolKey key, uint160 sqrtPriceX96, int24 tick) returns (bytes4)`selector 0x6fe7e6ebUniswap PoolManager only	The hook called after the state of a pool is initialized Inherited from BaseHook.
afterRemoveLiquidity`afterRemoveLiquidity(address sender, PoolKey key, ModifyLiquidityParams params, int256 delta0, int256 delta1, bytes hookData) returns (bytes4, int256)`selector 0x6c2bbe7eUniswap PoolManager only	The hook called after liquidity is removed Inherited from BaseHook.
afterSwap`afterSwap(address sender, PoolKey key, SwapParams params, int256 delta, bytes hookData) returns (bytes4, int128)`selector 0xb47b2fb1Uniswap PoolManager only	The hook called after a swap Inherited from BaseHook.
beforeAddLiquidity`beforeAddLiquidity(address sender, PoolKey key, ModifyLiquidityParams params, bytes hookData) returns (bytes4)`selector 0x259982e5Uniswap PoolManager only	The hook called before liquidity is added Inherited from BaseHook.
beforeDonate`beforeDonate(address sender, PoolKey key, uint256 amount0, uint256 amount1, bytes hookData) returns (bytes4)`selector 0xb6a8b0faUniswap PoolManager only	The hook called before donate Inherited from BaseHook.
beforeInitialize`beforeInitialize(address sender, PoolKey key, uint160 sqrtPriceX96) returns (bytes4)`selector 0xdc98354eUniswap PoolManager only	The hook called before the state of a pool is initialized Inherited from BaseHook.
beforeRemoveLiquidity`beforeRemoveLiquidity(address sender, PoolKey key, ModifyLiquidityParams params, bytes hookData) returns (bytes4)`selector 0x21d0ee70Uniswap PoolManager only	The hook called before liquidity is removed Inherited from BaseHook.
beforeSwap`beforeSwap(address sender, PoolKey key, SwapParams params, bytes hookData) returns (bytes4, int256, uint24)`selector 0x575e24b4Uniswap PoolManager only	The hook called before a swap Inherited from BaseHook.
registerPool`registerPool(PoolKey key, address memecoin, address creator, address buybackCreatorRecipient, uint16 creatorTaxBps, bool buybackEnabled, FeePolicySnapshot policy)`selector 0x79f78674Factory only	Registers a pool with fee terms frozen at launch by the factory. `buybackCreatorRecipient` is the creator recipient the curve was constructed with, passed so the vest this pool tops up lands in the same vault epoch as any tranche the curve locked pre-graduation. It is not immutable in effect. The vault only reads it to seed an empty slot, and the factory forwards every later creator-fee-recipient rotation into `updateCreatorRecipient`, so the live beneficiary follows the creator fee stream. That is deliberate: it is what lets a compromised creator key be recovered without orphaning the vest.
rescuePoolFees`rescuePoolFees(bytes32 poolId) returns (uint256 protocolAmount, uint256 creatorAmount)`selector 0x5cbe8117Owner	Owner-only escape hatch for a pool's pending quote-token fees when they can no longer reach the protocol and creator through the normal exact-delivery path, for example an approved pair token that later turns out to be fee-on-transfer, rebasing, or otherwise unable to move its exact nominal amount. `sweepPoolFees` would revert indefinitely in that case, since `_payOut` enforces exact delivery into the fee escrow and there is no way to satisfy it. This bypasses the escrow and the buyback conversion entirely (the buyback swap would fail for the same underlying reason) and pays the protocol and creator their regular split with a direct transfer instead, so the quote-token balance the hook already holds is never permanently stuck. A native quote leg is skipped rather than rejected: ETH cannot fail an exact-delivery transfer, so it has nothing to rescue. The pool's memecoin-denominated fees are rescued regardless of what the quote currency is, because their only ordinary exit is the conversion swap. Gating the whole function on an ERC-20 quote would leave a native pool's memecoin fees with no recovery at all, and would also strand its ETH fees behind them, since sweepPoolFees converts before it distributes and reverts as a unit. The creator side is split with the launch interface exactly as a sweep splits it, so the owner can never use this path to take the interface's share away.
setBuybackBurnBps`setBuybackBurnBps(uint256 bps)`selector 0x48332680Owner	Sets the buyback share of the creator part of the base fee for new launches (at most 100%).
setBuybackEnabled`setBuybackEnabled(bytes32 poolId, bool enabled)`selector 0x2ce8b029Factory only	Updates whether a registered launch routes its configured fee share through buyback-and-lock. Applies to fees charged from here on, not to fees already pending. Each swap earmarks its buyback slice as it is charged, so a toggle cannot reach back and reroute value that accrued under the opposite setting. Without that, a disable landing before a sweep would divert a buyback the creator had already earned into their own payout, and an enable would sweep fees earned under a plain split into the vest.
setBuybackVault`setBuybackVault(address buybackVault_)`selector 0x7862505cOwner	One-time wiring of the shared five-year buyback vest, set after both are deployed, so `_distribute` can lock the buyback leg into it instead of burning it.
setCreatorFeeRecipient`setCreatorFeeRecipient(bytes32 poolId, address newRecipient)`selector 0xed8ef7a3Factory only	Updates who receives this pool's creator fee share. Restricted to the factory, which gates both self-service creator transfers and protocol-owner overrides before forwarding here, so this contract only needs to trust one caller.
setFactory`setFactory(address factory_)`selector 0x5bb47808Owner	One-time wiring of the launch factory, set after both are deployed since the factory needs this hook's mined address to build pool keys.
setFeeSweepOperator`setFeeSweepOperator(address operator)`selector 0x54faf9c3Owner	Sets the trusted operator that executes fee conversions with explicit minimum outputs, preventing arbitrary callers from triggering predictable swaps against a manipulated spot price.
setHookFeeBps`setHookFeeBps(uint256 bps)`selector 0xbfe7af83Owner	Sets the pool trading fee for new launches (at most 10%).
setMaxInternalPriceImpactBps`setMaxInternalPriceImpactBps(uint256 bps)`selector 0xb89eddabOwner	Sets the price impact cap on fee conversion and buyback swaps for new launches (above 0% and below 100%).
setProtocolFeeRecipient`setProtocolFeeRecipient(address recipient)`selector 0xe521cb92Owner	Moves the protocol's revenue address for every pool, existing and future. Creator shares are unaffected.
setProtocolFeeShareBps`setProtocolFeeShareBps(uint256 bps)`selector 0xfc75e481Owner	Sets the protocol share of the base fee for launches made from now on. It can never go below the trade referrer share: the referrer is paid out of the protocol part, so a lower share would quietly cut the published referrer rate for future launches.
sweepPoolFees`sweepPoolFees(bytes32 poolId, uint256 minConversionQuoteOut, uint256 minBuybackTokensOut)`selector 0x3d61055eFee sweep operator, or the coin's creator fee recipient when no conversion or buyback is pending	Converts any pending memecoin-denominated fee into the pool's quote currency against the pool's own liquidity, then pays the protocol bucket and splits the creator side into launch interface / buyback-and-lock / creator, exactly mirroring the bonding curve's own sweep. The trusted sweep operator is required whenever the sweep would execute an internal conversion or buyback. The creator may still distribute already-quoted fees when no internal swap is needed.
transferOwnership`transferOwnership(address newOwner)`selector 0xf2fde38bOwner	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.
unlockCallback`unlockCallback(bytes data) returns (bytes)`selector 0x91dd7346Uniswap PoolManager only	Called by the pool manager on `msg.sender` when the manager is unlocked
receive`receive() payable`Anyone	Accepts native ETH taken out of the PoolManager when the hook collects fees or settles an internal swap.

Events (19)

Event	What it means
BuybackBurnBpsUpdated`BuybackBurnBpsUpdated(uint256 bps)`topic0 0x19334947354816ac556f5ffa00c9e0adf0e86726151ae0892982d53797da69a5	The buyback share for new launches changed. Emitted by setBuybackBurnBps
BuybackEnabledUpdated`BuybackEnabledUpdated(bytes32 indexed poolId, bool enabled)`topic0 0xfebf5d5a892f779904618832d01bf549d0c159d7d0bf88067a8bffbf9ef6e7d4	Buyback-and-lock was turned on or off for a graduated pool. Emitted by setBuybackEnabled
BuybackVaultSet`BuybackVaultSet(address vault)`topic0 0x49e94f33a5714648c99c03d3c96612ffea74b1df6b5cefe68ed97448187ad07c	The buyback vault was wired (once). Emitted by setBuybackVault
CreatorFeeRecipientUpdated`CreatorFeeRecipientUpdated(bytes32 indexed poolId, address indexed previousRecipient, address indexed newRecipient)`topic0 0xb45e6b72a7de9a2077babe9717744436f3880e114099956ca85f91a77469a532	A graduated pool's creator fee recipient changed. Emitted by setCreatorFeeRecipient
FactorySet`FactorySet(address factory)`topic0 0x1edf3afd4ac789736e00d216cd88be164ddcef26a6eedcc30cdb0cb62f3741b1	The launch factory was wired (once). Emitted by setFactory
FeeSweepOperatorUpdated`FeeSweepOperatorUpdated(address operator)`topic0 0xae994ca926e252e299c3df7516cb609272a57bf80b0e0715297e55939f873420	The fee sweep operator changed. Emitted by setFeeSweepOperator
HookFeeBpsUpdated`HookFeeBpsUpdated(uint256 bps)`topic0 0xaea8b8d37d8110dd00c418d9c1c268f0fbadacb802c284b71a1777e411cd965a	The pool trading fee for new launches changed. Emitted by setHookFeeBps
HookFeeCollected`HookFeeCollected(bytes32 indexed poolId, address currency, uint256 feeAmount, uint256 taxAmount, address indexed referrer, uint256 referrerAmount)`topic0 0xb4e7942917b25be15f017ad4e591b521ad2a5098e6ad869e775763bac1ce8b43	Reported separately because the two accrue to different balance records: the fee splits across referrer, protocol, buyback and creator, while the tax is paid to the creator side in full. `referrerAmount` is the part of `feeAmount` already credited to `referrer` in the same swap. Emitted by afterSwap
InterfaceRescuePaymentFailed`InterfaceRescuePaymentFailed(address indexed launchInterface, uint256 amount)`topic0 0x13fc474d451710c03b0943644cb956c06ad9b11f3a8c65ce25e81b53938145ff	During a pool fee rescue, the launch interface's share could not be sent and went to the creator instead. Emitted by rescuePoolFees
MaxInternalPriceImpactUpdated`MaxInternalPriceImpactUpdated(uint256 bps)`topic0 0x6968b68c1fb468c8b257b012290bf803a6a6d7e79468e0326050724f7573cf01	The price impact cap for new launches changed. Emitted by setMaxInternalPriceImpactBps
OwnershipTransferred`OwnershipTransferred(address indexed previousOwner, address indexed newOwner)`topic0 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0	Ownership moved to a new owner (at deployment, or when a pending owner accepted). Emitted by acceptOwnership, `constructor`
OwnershipTransferStarted`OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)`topic0 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700	The owner named a pending owner; ownership moves when that account accepts. Emitted by transferOwnership
PoolBuybackSkipped`PoolBuybackSkipped(bytes32 indexed poolId, uint256 foldedBackQuote)`topic0 0xbdb9140e5a6bcb57cebdbf44a42f8c0f6c96af972d8f88cc3ae2b974f193bc0d	A sweep's buyback swap bought nothing (price impact cap or thin pool); the quote went to the creator instead. Emitted by sweepPoolFees
PoolConversionSkipped`PoolConversionSkipped(bytes32 indexed poolId, uint256 retainedMemecoin)`topic0 0xeed2d18eb96f3c2cb8c7b6993512a506c170e17d29355f2d7a0d5961f338de09	A sweep could not convert pending coin-denominated fees; they stay pending for a later sweep. Emitted by sweepPoolFees
PoolFeesRescued`PoolFeesRescued(bytes32 indexed poolId, address indexed quoteToken, uint256 protocolAmount, uint256 creatorAmount, uint256 interfaceAmount)`topic0 0xfe1efbc487f9fcadfd2bb7b02dcfee2f830c4086fd287372339f134b4891f143	The owner paid a pool's pending fees in one currency straight to the protocol, creator and launch interface. Emitted by rescuePoolFees
PoolFeesSwept`PoolFeesSwept(bytes32 indexed poolId, uint256 protocolAmount, uint256 buybackAmount, uint256 creatorAmount, uint256 tokensLocked, uint256 interfaceAmount)`topic0 0xcfd485351f5deaaf981520031894f53e411082baf0e9e0feb1f2e1f4a50eb408	A pool's pending fees were paid out: protocol, buyback spent, creator, coins locked and launch interface amounts. Emitted by sweepPoolFees
PoolRegistered`PoolRegistered(bytes32 indexed poolId, address memecoin, address quoteToken, address creator)`topic0 0x01bf263a1db1652580721573296e1a1fa70b3d4c87f61d02a69c4e1109d2d573	The factory registered a graduated pool with the hook. Emitted by registerPool
ProtocolFeeRecipientUpdated`ProtocolFeeRecipientUpdated(address recipient)`topic0 0xc1b5345cce283376356748dc57f2dfa7120431d016fc7ca9ba641bc65f91411d	The protocol fee recipient changed for every coin. Emitted by setProtocolFeeRecipient
ProtocolFeeShareUpdated`ProtocolFeeShareUpdated(uint256 bps)`topic0 0x4d1fc9430e27afb14db15169fd1c79e8b51773302919ac8c049f1c41995e380b	The protocol share of the base fee for new launches changed. Emitted by setProtocolFeeShareBps

Structs

Struct	Fields, in ABI order
`FeePolicySnapshot`	`uint16 protocolFeeShareBps, uint16 buybackBurnBps, uint16 hookFeeBps, uint16 maxInternalPriceImpactBps`
`ModifyLiquidityParams`	`int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt`
`Permissions`	`bool beforeInitialize, bool afterInitialize, bool beforeAddLiquidity, bool afterAddLiquidity, bool beforeRemoveLiquidity, bool afterRemoveLiquidity, bool beforeSwap, bool afterSwap, bool beforeDonate, bool afterDonate, bool beforeSwapReturnDelta, bool afterSwapReturnDelta, bool afterAddLiquidityReturnDelta, bool afterRemoveLiquidityReturnDelta`
`PoolKey`	`address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks`
`SwapParams`	`bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96`

Two launcher sets on Base

Addresses are listed for launcher 2.1.0, where new coins launch, and for launcher 2.0, which keeps serving the coins launched before the cutover. A coin stays on the set that launched it. The functions and events are the 2.1.0 contracts'; the 2.0 contracts are an earlier version of the same code and have no interface registry, so check a 2.0 contract's verified source on Basescan before relying on a detail listed here.

How the fees are split is on fees, what the owner can and cannot change is on security, and short answers are in the FAQ.

Meme coins are highly speculative and most lose their value. Nothing here is financial advice.

Last updated 2026-10-21.