How it works, in writing

Part of every trade fee goes into the token's vault. Any holder can sell tokens back to the vault at the floor price, at any time. The floor is not a promise of profit: it is the price the vault pays, whatever the market does.

These pages put in writing what a launchpad owes you: what a launch costs, who gets paid, what is locked, what the floor does and does not do, and what can still go wrong. The interface chapters come first, the protocol chapters follow, and the reference at the end is for people who read contracts.

Three spaces

Explore to discover tokens. Launch to create one. Portfolio to follow your positions and claim your creator fees.

Search

Press / on the home page, or ⌘K / Ctrl K from anywhere. Search matches a name, a ticker or a contract address.

Three lists

Trending ranks by 24h change, Strongest floors by how close the floor is to the price, Just launched by age. Keys 1, 2 and 3 jump to each list.

Lists that hold still

While you hover, scroll or touch a list, its order is frozen: a row never moves under your cursor. Prices inside the rows stay live. New tokens are announced by a button above the list instead of being inserted.

Tags

A creator can give a token up to 3 tags, or none. The filter row shows one tag at a time: Meme, AI, Community, Art, Gaming, Base, Charity, Music, Sports, or No tag.

Quick buy

Each row has a Buy button for the amount selected above the lists, from 0.005 to 0.1 ETH. The first time, a confirmation shows what you receive, the fee and your slippage. You can skip it afterwards.

Market cap first

The large figure is the market cap, in dollars. It is the reference value across the site. The price of one token is in the stats below it.

Very small prices

A token price has many zeros. 0.0₈296 means eight zeros after the decimal point, then 296.

The chart

The line is the market cap. The orange step under it is the floor cap: the floor price multiplied by the total supply. The gap between the two is what the market adds on top of the floor.

Floor ratio

Price divided by floor. 1.00× means the price sits on the floor. 4.00× means the price is four times the floor.

Your position

With a balance, a banner shows what you hold, its value at the market price and its value at the floor.

Below the floor

When the market price falls under the floor, a banner says so: selling to the floor then pays more than selling on the market.

Trades

Every buy, sell and sale to the floor, with the amount that went into the vault.

launch(LaunchParams) on the Launchpad contract deploys the token, opens its Uniswap v4 pool against ETH, puts the entire supply in that pool and locks it. There is no queue, no review and no approval step.

Supply

1,000,000,000 tokens, 18 decimals, minted once

Team allocation

0%

Liquidity

100% of the supply, in a Uniswap v4 ETH pool, locked forever

Launch fee

0.001 ETH, paid into the token's own vault

Creator first buy

Optional, at most 3% of the supply, inside the launch transaction

Value to send

0.001 ETH plus the first buy, if any. Network gas is separate

The launch fee does not go to the protocol. It is the first ETH in the token's vault.

Every token is paired with ETH today: it is bought and sold against ETH, and its vault holds ETH. Pairs against tokenized stocks (NVDA, AAPL, GOOGL, TSLA and others) are coming. They cannot be selected yet.

What you choose

Image

Required. PNG, JPG, GIF or WebP, 4 MB at most

Name

Required, 1 to 32 characters

Ticker

Required, 1 to 10 characters, A-Z and 0-9

Description

Optional, 280 characters at most

Tags

Optional, up to 3

Links

Optional: X, Telegram, Farcaster, website

The image and the other details are pinned on IPFS as a JSON file, and the token stores its address as metadataURI. A launch reverts with InvalidSymbol, LaunchFeeTooLow or CreatorBuyTooLarge when one of the rules above is not met.

Each token has one Uniswap v4 pool, quoted in ETH, created at launch. buy(token, minTokensOut, recipient) on the Router pays ETH and returns tokens. sell(token, tokensIn, minEthOut, recipient) returns ETH.

The fee is taken by the pool's hook on every swap, in both directions, and split on the spot between the vault, the creator and the protocol. See Fees. The token itself carries no transfer tax.

Quote, price impact, slippage

The order panel asks quoteBuy or quoteSell before you sign, and shows what you receive and the fee. Every trade moves the price: the panel prints the price impact and warns above 5%.

Slippage is the gap you accept between the quote and the execution. The presets are 1%, 5%, 8%, 15%, and the default is 5%. Beyond it the transaction reverts with SlippageExceeded: your ETH or tokens stay in your wallet, and only network gas is spent.

Four states, always visible

A transaction waits for your signature, is sent, then confirms or fails. Once sent, the site shows its hash and a link to the explorer. A failure names its reason and offers the fix when there is one.

The vault holds ETH only, and fills from three sources:

• The vault share of every trade fee: 1% of each buy and each sell for a standard token.
• The launch fee of 0.001 ETH.
• The 2% that stays behind on every sale to the floor.

floor = ETH in the vault / tokens in circulation

tokens in circulation = total supply - tokens still in the pool - tokens burned

floorPrice(token) on the Vault contract returns the floor in wei for one whole token, and vaultBalance(token) the ETH it holds. The interface never recomputes the floor: it displays the value the contract or the indexer answers.

redeem(token, tokensIn, minEthOut) on the Vault burns the tokens you send and pays you from the vault. The other 2% stays in the vault. quoteRedeem(token, tokensIn) returns the exact amount before you sign.

Burned tokens leave the supply for good. Because 2% of their floor value stays behind, the floor of every remaining token rises a little with each redemption.

The order panel has a Sell to Floor tab next to Sell, and shows what each route pays. Selling on the market pays the market price, minus the 2% fee and the price impact. Selling to the floor pays 98% of the floor, with no price impact.

If the vault cannot cover a redemption, the transaction reverts with InsufficientVault instead of paying less.

Nothing is reserved for the creator and nothing for Floorline. Nobody can withdraw the pool's liquidity afterwards: not the creator, not the protocol.

The split is fixed when the token launches and cannot change afterwards. Each token publishes its own as feeSplitBps, and the order panel prints it before you sign.

Launch fee

0.001 ETH, once, paid by the creator into the token's vault

Sale to the floor

2% of the floor value stays in the vault. No trading fee on top

Token transfers

No fee

Network gas

Separate, paid to the network

Creator fees

The creator share accrues per token. claimableCreatorFees(token) returns the pending amount, and claimCreatorFees(token) pays it. On the site this is the Claim fees button in Portfolio. There is no schedule, no vesting and no minimum.

It is launched first, by the protocol multisig, through launchProtocolToken, a function that can succeed only once. Same supply, same locked liquidity, its own vault, and the same right to sell to the floor.

Its 2% fee is split 0.5% to its vault and 1.5% to the protocol treasury. There is no creator share. The split is fixed at launch like any other, and shown on its page under the Platform token label.

• Anyone can launch anything. There is no review and no listing standard. A token being on Floorline says nothing about the people behind it.
• Names, tickers and images can be copied. Two tokens can look identical on screen. The contract address is the only identity that cannot be forged.
• A floor is not a profit. The price can fall to the floor. Whoever bought above it loses the difference, and a sale to the floor pays 98% of it.
• A young floor is a small floor. A vault starts with 0.001 ETH and grows with trading. With little volume, it stays small.
• The creator's incentive is volume. A creator earns 0.6% of every trade and may hold up to 3% of the supply from the first buy, plus anything bought later like anyone else.
• The contracts are new. Until an audit report is linked on this page, assume there is none. A bug in a contract that holds value is a real risk.
• Dollar amounts are conversions. The contracts only know ETH. A dollar figure moves with the price of ETH even when nothing happens to the token.
• Everything between you and the chain can break. This interface, the indexer and any public RPC can go down or answer late.
• Numbers on screen were true when the page read them. A quote describes a trade that has not happened yet. The chain decides what it finally pays.

Market cap

Price of one token multiplied by the total supply of 1,000,000,000. Always shown in dollars.

Price

The current pool price of one token. Shown in ETH or in dollars, with the switch on the token page.

Floor

What the vault pays for one token before the redemption share: ETH in the vault divided by tokens in circulation.

Floor cap

Floor multiplied by the total supply. What the market cap would be if the price sat on the floor.

Floor ratio

Price divided by floor. The closer to 1.00×, the closer the price is to the floor.

Vault

ETH held in the token's vault.

24h volume

ETH traded over the last 24 hours, buys and sells together.

24h change

Price change over the last 24 hours. Always shown with an arrow, never by colour alone.

Holders

Addresses with a balance above zero.

In floor vaults

On the home page: the sum of every token's vault.

Test network

Base Sepolia, chain 84532

Main network

Base, chain 8453, after testing

Native asset

ETH

Explorer

sepolia.basescan.org

Exchange

Uniswap v4, one ETH pool per token

Supply per token

1,000,000,000, fixed, 18 decimals

Trading fee

2% of every buy and sell

Launch fee

0.001 ETH, into the token's vault

Creator first buy

3% of the supply at most

Sale to the floor

Pays 98% of the floor value

After each deployment, the addresses are published in deployments/<chainId>.json as { launchpad, router, vault, startBlock }, with the ABIs in abis/. This table is filled from that file.

Functions the interface calls

// Launchpad
function launch(LaunchParams calldata p) external payable returns (address token);
// Protocol multisig only, succeeds once: launches $FLOOR
function launchProtocolToken(LaunchParams calldata p) external payable returns (address token);
// msg.value = 0.001 ETH + the creator's first buy (0 if none)
struct LaunchParams {
  string name;
  string symbol;
  string metadataURI;       // ipfs://… JSON: image, description, tags, links
  uint256 creatorBuyMinOut; // 0 without a first buy
}

// Router (buy and sell, through the Uniswap v4 hook)
function buy(address token, uint256 minTokensOut, address recipient) external payable returns (uint256 tokensOut);
function sell(address token, uint256 tokensIn, uint256 minEthOut, address recipient) external returns (uint256 ethOut);
function quoteBuy(address token, uint256 ethIn) external view returns (uint256 tokensOut, uint256 fee);
function quoteSell(address token, uint256 tokensIn) external view returns (uint256 ethOut, uint256 fee);

// Vault (the floor)
function redeem(address token, uint256 tokensIn, uint256 minEthOut) external returns (uint256 ethOut);
function floorPrice(address token) external view returns (uint256 weiPerToken); // for 1e18 units, one whole token
function vaultBalance(address token) external view returns (uint256 wei);
function quoteRedeem(address token, uint256 tokensIn) external view returns (uint256 ethOut);

// Creator
function claimCreatorFees(address token) external returns (uint256 wei);
function claimableCreatorFees(address token) external view returns (uint256 wei);

Errors

Events

event TokenLaunched(address indexed token, address indexed creator, string name, string symbol, string metadataURI, uint256 fairLaunchEndsAt);
event Trade(address indexed token, address indexed trader, bool isBuy, uint256 ethAmount, uint256 tokenAmount, uint256 feeToVault, uint256 priceAfter);
event Redeemed(address indexed token, address indexed holder, uint256 tokensBurned, uint256 ethOut, uint256 floorAfter);
event CreatorFeesClaimed(address indexed token, address indexed creator, uint256 amount);

TokenLaunched is the one to index first: it carries the token, its creator, its metadata and the end of its fair launch window. Start from startBlock.

Token metadata

{
  "image": "ipfs://…",
  "description": "text, or absent",
  "tags": ["meme", "base"],
  "links": { "x": "https://x.com/…", "telegram": null, "farcaster": null, "website": null }
}

Allowed tags: meme, ia, communaute, art, gaming, base, caritatif, musique, sport. A token without tags has an empty list.

Every amount is a decimal string in wei, never a JavaScript number. Every date is in Unix seconds. Lists are paginated with a cursor: Page<T> = { items, nextCursor }.

tag takes a tag slug, or untagged. sort=floor ranks by floor divided by price.

type Address = `0x${string}`;

type TokenSummary = {
  address: Address;
  name: string;
  symbol: string;
  image: string;            // https URL (IPFS gateway)
  tags: string[];           // slugs, may be empty
  creator: Address;
  createdAt: number;
  fairLaunchEndsAt: number;
  priceWei: string;         // price of one token, in wei
  floorWei: string;         // floor of one token, in wei
  marketCapWei: string;
  vaultWei: string;
  volume24hWei: string;
  change24hPct: number;     // e.g. 12.4
  holders: number;
};

type TokenDetail = TokenSummary & {
  description: string | null;
  links: { x: string | null; telegram: string | null; farcaster: string | null; website: string | null };
  circulatingSupply: string;
  creatorHoldingPct: number;
  creatorLaunches: { total: number; aliveAfter30d: number };
  isProtocolToken: boolean; // true for $FLOOR
  feeSplitBps: { vault: number; creator: number; protocol: number }; // 100/60/40, or 50/0/150 for $FLOOR
};

type Candle = { t: number; o: string; h: string; l: string; c: string; floor: string; v: string };
type TradeRow = { tx: `0x${string}`; t: number; trader: Address; kind: "buy" | "sell" | "redeem"; ethWei: string; tokens: string; toVaultWei: string };
type Holder = { address: Address; balance: string; pct: number };
type Position = { token: TokenSummary; balance: string; valueWei: string; floorValueWei: string };
type FeedEvent =
  | { type: "launch"; t: number; token: TokenSummary }
  | { type: "trade"; t: number; token: Pick<TokenSummary, "address" | "symbol" | "image">; trade: TradeRow }
  | { type: "floor_record"; t: number; token: Pick<TokenSummary, "address" | "symbol" | "image">; floorWei: string };

type Page<T> = { items: T[]; nextCursor: string | null };

• Simulated data. Tokens, prices, trades and holders are generated in your browser, following the rules on this page. Nothing is read from a chain, and a Demo label says so in the header.
• Your wallet, or a demo wallet. Connect offers both. Either way the balance on screen is test ETH, trades are simulated, nothing is sent to your wallet to sign and no funds move. A real wallet starts with test ETH and an empty portfolio; the demo wallet comes with a sample one.
• Fixed ETH price. Dollar amounts use a fixed rate of $3,200 per ETH until a price feed is connected.
• Next step. When the contracts are deployed on Base Sepolia, the site switches to live data and the addresses appear in Contracts.

It is provided as is, without warranties of any kind. It holds no funds and takes no custody: every state change is a transaction you sign yourself.

• Nothing here is investment, legal or tax advice.
• We do not pick the tokens launched through these contracts, and we endorse none of them.
• Do not use the Floorline name or logo in a way that leaves people unsure who they are dealing with.