Earlier generations

New versions of the launchpad ship as new factory generations, and a coin keeps the economics it launched with forever: the numbers are constructor arguments on ownerless contracts with no setters. So everything on this page is still live and still pays out; it just has nothing to do with new launches. Current-generation docs live in Fees and Contract addresses.

One constant across every generation since gen-3: the house takes 0.10% of trade volume. The generations differ in what a trade pays on top of that, and where it goes.

Gen-4: the first v4 generation

Uniswap v4 pools quoted in native ETH, flat 1% fee charged by the hook on the ETH leg: 0.10% of volume to the house, 0.90% to the creator. Promoted as the default board 2026-08-05. Not audited.

Contract	Address (4663)
`LaunchpadFactoryV4`	`0x1B6479A5Da9Ef6c698bB09D821d65eD0F8e565B1`
`MerrymenHook`	`0xFD849C5Efeb2A3115c2d89Bd3870af786781A0Cc`
`LpLockerV4`	`0x766867377258FbF189D823cD28779a566923500a`

Everything on what v4 changes for an integrator applies to gen-4 coins: PoolId/PoolKey, LP fee 0, hook-charged fees, TokenLaunchedV4 events.

The V3 generations (gen-3 and gen-1)

Before v4, launches seeded Uniswap V3 pools: TOKEN/WETH, 1% fee tier (fee = 10000, tickSpacing = 200), single-sided and permanently locked in LpLocker. The pool’s fee tier is the trading fee. Gen-3 splits it 0.10% of volume to the house, 0.90% to the creator.

Contract	Address (4663)
`LaunchpadFactory` (gen-3)	`0xFB320dD4Cc5c8599B34C25F2328406D49e1417f4`
`LpLocker` (gen-3)	`0x5Fd21fcD7962FB120a0B868AB3d5E876d8A0ee43`
`LaunchpadFactory` (gen-1)	`0x4337a34535abf5cdae8f9074d4824f87d5e79daa`
`LpLocker` (gen-1)	`0x6e21a031650e866bcab71da2a5d36988b877aa26`
`BuybackTreasury` (gen-1)	`0x6b5fcea2899fbb77ad1e6c76e0a823ef2b5f38a1`
`LaunchDelegate`	`0x9ef6874ac4bdfaa0ba8f8ac577c65e54999e18f8`

A gen-2 factory (0xeC9a1675672B675C79642dD29d9fb0034a4a3F7C) with a 40/40/20 NOXA-burn split was deployed in July 2026 and never launched a coin. It is retired unused; do not integrate against it.

Integrating V3 coins

A V3 coin has a real pool address (pool on the API, with tokenIsToken0 telling you the ordering) and trades like any V3 pool:

Discovery: index TokenLaunched on the V3 factory:

event TokenLaunched(
    address indexed token,
    address indexed creator,
    address pool,          // the TOKEN/WETH V3 pool
    uint256 positionId,    // the locked V3 position NFT id
    uint256 totalSupply,
    uint256 creationFeeWei
);

Launches routed through the LaunchDelegate also emit Launched(eoa, token, positionId).

Trading: standard V3 pool events (Swap, Mint/Burn/Collect). Resolve the pool from the event or UniswapV3Factory.getPool(token, weth, 10000).
Reads: slot0() for price, liquidity(), fee() returns 10000. The locker exposes locks(positionId) (the fee creator) and pendingCreator(positionId) exactly like the v4 lockers.

Fees: the locker’s claimFees collects the position’s V3 fees and splits them per the coin’s generation, emitting:

event FeesClaimed(
    uint256 indexed tokenId,
    address indexed creator,
    uint256 amount0, uint256 amount1,
    uint256 ops0, uint256 ops1,
    uint256 buyback0, uint256 buyback1   // zero on gen-3
);

Quoting: QuoterV2.quoteExactInputSingle with fee = 10000.

The V3 router trap

Testnet and mainnet ship different Uniswap V3 routers with different ABIs, the single most common V3 integration mistake:

Network	Router	`exactInputSingle` shape	Selector
Mainnet (4663)	SwapRouter02 `0xcaf681a66d020601342297493863e78c959e5cb2`	No deadline	`0x04e45aaf`
Testnet (46630)	SwapRouter `0xf0913b7291C1FD842e5c808aeb2e96353B156DFE`	Deadline in struct	`0x414bf389`

Encode the swap for the wrong variant and it reverts. On both networks the UniversalRouter cannot route the V3 pools (factory / init-code-hash mismatch); never send V3 swaps through it.

V3 dependencies

Contract	Mainnet (4663)	Testnet (46630)
WETH	`0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73`	`0x8d949e9D5a2cD5D6DCfB27e461D3aC23aEE5708c`
`UniswapV3Factory`	`0x1f7d7550B1b028f7571E69A784071F0205FD2EfA`	`0x7F318400ed8d1534652801d636AD22F0726Cc106`
`NonfungiblePositionManager`	`0x73991a25C818Bf1f1128dEAaB1492D45638DE0D3`	`0xdcfeb9a5640ffDa9Ab51Fa4Ca6371501a661682D`
`QuoterV2`	`0x33e885ed0ec9bf04ecfb19341582aadcb4c8a9e7`	`0x9De4ff50C5b1b3614A758FC2432FA1bF598C87AA`

Testnet Merry Men contracts: factory 0xEdA68ADFeE36c80F5FF2503d12b03dbD76363C1c, locker 0xf1a64F0affE4ddf3F27342Fa65E08453E4d6e4fd, treasury 0xEb85a2FA0abbe388bE759509657D08904cf80135. RPC: https://rpc.testnet.chain.robinhood.com.

A stable V3 fixture: TEST

TEST is the first LaunchToken on the gen-3 factory, Blockscout-verified, served by the live indexer, and the team’s own token, so it will not disappear. Use it to validate a V3 read path end to end.

Field	Value
Token	`0xc20c0ce729ee8d57f9d9b630f9939abc2b7510a6`
Pool	`0xe85ec937ef140d8fd06e98a6687c28e20b255dd7` (TEST / WETH, 1%)
`tokenIsToken0`	`false` (TEST sorts above WETH)
Quote	WETH `0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73`

Gen-1: the 50/35/15 split and the buyback

The first generation split the 1% fee three ways, as shares of volume:

Destination	Share of trade volume
Creator	0.50%
Buyback treasury (launched tokens)	0.15%
Operations	0.35%

Gen-1 coins’ fees keep funding a pooled buyback-and-burn treasury: fees from all of them flow into one platform-wide pool, not per-token escrow. Because only qualifying tokens get bought back, holders of tokens that never qualify contribute to platform-wide burns. That is how it was designed: qualification is open to every gen-1 token on identical public rules.

How the buyback works

Each round, the treasury buys and burns the top 20 gen-1 tokens ranked by fees contributed to the pool, among tokens passing a qualification gate:

Locked liquidity: true by construction for every launch.
Minimum age: filters instant rugs (configurable immutable).
Fee-contribution floor: a sustained activity floor over a rolling window, proving real trading rather than a one-time spike (configurable immutable).

Fees-contributed is the ranking metric because it is the hardest to fake cheaply: a token’s activity funded the pool, so its activity earns its slot. (Market cap would bias toward already-large tokens; raw volume invites wash trading.) An earlier design’s randomness-lottery tier was dropped so selection stays fully deterministic and on-chain-verifiable.

Every token bought is burned on execution. Nothing enters a wallet the team controls; there is no held inventory anyone can sell.

Front-running defences: executeRound(uint256[] minOut) takes a per-buy slippage bound (the keeper simulates the round and submits tight bounds), and when a keeper address is configured only it may execute, so rounds go through a private mempool. The keeper controls timing only; selection is deterministic.

The treasury (BuybackTreasury.sol) is immutable, holds protocol revenue, and is unaudited.