Launch a coin that is real from block one.

What is PotatoPad

PotatoPad is a memecoin launchpad on Robinhood Chain (an Arbitrum Orbit L2, chainId 4663). You can spin up a token in a couple of clicks, and it starts trading the instant it launches. No forms to fill out with a market maker, no waiting for a listing.

The one-line pitch: launch a coin that is live on Uniswap V3 from block one, with a supply that can never change and liquidity that is locked forever, so the person who created it cannot pull the liquidity.

The name is a nod to Robin Hood. The theme is potatoes and giving to the poor, and one of the launch types (Give-to-the-Poor mode) even rewards small holders with a bigger slice of trading fees. Warm and a little silly on the surface, with strict guarantees underneath.

How it started. The very first coin planted here was CHIP (CHIP/WETH on Uniswap V3, launched 16 July 2026, 0x1e4d3243a287EDb687A4cBf2A1223dA54E8c835f). One potato, then a whole sack.

What makes it different

Four things are true of every PotatoPad coin, and they are enforced by the contracts, not by a promise:

• Live on Uniswap V3 from block one. There is no separate "bonding curve contract" that later migrates to a DEX. The curve IS a single-sided Uniswap V3 position holding the whole supply. So your coin is a normal Uniswap V3 pool from the very first block. It can be priced, charted, and traded like any other V3 token, and there is never a risky migration step.
• Fixed 1,000,000,000 supply, forever. Every launch mints exactly one billion tokens (18 decimals) and that is the entire supply for all time. The token is a plain immutable ERC20: no owner, no mint function, no pause switch, no blacklist. Nobody can print more, freeze your wallet, or change the rules after the fact.
• Liquidity locked forever. Essentially all of the supply is seeded into that one Uniswap V3 position at launch, and the position is held in a fee locker with no withdraw path and no way to pull liquidity back out. The creator literally cannot rug the pool. (Trading fees still accrue and can be collected; the liquidity itself stays put.)
• Fair launch, self-custody. No presale and no team allocation quietly set aside. Everyone, including the creator, buys from the same pool on the same curve. The creator can make an optional buy at launch, but it goes through the open market like anyone else's, not a discounted private round. And PotatoPad never holds your coins or your funds. Everything lives in your own wallet and in the public Uniswap pool.
• You choose who earns the fees. Every coin charges a 1% trading fee. At launch you decide how the creator half of that fee is handled: keep it yourself, share it with holders on a slider, or give it away entirely (Give-the-Poor). See Launch modes for the details.

How a coin's life goes

1. Launch. The pad mints one billion tokens into a single Uniswap V3 position and locks the LP. Opening valuation starts around 1.3 ETH FDV. A short anti-snipe window (see Safety) caps how much any one wallet can grab in the first 1200 blocks.
2. Trade / bonding curve. From block one, anyone can buy or sell on Uniswap V3 (1% fee on buys and sells). Because the whole supply sits in one concentrated range, buys walk the price up that range. That is the "bonding curve," just built out of a real V3 position instead of custom math.
3. Graduate ("bond") at ~23 ETH FDV. When the price climbs to the bond mark (around 23 ETH fully-diluted valuation), the coin is considered graduated. Nothing mechanical happens: no migration, no new pool, the LP was already locked at launch, and the fee stays 1%. Graduation is just a milestone the price crossed.
4. Keeps trading. After graduation it is the same pool it always was. It keeps trading on Uniswap V3 for good, with fees continuing to accrue to the locked position.

Safety and risks

Read this part plainly. It is written to be honest, not to sell you anything.

PotatoPad is UNAUDITED. The contracts have not been through a formal third-party security audit. They are open and original (MIT licensed), but "unaudited" means exactly that: use them at your own risk, and do not put in more than you can afford to lose.

What the contracts DO protect

These are guarantees enforced in code, and you can verify each one on-chain:

• Liquidity is permanently locked. The launch LP lives in the fee locker with no withdraw and no decrease-liquidity path. There is no function a creator can call to pull the pool. Fees can still be collected (and that call is permissionless, so anyone can trigger it), but the liquidity itself cannot be removed by anyone.
• Tokens are immutable. A PotatoPad token has no owner and never had one: no mint, no pause, no blacklist, nothing an insider could flip. The full 1,000,000,000 supply is minted once at launch and can never grow. (Its owner() getter returns the zero address, which is just there so scanners and DEX tools mark it as renounced.) Nobody can freeze your balance or change the token after it ships.
• Non-custodial. PotatoPad never takes custody of your coins or your money. Your tokens sit in your wallet; the liquidity sits in a public Uniswap V3 pool. There is no deposit contract holding user funds.

One thing that is explicitly NOT a hidden tax, so you know what you are looking at: the only extra rule in the token beyond a vanilla ERC20 is a time-boxed anti-snipe cap. For the first 1200 blocks after launch (about two minutes at current block times), a single non-exempt wallet cannot end a transfer holding more than 2% of supply. After that deadline block it is a complete no-op and the token behaves like any normal ERC20 forever. It is a max-wallet limit during launch, not a buy/sell tax and not a decaying fee.

What the contracts do NOT protect

Locked liquidity and an immutable token protect you from a rug and from a surprise reprint. They do not protect you from the market.

• Memecoins are volatile and can go to zero. Nothing here guarantees a price, a floor, a return, or that anyone will be on the other side of your sell. A locked pool can still be a pool almost nobody is buying.
• Graduation is not a floor. Reaching ~23 ETH FDV is a milestone the price crossed, not a support level. Price can (and often does) retrace afterward. The graduation flag is best-effort and mostly cosmetic.
• The creator can still sell. A locked pool stops the creator from removing liquidity. It does not stop them (or anyone) from selling the tokens they bought. Look at how the supply is distributed.
• You are responsible for what you buy. Verify the token address, look at the pool and the holders, and understand that a warm theme and a locked pool say nothing about whether a given coin is a good idea.

Do your own research. This is not financial advice. PotatoPad gives you strong, checkable guarantees about how the contracts behave. It gives you zero guarantees about price or profit. Treat every launch as high risk, verify things yourself on the explorer (https://robinhoodchain.blockscout.com), and only risk what you are fine losing.

Getting started

You need two things to use PotatoPad: a wallet connected to Robinhood Chain, and a little ETH on that chain for gas. Here is the whole setup.

1. Add Robinhood Chain to your wallet

PotatoPad runs on Robinhood Chain, an Arbitrum Orbit L2. Any EVM wallet works (MetaMask, Rabby, and similar). Add the network with these details:

Connecting your wallet on potato.fm will usually offer to add or switch to the network for you.

2. Launch or trade

• Launch a coin. Go to potato.fm/create, fill in the name, symbol, image, and any socials, and sign one transaction. Launching costs only gas, plus whatever ETH you choose to put into an optional dev buy. There is no separate launch fee.
• Trade or view a coin. Every token has a page at potato.fm/token/<tokenAddress> with a live chart and a built-in buy/sell widget. You can also trade through any Uniswap V3 compatible interface.

Where to get help

The community lives on the Telegram linked from potato.fm. That is the place for questions, help, and updates.

Launching a token

Launching on PotatoPad is one signed transaction. No presale to run, no liquidity to add yourself, no contract to write. You bring a name, a symbol, and some art. The pad does the rest.

What you choose

• Name and symbol (for example "PotatoRocket" and PROCK).
• Image and, if you have them, socials: website, X/Twitter, Telegram. These are recorded on-chain in the launch event when you create the token.
• An optional dev buy: attach some ETH and the pad makes the first buy for you in the same transaction (details below).

Then you sign once.

What the pad does in that one transaction

1. Grinds a vanity address. Before sending, your browser searches for a launch salt so your token lands on an address that starts with 0x7a70. That is "TATO", the closest you can spell to "potato" in hex (p, t, and o are not hex digits). It is cosmetic, and it costs you nothing.
2. Deploys the token. A plain, fixed-supply ERC20: exactly 1,000,000,000 tokens (1 billion, 18 decimals), minted in full to the pad. The token has no owner, no mint function, no pause, and no blacklist. Its owner() returns the zero address, so scanners read it as renounced. Once deployed it can never be changed.
3. Opens the pool and the curve. The pad creates the token's Uniswap V3 pool against WETH at the 1% fee tier (10000, tick spacing 200), then mints essentially the entire supply into one single-sided concentrated-liquidity position. Single-sided means only your token goes in, zero ETH. The pad reverts the launch if any WETH is consumed. That one position is the bonding curve. There is no separate curve contract, and there is no migration, ever.
4. Locks the LP. The position is sent straight to the PotatoFeeLocker at launch. There is no withdraw and no decrease-liquidity path, so the liquidity is locked permanently from block one, not at graduation.
5. Runs your dev buy, if you added one. See below.

Opening price and FDV

The pool opens at a fully-diluted valuation of about 1.3 ETH (the exact on-chain actualStartFdv is roughly 1.3025 ETH, after the pad snaps the opening price to the 1% tier's tick spacing). FDV is just token price times the 1,000,000,000 supply, denominated in ETH.

Because essentially all of the supply sits in that one position starting at the opening price and running upward with no ceiling, the price is simply the pool's slot0 tick. Every buy walks the price up the range, every sell walks it back down. From block one it is a normal Uniswap V3 pool that anyone can trade, chart, and price like any other token.

Anti-snipe: 2% max wallet for the first 1200 blocks

For the first 1200 blocks after launch (roughly 2 minutes at Robinhood's ~0.1s block time), no ordinary wallet may finish a transfer holding more than 2% of supply (20,000,000 tokens). An over-cap transfer reverts. This throttles bots from vacuuming up the launch supply in the opening blocks.

After that deadline block the cap is a complete no-op and the token behaves like a vanilla ERC20 forever, with no residual limit. (The launch infrastructure, the pad, pool, position manager, locker, and burn address, is exempt so normal pool mechanics and fee collection never trip the cap.)

The optional dev buy

If you attach ETH to the launch, the pad performs the very first buy for you on the same pool, at the same 1% fee everyone else pays. Two things to know:

• During the anti-snipe window the dev buy is held to the same 2% cap. If your buy would land you more than 2% of supply, the whole launch reverts, so size it under the cap.
• The buy cannot push the price past the bond (graduation) price no matter how much ETH you send, and any ETH it does not spend is refunded to you in the same transaction.

It is a fair launch

Essentially all 1,000,000,000 tokens go into the pool. There is no presale, no team allocation, no vesting, and nothing held back. The only way anyone, including you, starts with a bag is the dev buy, and that is an ordinary market buy on the same pool, at the same price and fee as the public, capped at 2% during the window.

Once launched, the token is immutable and the LP is locked. PotatoPad never custodies your funds and holds no keys to your token.

A quick walk-through

You upload art for "PotatoRocket" ($PROCK), paste your X link, and decide to make a small dev buy. You sign one transaction. Out comes a 0x7a70… token with a 1,000,000,000 supply, a live Uniswap V3 pool opening near 1.3 ETH FDV, and all of its liquidity locked in the fee locker. Your dev buy lands your first tokens (under the 2% cap), any unused ETH comes back, and from that block on anyone can buy or sell.

The standard launch above is one of a few types. Holder-reward and Give-to-the-Poor launches share this exact machinery (same fair launch, same single-sided locked LP, same anti-snipe) but change how fees are shared, and Give-to-the-Poor tokens keep permanent per-wallet caps rather than the time-boxed one. Those are covered in their own sections.

Trading and pricing

Every PotatoPad token trades on Uniswap V3 from block one. There is no waiting for a bonding curve to fill on some custom AMM, and no "graduation" step that flips trading on later. At launch the pad seeds the entire supply into a single Uniswap V3 position, and that position is the curve. So the moment a token exists, it has a real, public Uniswap V3 pool that anyone can buy from or sell into.

The fee is 1% each way

Trading costs 1% on buys and 1% on sells. This is the standard Uniswap V3 pool fee for the 1% fee tier (fee tier 10000, tick spacing 200), charged on the amount you put in. It is symmetric, so the rate is 1% in both directions, charged on whichever asset you put in: WETH on a buy, the token on a sell.

A couple of things worth knowing:

• It is a pool swap fee, not a transfer tax. The token contract itself takes no cut. Sending tokens to another wallet, approving a spender, or any move that is not a swap costs nothing extra. Only trades through the pool pay the 1%.
• The fee does not change over time and does not change at graduation. It is 1% before "bond" and 1% after, forever.

Where that 1% goes is covered in the fees section: in short, the token side of collected fees is burned and the ETH side is split between the creator and the treasury (and holders, on the reward and Give-to-the-Poor launch types).

Price comes straight from the Uniswap pool

There is no custom pricing formula to trust. Price is simply the pool's current tick, read from Uniswap V3's slot0. Because the whole supply sits in one concentrated-liquidity range, buying walks the price up that range and selling walks it back down, exactly like any other Uniswap V3 pool. As buyers push the price up through the range, the token moves toward its bond target. Nothing about that mechanism is special to PotatoPad. If you can price or chart a Uniswap V3 token, you can price and chart a PotatoPad token.

FDV in one line

Fully-diluted valuation is just price times total supply:

FDV = price x 1,000,000,000

Every PotatoPad token has a fixed supply of exactly 1,000,000,000 (1 billion) tokens, so FDV is the current pool price of one token multiplied by 1 billion, denominated in the quote asset (ETH / WETH on Robinhood Chain). For reference, a fresh curve launch opens near ~1.3 ETH FDV and its bond target sits near ~23 ETH FDV. For exact, tick-aligned figures, read the pad's on-chain getters (actualStartFdv(), actualTopFdv()) rather than hand-math.

How to trade

You have two easy paths, and they hit the same pool:

• The token page on potato.fm. Go to https://potato.fm/token/<tokenAddress> and use the built-in trade widget. Robinhood Chain (chainId 4663) is the default, so there is nothing extra to configure.
• Any Uniswap-V3-compatible router or app. Since the token is just a normal Uniswap V3 pool from launch, any wallet or aggregator that speaks Uniswap V3 can route a buy or sell against it. Point it at the token's pool on the 1% fee tier.

Same pool, same 1% fee, same price either way. PotatoPad never sits between you and the trade. This is not financial advice, and PotatoPad is unaudited, so trade with care.

Graduation (bonding)

A curve-pad token on the current pad starts life around 1.3 ETH fully-diluted valuation (FDV) and climbs as people buy. When its price reaches the bond level, about 23 ETH FDV on that pad, the token "graduates" (also called bonding). FDV here is just price times the fixed 1,000,000,000 supply, priced in ETH.

Here is the part that trips people up, so we will say it plainly: graduation is a milestone, not a migration. Nothing mechanical changes.

What does NOT happen at graduation

• No liquidity migration. The token has been a normal Uniswap V3 pool since block one, because the bonding curve IS a single-sided V3 position. There is nothing to move to a "real" DEX later, it was already there. No V2 step, no V4 step, no re-pooling.
• The LP is not "unlocked" or moved. The liquidity was permanently locked in the fee locker at LAUNCH, not at graduation. The locker has no transfer function and no path to decrease liquidity, so graduation does not touch it.
• The fee does not change. It stays the same 1% Uniswap V3 pool fee (tier 10000) on buys and sells, before and after bond.
• Trading does not pause or reset. The same pool, the same price, the same chart. A buy that happens to cross the bond level is just a normal swap.

What actually happens

On-chain, graduation is tiny. Someone calls bond(token), and if the price is at or above the bond tick, the pad flips one flag (bonded = true) and emits a Bonded event. That is the whole state change. In the contract's own words, bond() "moves no funds or liquidity" and "only flips the bonded progress flag and emits an event (a marker for the UI, not a state migration)." Think of it as a badge the token earns, not a gear that shifts.

Reading graduation status (for integrators)

The single most important thing to know: the Bonded event is best-effort, not a reliable oracle. bond() is permissionless (anyone can call it), and it only latches if it is called while the price is at or above the bond tick. The chain keeps no memory of past crossings, so a token can effectively be past its bond price without Bonded ever having fired. Do not treat "no Bonded event" as "not graduated."

Instead, derive status from live price versus the bond tick:

• Direct: read the pool slot0 tick and compare to the pad's tickCeil(). The pad does exactly this internally, accounting for token ordering: if the launched token is token0 the price rises with buys (tick >= tickCeil), and if it is token1 the price reads inverted (tick <= -tickCeil).
• Easier: call the pad's view helpers.
  • bondable(token) returns true once the price has reached the bond level (and it has not been latched yet).
  • curveProgressBps(token) returns progress from launch to bond as 0 to 10000 basis points, and 10000 once bonded. One caveat: it measures the tick range, and ticks are logarithmic in price, so it is not a straight-line share of the ETH FDV climb. A reading of 6200 is about 62% of the tick span to the bond tick, but only roughly a third of the 1.3-to-23 ETH FDV distance. Read it as a curve-position gauge, not a percentage of market cap.

For exact FDV thresholds rather than the round "1.3 ETH / 23 ETH" figures, read the on-chain getters actualStartFdv() and actualTopFdv() (the pad snaps the underlying ticks to spacing 200, so the enforced values differ slightly from the round targets, which are themselves on-chain as targetStartFdv() and targetTopFdv()). These bounds are set per pad at deploy time as constructor parameters, so for a token on an older curve pad, read them from that pad rather than assuming the current 1.3/23 numbers.

Bottom line: graduation is a celebration marker, not a mechanism. The token traded on Uniswap V3 the whole way up and keeps trading on the exact same pool, at the exact same 1% fee, the moment after it bonds.

Fees and creator earnings

Every swap on a PotatoPad token pays a flat 1% pool fee. It is the standard Uniswap V3 fee tier (10000, tick spacing 200), and it is symmetric: 1% on buys and 1% on sells. This is a pool swap fee, not a tax baked into the token, so moving tokens wallet to wallet costs nothing.

Because Uniswap charges the fee on whatever token you put in:

• A buy pays its 1% in WETH (you are spending WETH).
• A sell pays its 1% in the launched token (you are spending the token).

Where the fees live. The launch LP is minted straight into the PotatoFeeLocker and locked there forever. There is no withdraw and no decrease-liquidity path, so the principal can never be pulled. What the locker does let out is the swap fees, which pile up inside that locked position as people trade.

Realizing the fees is permissionless. Fees do not sweep themselves on every swap. Anyone (a creator, a bot, a curious holder, whoever) can call collect(positionId) on the locker to harvest the accrued fees into it. A plain swap does not trigger this, so someone has to crank it, but that someone can be anybody.

The split of what gets collected:

• Launched-token side: burned. The token portion of the fees is sent to 0x000000000000000000000000000000000000dEaD in full. Neither the creator, the treasury, nor holders receive it. This is the deflationary part: every sell quietly burns a sliver of supply.
• WETH side: 50% creator / 50% treasury (by default). The constant is CREATOR_FEE_SHARE_BPS = 5000 (50%). The treasury's half is auto-forwarded on every collect (pushed straight out, with a claimable fallback so collection can never get bricked). The creator's half is pull-claimed: it waits as a claimable balance until the creator withdraws it, at which point the WETH is unwrapped and paid out as native ETH.

We say "by default" because the pad owner can set a different treasury share per token on standard launches (for example, leaving a team 90% and keeping 10% for the treasury). That lever only ever touches future fees, never the locked principal or fees already accrued.

On the token page. The "Creator fees" (Harvest) card folds both steps into one button. If you are the creator, "Collect & claim" fires collect and then claims your WETH out to your wallet. If you are just passing through, the same card offers a plain "Collect fees" crank that harvests the fees into the locker (the creator's share still only ever goes to the creator, so cranking it for someone else just does them a favor).

Fees are perpetual. Because the LP is locked at launch and lives on Uniswap V3 the whole time, fees start accruing from block one and keep accruing for as long as the token trades. Graduation ("bond") does not change the fee: it stays 1% before and after.

Worked example. Someone buys with 1 WETH. The pool keeps 1%, so 0.01 WETH, as the fee. After a collect, that 0.01 WETH splits into 0.005 auto-sent to the treasury and 0.005 set aside for the creator to claim. A sell, by contrast, pays its 1% fee in the launched token, and that side is burned.

Launch modes: who earns the fees

Every launch splits the 1% trading fee the same way at the top: the treasury always takes 50%, and the other 50% (the "creator half") is what a launch mode decides how to hand out. You pick this once at launch, and it is fixed for the life of the token. There are three ways to go.

Standard. The creator keeps the full creator half. Of total fees that is 50% creator, 50% treasury, and holders get nothing extra. This is the default.

Holder rewards. Instead of keeping it all, the creator shares the creator half with everyone holding the token. A slider at launch sets how much the creator keeps (anywhere from 0 up to 45% of total fees); holders split the rest (5% up to 50% of total fees). This is the ability to give more fees away: the further you slide toward holders, the more of the trading fees flow to the people holding your coin, paid out continuously as it trades.

Give-the-Poor (Cashback). The all-in version of holder rewards: the creator keeps nothing, and the entire creator half (a full 50% of every trading fee) streams to holders. Pure Robin Hood, the dev earns zero and the crowd earns it all.

How holders get paid. On a holder-rewards or Give-the-Poor launch, each holder earns a share of the reward pool in proportion to how much of the token they hold, accruing as the token trades. You claim it as native ETH from the token page: claim() on the token pays you out, and pendingRewards(yourAddress) shows what you are owed. The "Creator fees" Harvest card is replaced by a holder-rewards card on these launches.

No extra wallet caps. Reward tokens behave like every other PotatoPad token. The only transfer rule is the standard launch anti-snipe (max 2% per wallet for the first 1200 blocks, then a plain ERC20 forever). There is no permanent per-wallet cap.

One more lever, separate from the mode you pick: on standard launches the pad owner can set a different treasury share for a specific token (for example, leaving a team 90% and keeping 10% for the treasury). That is an owner tool, not a launch option, and it only ever affects future fees, never the locked liquidity or fees already accrued.

Rewards and creator earnings come from trading fees, so they depend entirely on how much the token trades. They are never a fixed yield and never guaranteed. None of this is financial advice.

For developers (integration)

This is the short version for teams building indexers, wallets, aggregators, or charts on top of PotatoPad. The full technical reference, with complete ABIs and exact event signatures, lives in POTATOPAD_INTEGRATION.md at the repo root, and every ABI plus a minimal Uniswap V3 pool ABI ships in potatopad-abi.json. When this summary and that doc disagree, the doc wins.

The one idea that makes everything else simple: every PotatoPad token is a normal Uniswap V3 pool from block one. There is no custom curve contract and no migration. You price it, chart it, and detect its trades exactly like any other Uniswap V3 token.

Network

• Chain: Robinhood Chain (an Arbitrum Orbit L2), chainId 4663
• RPC: https://rpc.mainnet.chain.robinhood.com
• Explorer (Blockscout): https://robinhoodchain.blockscout.com
• Quote asset is ETH/WETH. WETH is 0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73.

Key contracts

The two CREATE2 deployer factories (PotatoTokenFactory 0x713fA9c01E9605F45a46284AbE848A32Ae7917fc, PotatoPoorTokenFactory 0x477782AD8EA1bBD93d833D627cb42b892CE1E8A6) emit no events. Do not watch them. Every launch log is emitted by the pad.

Indexing every token ever launched

New-token creation is emitted by the pad, so the emitting address on the log is the pad, never a factory. Watch:

event TokenCreated(address indexed token, address indexed creator, string name, string symbol,
                   address pool, string imageURI, string website, string twitter, string telegram);

TokenCreated.pool is the token's Uniswap V3 pool, the thing you index for Swap events and pricing. A companion CurveOpened(token, pool, positionId, liquidity) fires in the same launch transaction.

The pad is versioned. 0xbE2aCD...9d4B is the current pad (deployed around block 20461687) and is where new launches land, but older tokens still live on earlier pads and still trade on their own standard 1% pools. To resolve every token ever created, scan the same TokenCreated signature on every pad below (one ABI parses them all). A token belongs to exactly one pad, so dedup by token address.

The "index from" blocks are practical starting points, not exact deploy blocks, and the ranges overlap slightly where one pad handed off to the next, which is the other reason dedup by token address is required.

The type column matters for the rest of this section:

• curve pads use the bonding-curve model (single-sided V3 position, graduation via tickCeil). Only these tokens have curve state and a graduation concept.
• direct pads are the older launcher that seeded liquidity directly. Same TokenCreated event, same standard Uniswap V3 1% pools, but no curve and no graduation. The getters in the next two subsections do not apply to them.

Reading a token's state (curve-pad tokens only)

On a curve pad, curves(tokenAddress) returns the token's curve record: creator, pool, positionId, and a bonded bool. If creator comes back as the zero address, that token was not launched on this pad (for example, a direct-pad token), so treat it as "not a curve token here" rather than "0% bonded".

Two view helpers on the pad give you progress without any tick math:

• bondable(token) returns true when price currently sits at or above the bond threshold.
• curveProgressBps(token) returns 0 to 10000 (basis points) of the way from the opening price to the bond price.

Call these only against a curve pad and only for a token that pad launched. Reading them for a direct-pad token is meaningless.

Pricing and detecting graduation

Price comes straight from the pool's slot0 (the sqrtPriceX96 / tick), same as any Uniswap V3 pool. Fixed supply is 1,000,000,000 tokens (18 decimals), so:

FDV (in ETH) = price (ETH per token) x 1,000,000,000

Multiply by an ETH/USD spot price for a dollar figure. The pad's opening and bond targets are 1.3 ETH and 23 ETH (readable as targetStartFdv() and targetTopFdv()), but the pad snaps the derived ticks to tick spacing 200, so the enforced values differ slightly. For the exact enforced numbers read the on-chain getters actualStartFdv() and actualTopFdv() (both return wei), plus tickFloor() and tickCeil(). On the current pad actualStartFdv is about 1.3025 ETH and actualTopFdv is about 23.2 ETH.

Graduation is the token's price crossing the bond tick. Do not rely on the Bonded(token, pool, positionId) event as your source of truth. bond() only latches while price is above the threshold, the chain keeps no memory of past crossings, and bond() reverts with AlreadyBonded() once set, so a token can cross, retrace, and never emit Bonded at all. Treat the event as a best-effort marker only.

Derive graduation yourself. The cleanest path is bondable(token) (or curveProgressBps(token) == 10000). If you want to compute it from the live pool tick directly, use the exact ordering rule the pad uses, where the token is token0 when its address sorts below WETH:

graduated = (token < WETH) ? (tick >= tickCeil()) : (tick <= -tickCeil())

WETH is 0x0Bd7D308..., so real tokens sort on both sides of it. Getting that sign backwards is the most common integration bug here, so use both branches.

Nothing mechanical changes at graduation: no migration, no re-pooling, no fee change. The LP was permanently locked in the fee locker at launch, and the pool fee stays 1% (10000, tick spacing 200) before and after. So for trade detection you always read Swap on the token's V3 pool, and WETH flowing into the pool is a buy of the launched token.

Token page URL

https://potato.fm/token/<tokenAddress>

chainId 4663 is the default, so no query parameter is needed. Example: https://potato.fm/token/0x1d0a632CF332256ff26537B4d9583C74b4266896.

For full ABIs, exact event signatures, the fee-split details, and the anti-snipe and Give-the-Poor cap rules, read POTATOPAD_INTEGRATION.md and load potatopad-abi.json. This is a summary, not the spec, and PotatoPad is unaudited. None of this is financial advice.