Memecoins die of thin liquidity and of creators who sell. 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. Whale Capital points the side door down. The creator of every coin here is a whale. It eats half of every fee in coins and never sells, because it has no function to sell. The other half it sinks into the pool as liquidity nothing can remove.
A launchpad on Pons v2. Launching here is one transaction: the whale factory deploys a whale for your coin, launches the coin on Pons, and hands the coin's creator fee recipient to that whale before anyone has traded. From then on every creator fee the coin earns is the whale's, and the whale can only do one thing with it.
The factory has no owner. The whale has no owner and no way to move coins or liquidity out; the only ETH that ever leaves it is the cut owed to feeders. This site is a front end; it holds nothing and sends transactions from your own wallet.
| 1 · claim | The whale claims whatever Pons has moved into the fee escrow for the coin, in ETH, and adds it to any ETH it already held. |
| 2 · cut | A share of that is owed to the wallet that pressed feed: 0.10% right after the last feed, rising to 5.00% at 24 hours. Nothing else is taken. |
| 3 · split | The rest is split in two. Half for buys, half for liquidity. |
| on the curve | The buy half buys the coin on its own Pons curve, and the coins stay in the whale. That pushes the coin toward graduation. The liquidity half is held in ETH, because there is no pool yet. |
| in the pool | In one call to the Uniswap v4 pool manager the whale swaps the buy half plus a quarter of the liquidity half into the coin, then mints the remaining ETH and the matching coins as a full range position it owns and cannot remove. Everything reserved on the curve goes in on the first feed after graduation. The coins bought stay in the whale. |
| who can feed | Anyone. It costs gas and pays the cut. There is no keeper, no schedule and no operator. If nobody feeds, the ETH sits in the whale and the cut keeps climbing until somebody does. |
| the floor | A feed under 0.0005 ETH reverts, so nobody can reset the pressure clock with dust. |
| the whale | Half of every feed after the cut, as coins it never sells. Verifiable: the whale's address holds them, and its code has no transfer. |
| the pool | The other half, permanently, as full range liquidity. A rounding sliver waits in the whale and goes into the next feed. |
| the feeder | 0.10% to 5.00% of every feed, depending on pressure. |
| the creator | Nothing. A coin launched here has given its creator fees to its own whale. |
| pons | Its usual cut of the 1% base fee, before any of this. Whale Capital does not touch it. |
| whale capital | Nothing. No fee on launch, no fee on feeds, no treasury, no allocation. |
The cut paid to the feeder is a Dutch auction on time. It starts at 0.10% the moment a feed lands and climbs linearly to 5.00% at 24 hours, where it stays. A small feed that pays less than gas is not worth pressing, so the whale waits, pressure builds and it pays more, until somebody decides it is. Bots and people compete for the same button, and the coin wins either way.
| name and ticker | Written into the token contract. Neither can be changed afterwards. |
| image | A square png, jpg or webp, hosted anonymously or pasted as a url. It is written into the token and cannot change, so a dead link is dead forever. |
| description, X, telegram, website | Metadata on the token. Explorers and this site read them. |
| creator tax | 0% to 10%, charged on every trade on top of the 1% base fee. All of it feeds the whale. Higher feeds 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. If the buy would finish the curve, Pons clamps it and the factory returns the remainder to you. |
The launch fee of 0.0005 ETH is Pons's, not the launchpad's. Whale Capital charges nothing to launch and takes nothing from the launch.
| whale factory | 0x96b9FA…79CDfC ours. launches a coin on Pons and deploys its whale, in one transaction. no owner. |
| whale vault | one per coin ours. holds the coin's fees and coins and can only feed. no owner, no transfer of coins, no removal of liquidity. its address is on every coin page. |
| pons factory | 0x7eD598…01EC7e theirs. creates the coin, the curve and the graduated pool. |
| pons fee escrow | 0xd3AFEB…16Ac9e theirs. holds creator fees until the recipient claims them. a feed claims from here. |
| pons meme hook | 0xE5e702…6Be044 theirs. the Uniswap v4 hook on every graduated Pons pool. after graduation the creator tax accrues here, in the currency that came out of each swap, until Pons sweeps it to the escrow. |
| uniswap v4 | 0x8366a3…e40951 the pool manager. a feed 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 whale mints full range, ticks -887200 to 887200.
Nothing on this site is privileged. The whole launchpad is a handful of public reads, and pressing feed is one public write anybody can send.
import { createPublicClient, http, parseAbi } from "viem";
const client = createPublicClient({ transport: http("https://rpc.mainnet.chain.robinhood.com") });
const FACTORY = "0x96b9FAbb57B2950a6dE658E1BD18E3093579CDfC";
const factory = parseAbi(["function count() view returns (uint256)", "function tokens(uint256) view returns (address)", "function vaultOf(address) view returns (address)"]);
const vault = parseAbi([
"function pending() view returns (uint256 inEscrow, uint256 inVault, uint256 reserved)",
"function currentRewardBps() view returns (uint16)",
"function feed()",
"function withdraw()",
]);
const n = await client.readContract({ address: FACTORY, abi: factory, functionName: "count" });
for (let i = 0n; i < n; i++) {
const token = await client.readContract({ address: FACTORY, abi: factory, functionName: "tokens", args: [i] });
const v = await client.readContract({ address: FACTORY, abi: factory, functionName: "vaultOf", args: [token] });
const [inEscrow, inVault] = await client.readContract({ address: v, abi: vault, functionName: "pending" });
const bps = await client.readContract({ address: v, abi: vault, functionName: "currentRewardBps" });
// feed() pays you (inEscrow + inVault) * bps / 10000. send it with about 1.5x the estimated gas.
}A feed is a deep call: the pool manager calls back into the whale, 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.
| Launched | token, vault, creator, curve, name, symbol, devBuy. Emitted by the factory, once per coin. |
| Fed | feeder, claimed, reward, rewardBps, toBuys, coinsBought, toLiquidity, liquidity. Emitted by a whale on every feed. On the curve, liquidity is zero and toLiquidity is what got reserved. |
| Held | feeder, claimed, balance. Emitted instead when the coin is swept without a pool or rescued by Pons. |
| Withdrawn | who, amount. A feeder collecting the cut it was owed. |
Robinhood Chain has a testnet, but Pons is not on it, so nothing about this launchpad can be tested there. Everything below ran against a fork of the real chain with the real Pons factory, router, fee escrow, hook and the real Uniswap v4 pool manager, with real state and no real money. Thirteen tests, all green.
| a real launch | A coin created through the factory on real Pons, with the whale named as its creator fee recipient in the same transaction, with and without an opening buy. |
| feeding on the curve | The whale bought its own coin on the real curve, kept the coins, reserved half the ETH for the pool and owed the feeder its cut. |
| graduation | Bought out to 4.2 ETH and graduated into a real v4 pool behind the Pons hook. |
| feeding in the pool | The whale swapped through the hook and minted full range. Pool liquidity rose by exactly the amount the whale reported, to the last digit. |
| real trading fees | A swapper traded the graduated pool and the Pons hook accrued the creator tax for the whale. |
| pressure | 0.10% right after a feed, 2.50% at 12 hours, 5.00% at 24 hours, still 5.00% three days later. |
| the floor | A feed under 0.0005 ETH reverts and the clock does not move. |
| a re entering feeder | A contract that calls withdraw again from inside its own payout got exactly what it was owed and not a wei more. |
| a donation | ETH sent to a whale by a stranger is eaten like any other income. |
| doing it again | Six trade and feed cycles in a row. The pool was deeper after every one. |
| no exit | The whale's writable functions are feed, withdraw, init and the pool manager callback. Nothing transfers coins or removes liquidity. |
| coins, whales, feeds | Live. Read from the factory and each whale every 15 seconds. |
| market cap, liquidity | Live. From the pool itself and Dexscreener for graduated coins. On the curve, from the curve's own reserves and the Chainlink ETH/USD feed. |
| the feed ledger | Live. From each whale's own events. |
| fees reaching the escrow | Pons. On the curve, Pons moves the creator tax to the escrow. After graduation the tax accrues on the Pons hook until Pons sweeps it. The whale eats what has arrived. |
| a keeper | None. By design. Anyone can feed and is paid for it. |
| the fee recipient | Pons. The whale is named as each coin's creator fee recipient, and Pons owns that record. The Pons factory is not verified on the explorer. If Pons ever pointed it elsewhere, future fees would stop reaching the whale; nothing already in the whale or in the pool can be touched. |
Price moves during a feed. The whale swaps at whatever the pool price is when feed is pressed, with no slippage guard beyond the pool's own limits. On a thin pool a large feed moves the price against itself. The coins and the liquidity still land; they land at that price.
The coins and the liquidity are permanent. That is the promise and also the risk: nothing, including a bug, can get them back out.
Whale Capital has no owner. The factory and every whale have no owner, no pause, no upgrade path and no function that moves coins or liquidity out: check them on the explorer rather than taking this sentence for it. The same properties mean nothing can be repaired either. Pons does have an owner, and its factory code is not published.
None of this is advice. It is a launchpad with its rules printed on it.
| the curve | A Pons bonding curve. Before a coin graduates, every buy and sell happens against it. |
| graduation | At 4.2 ETH raised the curve closes and Pons puts what it collected, plus a reserved slice of the supply, into a Uniswap v4 pool as one locked position. |
| a feed | One press of the button. Claim, cut, buy half, sink half. Anyone can do it and is paid for it. |
| pressure | How long since the last feed, expressed as what the whale pays: 0.10% up to 5.00%. |
| whale share | The share of the coin's supply the whale holds. Bought with half of every feed. It never moves again. |
| full range | A liquidity position spread from almost zero to almost infinity, so it is never out of range and never needs managing. |
| the escrow | Where Pons holds creator fees until the named recipient claims them. For a coin launched here, that recipient is the whale. |
| the hook | The Pons contract attached to every graduated pool. After graduation, fees collect here first and reach the escrow when Pons sweeps them. |
| swept | A graduation that stopped half way: the curve is closed but the pool has not been created. Anyone can finish it, and this site offers the button. |
| owed | The feeders' cuts, recorded against their addresses and sitting in the whale until they withdraw. A feed never spends it. |
$WHALE is the launchpad's own coin, launched through this same factory, so it has a whale of its own that eats its creator fees like any other coin here. The launchpad takes nothing from it or from any coin on the pad.
Not launched yet. When it is, the address appears here first.