docs
the machine,
opened up
How the letscash contracts actually work: launch modes, the fee lifecycle, dividends, 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.
dividend distributor
Fee recipient for dividend launches. It converts each pool's fee stream into that token's chosen reward asset and pushes it to qualifying holders' wallets, pro rata. One ownerless contract serves every dividend token: it has no withdrawal function, no operator, and no way to redirect a pool's stream. Every step of a payout round is a public function that pays whoever calls 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
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. Earlier launches could pick a tax up to 15%; those configs are now switched off in the contract itself, and tokens launched on them keep the tax they were born with.
dividends · closed to new launches
Tokens whose creator share rewards holders instead: fees convert into the payout asset the launcher chose and land directly in qualifying wallets, nothing to claim. New dividend launches are switched off at the contract level. Every dividend token already launched keeps paying out forever; its wiring is fixed at birth and cannot be changed 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 / burn / distribute
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. On dividend tokens, the distributor claims it, buys the reward asset, and pays holders.
the platform's 0.3% buys CASHCAT, burns it, and funds its treasury — 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.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 and dividend tokens are the exceptions. Their streams are owned by the burner and distributor contracts, locked to burning and to paying holders, 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 )
dividends, in detail
This section covers the dividend tokens already launched; new dividend launches are switched off at the contract level. For those tokens the machinery below runs forever. The simple version: fees build up, then a payout happens. Rewards go straight to holders' wallets and there is never anything to claim. The full version is a five-step round that anyone can drive:
- 01 · trading accrues the creator share as dividend fuel in the hook, exactly like a standard token accrues creator fees.
- 02 · once at least 0.005 ETH is available, anyone calls startRound(poolId). It claims the fees, takes an immutable snapshot of the token's holder balances, buys the reward asset on its live pool, and opens a 10 minute enrollment window. The caller earns 1% of the round.
- 03 · anyone submits holder addresses with enroll(poolId, holders). The contract checks every address against the snapshot itself: balances cannot be faked, duplicates are rejected, and anyone left out can add themselves with selfEnroll(poolId). Submitters earn a tip per newly enrolled holder.
- 04 · after the window, finalizeEnrollment(poolId) locks the list. It cannot be called early, so there is always time to complete the list.
- 05 · payout(poolId, max) pays every enrolled wallet its exact pro-rata share of the reward pot, in batches. Failed transfers and rounding dust roll into the next round; nothing strands.
The snapshot is what makes it fair: your balance at the moment the round starts is your weight for that round. Buying after the snapshot counts toward the next round; selling after it does not erase what the snapshot already recorded. Big pots drain across multiple rounds (at most 0.5 ETH converts per round), so a busy token simply pays out again and again. The eligibility floor set at launch caps a round at 10,000 wallets, which keeps every step cheap enough to crank.
dist.nextStep(poolId) → 0 start a round → 1 enroll holders → 2 finalize the list → 3 pay wallets → 4 nothing to do yet
// the whole lifecycle dist.startRound(poolId) dist.enroll(poolId, holders[]) dist.selfEnroll(poolId) dist.finalizeEnrollment(poolId) dist.payout(poolId, maxEntries)
// watch it happen event RoundStarted( poolId, roundId, potAsset, ethConverted, enrollEnd) event Enrolled(...) event RoundFinalized(...) event RoundClosed( poolId, roundId, distributed, carried)
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. letscash 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
- Start a dividend round:1% of the round's ETH, paid instantly. Rounds open at 0.005 ETH and convert up to 0.5 ETH each, so the bounty scales with the backlog.
- Crank enrollment and payout:a flat ETH tip per holder you enroll and per wallet you pay, funded by a reserve each round sets aside. Whoever lands the final payout batch also collects that round's unused reserve.
- Trigger self burns: burn(poolId) on the self burner pays 1% of every claim it converts.
- Trigger CASHCAT buybacks:the platform's own burner pays a bounty too; the live number sits on the tokenomics page.
A minimal keeper is a loop: read nextStep(poolId)for pools you care about, do whatever it says, collect the bounty. Holder lists are free: index the token's Transfer events yourself, or use our public candidates endpoint below. Either way the contract re-verifies every address against the snapshot, so a bad list can never inflate anyone's share, and gas on this chain costs a fraction of the tips.
// free candidate list for any
// dividend token, floor applied
GET /api/tokens/{token}/dividend-holders
// everything a round pays, live
GET /api/tokens/{token}
→ dividendInfo.bounties// the loop step = dist.nextStep(poolId) if step == 0: startRound(poolId) if step == 1: enroll(poolId, missing) if step == 2: finalizeEnrollment(poolId) if step == 3: payout(poolId, 200)
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: