Launch a coin.
Every trade
makes it deeper.
Each coin's creator fees roll into its own locked liquidity. Anyone can press roll, and the vault can never take that liquidity back out.
Coins on the snowball
Launch a coin
| the coin | a pons v2 token with a bonding curve, graduating at 4.2 ETH into a Uniswap v4 pool with permanently locked seed liquidity |
| the vault | a contract with no owner and no way to remove liquidity, named as your coin's creator fee recipient before the first trade |
| every roll | 99.5% into your pool as full-range liquidity, permanently · 0.5% to whoever pressed roll · nothing to us |
| before graduation | fees accumulate in the vault. there is no pool to deepen yet. |
| after graduation | anyone can roll, any time there is enough to roll. you never have to touch it again. |
| your fees | none come to you. that is the point of launching here. |
How snowball capital works
Memecoins die of thin liquidity. A pons coin graduates into a pool seeded with 4.2 ETH and that is all the depth it ever gets, while its creator fees leave through the side door. Snowball capital points the side door back at the pool.
what this is
A launchpad on pons v2. Launching here is one transaction: the snowball factory launches your coin on pons, deploys a vault for it, and hands the coin's creator fee recipient to that vault before anyone has traded. From then on every creator fee the coin earns is the vault's, and the vault can only do one thing with it.
The factory has no owner. The vault has no owner and no way to move liquidity out; the only ETH that ever leaves it is the 0.5% owed to rollers. This page is a front end; it holds nothing and sends transactions from your own wallet.
what a roll does
| 1. claim | The vault claims whatever pons has swept into the fee escrow for the coin, in ETH. |
| 2. cut | 0.5% of the roll is owed to the wallet that pressed it. Nothing else is taken. |
| 3. swap | Half of the rest is swapped into the coin, through the coin's own pool. |
| 4. mint | The ETH and the coin are minted as a full-range Uniswap v4 position owned by the vault, which cannot remove it. The pool is now deeper than it was. The mint holds back a half-percent margin on both sides for rounding; that sliver, and the pool's usual fee on the swapped half, waits in the vault and goes into the next roll. |
| before graduation | Step 1 only. The vault claims and holds. Nothing is cut and nobody is paid until pons has created the pool; the first roll after graduation takes the cuts on everything held. |
| who can roll | Anyone. It costs gas and, once the coin has graduated, pays 0.5%. There is no keeper, no schedule and no operator. If nobody rolls, the ETH sits in the vault and waits. |
where the money goes
| the pool | 99.5% of every roll, permanently, less a rounding sliver that rolls next time. |
| the roller | 0.5% of every roll. |
| the creator | Nothing. A coin launched here has given its creator fees to its own pool. |
| pons | Its usual 30% of the 1% base fee, before any of this. Snowball capital does not touch it. |
launching a coin
One transaction on pons. It creates the coin and its bonding curve, deploys the coin's vault, and names that vault as the creator fee recipient before anyone has been able to trade. Every field on the launch form, and what it does:
| name and ticker | Written into the token contract. Neither can be changed afterwards. |
| image URL | A square png, jpg or webp that you host, or an ipfs:// URI. It is written into the token and cannot change, so a dead link is dead forever. |
| description, X, website | Metadata on the token. Explorers and this page read them. |
| creator tax | 0% to 10%, charged on every trade on top of the 1% base fee. All of it goes to the vault, so all of it becomes liquidity. Higher rolls faster and trades worse. |
| opening buy | Optional ETH spent on the curve in the same transaction as the launch. The coins go to your wallet. The launching address is exempt from the opening snipe tax, so this buy pays none. If the buy would finish the curve, pons clamps it and the factory sends the remainder straight back to you. |
| team wallets | Optional addresses, up to 30, exempt from the opening snipe tax. They cannot be added later. |
The launch fee is pons's, not the launchpad's. Snowball capital charges nothing to launch and takes nothing from the launch.
the contracts
Two of them are ours and the rest are pons's. Every address here is the real one; the launchpad reads all of them live.
| snowball factory | not deployed yetours. launches a coin and deploys its vault, in one transaction. no owner. | |
| snowball vault | one per coinours. holds the coin's creator fees and can only roll them into the pool. no owner, no withdraw of liquidity. its address is on every coin page. | |
| pons factory | 0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7etheirs. creates the coin, the curve and the graduated pool. | |
| pons fee escrow | 0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9etheirs. holds creator fees until the recipient claims them. a roll claims from here. | |
| pons meme hook | 0xE5e702641Ea86F4ae6cC3cDaeD2B886f976Be044theirs. the Uniswap v4 hook on every graduated pons pool. post-graduation fees accrue here until pons sweeps them to the escrow. | |
| uniswap v4 | 0x8366a39CC670B4001A1121B8F6A443A643e40951the pool manager. a roll swaps and mints through it. | |
Chain id 4663. Every coin's pool key is ETH as currency0, the coin as currency1, a zero LP fee, tick spacing 200 and the pons hook. The vault mints full range, ticks -887200 to 887200.
read it yourself
Nothing on this page is privileged. The whole launchpad is four public reads, and pressing roll is one public write that anybody can send. Two ways to do it from a script:
import { ethers } from "ethers";
const rpc = new ethers.JsonRpcProvider("https://rpc.mainnet.chain.robinhood.com");
const factory = new ethers.Contract(FACTORY, [
"function count() view returns (uint256)",
"function tokens(uint256) view returns (address)",
"function vaultOf(address) view returns (address)",
], rpc);
const VAULT = [
"function pending() view returns (uint256 inEscrow, uint256 inVault)",
"function owedTotal() view returns (uint256)",
"function roll()",
];
// find every coin with enough waiting to be worth rolling
for (let i = 0; i < await factory.count(); i++) {
const token = await factory.tokens(i);
const vault = new ethers.Contract(await factory.vaultOf(token), VAULT, rpc);
const [inEscrow, inVault] = await vault.pending();
const owed = await vault.owedTotal();
// the owed cut is already promised to whoever rolled before. roll()
// will not spend it, so do not count it.
const rollable = inEscrow + (inVault > owed ? inVault - owed : 0n);
if (rollable >= ethers.parseEther("0.0005")) {
console.log(token, ethers.formatEther(rollable), "ETH");
}
}
// press it. you are paid 0.5% of whatever the roll turns out to be.
const signer = new ethers.Wallet(KEY, rpc);
const v = new ethers.Contract(VAULT_ADDRESS, VAULT, signer);
const gas = await v.roll.estimateGas();
await (await v.roll({ gasLimit: gas * 15n / 10n })).wait();RPC=https://rpc.mainnet.chain.robinhood.com
# how many coins have been launched here
cast call $FACTORY "count()(uint256)" --rpc-url $RPC
# the first one, and its vault
TOKEN=$(cast call $FACTORY "tokens(uint256)(address)" 0 --rpc-url $RPC)
VAULT=$(cast call $FACTORY "vaultOf(address)(address)" $TOKEN --rpc-url $RPC)
# what is waiting: (in the escrow, in the vault)
cast call $VAULT "pending()(uint256,uint256)" --rpc-url $RPC
# and what is already owed to past rollers
cast call $VAULT "owedTotal()(uint256)" --rpc-url $RPC
# press roll. the call stack is deep, so give it room.
cast send $VAULT "roll()" --gas-limit 400000 \
--rpc-url $RPC --private-key $KEY
# take what you earned, whenever you like
cast send $VAULT "withdraw()" --rpc-url $RPC --private-key $KEYA roll is a deep call: the pool manager calls back into the vault, which swaps through the pons hook and then mints. Gas estimators under-call it. Send with about 1.5x whatever you are quoted; the unused gas comes back.
events
Every figure on this site comes from these. There is no database and no indexer.
Launched | token, vault, creator, curve, name, symbol, devBuy. Emitted by the factory, once per coin. | |
Rolled | roller, claimed, rolled, liquidity, protocolCut, rollerCut. Emitted by a vault on a roll that reached the pool. The ledger on each coin page is this event and nothing else. | |
Held | roller, claimed, balance. Emitted instead when the coin has not graduated: the fees were claimed into the vault and are waiting for a pool to exist. | |
Withdrawn | who, amount. A roller taking the cut it was owed. | |
what was proven, and how
There is no testnet worth using: Robinhood Chain has one, at chain id 46630, but pons is not deployed on it, so nothing about this launchpad can be tested there. Everything below was run against a local fork of the real chain instead, which uses the real pons factory, the real fee escrow, the real Uniswap v4 pool manager and the real pons hook, with real state and no real money. Two suites, eighteen tests, all green.
| a real launch | A coin created through the factory on real pons, with the vault named as its creator fee recipient in the same transaction. | |
| graduation | Bought out to 4.2 ETH and graduated into a real v4 pool behind the pons hook. When the finishing buy stalled in the swept state, the public button on this site pushed it through. | |
| a roll | Claimed the real escrow balance, swapped half, minted full range. Pool liquidity rose by exactly the amount the vault reported minting, to the last digit. | |
| real trading fees | A swapper contract traded the graduated pool, and the pons hook accrued fees the way it does for any trader. | |
| the leg pons owns | pons's own fee sweep operator was impersonated on the fork and ran the real sweep: the hook went to zero and the vault's escrow credit rose by the same amount, which was then rolled into the pool. This is the only way to test that leg and it works. | |
| doing it again | Six trade, sweep and roll cycles in a row. The pool was deeper after every one, and none were skipped. | |
| a re-entrant roller | A contract that calls roll again from inside its own payout. It got exactly what it was owed and not a wei more. | |
| a roller that cannot be paid | A contract that rolls and then reverts on payment. Its own cut stays owed and unclaimable; the pool is deepened anyway and every other roller still withdraws in full. | |
| a donation | ETH sent to a vault by a stranger is rolled into the pool like any other income. There is no other door. | |
| the two override paths | pons's owner was impersonated and told to point a live vault's fees somewhere else, through the factory and through the hook. The chain refused both. | |
What a fork cannot prove: real fees accruing from many wallets over days, real wallet software, and real gas under load. The first coin launched here is the first test of those, and it is being done with pocket change.
what is live, and what is not
| coins, vaults, rolls, pending | live | Read from the factory and each vault every 15 seconds. |
| market cap, liquidity | live | Dexscreener for graduated coins. Pre-graduation, from the curve's own reserves and Chainlink ETH/USD. |
| the roll ledger | live | From each vault's own events. |
| post-graduation fee sweeps | pons | After graduation, fees accrue on the pons hook until pons's operator sweeps them to the escrow. The vault rolls what has been swept. What is still on the hook is shown as pending. |
| a keeper that rolls for you | none | By design. Anyone can press roll and is paid for it. |
| the fee recipient | pons | The vault is named as each coin's creator fee recipient, and pons owns that record. Both of the ways pons could point it somewhere else were tried on a fork of the real chain, as the pons owner, and both were refused. The pons factory is not verified on the explorer, so a path nobody has found cannot be ruled out. If one exists it would stop future fees reaching the vault; it could not touch liquidity already in the pool. |
what can go wrong
Price moves during a roll. The vault swaps half its ETH at whatever the pool price is when roll is pressed, with no slippage guard beyond the pool's own limits. On a thin pool a large roll moves the price against itself. The liquidity still lands; it lands at that price.
The liquidity is permanent. That is the promise and also the risk: nothing, including a bug, can get it back out.
Snowball capital has no owner. Nobody can rug the factory or a vault, and nobody can fix them. pons does have one. Its owner was impersonated on a fork of the real chain and told to redirect this vault's fees, through the factory and through the hook, and the chain refused both. That is what was tested, not a promise about what is possible: the pons factory's code is not published, so an admin path nobody has found cannot be ruled out. Even so, nothing pons can do reaches liquidity the vault has already rolled into the pool. The code and its tests are in the folder. A fork of Robinhood Chain ran the whole path against the real pons contracts before this went live, and that is not a guarantee either.
None of this is advice. It is a launchpad with its rules printed on it.
words used here
| the curve | A pons bonding curve. Before a coin graduates, every buy and sell happens against it and the price is a function of how much has been raised. | |
| graduation | At 4.2 ETH raised the curve closes and pons puts everything it collected, plus a reserved slice of the supply, into a Uniswap v4 pool as one locked position. That is the coin's starting depth and, without a vault, its permanent depth. | |
| a roll | One press of the button. Claim, cut, swap half, mint the pair as liquidity. Anyone can do it and is paid 0.5% of it. | |
| full range | A liquidity position spread from almost zero to almost infinity, so it is never out of range and never needs managing. It earns less per dollar than a tight range and it never needs anyone to come back. | |
| the escrow | Where pons holds creator fees until the named recipient claims them. For a coin launched here, that recipient is the coin's vault. | |
| the hook | The pons contract attached to every graduated pool. After graduation, fees collect here first and reach the escrow only when pons sweeps them across. | |
| swept | A graduation that stopped half way: the curve is closed and the reserves are held, but the pool has not been created. Anyone can finish it, and this site offers the button. | |
| owed | The rollers' 0.5%, recorded against their addresses and sitting in the vault until they withdraw. A roll never spends it. | |
the coin
The launchpad's own coin has not been launched yet. When it is, it goes through the factory like any other coin, so its creator fees roll into its own liquidity and nowhere else. The launchpad earns nothing from any of this: launching through it costs it nothing, so it takes nothing. Whoever built it is holding the same coin as everybody else.