The Hood Documentation

Introduction

The Hood is a community token launchpad on Robinhood Chain. Anyone can mint a fixed supply ERC20 from a form, trade it on a bonding curve from the very first second, and once the curve fills, watch it graduate into a SushiSwap V3 pool whose liquidity position is locked forever in an immutable locker with no withdrawal path, so the pool trading fees keep funding the creator and the platform while the principal can never be moved. It is fully noncustodial: every transaction is signed and submitted by your own wallet, and The Hood never takes custody of your assets.

Tokens are immutable. There are no owner keys, no mint function, no tax and no blacklist. What ships at launch is what trades forever. Every token address ends in 400D.

Two things make The Hood different from a plain launchpad: an onchain referral that rewards both sides forever (a trader’s referrer and a creator’s referrer), and an EcosystemFund that routes a fixed share of platform fees back into the communities that build here.

The Vision

The Hood was built on a feeling.

A feeling that communities, users and creators aren’t really being listened to, even when many of the changes they ask for are simple. The people using launchpads every day understand what works, what doesn’t and what could be improved, yet too often those conversations never lead anywhere.

We believe that can be different.

Our ambition isn’t to build just another launchpad. We want to build a platform that people feel is theirs. One that grows with its community instead of simply extracting from it. One that listens, adapts and isn’t afraid to evolve.

That’s why the majority of platform fees generated by The Hood will be deployed back into the ecosystem and the communities that choose to build here. Whether that’s supporting projects, strengthening liquidity or creating new opportunities for builders, our goal is the same: help the ecosystem grow alongside the platform.

From day one, we’re also introducing a referral system. If you help build The Hood, you should have the opportunity to benefit from it too.

Robinhood Chain is where this journey begins, but it isn’t where the vision ends.

The Hood isn’t built for one chain. It’s built around a simple belief: communities deserve better and the platforms they help build should create value that flows back into the ecosystem.

This is where we start.

Welcome to The Hood.

Network

The Hood runs on Robinhood Chain, an Ethereum L2 built on the Arbitrum stack.

Note: on this Arbitrum technology chain, the EVM block.number advances every 12 to 14 seconds while RPC visible L2 blocks are produced roughly every 100 ms. The Hood’s contracts key every time window on block.timestamp, never on block numbers.

Deployed contracts

The launchpad contracts on Robinhood Chain. Graduated tokens trade in SushiSwap V3 pools.

How it works

Every token walks the same one way path:

1. Create. You submit a name, ticker, image and socials plus a small creation fee. TokenFactory clones an immutable LaunchToken and opens its curve on BondingCurveMarket. An optional dev buy in the same transaction is capped for fairness.
2. Trade (TRADING). Buys and sells run against a constant product bonding curve. There is no order book and no counterparty needed; price is pure math on the reserves.
3. Freeze (FROZEN). The buy that pushes collected ETH to the graduation threshold atomically freezes the token and emits GraduationReady. No trading happens while a token is frozen.
4. Graduate (GRADUATED). A permissionless keeper (or anyone) calls GraduationManager.migrate(): the graduation budget is deposited as a full-range SushiSwap V3 position at the curve-final price, minted straight into the HoodLiquidityLock where the principal is locked forever while its pool fees stay collectable. If any step fails the whole transaction reverts and the token stays safely frozen, so there is no stranded state.

The bonding curve

Pricing is a constant product curve over virtual reserves, so a brand new token has depth from block one. The canonical (mainnet scale) parameters:

ETH denominated values scale per deployment; token amounts and percentages do not. The web app quotes trades with a curve mirror that is tested to match the Solidity exactly, but the contract is always the source of truth.

Fees & referrals

Every curve trade pays a flat 1% fee, split four ways onchain:

That is the referral working on both sides: whoever referred you earns 0.10% of everything you trade, which is 10% of the 1% trading fee, and whoever referred a token’s creator earns 0.10% of every trade on that token. Referrals bind on your first transaction and are permanent. Every stream accrues in the FeeVault and is claimed with a pull payment; nothing is ever pushed to you.

Of the platform’s share, a fixed 20% is routed to the EcosystemFund, the structural reinvestment commitment behind the vision above, with the remainder to the treasury.

Graduation

When a token’s collected ETH reaches the threshold, a buy atomically freezes it and emits GraduationReady. From there:

• GraduationManager.migrate(token) is permissionless and atomic. A keeper calls it within seconds, but anyone can, and the UI also exposes a finalize button.
• It pulls the graduation budget and mints a full-range SushiSwap V3 position at the curve-final price, straight into the HoodLiquidityLock — a contract with no code path to withdraw it, so the liquidity is locked forever and provable onchain. The lock collects the pool trading fees so creators and the platform keep earning after graduation (see The liquidity lock).
• A one way FROZEN → GRADUATED transition guarded by a reentrancy lock means a token graduates at most once; calling migrate again reverts harmlessly.
• No admin path can touch pooled ETH. Recovery, if a migration ever reverts, is always “retry migrate,” never “move funds.”

The liquidity lock

When a token graduates, its whole graduation budget — the 20% of supply reserved for the pool plus the ETH collected on the curve — is deposited as a single full-range liquidity position in the token’s SushiSwap V3 pool. That position is a transferable NFT, and it is minted directly into the HoodLiquidityLock, where it stays permanently.

“Permanently” here is structural, not a promise. The lock has no function that can withdraw, decrease, burn or transfer a position — that code does not exist, so no key, no admin and no upgrade can ever move the underlying liquidity. Anyone can confirm it by reading the verified contract. This is the same “liquidity locked forever” guarantee a burn gives, made provable onchain.

The difference is the trading fees. A SushiSwap V3 position earns a fee on every swap in its pool. Simply burning the position would throw those fees away for good; the lock instead keeps the principal frozen forever while still collecting the fees. Collection is permissionless — anyone can call collect(token), at any time — and the proceeds route automatically: the ETH side flows through the FeeVault on the same four-way split as a curve trade (platform, creator, and both referral legs), and the token side goes to the treasury. So a token’s creator and their referrer keep earning from its pool for as long as it trades, long after graduation.

Governance can only ever change where collected fees are sent; it can never reach the locked liquidity itself. There is no admin path to pooled funds, before or after graduation.

The token

Each token is a minimal proxy clone of the LaunchToken implementation: a standard ERC20 with a fixed supply minted once at creation. There is no owner, no mint, no pause, no tax and no blacklist. The symbol’s case is preserved exactly as you type it. Because the token is a clone, deployment is cheap and the bytecode is identical across every launch.

Create a token

Call createToken on the factory with a little ETH for the creation fee (plus any optional dev buy). referrer binds your creator referral; pass the zero address for none.

import { createWalletClient, http, parseEther, zeroAddress } from 'viem';
import { factoryAbi } from '@thehood/sdk';

const token = await wallet.writeContract({
  address: TOKEN_FACTORY,
  abi: factoryAbi,
  functionName: 'createToken',
  args: [
    'My Token',          // name
    'MYTKN',             // symbol
    metadataURI,         // data: or ipfs: JSON envelope (image + socials)
    metadataHash,        // keccak256 of the stored metadata string
    referrer,            // your creator referrer, or zeroAddress
    0n,                  // minTokensOut for the optional dev buy
    BigInt(Math.floor(Date.now() / 1000) + 300), // deadline
  ],
  value: creationFee,    // plus optional dev buy ETH
});

Buy

Send ETH to buy. minTokensOut is your slippage floor; referrer binds your trader referral on first use.

import { marketAbi } from '@thehood/sdk';

const hash = await wallet.writeContract({
  address: BONDING_CURVE_MARKET,
  abi: marketAbi,
  functionName: 'buy',
  args: [token, minTokensOut, deadline, referrer],
  value: parseEther('0.1'),
});

Sell

Approve the market to move your tokens, then call sell. minEthOut is your slippage floor.

import { erc20Abi, marketAbi } from '@thehood/sdk';

await wallet.writeContract({
  address: token,
  abi: erc20Abi,
  functionName: 'approve',
  args: [BONDING_CURVE_MARKET, tokenAmount],
});

const hash = await wallet.writeContract({
  address: BONDING_CURVE_MARKET,
  abi: marketAbi,
  functionName: 'sell',
  args: [token, tokenAmount, minEthOut, deadline, referrer],
});

Quoting & slippage

Read live reserves from getState and price the trade off the constant product curve, then apply a tolerance to set minTokensOut or minEthOut. The mirror in @thehood/sdk reproduces the onchain math exactly:

import { quoteBuy } from '@thehood/sdk';

const state = await client.readContract({
  address: BONDING_CURVE_MARKET,
  abi: marketAbi,
  functionName: 'getState',
  args: [token],
});

const { tokensOut } = quoteBuy(config, state, parseEther('0.1'));
const minTokensOut = (tokensOut * 995n) / 1000n; // 0.5% slippage

Claim fees

Creator earnings and both referral legs accrue in the FeeVault. Check what you are owed, then pull it. Claims are permissionless, and only you can claim your own balance.

import { feeVaultAbi } from '@thehood/sdk';

const owed = await client.readContract({
  address: FEE_VAULT,
  abi: feeVaultAbi,
  functionName: 'claimable',
  args: [me],
});

if (owed > 0n) {
  await wallet.writeContract({ address: FEE_VAULT, abi: feeVaultAbi, functionName: 'claim' });
}

Read state

getState(token) returns the creator, the lifecycle phase and the live reserves. The phase is the whole story:

For batched reads across many tokens (discovery grids, indexers), use LaunchpadLens rather than many individual calls.

Notes

• Tokens are immutable after launch: no owner, mint, pause, tax or blacklist.
• Symbol case is preserved onchain exactly as entered; the app displays tickers in caps.
• All deadlines and windows use block.timestamp, since Arbitrum stack block numbers are not wall clock time.
• Slippage that would breach your minTokensOut or minEthOut reverts the trade; nothing partially fills.
• Migration is permissionless and safe to retry; a frozen token can always be finalized by anyone, and funds are never stranded.
• This documentation describes the protocol; the deployed contracts are the source of truth for exact parameters on Robinhood Chain.