# 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](https://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.

::: warning 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](/introduction/networks).
:::

## 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.

::: info 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](#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](/introduction/concepts#collateral-and-lvtoken); token
amounts here use the standard 18-decimal convention described in
[Precision & Units](/introduction/precision).