moto.fun overview

One curve contract, cloned tokens, a read lens and two APIs. Which one to build against.

moto.fun is Motoswap's bonding-curve launch surface. Every coin on every curve lives in one contract: there is no per-coin curve, no per-coin pool, and no factory to enumerate. A coin is an EIP-1167 clone of a fixed ERC-20 template, and the curve holds its entire supply until it graduates.

Source code

Contracts on this page: LaunchpadCurve, LaunchpadToken, LaunchpadLens, CreatorFeeRegistry, CreatorFeeVault. Every function, event, error and constant: moto.fun contracts inventory.

The mental model in six facts

One curve contract holds every coin. State is curves(address token), keyed by the coin. Discovery is TokenCreated logs on that one address, not a PairCreated sweep.
A coin is a clone at a CREATE2 address derived from (creator, salt). The address is known before the coin exists, which is why a coin can be listed as pending with no code at it yet.
Trading is ETH in, ETH out, against virtual reserves. No LP, no pair, no route, no getAmountsOut. The virtual reserves are per coin, fixed at launch, and read with paramsOf(token). Quote through LaunchpadLens, which does that for you.
Graduation is the state transition that matters. Status goes Trading → Frozen → Graduated, and only at Graduated do real pools exist. It opens TOKEN/WETH and TOKEN/MOTO together at the final curve price and burns both LP positions, or it reverts and changes nothing.
Curve trades are DEX trades for fees, Points and Rakeback. The 0.70% protocol fee goes to the same Collector, in WETH, at the same rate as FeeRouter.
Nothing about a coin is mutable. Fixed supply, no owner, no tax, no mint, metadata committed by hash at launch, curve parameters stamped at launch. The curve contract itself sits behind a proxy with a timelocked upgrade path, which is a separate question from the coin.

The pieces

Piece	What it is	Where
`LaunchpadCurve`	The singleton. Launch, buy, sell, graduate, PvE escrow, fee routing. A UUPS proxy: upgrades go through a timelock, day-to-day setters through the owner	Contracts
`LaunchpadToken`	The ERC-20 template. One clone per coin, 1e27 fixed supply	Contracts
`LaunchpadLens`	Read-only companion. Quotes, price, progress, graduation readiness	Contracts
`CreatorFeeRegistry` / `CreatorFeeVault`	Shared with the DEX. Who the creator is, and the claim escrow	Contracts
Motoswap API `/motofun/*`	The documented public read surface. ETag-cached, in `/openapi.json`	API
The moto.fun app backend	The app's own service. Candles, holders, intents, SSE	API

Which API to build against

There are two, and they are not the same service.

Start with the Motoswap API

https://api.motoswap.org/motofun/* is the surface to integrate against. It is in /openapi.json, ETag-cached, rate-limited generously, and versioned on the curve's own head block. Use it for discovery, listings, venue stats and revenue.

The moto.fun app's own backend serves what the app needs and the Motoswap API does not carry: candles, holder tables, pending launch intents, per-wallet positions, a graduated-coins feed, and a Server-Sent Events stream. It serves ETags. Only the board and the graduated feed are paginated. Reach it at the moto.fun origin, which GET https://api.motoswap.org/config gives you as motofunUrl, under /backend-fun/<chain-slug>/. Both are documented on the API page.

Ordering, in one sequence

sign LaunchIntent  ──►  POST /intents        (coin is pending, address known, no code)
                          │
first buy ────────────────┴──► buyWithIntent(intent, sig, minOut)   or   launch(...) payable
                                    │
                                    ├─► TokenCreated   coin exists
                                    └─► Trade          every buy and sell
                                          │
                    floor supply reached ─┴──► FloorReached      Status = Frozen, trading stops
                                                    │
                                            graduate(token)  (permissionless, bounty-paid)
                                                    │
                                                    └─► Graduated  two pools or a revert, LP burned to 0xdead

A creator taking a dev buy skips the intent path entirely and calls launch directly, which deploys and buys in one transaction.

What is deliberately absent

No ticker exclusivity or reservation. No deadline parameter on curve trades. No max buy, no per-wallet cap, no cooldown, no launch block delay. No LP lock, because LP is burned rather than locked. No sweep or withdraw function on the curve. Building around any of these is building around something that does not exist.

Where to go next

Contracts for the call surface and the event catalog.
Addresses for discovery, and why nothing here is hardcoded.
API for both HTTP surfaces.
Realtime for the SSE stream and the candle rules.
Aggregators for listing a curve coin.