Developers & integration

Trading is fully permissionless and on-chain — bots, aggregators, and other apps can trade any HoodLaunch token by calling the contracts directly. The one thing to internalize: a token on the bonding curve is not on any DEX yet. Until it graduates there is no Uniswap pool, so standard DEX tooling can't see it — you trade against the launchpad, which is itself the market maker. After graduation it's an ordinary Uniswap V2 pair. Everything below branches on that one flag.

The HoodLaunchpad contract is the AMM. Quotes are exact — they mirror the on-chain rounding — so you can size slippage tightly:

• quoteBuy(token, grossEthIn) → tokens out; quoteSell(token, tokenAmount) → net ETH out.
• buy(token, minTokensOut) is payable — send ETH as msg.value. No approval needed.
• sell(token, amount, minEthOut) pulls tokens via transferFrom, so approve the launchpad first (a one-time approve(launchpad, max) is simplest).
• Quotes already net out the dynamic fee — trust them rather than recomputing. tradeFee(token) returns the current tier if you need it.

A buy that crosses the target is clipped, the excess ETH refunded, and the token migrates to Uniswap inside that same transaction. Afterwards buy / sell revert with graduated: trade on Uniswap, and the quote functions return 0. Always check getLaunch(token).graduated (or treat a 0 quote as the signal) and re-route.

The pair is token / WETH (resolve via token.pair() or factory.getPair). Graduated tokens charge the fee on pair transfers, so they are fee-on-transfer tokens: you must use the router's swapExact*SupportingFeeOnTransferTokens methods (the plain variants revert), and set amountOutMin allowing for the fee.

Watch events instead of polling:

• TokenLaunched — new tokens (addresses are CREATEd, so read them from the event, not ahead of time).
• Trade — every curve trade, carrying the post-trade virtual reserves, so you can track price with zero extra reads.
• Graduated — the hand-off to Uniswap. For enumeration: launchCount() and recentLaunches(offset, limit).

The protocol can be redeployed over time. When that happens the older contract stays online and keeps hosting every token launched on it — those tokens remain fully tradeable — while new launches only ever go to the active launchpad. So a token address may belong to the active launchpad or to a legacy one, and integrations that assume a single contract will miss tokens.

• Resolve the owner per token. Call getLaunch(token) on each deployment; the one that owns it returns a real creator, while the others return a zero-address creator. All per-token calls — buy, sell, claimCreatorFees, quoteBuy/Sell — must target that owning launchpad, and Trade events for it are emitted there.
• Enumerate across all of them. Run launchCount() / recentLaunches(offset, limit) against every deployment and merge.
• ABI compatibility. Legacy launchpads predate the rewards-wallet lock, so their LaunchView has no feeRecipientLocked field and they lack the creator setters below. Decode their views with the matching (pre-lock) ABI; all trade functions share the same signatures across versions. Legacy deployments also predate referrals, so their launchToken has no referrer argument and they expose none of the referral functions or events.

The network table at the foot of this page lists the active launchpad and any legacy ones for the selected network.

Each token pays its creator fee share to a rewards wallet, readable as getLaunch(token).feeRecipient. On the active launchpad it can be reassigned:

• creatorSetFeeRecipient(token, newRecipient) — the token creator changes their own rewards wallet. Reverts once locked.
• creatorLockFeeRecipient(token) — the creator permanently locks it (one-way). getLaunch(token).feeRecipientLocked then reads true.
• adminSetFeeRecipient(token, newRecipient) — the protocol admin only; works even after a creator lock.

A token can also be launched with the lock already engaged. Both are announced on-chain, including at launch: every launch emits FeeRecipientChanged(token, 0x0, recipient) (so event-only indexers learn the initial recipient without an extra call — TokenLaunched.creator is the launcher, which may differ), plus FeeRecipientLocked when launched locked. Watch both to track a token's rewards wallet over its whole life.

A launch can attribute a referrerwho earns 1% of the token's creator rewards (taken from the creator's share, not added on top). On-chain the referrer is a plain address — the tenth argument to launchToken. The ?ref= codes shared in the UI are just a short off-chain slug the app resolves to that address before launching; integrations pass the address directly.

• launchToken(…, lockFeeRecipient, referrer) — pass the referrer address, or the zero address for none. A referrer equal to the launcher or the rewards wallet is ignored (no self-referrals). When set, the launch emits ReferralAssigned(token, referrer); read it back any time with referrerOf(token).
• The 1% accrues at the same moment as the creator fee — on every curve buy/sell and on each post-graduation fee swap — into a single pooled balance per referrer, readable as referralFees(referrer).
• claimReferralFees()pays the caller their whole accumulated balance in ETH (across every token they've referred) and emits ReferralFeesClaimed(referrer, amount). It's a pull-payment, so the referrer claims for themselves.
• creditReferral(referrer) is an internal hand-off used by graduated tokens to route their post-graduation referral cut back into the pool — only a token the launchpad deployed can call it. Integrations don't call it directly.

Referrals are a feature of the active launchpad only — legacy deployments have no referral functions or events, so scope any referral reads and the claim to the active contract.

import { createPublicClient, http, parseEther } from "viem";
import { launchpadAbi, launchTokenAbi } from "./contracts";

// The launchpad that owns this token. With multiple deployments, probe each
// (see "Multiple launchpad versions") — the owner returns a real creator.
const LAUNCHPAD = "0x…";            // see the network table below
const pub = createPublicClient({ transport: http(RPC) });

// 1. Which venue is this token on?
const info = await pub.readContract({
  address: LAUNCHPAD, abi: launchpadAbi,
  functionName: "getLaunch", args: [token],
});

if (!info.graduated) {
  // ---- BUY on the curve: quote, then send ETH ----
  const ethIn = parseEther("0.1");
  const out = await pub.readContract({
    address: LAUNCHPAD, abi: launchpadAbi,
    functionName: "quoteBuy", args: [token, ethIn],
  });
  await wallet.writeContract({
    address: LAUNCHPAD, abi: launchpadAbi, functionName: "buy",
    args: [token, (out * 99n) / 100n],   // 1% slippage
    value: ethIn,
  });

  // ---- SELL on the curve: approve once, then sell ----
  await wallet.writeContract({
    address: token, abi: launchTokenAbi,
    functionName: "approve", args: [LAUNCHPAD, amount],
  });
  const eth = await pub.readContract({
    address: LAUNCHPAD, abi: launchpadAbi,
    functionName: "quoteSell", args: [token, amount],
  });
  await wallet.writeContract({
    address: LAUNCHPAD, abi: launchpadAbi, functionName: "sell",
    args: [token, amount, (eth * 99n) / 100n],
  });
} else {
  // ---- Graduated → Uniswap V2 (fee-on-transfer token) ----
  const pair = await pub.readContract({
    address: token, abi: launchTokenAbi, functionName: "pair",
  });
  // router.swapExactETHForTokensSupportingFeeOnTransferTokens(...)
  // router.swapExactTokensForETHSupportingFeeOnTransferTokens(...)
}

The ABIs live in the open-source repo (contracts/HoodLaunch.sol, lib/contracts.ts).

Addresses for the currently selected network — the active launchpad, any legacy launchpads still hosting tokens, plus the Uniswap deployment used for graduation liquidity: