How HoodMint works.

Overview

HoodMint is a place to launch and trade tokens on Robinhood Chain. You can browse launches, open any token to see its details, and trade straight from your wallet.

HoodMint never holds your funds. Every launch and trade is a transaction your wallet asks you to approve, against contracts with no owner, no pause switch, and no upgrade path.

How launches work

Creating a coin deploys the token and opens its bonding curve in a single transaction. Creation is free — you pay only gas. The creator sets the name, symbol, image, description, and links at creation, and the terms are immutable from that moment.

Every token starts with a fixed supply of one billion. 793.1M tokens are sold by the curve; the remaining 206.9M are reserved for the Uniswap pool at graduation. There is no creator allocation.

Launch protection

A snipe guard is optional and set by the creator at launch. For a window after launch — at most one day; the interface default is two minutes — each wallet’s cumulative buys are capped at a share of supply (interface default 2%). Oversize buys fill to the cap and refund the rest. Selling is never restricted, the creator’s atomic first buy is exempt — it cannot be front-run by construction — and all limits end when the window closes.

Robinhood Chain sequences transactions first-come-first-served, so sniping is a latency race rather than a gas auction. The guard bounds what any single address can grab in that race.

Trading and pricing

Before graduation, every token trades against ETH on its bonding curve — a constant product over virtual reserves, using pump.fun’s exact constants ported to ETH. After graduation it trades against WETH in its own Uniswap V3 pool. The price you see is live and moves with each trade; the amount you actually receive can differ slightly from the quote. Slippage sets how much of that movement you accept.

Graduation

A token graduates when the curve sells out — all 793.1M curve tokens bought. Graduation is reserve depletion, not an ETH threshold: with HoodMint’s constants it arrives after roughly 4.25 ETH has been raised, at a market cap near 20.5 ETH, with the price up about 14.7× from launch. The progress line tracks how close a launch is.

Migration is permissionless and idempotent: anyone can trigger it, and triggering it twice does nothing. It creates a 0.30% Uniswap V3 pool at exactly the final curve price — so there is no arbitrage gap at graduation — mints a full-range position from the raised ETH and the reserved 206.9M tokens, and locks that position in the LpLocker forever. The locker has no function that removes liquidity.

If someone sells between graduation and migration, the curve reopens: holders always retain an exit, even if an external Uniswap dependency is unavailable.

Fees and claims

Curve trades charge a 1.25% fee, split creator-first: 0.88% to the token’s creator and 0.37% to the protocol — about 70% of every fee goes to the creator. On buys the fee comes off the input before the curve math; on sells it is deducted from the output. The split is a constant of the deployed contract; there is no admin who can change it.

Creator fees accrue per token inside the curve contract and can be pushed to the creator at any time with claimCreatorFees — anyone may trigger the claim, and the proceeds always go to the creator. After graduation, the locked position’s swap fees are claimed with collect on the LpLocker, which splits them 70/30 between the creator and the protocol in the same transaction.

Protocol fees accrue to a single accumulator that anyone can sweep to the immutable protocol recipient. There is no other path by which ETH leaves the contract.

Risk disclosures

Tokens launched through HoodMint are user-created and experimental. Review the token address, creator, liquidity, holder concentration, and transaction preview before signing.

• Prices can move quickly and liquidity can be thin.
• Similar names and images can represent unrelated tokens.
• Smart contracts, wallets, RPCs, and indexers can fail.
• Displayed values are estimates, not execution guarantees.
• The contracts are immutable: there is no pause switch, no rollback, and no rescue authority.

HoodMint is an interface, not investment advice or a representation of token quality.

Network

A minimal, verifiable integration surface: everything below reads directly off the contracts. Index the curve’s events for a trust-minimized onchain source of truth.

Contracts

Deployed addresses on Robinhood Chain. The curve is a singleton: every launch, trade, quote, and claim goes through it.

Onchain events

Index the curve’s events from its deployment block. Every launch, trade, graduation, and migration is emitted by the single curve contract — one address to watch, with no per-token pools to register before graduation. Onchain events are the authoritative source of truth.

import { createPublicClient, http, parseAbiItem } from "viem";

const client = createPublicClient({
  chain: {
    id: 4663,
    name: "Robinhood Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: { default: { http: ["https://rpc.mainnet.chain.robinhood.com"] } },
  },
  transport: http(),
});

const CURVE = "0x570e51c509a20C63C409A43Bc8d9e2aeA564B61b";

const launches = await client.getLogs({
  address: CURVE,
  event: parseAbiItem(
    "event Launched(address indexed token, address indexed creator, string name, string symbol, string metadataURI, uint24 guardSeconds, uint16 guardMaxBuyBps)",
  ),
  fromBlock: 15675879n,
  toBlock: "latest",
});

const trades = await client.getLogs({
  address: CURVE,
  event: parseAbiItem(
    "event Trade(address indexed token, address indexed trader, bool isBuy, uint256 ethGross, uint256 ethNet, uint256 tokenAmount, uint256 protocolFee, uint256 creatorFee, uint128 virtualEth, uint128 virtualToken, uint128 realEth, uint128 realToken, bool complete)",
  ),
  fromBlock: 15675879n,
  toBlock: "latest",
});

Every Trade log carries the trade’s direction (isBuy) and the full post-trade reserve state, so an indexer can price the curve from logs alone with no extra reads. After migration, index the token’s Uniswap pool Swap events for post-graduation trades; the pool address is in the Migrated event.

Reading curve state

Every launch is self-describing onchain. The token is a standard ERC-20 (name, symbol, 18 decimals); its image, description, and links live at the metadataURI emitted with the Launched event; and everything else is in the curve’s curves mapping.

import { parseAbi } from "viem";

const curveAbi = parseAbi([
  "function curves(address token) view returns (uint128 virtualEth, uint128 virtualToken, uint128 realEth, uint128 realToken, address creator, bool complete, bool migrated, uint40 launchedAt, uint24 guardSeconds, uint16 guardMaxBuyBps)",
  "function spotPrice(address token) view returns (uint256)",
  "function quoteBuy(address token, address trader, uint256 ethGross) view returns (uint256 tokensOut, uint256 fee, uint256 refund)",
  "function quoteSell(address token, uint256 tokenAmount) view returns (uint256 ethOut, uint256 fee)",
]);

const [virtualEth, virtualToken, realEth, realToken, creator, complete, migrated] =
  await client.readContract({
    address: CURVE,
    abi: curveAbi,
    functionName: "curves",
    args: [token],
  });

quoteBuy and quoteSell return exactly what the contract would execute, including fees, snipe-guard caps, and the final-buy refund. Snipe-guard state for a specific wallet is available from guardStatus(token, buyer).

Pricing and graduation

Price is the ratio of the curve’s virtual reserves. Token and ETH both use 18 decimals, so no decimal scaling is needed. Convert to USD with any ETH oracle.

const priceEth = Number(virtualEth) / Number(virtualToken);
const priceUsd = priceEth * ethUsd; // ethUsd from any ETH oracle

const SUPPLY = 1_000_000_000;
const marketCapUsd = priceUsd * SUPPLY; // supply is fixed; FDV equals market cap

// Graduation progress: share of the 793.1M curve tokens already sold.
const REAL_TOKEN_RESERVES = 793_100_000n * 10n ** 18n;
const progress = 1 - Number(realToken) / Number(REAL_TOKEN_RESERVES);

complete flips when the last curve token is bought and the Graduated event fires; migrated flips when migration lands and the Migrated event carries the pool and position id. From then on, price comes from the pool’s slot0 — square sqrtPriceX96, and invert when the token is not token0.

const lockerAbi = parseAbi([
  "function locks(uint256 tokenId) view returns (address creator, address token0, address token1)",
  "function collect(uint256 tokenId) returns (uint256 amount0, uint256 amount1)",
]);

// collect() claims the position's accrued swap fees and splits them
// 70/30 between the creator and the protocol in the same transaction.

Both claim paths — claimCreatorFees on the curve and collect on the locker — are callable by anyone; proceeds always go to the creator and the immutable protocol recipient.

Versioning and terms

Deployed contracts are immutable and unowned. New versions ship as new curve and locker addresses, listed under Contracts.

The interface’s REST API is an implementation detail of the app, not a stable public contract. Build integrations on the events above.

Onchain data is public and free to read; you are responsible for how you use it. HoodMint is provided as is, without warranties, and the team is not liable for losses arising from integrations, interfaces, RPCs, or indexers. Availability of interfaces and public infrastructure is not guaranteed. Do not present third-party services as operated by HoodMint, and do not imply a partnership or endorsement without a written agreement.