Fair Launch

Fair Launch is LeverUp's fixed-target fundraising and token-launch mechanism on Monad. A builder publishes a plan: a target amount of LVMON, a time window, the token's identity, and an incentive wallet. Users contribute LVMON — or native MON, which is minted into LVMON 1:1 — until the target is reached. A successful plan is launched through Nad.Fun by a keeper: the token is created, the raise buys out the bonding curve and seeds the DEX position, and contributors claim their share. A plan that misses its target never launches, and every contribution is refundable.

In code the system is called the Launchpad (NadFunFundraisingLaunchpad); Fair Launch is the product name. This page uses the two interchangeably.

Deployment status

Fair Launch is currently live on Monad testnet in early access. The addresses on this page are testnet addresses; the mainnet deployment has not been published yet. Everything else on this site targets mainnet — see Networks & Contracts.

Lifecycle

A plan moves through three onchain statuses:

Status	Value	Meaning
Active	0	Raise is open (or has ended below target — check refundable)
ReadyToLaunch	1	Target reached; waiting for the keeper
Launched	2	Token created; claiming is open

The full flow:

1. Create. The builder calls createPlan. The raise starts immediately and runs until endTime.
2. Whitelist phase (optional). For the first whitelistDuration seconds only addresses in the plan's merkle tree can contribute, each up to its own maxWhitelistLVMON cap.
3. Public phase. Anyone can contribute. There is no per-address cap; the only limit is what is left of the target.
4. Target reached. The plan flips to ReadyToLaunch and stops accepting contributions. A contribution that would overshoot is trimmed — the contract accepts only what fits and the rest never leaves your wallet.
5. Launch. After endTime, an authorized keeper calls launch, which creates the token on Nad.Fun and deploys the raised LVMON (details below).
6. Claim. Contributors claim their pro-rata share of the public-sale allocation.

Failure path: if endTime passes with the target unmet, the plan never launches. refundable becomes true and each contributor can call refund for their full contribution in LVMON. A live raise cannot be refunded early, and a launched plan cannot be refunded at all.

Filling early does not launch early

A plan that hits its target mid-window sits in ReadyToLaunch until endTime passes — the keeper only launches after the window closes. Both gates matter: status == ReadyToLaunch and block.timestamp >= endTime.

Plan parameters

Everything a builder sets at creation, and the rules the LeverUp app applies on top:

Parameter	Meaning	Rule / default
targetLVMON	Fixed raise target (18 decimals)	Minimum 230,000 LVMON; the app's slider ranges up to 15,000,000
startTime / endTime	Raise window	Starts immediately; default window 24 hours
whitelistDuration	Whitelist phase length, in seconds from start	0 = no whitelist; app default 30 minutes; the raise must extend at least 5 minutes beyond it
whitelistRoot	Merkle root over (contributor, maxWhitelistLVMON) leaves	Full tree is published as a public JSON manifest, so anyone can rebuild proofs
incentiveRecipient	Wallet that receives the builder-incentive allocation at launch	Visible onchain before you contribute
launchMetadataURI	Extended metadata: description, roadmap, whitelist manifest	—
createParams	Nad.Fun token identity: name, symbol, metadata URI, fee vaults, DEX type	Token image is rejected if Nad.Fun flags it NSFW; fee-stream vaults are set to 10% platform / 90% creator; dexType 0 (V2)

The minimum target is not arbitrary: 230,000 LVMON is just above the create fee plus a full bonding-curve buyout (10 + 229,596 — see What launch does), so every successful Fair Launch graduates its token to a live DEX pool in the launch transaction. There are no half-filled bonding curves.

Contributing

There are four entry points, all feeding the same per-address total (contributionOf):

Function	Path
contributeLVMON	Contribute LVMON directly
contributeNative	Send MON with the call; it is minted into LVMON 1:1 and credited
contributeLVMONWhitelist / contributeNativeWhitelist	Same two paths during the whitelist phase — additionally take the address's cap and merkle proof

Contributing twice adds up. There is no oversubscription: once raisedLVMON reaches the target, the raise is closed, and a contribution that would cross the line is accepted only partially. previewContribution(planId, amount) shows exactly how a contribution would split (acceptedLVMON / unusedLVMON) and estimates the resulting token allocation — surface it before any contribute button.

What launch does

launch is keeper-gated. The LeverUp app runs the keeper: it scans for launchable plans every 60 seconds (up to 5 per round), mines a CREATE2 salt through Nad.Fun's API so the token address is deterministic, and submits with a 1,200-second transaction deadline.

Inside the launch transaction, the raised LVMON is spent in three steps:

1. Create fee — up to 10 LVMON (maxCreateFee()) paid to Nad.Fun for token creation.
2. Curve buyout — up to 229,596 LVMON is the initial buy on the token's bonding curve. This is exactly the amount that fills the curve, so the token graduates immediately: Nad.Fun moves it to its DEX with an opening pool of roughly 191.09M tokens / ~224k MON.
3. DEX buy — everything left is swapped in that fresh pool (standard Nad.Fun swap fees apply on this leg, 160 bps total in the current V2 model).

All tokens acquired in steps 2–3 land in the launchpad contract, which then splits them between contributors and the builder (next section). The incentive allocation is transferred to incentiveRecipient in the same transaction.

Token allocation

Every Fair Launch token has a fixed total supply of 1,000,000,000 (18 decimals). At launch the contract computes:

• launchMarketCapLVMON — total supply × the pool's post-launch spot price.
• Public sale — totalSupply × targetLVMON / launchMarketCapLVMON, capped at what the launchpad holds. This is the contributors' pool: collectively worth exactly the raise at the launch price, so contributors enter at the launch market cap, not below it.
• Builder incentive — everything the launchpad holds beyond the public sale, sent to incentiveRecipient. Economically this is the spread the raise captured by buying through the bonding curve below the final price.

previewPlanAllocation(targetLVMON) returns all of this for any hypothetical target before a plan exists. Values from the deployed testnet contract:

Target (LVMON)	Launch market cap (LVMON)	Public sale	Builder incentive	Stays in DEX pool
230,000	1.16M	198.71M (19.87%)	610.53M (61.05%)	190.76M (19.08%)
500,000	5.53M	90.44M (9.04%)	822.22M (82.22%)	87.34M (8.73%)
1,000,000	22.22M	45.01M (4.50%)	911.40M (91.14%)	43.59M (4.36%)
5,000,000	557.41M	8.97M (0.90%)	982.33M (98.23%)	8.70M (0.87%)
15,000,000	5.02B	2.99M (0.30%)	994.11M (99.41%)	2.90M (0.29%)

Two dynamics to surface to users:

• The launch market cap grows super-linearly with the target. Past the curve buyout, every extra LVMON buys tokens out of the same AMM pool, pushing the spot price — a 65× larger target produces a ~4,300× larger launch market cap.
• Larger targets shift allocation from contributors to the builder. At the minimum target contributors receive ~20% of supply; at 15M LVMON they receive 0.3% and the incentive wallet holds ~99%. Integrators should show previewPlanAllocation output next to any contribute button.

TIP

The builder incentive is not a fixed percentage — it is a residual. Evaluate a plan by its target, the resulting split above, and the incentiveRecipient wallet, all of which are onchain before you contribute.

Claiming and refunds

After launch, claim transfers a contributor's share of the public-sale pool, pro-rata to contribution: publicSale × contribution ÷ raised. It can be called once or repeatedly — previewClaim(planId, user) reports the contributed, total claimable, already-claimed and remaining amounts, and claim always sends whatever is still owed.

refund only works on a plan whose window ended below target. It returns the full contribution in LVMON and is tracked per address in refundedOf.

Core numbers

Setting	Value	Where it lives
Minimum raise target	230,000 LVMON	Creation flow (economic floor: fee + curve buyout)
Create fee	≤ 10 LVMON	Contract, maxCreateFee()
Bonding-curve buyout (max initial buy)	229,596 LVMON	Contract launch logic
Token total supply	1,000,000,000 (18 decimals)	Nad.Fun
Post-graduation pool	~191.09M tokens / ~224k MON	Nad.Fun V2 curve
MON → LVMON conversion	1:1	LVMON issuer
Default raise window	24 h	App default
Default whitelist window	30 min	App default
Minimum public phase after whitelist	5 min	App validation
Target slider range	230,000 – 15,000,000 LVMON	App form
Post-launch fee-stream split	10% platform / 90% creator vault	createParams.vaults
Nad.Fun DEX type	0 (V2)	createParams.dexType
Keeper launch scan	Every 60 s, ≤ 5 plans per round	LeverUp keeper
Launch transaction deadline	1,200 s	LeverUp keeper

Contract reference

Testnet addresses:

Contract	Address
Launchpad	0xC466F271bE0DC8D53B3f42Af0A8375bd8F2b2c3E
LaunchpadUIHelper	0x90F5b77861b9b250dC0D23C863CBbfbfe0adaA95

The calls an integrator actually needs:

Call	Returns
getPlan(planId)	Full raise state: target / raised / remaining, launchMarketCapLVMON, time fields, status, and the derived canLaunch / refundable / whitelistActive
planCount()	Total number of plans
contributionOf / claimedOf / refundedOf	Per-address accounting for a plan
isWhitelistPhase(planId)	Whether the whitelist window is currently active
previewContribution(planId, amount)	Accepted / unused split and estimated token allocation
previewClaim(planId, user)	Contributed, claimable, claimed and remaining amounts
previewPlanAllocation(targetLVMON)	Market cap and the three allocations for any target
whitelistLeaf(contributor, maxWhitelistLVMON)	Exact leaf encoding for merkle-proof construction
UIHelper getLaunchCards(launchpad, offset, limit, viewer)	Batched list rows, including viewer's own contribution per plan

Events:

Event	Emitted when
PlanCreated(planId, creator, targetLVMON, startTime, endTime)	A plan is created
WhitelistConfigured(planId, whitelistRoot, whitelistEndTime)	A plan is created with a whitelist

LVMON itself is covered in Core Concepts; token amounts here use the standard 18-decimal convention described in Precision & Units.