Documentation

HudPad is a multi-type token launchpad on Robinhood Chain, paired with the .hud name service. Anyone launches a token in one transaction; it trades on a real DEX pool from block one. Every rule below is enforced by immutable contracts — no admin keys, no upgrade path, no pause.

• Fair launch — no presale, no team allocation, no pre-seeded insider liquidity.
• Fixed supply — 1,000,000,000 tokens minted once, with no mint function ever.
• Live instantly — the whole supply becomes single-sided liquidity in a Uniswap-V3 pool; trading opens immediately, no curve to fill.
• Deflationary — the token side of every fee collection is burned forever.
• Own your name — claim a yourname.hud identity, a fully on-chain ERC-721.

A single launch flow, three selectable structures. Pick one at deploy time; each mints a token (or collection) with its own economics. The V3 Direct type is the default and is live today — the other two are on the roadmap.

1 · V3 Direct default · live

A fixed-supply ERC-20 launched straight into a Uniswap-V3 pool as a single-sided position — no bonding curve, no graduation. The entire supply is placed as an "ask ladder" above the opening price, so the market fills it as people buy. Trading is open from the first block on HudSwap (the 1% V3 pool). Creators earn the ETH side of the swap fee forever; the token side is burned.

2 · Reserve curve (sat0-style) coming

An ERC-20 issued through an exponential bonding curve where the pool is the reserve. Minting moves ETH into the contract and advances the curve; burning redeems ETH along the inverse curve. There is no graduation and no admin key — ether deposited at mint is ether available at burn, less protocol fees. Curve size (K, S) is chosen per-coin.

3 · NFT mint curve coming

An NFT collection minted along a bonding curve — each mint costs more than the last, reserve-backed, with an optional burn/redeem along the inverse curve. Creators upload their art and pick from bounded presets.

The default launch type deploys two things in one transaction: the token, and its market.

1. Token — a fixed 1,000,000,000-supply ERC-20 (no mint function), created with CREATE2 so its address always sorts below WETH (it is pool token0). Immutable creator and metadataURI.
2. Pool — a canonical Uniswap-V3 pool (1% fee tier) is created and initialized at your chosen opening price, derived from a start market cap.
3. Liquidity — the whole supply is minted into the pool as a single-sided position strictly above spot. No ETH is required to launch; the position is the sell-side depth.
4. Dev buy (optional) — send ETH with the launch to take the first fill atomically, in the same transaction, before anyone else can snipe.

Because the position principal is never withdrawable — the launcher can only collect fees — the liquidity can never be pulled. This is the "can't be rugged" guarantee, enforced by the absence of a withdraw function, not by a lock timer.

.hud is a name service in the ENS tradition: a human-readable identity for your wallet on Robinhood Chain. Each name is a fully on-chain ERC-721 — the card art is rendered as an SVG inside the contract, no server or IPFS in the loop — so it shows up in any wallet and can be traded on any marketplace.

• Yearly rental, priced in USD and paid in ETH via a Chainlink feed: $100/yr for 3 characters, $10/yr for 4, $5/yr for 5+.
• 90-day grace after expiry before a lapsed name can be re-registered by anyone.
• Resolution — set a target address (name → wallet) and a primary record (wallet → name), so alice.hud can display across the board and feeds instead of a raw 0x….
• Secondary market — list a name at a fixed price, or make an offer on any name (ETH held in escrow, 7-day expiry, cancel anytime). Accepting is pinned to the exact offerer and amount, so a swapped or lowered offer can never be accepted silently.

Everything a trading or sniper bot needs to plug into HudPad. All contracts are immutable and permissionless — integrate once, nothing changes under you. Mainnet contract addresses will be published here at launch.

Discover launches

Subscribe to the launcher’s event — every new coin emits it in its deploy transaction, pool included, tradable that same block:

event TokenLaunched(
  address indexed token,   // ERC-20, always pool token0
  address indexed pool,    // Uniswap-V3 pool (1% tier), WETH = token1
  address indexed creator,
  address feeRecipient,
  uint256 supply,          // fixed 1e27 (1B · 1e18)
  uint24  feeTier,         // 10000
  int24   initialTick,
  string  name, string symbol, string metadataURI
)

Cold-start enumeration: tokensLength() / allTokens(uint256) on the launcher.

Trade

Two equivalent paths — the HudSwap router (simplest) or the V3 pool directly (standard Uniswap semantics).

// HudRouter
function buy(address token, uint256 minOut) payable returns (uint256 out)
function sell(address token, uint256 amountIn, uint256 minOut) returns (uint256 out)
// sells need a prior token.approve(router, amountIn)

Fills are the pool’s standard Swap events. Spot price from slot0.sqrtPriceX96: price = (sqrtPriceX96 / 2^96)^2 ETH per token unit. Token is always token0, so buys are zeroForOne = false.

60-second quickstart (viem)

import { createWalletClient, http, parseAbi, parseEther } from "viem";

const ROUTER = "0x…"; // published here at mainnet
const routerAbi = parseAbi([
  "function buy(address token, uint256 minOut) payable returns (uint256)",
  "function sell(address token, uint256 amountIn, uint256 minOut) returns (uint256)",
]);

// quote straight from the pool (POOL comes from the TokenLaunched event)
const poolAbi = parseAbi(["function slot0() view returns (uint160,int24,uint16,uint16,uint16,uint8,bool)"]);
const [sqrtP] = await client.readContract({ address: POOL, abi: poolAbi, functionName: "slot0" });
const spot = (BigInt(sqrtP) * BigInt(sqrtP) * 10n ** 18n) / 2n ** 192n; // ETH-wei / 1e18 tokens
const ethIn = parseEther("0.05");
const est = (ethIn * 99n * 10n ** 18n) / (100n * spot); // 1% pool fee off spot

await wallet.writeContract({
  address: ROUTER, abi: routerAbi, functionName: "buy",
  args: [TOKEN, (est * 97n) / 100n], value: ethIn,
});
// exit: token.approve(ROUTER, amount) then sell(TOKEN, amount, minEthOut)

Optional: HTTP snapshot

Bots don’t need our site or API — discovery, pricing and trading above are pure chain, so you run everything in your own environment. A ready-made JSON mirror exists if you want one, but nothing depends on it:

• GET /api/feed — newest coins page + recent trades + ETH/USD, cursor-paginated (?cursor=<nextCursor>&limit=100, ?token=0x… for one coin). priceX18 = ETH-wei per 1e18 token units.
• GET /api/stream — the same snapshot over SSE on every market change.

Agents integrate against the chain, not our UI — discovery, pricing and execution all live in immutable contracts your agent reads over its own RPC. The site is just a human window onto the same state. A minimal loop:

1. Observe — subscribe to TokenLaunched on the launcher and Swap on the pools with your own RPC/websocket. Cold start: tokensLength() / allTokens(i).
2. Quote — read the pool’s slot0.sqrtPriceX96: price = (sqrtPriceX96 / 2^96)^2 ETH per token unit, then tokensOut ≈ ethIn · 0.99 / price (1% pool fee; a real fill walks the ask ladder).
3. Guard — always send a non-zero minOut (e.g. quote − 3%). Never trade on a zero or missing quote.
4. Act — router.buy{value: ethIn}(token, minOut); exits are approve + router.sell(token, amount, minOut). Standard V3 swaps directly on the pool work identically.
5. Confirm — check the receipt; your fill is the pool’s Swap event in the same transaction.

Agent guardrails

• Depth awareness — liquidity is a single-sided ask ladder; read pool.liquidity() and recent Swap volume before sizing. Large buys move price sharply.
• Gas — Robinhood Chain is an Arbitrum Orbit L2: use generous gas limits (swaps ~600–900k) or transactions revert on estimation.
• Idempotency — key every action by txHash.
• Names — agents can hold identities too: HudNames.available(name) / priceOf(name, years) / register{value}(name, target, years).

Every guarantee is enforced by the contract code itself — not a promise, a policy, or a setting an admin can flip.

• Liquidity can’t be pulled — the launcher has no function to withdraw a pool position; it can only collect fees.
• Fixed supply, no mint — 1B minted once, with no mint function anywhere in the token.
• Deflationary — the token side of every fee collection is burned to the dead address.
• No admin keys — no owner switch, no pause, no upgrade path; the protocol treasury address is immutable from deployment.
• Reentrancy-guarded — every state-changing path is protected, and a bad fee recipient can only block its own payout.