KingPad Docs

What is KingPad

KingPad lets anyone launch a token on Robinhood Chain — you pay network gas plus a 0.0005 ETH launch fee. Every new token starts on its own bonding curve: a fair, automatic market where the price rises as people buy and falls as they sell, with no liquidity to seed yourself.

Once a token reaches its graduation target its liquidity moves into a locked Uniswap v4 pool automatically. KingPad is non-custodial — your wallet signs every action and holds your assets.

The contracts are called KingLaunch; KingPad is the interface in front of them.

How it works

Each launch deploys its own token and its own bonding curve — the curve is not shared. The curve is constant-product (x·y=k), seeded with a phantom quote reserve so trading works from the first block:

• Fixed supply: 1,000,000,000 tokens per coin
• Phantom quote reserve: 1.68 ETH (virtual — nobody deposited it)
• Graduation threshold: 4.2 ETH of real quote reserve
• Trading fee: 1% per trade (feeBps = 100)
• Fee split: 30% platform / 70% creator (protocolFeeShareBps = 3000)
• Not all supply is sellable into the curve — the rest is reserved for the graduation pool

The price you see comes straight from the curve's reserves, so it moves the moment anyone trades.

Paired assets

A launch does not have to be quoted in ETH. Any approved pair token can be the quote asset — including tokenized equities on this chain such as NVDA, TSLA or AAPL. Buyers spend that asset, sellers receive it, graduation is measured in it, and creator fees accrue in it. Check one with approvedPairTokens(address) on the factory.

Snipe tax

For the first few seconds of a launch a decaying tax is applied to buys, so a bot cannot take the whole curve at the opening price. It starts at snipeTaxStartBps and decays linearly to zero over snipeTaxSeconds. Read the live value for a given buyer with currentSnipeTaxBps(recipient).

Creating a token

• Connect your wallet (top-right) — make sure it's on Robinhood Chain and has a little ETH for gas.
• Go to Create, enter a name, symbol, optional description, and upload an image or GIF.
• Pick the paired asset — ETH by default, or any approved token including tokenized stocks.
• Optionally add social links and a creator fee recipient.
• Click Launch and approve the transaction. Your token is live immediately and appears on the board.

Launching costs the 0.0005 ETH launch fee plus gas.

Trading & fees

Buy or sell any token from its trade page. A 1% fee applies to each trade, split 30% platform / 70% creator. Fees accrue on the curve and are swept to the fee escrow, where creators and the platform claim them from the Profile page.

A creator may also set an optional creator tax on top of the trade fee, capped by the factory's maxCreatorTaxBps. It is paid to the creator in full, and it is zero unless the creator chose otherwise.

Graduation

When a curve's real quote reserve reaches 4.2 ETH, KingLaunch:

• Creates a Uniswap v4 pool for the token, behind the KingLaunch meme hook
• Deposits the accumulated liquidity into it
• Locks the LP in the locker contract

After graduation the curve stops and the token trades in the v4 pool. The hook takes the protocol fee inside the swap itself, so the fee applies no matter who routes the trade.

Token images (IPFS)

Token artwork (including animated GIFs up to ~5 MB) is uploaded to public IPFS and pinned, and only the small ipfs://<cid> reference is stored on-chain. This keeps launch transactions cheap while the image lives permanently and decentralized.

Contracts

KingLaunch is deployed on Robinhood Chain (chainId 4663) from block 61650802. Every contract below is source-verified with an exact match on both runtime and creation bytecode — compiled with solc 0.8.28+commit.7893614a, optimizer 200 runs, evmVersion cancun, viaIR.

Each launch additionally deploys its own token and its own bonding curve, both at addresses the factory reports through getLaunchedToken(token).

Verifying independently

The source is published to Sourcify, which is explorer-independent — you can fetch and check it without trusting any particular explorer:

curl https://sourcify.dev/server/v2/contract/4663/0x9FD5995a2715678aB5fE367e7C14eFd26a35D13f

Most of these are also verified on Blockscout, the chain's default explorer. Sourcify is the authoritative copy.

Integration

KingLaunch is fully on-chain, so any project can index and read it with no off-chain source. Point a viem (or ethers) client at Robinhood Chain and read the factory, each launch's curve, and the token contracts directly. On-chain events are the authoritative source of truth.

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

const FACTORY    = "0x9FD5995a2715678aB5fE367e7C14eFd26a35D13f";
const MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
const DEPLOYED_AT = 61650802n;   // nothing to index before this block

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(),
});

The public RPC times out on very wide eth_getLogs ranges — backfill in bounded block chunks. It supports JSON-RPC batching and Multicall3, so batch reads for the whole token set through Multicall3 rather than one call per token. topics[1] accepts an array, which lets you pull trades for many curves in a single request.

Onchain events

Two places to index: the factory emits every launch, and each launch's own curve emits its trades. Buy/sell direction is explicit — separate events, no need to derive it from swap amounts.

// Every launch, from the factory
const launches = await client.getLogs({
  address: FACTORY,
  event: parseAbiItem(
    "event TokenLaunched(address indexed token, address indexed curve, address indexed deployer, address pairToken, uint256 launchConfigId, uint256 graduationThreshold)"
  ),
  fromBlock: DEPLOYED_AT, toBlock: "latest",   // chunk this on the public RPC
});

// Trades for one launch - note the address is the CURVE, not the factory
const buys = await client.getLogs({
  address: curve,
  event: parseAbiItem(
    "event CurveBuy(address indexed buyer, address indexed recipient, uint256 quoteIn, uint256 tokensOut, uint256 fee, uint256 tax)"
  ),
  fromBlock: DEPLOYED_AT, toBlock: "latest",
});
// event CurveSell(address indexed seller, address indexed recipient, uint256 tokensIn, uint256 quoteOut, uint256 fee, uint256 tax)

Amounts are denominated in the launch's pair token, which is not always ETH — read pairToken from the launch record before converting to a fiat value.

Reading token state

The factory holds a registry keyed by token address; per-trade state lives on that launch's curve.

const factoryAbi = parseAbi([
  "function getLaunchedToken(address token) view returns ((address token, address curve, address deployer, address creatorFeeRecipient, address pairToken, uint256 graduationThreshold, uint24 poolFee, int24 tickSpacing, uint16 creatorTaxBps, bool buybackEnabled, uint8 phase, uint256 sweptQuote, uint256 sweptTokens, uint256 sweptAt, bool exists))",
  "function launchFee() view returns (uint256)",
  "function launchEnabled() view returns (bool)",
  "function approvedPairTokens(address) view returns (bool)",
]);

const curveAbi = parseAbi([
  "function token() view returns (address)",
  "function pairToken() view returns (address)",
  "function getReserves() view returns (uint256 quoteReserve, uint256 tokenReserve)",
  "function realQuoteReserve() view returns (uint256)",   // excludes the phantom reserve
  "function sellableTokens() view returns (uint256)",
  "function graduationThreshold() view returns (uint256)",
  "function graduated() view returns (bool)",
  "function feeBps() view returns (uint16)",
  "function creatorTaxBps() view returns (uint16)",
  "function protocolFeeShareBps() view returns (uint16)",
  "function currentSnipeTaxBps(address recipient) view returns (uint256)",
]);

const tokenAbi = parseAbi([
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function decimals() view returns (uint8)",
  "function totalSupply() view returns (uint256)",
  "function logo() view returns (string)",          // ipfs://CID
  "function description() view returns (string)",
  "function balanceOf(address) view returns (uint256)",
]);

getLaunchedToken(token).exists is the cheapest way to answer "is this one of ours?" — one call, no log scan. Resolve logo() as an ipfs:// reference through any gateway.

Pricing & graduation

There is no quote function on the curve. Price and expected output are derived off-chain from the reserves and the fee parameters. Spot price is simply the reserve ratio:

const [quoteReserve, tokenReserve] = await client.readContract({
  address: curve, abi: curveAbi, functionName: "getReserves",
});

// price of one token, in the pair asset
const price = Number(quoteReserve) / Number(tokenReserve);

// expected tokens out for a buy, fees first, then constant product
const feeBps  = await client.readContract({ address: curve, abi: curveAbi, functionName: "feeBps" });
const taxBps  = await client.readContract({ address: curve, abi: curveAbi, functionName: "creatorTaxBps" });
const snipe   = await client.readContract({ address: curve, abi: curveAbi, functionName: "currentSnipeTaxBps", args: [buyer] });

const net = amountIn * (10000n - BigInt(feeBps) - BigInt(taxBps) - BigInt(snipe)) / 10000n;
const out = tokenReserve * net / (quoteReserve + net);

Market cap is price × totalSupply; supply is fixed, so FDV and market cap are the same number. If the pair asset is not ETH you need its own price to reach a fiat value.

Graduation progress is realQuoteReserve() / graduationThreshold() — use realQuoteReserve(), not getReserves()[0], or the phantom 1.68 ETH will make an untouched curve look 40% done.

const real = await client.readContract({ address: curve, abi: curveAbi, functionName: "realQuoteReserve" });
const goal = await client.readContract({ address: curve, abi: curveAbi, functionName: "graduationThreshold" });
const progress = Number(real) / Number(goal);   // 0..1

const done = await client.readContract({ address: curve, abi: curveAbi, functionName: "graduated" });
// once true, the curve is closed and trading is in the Uniswap v4 pool behind the meme hook

Reference launch

A live launch for validating an indexer or integration against known on-chain state:

Privacy Policy

KingPad is a non-custodial interface to smart contracts on a public blockchain.

• We do not collect personal information or require accounts. Your identity is your wallet address.
• Wallet addresses, transactions, and token data are public on-chain and displayed by the app.
• Optional profile details (display name, avatar) and holder-chat messages you submit are stored to power those features and are visible to other users.
• We do not sell your data. Third-party services (e.g. RPC, explorer, IPFS pinning) may process public on-chain requests to operate the app.

Terms of Use

• KingPad is provided "as is," without warranties of any kind. Use it at your own risk.
• Blockchain transactions are irreversible. You are solely responsible for your wallet, keys, and the transactions you sign.
• Tokens created on KingPad are user-generated, can be highly volatile, and may lose all value. Nothing here is financial, investment, legal, or tax advice.
• Do not use KingPad for unlawful activity or where prohibited. You are responsible for complying with the laws that apply to you.
• KingPad does not custody assets and is not liable for losses arising from use of the app or the underlying contracts.

© 2026 KingPad · All rights reserved