How mynt.lol works

mynt.lol turns a token launch into something that pays its holders. You launch your token through mynt.lol on pons.family (Robinhood Chain). In the same breath, mynt.lol mints an NFT collection and wires your token's trading fees to a vault behind it. Every buy and sell of your token drips ETH into that vault. Each NFT is a claim ticket on it.

The value of a ticket is not a promise or a peg. It is the vault balance split evenly across the NFTs, a number anyone can read on-chain and check with a calculator. The more your token trades, the more each NFT is worth. When a holder wants out, they burn their NFT and the contract pays them their share in ETH, on the spot. No form, no approval, no custodian.

pons.family is a launchpad. Every token launched on it has one address it pays its creator fees to, the creatorFeeRecipient, chosen at launch. Most launches point it at the founder's own wallet. mynt.lol points it at the collection's vault contract instead.

From that one wiring, everything follows. Trades on the pons curve charge a fee; pons credits your vault's balance inside a shared escrow contract, in native ETH. Only the vault can pull that ETH out, the escrow pays whoever is the recipient, and the recipient is the vault. So the money has nowhere to go except the floor, which is why anyone is allowed to trigger a claim: they can move it toward the holders, never away.

1. You fill in a theme, a name, and a supply, then click Launch, one transaction.
2. mynt.lol launches your token on pons, deploys the vault and the collection, and sets the vault as the token's fee recipient, all atomically.
3. Trading begins. Every buy and sell credits your vault's ETH balance in the pons escrow.
4. A keeper (or anyone) calls claimPonsFees() to pull that ETH into the vault. mynt.lol keeps 30% to buy back and burn the mynt token; 70% backs the floor.
5. Holders pay ETH to mint NFTs from the collection, and that payment backs the floor too.
6. Each NFT's value is the vault balance divided by the number of NFTs.
7. Any holder burns their NFT to receive that share in ETH, atomically.

RNFTVaultV3 is a Solidity contract deployed once per collection. It holds native ETHand is the token's creatorFeeRecipient on pons. Fees for it build up inside the pons escrow until someone claims them; the vault then holds that ETH and tracks how much of it backs the floor with internal accounting, not its raw balance.

claimPonsFees()pulls the vault's accrued fees out of the escrow and immediately runs a sweep. The sweep looks at how much ETH arrived since last time, takes the mynt.lol protocol cut off the top, and credits the rest to the redeemable balance. That is the only door ETH walks through on its way to the floor.

function _sweep() internal {
    uint256 accounted = internalEthBalance + accruedProtocolFees;
    uint256 bal = address(this).balance;
    if (bal <= accounted) return;

    uint256 incoming = bal - accounted;
    uint256 cut      = incoming * protocolFeeBps / 10000; // mynt.lol's 30%
    accruedProtocolFees += cut;
    internalEthBalance   += incoming - cut;               // backs the floor
}

The creator cannot withdraw the redeemable ETH. Neither can mynt.lol , only its accrued protocol cut. The floor balance is reachable by exactly one action: an NFT holder burning their NFT.

The backed floor price is simply:

internalEthBalance is the ETH credited by claims minus the ETH paid out by redemptions. totalSupply is the number of NFTs in circulation (minted minus burned). Both are on-chain values anyone can read.

The app also shows a liveFloor that adds the fees still sitting un-claimed in the escrow (net of the mynt.lol cut), so the number you see moves with every trade, not only after a keeper claims. Division rounds down: each redeemer gets a hair less than exact, the dust stays behind, and the last holder out sweeps up everything remaining.

Redeeming never lowers the floor for anyone else. If the vault holds V and there are c NFTs, each worth V/c:

The floor comes out unchanged. In practice it ticks up a few wei from rounding, but it can never fall because of a redemption. The pro-rata formula guarantees it.

NFTs can trade on secondary markets above or below the backed floor. The floor is the guaranteed part; the market decides the rest.

• Premium: market price above floor. Normal for a collection people want to hold, the extra is art, community, or a bet on future fees beyond the guaranteed redemption.
• Discount: market price below floor. That is free money: buy the NFT cheap, burn it, receive more ETH than you paid. Arbitrageurs close the gap, so the floor acts as a hard price support.

• pons creator fee: a cut of every trade on your token, paid to the vault in native ETH and held in the pons escrow.
• mynt.lol protocol fee: 30% of each amount claimed into the vault, taken on sweep. mynt.lol uses this to buy back and burn the mynt token. Capped at 30% and fixed per vault at deployment.
• What holders get: the other 70% of every claim backs the floor. Of 1 ETH in creator fees, 0.70 ETH becomes redeemable value for NFT holders and 0.30 ETH funds the mynt buyback and burn.
• Mint price: minting is paid in ETH, and the full payment goes into the vault as backing. Mint proceeds take no cut, so 100% of what you pay backs your NFT.
• Launch fee: a small flat fee in ETH, paid once when you launch. It is separate from the trading fees above.

The 70/30 split above is the Backed NFT mode. In the Fees to the dev mode the split does not apply. See Collection types.

When you launch, you choose where the token's trading fees go. The choice is fixed for the life of the collection. Both types pay the same flat launch fee, and in both types mint proceeds always back the NFT.

Launching is one click and one signature. There is no copy-paste step and no “now go set your fee wallet”. The factory does the whole wiring inside a single transaction.

1. On the Launch page, describe your collection: theme, name, symbol, supply, mint price.
2. Click Launch and confirm one transaction (it pays the small pons launch fee).
3. The RNFTLaunchFactory launches your token on pons, then deploys the RNFTVaultV3 and RNFTCollectionV3.
4. In the same transaction it hands the token's creatorFeeRecipient to the vault.
5. Trading fees now flow to your vault from the first block. Nothing else to do.

Minting an NFT costs a fixed amount of ETH, set by the creator at launch. The whole payment goes straight into the vault and backs the floor. Minting takes no cut, so every wei you pay is redeemable.

This means an NFT is backed the moment you mint it. Your own mint payment sits in the vault behind it, and the token's trading fees pile on top over time.

Fees land in the pons escrow automatically on every trade, but they only count toward the floor once they are pulled into the vault. claimPonsFees() does that pull, and it is permissionless, so anyone can call it.

function claimPonsFees() external returns (uint256 claimed) {
    claimed = escrow.claim();  // escrow pays the vault (the recipient)
    _sweep();                  // credit the floor, minus mynt.lol's 30%
}

It is safe to open to everyone because the escrow only ever pays the recipient, and the recipient is the vault. A keeper bot calls it on a schedule once the claimable amount clears a small gas threshold, so the floor stays current. If the keeper ever stops, the fees sit safely in the escrow and any holder can claim them.

Burning an NFT pays out internalEthBalance / totalSupply in native ETH to the holder, in one atomic transaction:

1. Your share is calculated from the current vault balance and supply (rounds down).
2. The NFT is burned (totalSupply drops by one).
3. The vault sends you your ETH.

No server signs it. No custodian approves it. The contract enforces it, and you sign the transaction yourself. That is the difference between a redeemable floor and a promise of one.

What is trustless, and where trust still lives: