How HoodPad works

The launch

One transaction creates your coin and its Uniswap V3 pool together. No bonding curve, no graduation, no migration. It's a normal WETH pair from the first block, so DexScreener, terminals, bots and aggregators pick it up on their own.

The mechanism is a V3 range placed entirely above spot. A range above the current price holds only the token — no ETH is needed to seed it. As buyers push price up through it, tokens convert to ETH inside the pool. That's mathematically a bonding curve; it just happens to be a real Uniswap pool.

The range runs from the opening price to the far edge of what Uniswap allows — it ends 72 ticks from the hard limit. There is no price ceiling and no point where your coin runs out of liquidity and stalls.

The dev buy

Any ETH you send beyond the launch fee buys your bag inside the same transaction as the launch. That's the point of doing it there: there is no block in between for a sniper to get in front of you. Optional, and the only thing exempt from the caps below.

Fees

Uniswap takes its 1% from whatever a trader pays in. A buyer pays ETH, so the fee accrues in ETH. A seller pays your coin, so the fee accrues in your coin. Roughly half your fees arrive as tokens. That isn't a choice we made — it's how V3 works, and it's the cost of being a normal pool that trades everywhere.

The ETH side always splits 90% to you, 10% to us. Rounding is floored on our side, so it always breaks your way.

Your 90% is frozen at launch

The split is written into tokenCreatorBps[yourCoin] when you launch, and read from there when fees are collected. We can change the split for future coins. We cannot change yours — not by a vote, not by an upgrade, not at all. There's a floor in the code too: MIN_CREATOR_BPS = 5000, so no future coin can be pushed under 50% either.

Handing off your fee rights

You can hand a coin's fee rights to another wallet — a cold wallet, a team multisig, the project you launched it for. It's one transaction and permanent: once you transfer, that wallet is the creator and you can't take it back. That's the point — it makes a handoff to a project a real commitment. A launchpad that let you redirect fees and then quietly point them back at yourself after the coin pumped would be handing you a rug; this can't.

We never sell your coin

An earlier version converted the token side to ETH when you claimed, which meant every claim dumped into your own pool in one lump, at a moment your holders didn't choose. That code is deleted. Collecting fees is transfers only — there is no swap in the contract.

Burn or Keep

You choose what happens to the token side at launch. It is frozen forever: there is no function to change it. A coin that launched as Burn can never become Keep, because the people who bought it on that basis would be the ones paying for the change.

Whichever you pick is shown on your coin's page, before anyone hits buy.

Launch guards

For the first 366 blocks — about 36 seconds at this chain's 0.1s blocks — buys from the pool are capped. Then the checks switch off permanently and your coin is a plain ERC-20 forever.

Those are constants, not settings. Nobody — including us — can widen them or extend the window.

You get no special treatment. The only exemption is the atomic dev buy inside your launch transaction. The instant it ends, you're capped like every other buyer. Some launchpads exempt the deployer for the whole window, letting the creator accumulate while buyers are throttled. That isn't protection — it's a head start paid for by the people it claims to protect.

What we control

There is an owner. Pretending otherwise would be a lie, so here is exactly what it reaches — and everything it doesn't.

It isn't upgradeable, deliberately. HoodPad holds the LP — an upgradeable contract holding everyone's liquidity means a withdraw() can be added later. Shipping changes means deploying a new launchpad: new coins use it, existing coins carry on trading regardless, because they never needed us to trade in the first place.

Community Take-Overs

One owner power reaches a live coin, and we'd rather name it plainly than bury it: we can reassign a coin's creator fee recipient. It exists for a real situation — a coin gets abandoned by its deployer, a community revives it and does the actual work, and the fees should follow the people building it, not sit with someone who walked away.

It is deliberately narrow. It moves only who receives the creator fee stream — never the liquidity, the supply, trading, our own 10%, or a single token any holder owns. A holder is unaffected either way. Every reassignment emits a public on-chain event, so it's auditable, and renounceOwnership removes even this for good. It's a stated trust assumption, not a hidden one.

Contracts

Verified, exact match. Read them instead of taking our word for any of this.

The test suite forks the live chain and runs against the real Uniswap V3 factory rather than a mock — pool pricing is the one thing a mock can't validate.

Limitations

Things that are true and inconvenient.

• The 1% fee is static. It does not decay as your market cap grows. A dynamic fee needs a Uniswap V4 hook, which isn't deployed here. If you ever see us claim fees drop to 0.10%, we're lying.
• Launch caps are evadable by splitting across wallets. They raise effort, not a wall.
• Your coin isn't a plain ERC-20 for ~36 seconds. It can reject an oversized buy during the guard window. After that it can never reject anything.
• Burn roughly halves your fee income. That's the trade for supply that shrinks instead of a market sell.
• Anyone can trigger a fee collection. It's permissionless — the split is fixed, so it can only ever pay you and us. But you don't control the timing.