docs
the machine,
opened up
How the letscashfun 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 — registered at launch in place of a person, so the creator of a self-burn coin earns nothing and has nothing to claim. It 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.
revenue splitter
Where the platform's share of every trade lands. It divides what arrives three ways: a quarter buys CASHCAT on the open market and sends it to the dead address, a quarter buys CASHCAT for the treasury, and the rest pays for running the platform. Both buys are public functions that pay a bounty to whoever calls them, so the burning is driven by whoever wants the fee — not by us.
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
A fixed 1% trading tax, collected in ETH on every trade: 0.7% accrues to the creator and 0.3% goes to the platform. The tax is public on every token page and card, fixed at launch, and cannot be raised afterwards by anyone — including us.
self burn
Fixed 1% tax with zero creator take: 0.7% buys the token on its own pool and destroys it, and the remaining 0.3% goes to the platform. 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 or 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, market-buys the token and destroys it — the creator has nothing to claim and never did.
what the platform's 0.3% does
The same in every mode, on every token. It lands on the revenue splitter and divides three ways:
the two CASHCAT buys are public functions that pay the caller a bounty, so anyone can trigger them and watch the tokens leave. 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.3%, 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 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 )
we're hiring keeper bots
No employer, no application. The machine runs on public functions that pay their caller, and "hiring" means the bounties are real and yours to take. letscashfun runs its own keeper as a backstop, but it deliberately waits before acting on every newly available step, so independent keepers always get first claim.
the bounty board
- Trigger self burns: burn(poolId) on the self burner pays 1% of every claim it converts. Busier tokens accrue faster, so the board refills itself.
- Trigger CASHCAT buybacks: the revenue splitter's two buy functions each pay the caller 1% of the chunk they spend — one burns what it buys, one fills the treasury. The live tank sits on the tokenomics page.
- Sweep any pool: sweep(poolId) is open to anyone. It pays no bounty, but it settles the split — worth knowing if you are waiting on a claim of your own.
A minimal keeper is a loop: read the pending fuel on the pools you care about, call the trigger when it clears your gas cost, collect the bounty. Gas on this chain costs a fraction of the bounties, and nothing here needs an allowlist, a key or our permission.
// self burns: is there fuel yet? hook.pending(poolId) burner.burn(poolId) // pays you 1%
// CASHCAT lanes, on the splitter splitter.allocate() // divide what has arrived splitter.burnTank() // fuel in the burn lane splitter.buyAndBurn() // pays you 1% splitter.buyForCashcatTreasury() // pays you 1%
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: