Architecture & Discovery

One launch, one contract

The launchpad is two contract shapes:

LunyaLaunchFactory — the singleton, and the only launchpad address you should ever hardcode. It creates launches, keeps the registry, holds the protocol’s accrued fees per quote token, and lists each graduating launch’s pool through the DEX lister it is configured with.
One clone per launch (EIP-1167 with immutable args) of the implementation registered for its launch type — for type 1, LunyaLaunchCP, the constant-product curve. Each launch holds its own unsold supply and its own raise, so nothing that happens to one can reach another. The launched ERC-20 (LunyaLaunchToken) is deployed by its launch.

Resolve once, then talk to the launch directly:

factory.launchOf(token) -> launch    // write-once; address(0) if unknown

ILunyaLaunch is the interface every launch implements, whatever runs underneath — the surface written to outlive any one launch type.

Discovery

event LaunchCreated(
    address indexed launch,
    address indexed token,
    address indexed creator,
    LaunchType launchType,   // uint8 — not indexed, not filterable
    address quoteToken,
    string name,
    string symbol,
    string contractURI,
    bytes launchParams       // the creator's own launch parameters, opaque to the factory
);

Reads on the factory:

Getter	Returns
`launchOf(address token)`	the launch for a token
`isLaunch(address)`	whether an address is a launch created here
`launchCount()` / `launchAt(uint256 i)`	enumeration
`quoteConfig(address token)`	`(approved, wrapsNative, nativeDivisor, creationFee, graduationReward)` — the quote tokens governance has approved (6 to 18 decimals), and what launching in each costs and pays
`typeParams(LaunchType, address quoteToken)`	the type’s parameters on that quote, as bytes only the implementation decodes
`implementationOf(LaunchType)` / `retired(LaunchType)`	the registry
`locker()`	the liquidity locker, shared by every launch
`lister()`	the DEX lister graduations list their pool through
`feeRecipient()` / `feesAccrued(address quoteToken)`	where protocol fees go, and what the factory holds for each quote
`nativeQuoteToken()`	the quote that is the chain’s own coin seen as an ERC-20

Creating a launch

struct CreateParams {
    LaunchType launchType;
    address quoteToken;
    string name;
    string symbol;
    string contractURI;
    address creatorFeeRecipient;   // zero means msg.sender
    uint256 initialBuyAmount;      // ignored by the native entry
    uint256 minTokensOut;
    bytes launchParams;
    bytes32 salt;
    bytes32 expectedTermsHash;     // zero skips the check
}

function createLaunch(CreateParams calldata params) external returns (address launch, address token);
function createLaunchWithNative(CreateParams calldata params) external payable returns (address launch, address token);

The creation fee is taken first; on the native entry, whatever msg.value is left becomes the opening buy. The opening buy is atomic with creation, so nobody can front-run a creator between the two — and it is made to the creator, who is exempt from the anti-snipe surcharge.

creatorFeeRecipient receives the creator’s share of the curve’s fees and of the graduated pool’s fees. A contract can hold that role — see Receiving fees in a contract.
launchParams are the creator’s own parameters. For type 1 they are empty, or abi.encode(address[] exempt) — up to 32 non-zero addresses exempt from the anti-snipe surcharge.

Token metadata

contractURI is the token’s whole off-chain identity, under ERC-7572’s name for it. Read it from the LaunchCreated log — the event carries the same string the token stores, so indexing needs no eth_call — or from token.contractURI(). It is written once. The token sets it in its constructor, bounded to 2,048 bytes (MAX_CONTRACT_URI_LENGTH, ContractURITooLong() past it), and has no setter. ERC-7572’s ContractURIUpdated is deliberately never emitted: what the creation log carries is final for the life of the token. The contract stores whatever the creator passed, so a reader handles three cases:

The string	What to do
`data:application/json;utf8,{…}`	The document is inline. This is the shape the Lunya app writes, and what nearly every token carries
`https://…` or `ipfs://…`	A link to the same document — possible for anyone calling the factory directly
Empty, or anything else	No metadata; fall back to the ERC-20 `name()` and `symbol()`

The document’s keys, all optional and omitted rather than emptied:

{
  "name": "Example",
  "description": "A token",
  "image": "ipfs://bafy…",
  "external_link": "https://example.com",
  "twitter": "https://x.com/example",
  "telegram": "https://t.me/example",
  "discord": "https://discord.gg/abcdef"
}

name repeats the ERC-20 name() so the document stands on its own. The two cannot drift: both are set in the same call, and neither has a setter.
image is ipfs://<cid> when the creator uploaded through the app, an https:// URL otherwise. Resolve ipfs:// through your own gateway.
external_link is the project’s website — ERC-7572’s name for it. Accept website as a synonym; some documents use that key.
Socials are full URLs as the app writes them, but a creator calling the factory directly can leave a bare handle. Normalise before rendering.

Three parsing rules worth copying:

Split at the first comma and check that the media type before it contains json.
The body is not percent-encoded — ;utf8, means the bytes are the document. Attempt decodeURIComponent only if the body matches %[0-9a-f]{2}, and keep the raw bytes if it throws: a description containing a literal % otherwise costs you the whole document.
Require a leading {, and treat a parse failure as “no metadata” rather than as an error on the token.

Deterministic addresses

Launch addresses are known before creation. Clones deploy via CREATE2 with a salt namespaced per creator — keccak256(abi.encode(creator, salt)) — so a salt only has to be unique among one creator’s launches, and nobody can take an address someone else was going to use.

function predictLaunch(
    LaunchType launchType,
    address quoteToken,
    address creator,
    address creatorFeeRecipient,
    bytes calldata launchParams,
    bytes32 salt
) external view returns (address launch, address token);

function termsHash(LaunchType launchType, address quoteToken) external view returns (bytes32);

predictLaunch returns both addresses: a fresh clone’s first CREATE is at nonce 1, so fixing the launch fixes the token. creatorFeeRecipient and launchParams are clone arguments, so they are part of the address — decide them first, then choose the salt.

The salt is mined, not chosen

A creation whose token would sort above its quote reverts with TokenAboveQuote(). Tooling that creates launches searches for an accepted salt — predictLaunch is a view, so the search is free:

for (uint256 i = 0; ; i++) {
    salt = bytes32(i);
    (, address token) = factory.predictLaunch(launchType, quoteToken, creator, feeRecipient, launchParams, salt);
    if (token < quoteToken) break;
}

The reason is the pool: forcing the token below its quote makes it token0 in its graduated pool, always, so the pool’s own price reads as quote per token. Mining is also how a creator picks a vanity address — add your condition to the same loop.

Terms can move the address

The clone’s arguments include the governance-set terms a launch is created under — the quote’s configuration, the fee defaults, the graduation pool type and the type’s parameters — so a retune moves the predicted address. Read termsHash(launchType, quoteToken) beside the prediction and pass it back as expectedTermsHash: a change then reverts TermsChanged instead of deploying somewhere you did not publish. The hash covers governance’s terms only; creatorFeeRecipient and launchParams are your own arguments.

What a launch promises

Views on ILunyaLaunch, stable across launch types:

token()          // the ERC-20 the launch sells
quoteToken()     // what it trades in — never the zero address
creator()
acceptsNative()  // whether the native entries are open on this launch
phase()          // None | Trading | ReadyToGraduate | Graduated
progress()       // how full the curve is, out of 1e18
reserve()        // quote held against the curve
pool()           // zero until it graduates

progress() rather than supply counters, deliberately: every launch that graduates has a completion condition, but not every launch type has a token counter that means the same thing. Build progress bars on it and they keep working across types. ReadyToGraduate is in the shared enum for launch types that graduate in two steps. Type 1 never reports it: the buy that fills its curve graduates it, so phase() goes from Trading to Graduated in one transaction. Watch phase(), read pool().

config(), sold(), openedAt(), launchParams(), quoteBuyFor(), currentSnipeTaxBps(), isExempt(), protocolFees(), creatorFees() and collectFees() exist on the type-1 implementation but are its vocabulary, not the cross-type promise. Use them to quote type-1 launches off-chain; use progress() for anything meant to outlive one type.

Units and quote tokens

Every amount is in the quote token’s own decimals — reserve, fees, quotes, event fields. On a 6-decimal quote, 2e18 is not “two units”. The exceptions are the values that exist only in the native coin: sellForNative’s minimum-out, quoteSellForNative’s nativeOut, and quoteBuyWithNative’s nativeRefund. Which tokens a launch may be quoted in is quoteConfig(token), and the set grows by governance call rather than by new factory. An approved quote is not yet a pair: each launch type carries its own parameters per quote (typeParams), because they are denominated in that quote’s units — a type with no parameters on a quote refuses to launch on it (PairNotOpen).

Launch types

LaunchType is a uint8 naming an implementation in an append-only registry; type 1 is the constant-product curve. A type’s implementation is fixed the moment it is registered, so a type-1 launch today runs the same code as one made a year from now; a different curve is the next number. A type can be retired — new launches on it stop, existing ones are untouched. For type 1, the parameters are (totalSupply, virtualQuote, virtualToken, curveSupply, lpSupply, snipeTaxBps, snipeWindow, snipeDecay) — the supply split, virtual reserves and anti-snipe window are set per quote token, not constants. A launch’s terms are fixed at creation. Two things are read live instead: the DEX lister, at graduation, and the protocol fee recipient, whenever protocol fees are paid. Read launchType from LaunchCreated and treat a launch’s ABI as a function of it.

Get Started

Exchange

Earn

Bridge

Launchpad

Raise

Points

Developers

One launch, one contract

Discovery

Creating a launch

Token metadata

Deterministic addresses

The salt is mined, not chosen

Terms can move the address

What a launch promises

Units and quote tokens

Launch types

​One launch, one contract

​Discovery

​Creating a launch

​Token metadata

​Deterministic addresses

​The salt is mined, not chosen

​Terms can move the address

​What a launch promises

​Units and quote tokens

​Launch types

One launch, one contract

Discovery

Creating a launch

Token metadata

Deterministic addresses

The salt is mined, not chosen

Terms can move the address

What a launch promises

Units and quote tokens

Launch types