Documentation

How Pons NFT works

A token launched here pays its trading fees to whoever holds a particular NFT. Sell the NFT and the income goes with it. This page explains the whole mechanism — in plain language first, with the exact numbers and contract behaviour underneath.

What this is

An NFT is normally worth whatever the next person will pay for it. Nothing about holding one produces income — you are betting on the picture, the community, and the next buyer.

Pons NFT changes that for any NFT someone chooses to back. Anyone can launch a token tied to a specific NFT. That token trades on pons v2, every trade pays a small fee, and the fee goes to whoever holds the NFT at that moment. The NFT now has a yield attached, and that yield transfers with it when it sells.

You do not have to own an NFT to launch a token for it, and launching one does not pay you. The holder gets paid, whoever they are and whenever they change.

›Why anyone would launch someone else's NFT

Because a token needs a reason to exist, and “this token pays the holder of a well-known NFT” is a clearer one than most. The launcher gets a token they believe in; the holder gets income they did not ask for. Nothing about the design assumes the two are the same person, and the contracts never treat the deployer as privileged.

How a launch works

1
Point at an NFT
Paste a link from OpenSea, Blur, Magic Eden, Rarible or a block explorer — or type the contract address and token ID. The site reads the collection and the current holder straight from the chain.
2
The contract checks who holds it
At launch, the registry calls ownerOf on the NFT and records that address as the beneficiary. Nobody types it in; it is read, not asserted.
3
A vault is created
A dedicated contract is deployed for this launch and set as the token's permanent fee recipient. Fees arrive there and nowhere else.
4
The token launches on pons v2
It trades on a bonding curve and graduates to Uniswap v4 with locked liquidity, exactly like any other pons launch. Nothing about the trading is special.
5
Fees accrue to the holder
Every trade pays the creator tax into the vault, which credits the current NFT holder. They withdraw whenever they like.

›What the deployer can and cannot do

The registry contract is the pons deployer for every launch, not the person who clicked the button. The person who launched has no privileged call afterwards — they cannot redirect fees, cannot change the beneficiary, and cannot recover the launch fee. There is a test named test_Pons_DeployerCannotRedirectFees that exists solely to keep that true.

The fee vault

Each launch gets its own small contract — a vault — and that vault is the token’s fee recipient forever. It is the piece that makes the whole idea work, and it exists for a specific technical reason.

›Why a vault, and not just an address

pons keeps its fee ledger keyed by recipient address, and only the recipient itself can move what it is owed:

if (msg.sender != launch.creatorFeeRecipient)
    revert NotCreatorFeeRecipient();

That means the fee recipient cannot be a shared contract handling many launches with one balance — the ledger would blend them together and there would be no way to tell whose fees were whose. So every launch gets its own recipient: an EIP-1167 minimal proxy clone, which costs a few tens of thousands of gas rather than a full deployment. One vault, one launch, one ledger entry.

The vault holds separate balances for the NFT holder and for the protocol. Neither can spend the other’s, and both are readable on-chain at any time.

›Handover without losing a wei

When the NFT changes hands, the vault harvests everything earned so far and credits it to the previous holder before switching the beneficiary. Fees earned while you held the NFT stay yours even if you never withdrew them and the NFT has since moved on twice. The vault also exposes withdrawFor, so anyone can push a payout to its rightful owner without being that owner.

Fees and the split

Every launch charges a 0.75% creator tax on trades. That number is a constant in the contract — not a form field, not a setting, and not something an admin can raise later. Every launch through this registry charges exactly the same.

Every fee, split three ways

80% The NFT holder: Withdrawable at any time
10% Marketing: Growing the protocol
10% Buyback and burn: Permanently removed from supply

The holder’s 80% is theirs to withdraw whenever they choose. The other 20% funds the protocol: half to marketing, half to buying and burning the protocol’s own token, which is a public on-chain transfer to a burn address that anyone can check.

›Where the rounding goes

The split is computed so the holder takes the remainder:

uint256 marketingCut = (credited * MARKETING_BPS) / 10_000;
uint256 buybackCut  = (credited * BUYBACK_BPS)   / 10_000;
uint256 holderCut   = credited - marketingCut - buybackCut;

Integer division always loses a little. Computing the holder’s share by subtraction rather than by its own multiplication means dust can never leak, and can never quietly accumulate in the protocol’s favour. A fuzz test — testFuzz_Split_NeverLeaksDust — asserts the three parts always sum to exactly what came in.

›What pons itself charges

pons takes its own protocol fee on trades, separately and before any of this. The 0.75% described here is the creator tax that this registry sets, and it is the only part these contracts control.

When the NFT is sold

Nothing happens automatically — the chain has no way to notify a contract that an NFT moved. Instead, anyone can call a single function that re-reads ownerOf and updates the vault to pay the new holder.

The new owner can call it themselves. So can anyone else, including a keeper that watches for stale launches. It costs one transaction and takes no permission, because it cannot be abused: it does not choose a beneficiary, it reads the one the NFT contract already reports.

›Sync, in detail

syncOwner(launchId) updates one launch; syncOwners(uint256[]) batches many. Both harvest pending fees to the outgoing holder first, so a handover never strands income. staleLaunchIds(offset, limit) lets a keeper find launches whose recorded beneficiary no longer matches ownerOf. Costs stay flat as the registry grows — there is a test that launches a thousand tokens and asserts the per-call cost does not move.

›Listing an NFT for sale does not redirect anything

An OpenSea or Blur listing is an off-chain signed order plus an approval. You keep custody, ownerOf still returns your wallet, and fees keep coming to you until the sale actually settles. What does matter is transferring an NFT into a staking, lending or fractionalisation contract — then that contract is the holder, and it probably has no way to withdraw. The launch form checks for this and warns before you commit.

NFTs on other chains

Launches and fees live on Robinhood Chain, but the backing NFT can live on Ethereum, Base, Arbitrum or Polygon. Those two facts are in tension, and the honest answer is that they are not equally trustworthy. The site labels which one you are looking at everywhere it matters.

Verified on-chain

The NFT lives on Robinhood Chain. The contract reads ownerOf itself, in the same transaction. Nothing is trusted, because nothing needs to be.

Attested

The NFT lives on Ethereum, Base, Arbitrum or Polygon. A signer reads ownership there and signs a statement your transaction carries. This is a weaker guarantee — you are trusting the signer.

›How attestation works, and what it costs you in trust

A signer service reads ownerOf on the NFT’s home chain and signs an EIP-712 statement of what it saw. Your transaction carries that signature, and the on-chain verifier checks it. The verifier refuses attestations claiming to be from its own chain, requires signatures in ascending signer order, and rejects anything observed more than 15 minutes ago or valid for more than an hour.

It is built for k-of-n signers and currently runs with one. That means today you are trusting a single service not to lie. That is a real limitation, not a rounding error, and it is why the tiers are labelled rather than blended. No signature is ever requested from your wallet for this — the attestation is produced by the service, not by you.

Duplicate launches

Anyone can launch a token for any NFT, which means the same NFT can back several tokens. That is deliberate. The alternative — first launch wins — would let a stranger permanently burn the slot for an NFT you own.

Instead the holder decides. Whoever holds the NFT can mark one launch as canonical, and the site shows that one as the real one. Every launch still pays its fees to the holder either way.

›What canonical does and does not change

setCanonicalLaunch(launchId) is callable only by the current holder of the backing NFT. It is a display and discovery signal; it does not stop the other launches trading, does not move their fees, and does not confer any claim over them. A launch made by the holder themselves is flagged separately, so you can always tell whether the NFT’s own owner started it.

Anyone can launch a token using any NFT, including one that imitates a well-known collection. Check the contract address, never the name.

Getting paid

Fees build up in the vault as trades happen. Nothing expires and nothing needs claiming on a schedule — the balance sits there until you withdraw it.

The Earnings page shows what is owed to your address across every launch you hold, and lets you withdraw. If you hold several NFTs with launches, they can be collected together rather than one at a time.

›The calls behind the button

harvest() pulls what pons owes the vault; withdraw(asset) sends your balance; harvestAndWithdraw() does both in one transaction. collectable(launchIds, account) is a read that answers “what is owed” without spending gas. Because withdrawFor is permissionless, a holder who has lost interest can still be paid by someone else — the funds are never stuck behind their inactivity.

Risks

Worth reading properly rather than skimming. Some of this cannot be fixed by anyone.

These contracts are unaudited.
They have an extensive test suite, and the source is published, but nobody independent has reviewed them. Treat that as the material fact it is.
pons v2 is itself under review.
This system depends on it completely. A problem there is a problem here.
Launch tokens can go to zero.
A token backed by an NFT is still a token. Fee income depends entirely on people trading it, and most launches on any platform do not sustain volume. “Yield” here means “a share of whatever trading actually happens”, which may be nothing.
Fees follow ownership, including away from you.
Sell the NFT and the income stops being yours the moment someone syncs the launch. That is the design working, not a failure — but it means the NFT and the income cannot be separated.
An NFT held by a contract may be unable to withdraw.
If the holder is a staking or escrow contract with no way to call withdraw, the fees credited to it are unreachable. The form warns before you launch into that situation.
ERC-1155 cannot be supported.
A 1155 token id can be held by thousands of wallets at once, so “whoever holds the NFT” has no single answer and there is no ownerOf to read. These are detected and refused rather than left to fail on-chain.
Cross-chain ownership rests on a signer.
For NFTs outside Robinhood Chain, ownership is attested rather than verified. See the section above for exactly what that means.

Nothing here is financial advice or an offer to sell anything. Figures in the calculator on the home page are a model built from numbers you enter, not a projection.

Verify it yourself

Every claim on this page is checkable. The contracts are on Robinhood Chain (chain id 4663).

Launcher (registry)0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496

Ownership attestor0x5b73C5498c1E3b4dbA84de0F1833c4a029d90519

pons v2 factory0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e

pons fee escrow0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9e

›Two reads worth doing before you trust any of this

# the tax is fixed at 0.75% and nobody can change it
cast call <launcher> "CREATOR_TAX_BPS()(uint16)"   # 75

# the split is a constant, not a setting
cast call <vault> "HOLDER_BPS()(uint16)"           # 8000

If those return anything other than 75 and 8000, this page is wrong and you should not use the site.

Ready to look around?

Browse what has already launched, or point at an NFT and see what a launch would look like.

Explore launches Start a launch