docs
the machine,
opened up
How the cashcat contracts actually work: launch modes, the fee lifecycle, self burns, bounties, and every function you can call yourself — from a wallet, a script, or a bot. Everything here is verifiable on chain.
the contracts
factory
The launcher. One transaction deploys the token, creates and seeds the Uniswap v4 pool, locks the liquidity, and runs your first buy. Upgradeable behind a proxy so new launch modes can ship — but it holds no funds and has no power over tokens already launched.
hook
The fee engine, riding inside every swap via Uniswap v4 hooks. Collects each pool's tax in ETH on every buy and sell — never in memecoins — and holds it until swept. It also rejects every attempt to remove pool liquidity, so the liquidity lock is enforced here — immutably, beyond any upgrade, including ours.
token
A fixed-supply ERC-20, ownerless after launch, with its logo, description, and socials stored on chain. Every address ends in "cc" — enforced by the factory, whoever launches. Any holder can burn() their own tokens, which genuinely reduces total supply.
one per launch — see any token page
self burner
Fee recipient for self-burn launches. Claims the creator share, market-buys the token on its own pool, and destroys it. No owner, no withdrawal path, no way to redirect — and it pays a bounty to whoever triggers it.
launch modes
A launch mode is a config on the factory — picked at launch, burned into the pool forever. New modes are added as new configs, without redeploying anything or touching existing tokens.
standard — the tax token
The creator sets a total trading tax between 1% and 15%, collected in ETH on every trade. The platform takes about 0.5% regardless of the tax; everything above it accrues to the creator. A 1% token splits 0.5 / 0.5; a 10% token pays the creator 9.5% per trade. The tax is public on every token page and card.
self burn
Fixed 1% tax with zero creator take: 0.5% to the platform, and the other 0.5% buys the token on its own pool and destroys it. Total supply drops on chain — explorers show it shrinking, not a dead-address wallet growing. The fee stream is registered to the burner contract at launch and can never be pointed anywhere else.
the live mode list is on chain — enumerate it yourself:
factory.launchConfigCount() → uint256 factory.getLaunchConfig(configId) → (supply, tickSpacing, startTick, creatorFeeBps, baseFeeRate, launchFeeRate, launchFeeDecay, enabled, selfBurn)
where every fee goes
1 · trade
Someone buys or sells, through any router or bot. The hook collects the pool's tax in ETH, inside the swap itself — there is no way to trade around it.
2 · pending
Fees sit in the hook as pending ETH, per pool, publicly readable: hook.pending(poolId).
3 · sweep
sweep(poolId) is callable by anyone. It converts the pot: platform share straight to the treasury, creator share onto the creator's tab. Neither side can block the other — we call it to collect our cut like anyone else could.
4 · claim / burn
On standard tokens, claim(poolId) pays the creator their whole tab in ETH — creator-only, callable from a wallet or a script. On self-burn tokens, the burner claims it and burns the token instead.
the platform's 0.5% is earmarked for the cashcat buyback burn in every mode — see the tokenomics page for the live numbers.
the fee stream is an asset
On standard tokens, the creator's share isn't welded to the wallet that clicked launch — it's a transferable claim on future fees. One call hands the whole stream, including anything unclaimed, to a new address. Most launchpads don't let you do this; here it's a first-class part of the design:
- Only the current recipient can move it, and the handoff is final — the new address takes full control, including the right to hand it on again.
- It moves who gets paid, never what traders pay: the tax rate, the platform's ~0.5%, and the locked liquidity are immutable no matter how many times the stream changes hands.
- Every handoff is public the instant it happens — a CreatorUpdated event on chain, and the app follows it: the claim flow always keys on the current recipient, not launch history.
What it's for: launch from a hot wallet and park the revenue in your team multisig. Hand a project to new owners with its income attached. Let a community takeover actually take over — dead token, live fee stream, one transaction. Or point it at a contract: a splitter, a vault, a bot. Self-burn tokens are the one exception — their stream is owned by the burner contract and locked to burning, forever.
// current recipient only hook.updateCreator(poolId, newAddr) // unclaimed ETH travels with it // newAddr can claim, or move it again // the tax itself never changes
// watch it happen event CreatorUpdated( poolId, oldCreator, newCreator )
self burn, in detail
- 01 — trading accrues the creator share as burn fuel in the hook, exactly like a standard token accrues creator fees.
- 02 — anyone calls burn(poolId) on the burner. It claims the fuel, pays the caller a 1% bounty of the claim, and market-buys the token with the rest.
- 03— the bought tokens are destroyed via the token's own burn(): total supply drops for real, visible on any explorer.
- 04— the burn's own swap pays the pool's tax too, so a small residue re-arms the next burn and feeds the cashcat burn.
The bounty is what makes burns self-driving: the moment a pool's fuel covers gas plus profit, it's rational for anyone — keeper bots, traders, holders — to pull the trigger. Busier tokens burn more often, automatically. Every self-burn token page shows the accrued fuel and a burn button that pays the bounty to your wallet.
burner.burn(poolId) → claims accrued fuel → pays caller 1% bounty → buys token on its pool → token.burn(amount) → returns tokensBurned
// watch it happen event Burned( poolId, token, ethIn, tokensBurned, bounty )
build on it
The site is one client. Everything it does, your script or bot can do directly against the contracts — launching, trading, claiming, sweeping, burning.
launch a token (with the …cc stamp)
// 1. find a salt whose address ends in "cc" — free view call
(salt, token) = factory.mineSalt(params, configId, you, randomStart, 4096)
// 2. launch — msg.value must equal launchFee + firstBuyIn exactly
factory.launch{value: fee + firstBuy}(params, configId, firstBuy, minOut, salt)
// simulate via eth_call first: returns (token, poolId)
// params.creator must be the caller — creator identity is earned by
// signing the launch. Launching for someone else? You launch, then
// hand them the stream with updateCreator.
// the factory rejects any salt whose address lacks the stamp,
// and salts are bound to the sender — nobody can steal yourscollect fees, programmatically
hook.pending(poolId) // unswept fees, anyone can read
hook.tab(poolId) // creator's swept, unclaimed ETH
hook.sweep(poolId) // anyone: settle the split
hook.claim(poolId) // creator only: sweep + pay tab in ETH
hook.updateCreator(poolId, addr) // creator only: move the stream
// (e.g. to a multisig or a bot)Tokens trade on standard Uniswap v4 rails — any terminal, aggregator, or bot on the chain can trade them with zero integration, and the tax applies identically wherever the trade comes from. One rule for exotic flows: when ETH is the exactly-specified side of a swap, the tax is charged on that specified amount, so a tight price limit that would only partially fill reverts instead of overtaxing you. Fills are all-or-nothing.
verify everything
Nothing on this site is self-reported. Every number is derived from chain events and checkable against the contracts' own state: