LilyPad docs

LilyPad is a launchpad where a new token is paired with a tokenized stock instead of ETH. Each token starts on a bonding curve quoted in the share and graduates to a Uniswap v4 pool once the curve has raised the stock's threshold. The curves and the factory are the public Pons V2 contracts on Robinhood Chain; LilyPad is the front end.

This page is the reference for creators and traders. Addresses and the integration contract are in the Contracts and Integrate sections.

How a pair works

Every token launched on LilyPad has exactly one bonding curve, and the curve's quote asset is a tokenized stock: NVDA, TSLA, SPY and the rest of the list on the Stocks page. We call the token and its stock a pair.

• Buying the token means paying in the stock token. Selling returns stock tokens.
• The price is a number of shares per token. The USD figure next to it is a reference computed from the stock's last on-chain price; it is not what the pool settles in.
• Nothing is pegged. The token trades freely against the stock; if the stock moves and the token does not, the USD reference moves with the stock.
• The curve is constant-product with a phantom quote reserve set per stock by the factory, so the first buy has a price instead of zero. getReserves() on the curve gives the live numbers.
• When the curve holds its graduation threshold of the stock, it seeds a Uniswap v4 pool with what it raised and the remaining tokens, and closes. From then on the pair trades on Uniswap.

Launching

1. Pick the stock. Permanent. It sets the quote unit and the asset the curve holds.
2. Name the token. Name, ticker (2 to 8 alphanumerics, never a stock symbol), a line of description, an image URL, optional links.
3. Optional first buy. An amount of the stock token spent on the new curve. Through the LilyPad launcher it lands in the same transaction as the launch (one approval of the stock, then one launch); calling the factory directly it is a second transaction. The creator is exempt from the launch-window snipe tax either way.
4. Sign. The factory deploys the token, mints the supply into a new curve quoted in your stock, and emits TokenLaunched. The pair is tradable in the same block.

Supply is 1,000,000,000, minted once by the factory. The creation fee is the factory's launchFee(), paid in ETH.

Trading

Open any pair from the Pairs board. The trade panel takes an amount of the stock token to buy, or an amount of the token to sell, and shows the quote, the price impact and the fee before you sign.

• You need the stock token in your wallet to buy.
• Slippage tolerance defaults to 3% on live curves. Young curves also charge a snipe tax on buys in the first minutes, which the quote does not include; the transaction reverts if the floor is not met.
• Trades on a curve are buy() / sell() on that curve; anyone can call them. After graduation the pair is an ordinary Uniswap v4 pool.

Fees

Creator tax accrues per trade in the Pons fee escrow and is claimed from there.

What holds

• The stock stays in the curve. Buys pay it in, sells take it out, and at graduation it seeds the Uniswap v4 pool. There is no withdraw function for the creator or for LilyPad.
• Supply. Minted once by the factory. No owner is left who could mint more.
• Graduation. Automatic, at a threshold the factory sets per stock and that every pair shows.
• Code. The factory and the curves are the public Pons V2 contracts, verified on the explorer. LilyPad's only contract is the launcher that bundles the first buy, published in this repository.

Contracts

The factory is the open Pons V2 LaunchFactory on Robinhood Chain (chain id 4663). It emits TokenLaunched(token, curve, deployer, pairToken, launchConfigId, graduationThreshold) on every launch; pairToken is the stock the coin is paired with. Each coin gets its own bonding curve, which emits CurveBuy and CurveSell for trades and hands over to Uniswap v4 once it graduates.

Stock tokens

Several tokens on Robinhood Chain use the same ticker; only the ones issued by Robinhood are approved as quote assets by the factory. The official list is at docs.robinhood.com/chain/contracts. When the live adapter is on, the tokens it has verified with approvedPairTokens() appear here, linked to the explorer.

Integrate

The site reads everything through one adapter object. To point it at a live deployment, define window.BONDED_ADAPTER before app.js loads, with these methods:

window.BONDED_ADAPTER = {
  async stats()             { return { pairs, volumeUsd, lockedUsd }; },
  async stocks()            { return [{ sym, name, price, pairs }]; },
  async pairs()             { return [{ name, ticker, stock, mcap, volume, change, holders, createdAt, address, desc, creator }]; },
  async pair(ticker)        { return { ...pair, liquidityUsd, series, trades }; },
  async connect()           { return { address }; },
  async createPair(payload) { return { txHash, tokenAddress, pairAddress }; },
  async quote({ ticker, side, amount }) { return { out, priceImpact, fee }; },
  async swap({ ticker, side, amount, minOut }) { return { txHash }; },
  async holdings(address)   { return [{ ticker, amount }]; },
  async launched(address)   { return [ticker]; },
  subscribe(onEvent)        { /* onEvent({ kind: 'launch'|'buy'|'sell', ... }) */ return unsubscribe; },
};

Amounts are in the stock token for buys and in the token for sells. series is an array of prices in shares per token, oldest first.

Live on Pons

The site ships with that adapter written: adapter.pons.js talks to the Pons V2 factory with no libraries. It is off by default; open any page with ?pons=1 to switch it on for the browser (and ?pons=0 to switch it off). With it on, Launch calls launchToken(params, launchConfigId, stockToken, []) with the factory's launchFee() attached and previewLaunchEconomics() as the economics digest, waits for the receipt, reads TokenLaunched and refuses to continue unless pairToken is the stock you picked. The first buy is a real curve.buy() paid in that stock. Trading on a pair page is curve.buy() / curve.sell() with a 3% slippage floor; quotes come from getReserves() and feeBps(); they do not include the creator tax or the launch-window snipe tax, which the slippage floor absorbs (the creator's own first buy is sent as a snipe-tax exemption).

The adapter discovers stock tokens from recent launches on the factory and only keeps the ones that pass approvedPairTokens(). To pin the official ones, define them before the scripts load:

<script>window.BONDED_STOCK_TOKENS = { TSLA: '0x…', NVDA: '0x…' };</script>

Before trusting any of it with money, run node scripts/verify-pons.mjs from a machine that can reach rpc.mainnet.chain.robinhood.com. It checks the chain id and factory code, reads launchEnabled(), launchFee() and every launch config, tallies the quote tokens of real launches, opens a live curve per stock to confirm pairToken(), and simulates launchToken() with a stock as quote. Pass --from 0xYourWallet to simulate as yourself and --stocks TSLA=0x… to check your own addresses.

Risks

• Tokenized stocks are issued by third parties. LilyPad does not issue them, custody them or guarantee their peg to the underlying.
• Tokens launched here are created by their creators. A curve that cannot be pulled does not make a token valuable; it only means the stock in it goes where the formula says.
• Robinhood's stock tokens are issued for eligible customers in the European Union and are geo-restricted. If you cannot hold the stock token, you cannot trade the pair.
• Stock tokens trade on chain around the clock. Their price can drift from the underlying while markets are closed.
• Nothing on this site is financial advice. Read your local rules before launching or trading.