HoodX Launchpad Docs

Deployed contracts

Each launch also deploys a unique BondingCurve and Hoodx via CREATE2. Token addresses always end in …663.

Architecture

1. Launch — call HoodxFactory.createLaunch to deploy curve + token.
2. Bonding curve — users buy/sell on the curve until 4.2 ETH is raised (2% trade fee).
3. Graduation — when the 4.2 ETH target is reached, ~4.1 ETH seeds a Uniswap V3 pool whose LP is locked permanently in Titan; the small remainder covers the Titan lock and splits 80% creator / 20% platform.
4. LP fees — the graduation LP is locked in Titan forever, but its Uniswap V3 trading fees never stop accruing and stay claimable for as long as the pool trades (collectFees() has no time gate): token side burned, WETH side split 80% creator / 20% platform on each collect.
5. DEX trading — after graduation, use HoodxDexRouter for V3 buys/sells or trade via Hood X.

Fees & custody. Hood X is non-custodial — every create, buy, sell, and graduation runs on-chain straight from your wallet, and the platform contract never holds your funds. Fees settle directly: the 0.0005 ETH launch fee and the platform's 1% of the 2% curve trade tax go to the fee wallet, the creator's matching 1% to the creator, and the graduation cut splits per the waterfall above. Because the LP is locked without a time gate, the position itself can never be withdrawn — only its trading fees are ever collected, and those keep flowing 80% creator / 20% platform.

1. Launch a token

Call createLaunch on the launchpad. Pay at least 0.0005 ETH launch fee; any extra ETH in the same tx is used as an optional creator dev-buy.

// HoodxFactory.createLaunch
function createLaunch(
  string name,
  string symbol,
  string metadataURI,   // ipfs:// or https:// JSON with name, symbol, image, socials
  uint256 minTokensOut, // slippage guard for optional dev-buy (0 if no dev-buy)
  bytes32 curveSalt,    // CREATE2 salt — curve address must end in 663
  bytes32 tokenSalt     // CREATE2 salt — token address must end in 663
) external payable returns (address curve, address token);

// Example (viem / wagmi)
await writeContract({
  address: "0x1c86eb4d7cf2fA3cF4A8B7A28d0d7a7fB594dE6a",
  abi: launchpadAbi,
  functionName: "createLaunch",
  args: [name, symbol, metadataURI, 0n, curveSalt, tokenSalt],
  value: parseEther("0.0005"), // launch fee only
});

Read launch metadata: launchpad.launches(launchId) or launchpad.curveToLaunchId(curve). Resolve token → curve: Hoodx(token).curve().

2. Buy on bonding curve (pre-graduation)

Send ETH to the curve's buy function. 2% fee is taken (1% platform ETH + 1% creator ETH accrued from curve trading).

// BondingCurve.buy — curve must not be graduated
function buy(uint256 minTokensOut) external payable;

await writeContract({
  address: curveAddress,
  abi: bondingCurveAbi,
  functionName: "buy",
  args: [minTokensOut],
  value: parseEther("0.1"),
});

// Quote before sending
const [tokensOut] = await readContract({
  address: curveAddress,
  abi: bondingCurveAbi,
  functionName: "quoteBuy",
  args: [parseEther("0.1")],
});

3. Sell on bonding curve (pre-graduation)

Approve the curve to spend tokens, then call sell.

// 1. Approve curve to spend tokens
await writeContract({
  address: tokenAddress,
  abi: erc20Abi,
  functionName: "approve",
  args: [curveAddress, tokenAmount],
});

// 2. Sell
function sell(uint256 tokenAmount, uint256 minEthOut) external;

await writeContract({
  address: curveAddress,
  abi: bondingCurveAbi,
  functionName: "sell",
  args: [tokenAmount, minEthOut],
});

4. Trade after graduation (Uniswap V3)

Once curve.graduated() == true, use HoodxDexRouter. The router executes the Uniswap V3 swap and records volume on the curve for the activity feed.

const DEX_ROUTER = "0x92bca96C1f8579399Ae583efF1bCc3DdBcDeBc7C";

// Buy with ETH
function uniBuy(address curve, uint256 minTokensOut) external payable;

await writeContract({
  address: DEX_ROUTER,
  abi: dexRouterAbi,
  functionName: "uniBuy",
  args: [curveAddress, minTokensOut],
  value: parseEther("0.1"),
});

// Sell tokens — approve DEX_ROUTER first, then:
function uniSell(address curve, uint256 tokenAmount, uint256 minEthOut) external;

await writeContract({
  address: DEX_ROUTER,
  abi: dexRouterAbi,
  functionName: "uniSell",
  args: [curveAddress, tokenAmount, minEthOut],
});

5. Read on-chain state

// BondingCurve views
curve.token()            // Hoodx address
curve.creator()          // launch creator
curve.graduated()        // true after migration
curve.uniswapPool()      // V3 pool (zero before grad)
curve.currentPrice()     // spot price in wei per token
curve.tokensRemaining()  // unsold sale inventory (800M cap)
curve.ethCollected()     // net ETH in curve
curve.tokensSold()
curve.graduationTarget() // 4.2 ETH target

// Hoodx
token.curve()            // bonding curve address

// Creator fees accrue on the CURVE in native ETH (1% of every trade) —
curve.claimCreatorFees() // permissionless; pays the accrued fees to the creator

6. Index trades (events)

Pre-graduation trades emit on the curve contract:

event Buy(address indexed buyer, uint256 ethIn, uint256 tokensOut, uint256 newPrice);
event Sell(address indexed seller, uint256 tokensIn, uint256 ethOut, uint256 newPrice);
event DevBuy(address indexed creator, uint256 ethIn, uint256 tokensOut, uint256 newPrice);
event Graduated(address pool, uint256 ethLiquidity, uint256 tokenLiquidity, uint256 ethToDev);

// Launchpad
event LaunchCreated(uint256 indexed launchId, address curve, address token, address creator, string name, string symbol);

Fetch historical logs via Blockscout: GET /api/v2/addresses/{curve}/logs

7. Token supply & curve math

• Total supply: 1,000,000,000 tokens
• Bonding curve sale: 800,000,000 tokens
• Uniswap LP allocation: 200,000,000 tokens (minted to curve, migrated at graduation)
• Virtual reserves: 1.43325 ETH + 1,073,000,000 virtual tokens (constant-product AMM)
• Graduation target: 4.2 ETH net collected